diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000..3e84d7c704
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,96 @@
+* text=auto !eol svneol=native#text/plain
+*.gitattributes text svneol=native#text/plain
+
+# Scriptish formats
+*.bat        text svneol=native#text/plain
+*.bsh        text svneol=native#text/x-beanshell
+*.cgi        text svneol=native#text/plain
+*.cmd        text svneol=native#text/plain
+*.js         text svneol=native#text/javascript
+*.php        text svneol=native#text/x-php
+*.pl         text svneol=native#text/x-perl
+*.pm         text svneol=native#text/x-perl
+*.py         text svneol=native#text/x-python
+*.sh         eol=lf svneol=LF#text/x-sh
+configure    eol=lf svneol=LF#text/x-sh
+
+# Image formats
+*.bmp        binary svneol=unset#image/bmp
+*.gif        binary svneol=unset#image/gif
+*.ico        binary svneol=unset#image/ico
+*.jpeg       binary svneol=unset#image/jpeg
+*.jpg        binary svneol=unset#image/jpeg
+*.png        binary svneol=unset#image/png
+*.tif        binary svneol=unset#image/tiff
+*.tiff       binary svneol=unset#image/tiff
+*.svg        text svneol=native#image/svg%2Bxml
+
+# Data formats
+*.pdf        binary svneol=unset#application/pdf
+*.avi        binary svneol=unset#video/avi
+*.doc        binary svneol=unset#application/msword
+*.dsp        text svneol=crlf#text/plain
+*.dsw        text svneol=crlf#text/plain
+*.eps        binary svneol=unset#application/postscript
+*.gz         binary svneol=unset#application/gzip
+*.mov        binary svneol=unset#video/quicktime
+*.mp3        binary svneol=unset#audio/mpeg
+*.ppt        binary svneol=unset#application/vnd.ms-powerpoint
+*.ps         binary svneol=unset#application/postscript
+*.psd        binary svneol=unset#application/photoshop
+*.rdf        binary svneol=unset#text/rdf
+*.rss        text svneol=unset#text/xml
+*.rtf        binary svneol=unset#text/rtf
+*.sln        text svneol=native#text/plain
+*.swf        binary svneol=unset#application/x-shockwave-flash
+*.tgz        binary svneol=unset#application/gzip
+*.vcproj     text svneol=native#text/xml
+*.vcxproj    text svneol=native#text/xml
+*.vsprops    text svneol=native#text/xml
+*.wav        binary svneol=unset#audio/wav
+*.xls        binary svneol=unset#application/vnd.ms-excel
+*.zip        binary svneol=unset#application/zip
+
+# Text formats
+.htaccess    text svneol=native#text/plain
+*.bbk        text svneol=native#text/xml
+*.cmake      text svneol=native#text/plain
+*.css        text svneol=native#text/css
+*.dtd        text svneol=native#text/xml
+*.htm        text svneol=native#text/html
+*.html       text svneol=native#text/html
+*.ini        text svneol=native#text/plain
+*.log        text svneol=native#text/plain
+*.mak        text svneol=native#text/plain
+*.qbk        text svneol=native#text/plain
+*.rst        text svneol=native#text/plain
+*.sql        text svneol=native#text/x-sql
+*.txt        text svneol=native#text/plain
+*.xhtml      text svneol=native#text/xhtml%2Bxml
+*.xml        text svneol=native#text/xml
+*.xsd        text svneol=native#text/xml
+*.xsl        text svneol=native#text/xml
+*.xslt       text svneol=native#text/xml
+*.xul        text svneol=native#text/xul
+*.yml        text svneol=native#text/plain
+boost-no-inspect text svneol=native#text/plain
+CHANGES      text svneol=native#text/plain
+COPYING      text svneol=native#text/plain
+INSTALL      text svneol=native#text/plain
+Jamfile      text svneol=native#text/plain
+Jamroot      text svneol=native#text/plain
+Jamfile.v2   text svneol=native#text/plain
+Jamrules     text svneol=native#text/plain
+Makefile*    text svneol=native#text/plain
+README       text svneol=native#text/plain
+TODO         text svneol=native#text/plain
+
+# Code formats
+*.c          text svneol=native#text/plain
+*.cpp        text svneol=native#text/plain
+*.h          text svneol=native#text/plain
+*.hpp        text svneol=native#text/plain
+*.ipp        text svneol=native#text/plain
+*.tpp        text svneol=native#text/plain
+*.jam        text svneol=native#text/plain
+*.java       text svneol=native#text/plain
diff --git a/example/allocation/Jamfile b/example/allocation/Jamfile
new file mode 100644
index 0000000000..5c7dbd3e8c
--- /dev/null
+++ b/example/allocation/Jamfile
@@ -0,0 +1,25 @@
+subproject libs/asio/example/allocation ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe server
+  : server.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/allocation/server.cpp b/example/allocation/server.cpp
new file mode 100644
index 0000000000..ce73cca99f
--- /dev/null
+++ b/example/allocation/server.cpp
@@ -0,0 +1,229 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/aligned_storage.hpp>
+#include <boost/array.hpp>
+#include <boost/bind.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+// Class to manage the memory to be used for handler-based custom allocation.
+// It contains a single block of memory which may be returned for allocation
+// requests. If the memory is in use when an allocation request is made, the
+// allocator delegates allocation to the global heap.
+class handler_allocator
+  : private boost::noncopyable
+{
+public:
+  handler_allocator()
+    : in_use_(false)
+  {
+  }
+
+  void* allocate(std::size_t size)
+  {
+    if (!in_use_ && size < storage_.size)
+    {
+      in_use_ = true;
+      return storage_.address();
+    }
+    else
+    {
+      return ::operator new(size);
+    }
+  }
+
+  void deallocate(void* pointer)
+  {
+    if (pointer == storage_.address())
+    {
+      in_use_ = false;
+    }
+    else
+    {
+      ::operator delete(pointer);
+    }
+  }
+
+private:
+  // Storage space used for handler-based custom memory allocation.
+  boost::aligned_storage<1024> storage_;
+
+  // Whether the handler-based custom allocation storage has been used.
+  bool in_use_;
+};
+
+// Wrapper class template for handler objects to allow handler memory
+// allocation to be customised. Calls to operator() are forwarded to the
+// encapsulated handler.
+template <typename Handler>
+class custom_alloc_handler
+{
+public:
+  custom_alloc_handler(handler_allocator& a, Handler h)
+    : allocator_(a),
+      handler_(h)
+  {
+  }
+
+  template <typename Arg1>
+  void operator()(Arg1 arg1)
+  {
+    handler_(arg1);
+  }
+
+  template <typename Arg1, typename Arg2>
+  void operator()(Arg1 arg1, Arg2 arg2)
+  {
+    handler_(arg1, arg2);
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      custom_alloc_handler<Handler>* this_handler)
+  {
+    return this_handler->allocator_.allocate(size);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      custom_alloc_handler<Handler>* this_handler)
+  {
+    this_handler->allocator_.deallocate(pointer);
+  }
+
+private:
+  handler_allocator& allocator_;
+  Handler handler_;
+};
+
+// Helper function to wrap a handler object to add custom allocation.
+template <typename Handler>
+inline custom_alloc_handler<Handler> make_custom_alloc_handler(
+    handler_allocator& a, Handler h)
+{
+  return custom_alloc_handler<Handler>(a, h);
+}
+
+class session
+  : public boost::enable_shared_from_this<session>
+{
+public:
+  session(boost::asio::io_service& io_service)
+    : socket_(io_service)
+  {
+  }
+
+  tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  void start()
+  {
+    socket_.async_read_some(boost::asio::buffer(data_),
+        make_custom_alloc_handler(allocator_,
+          boost::bind(&session::handle_read,
+            shared_from_this(),
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred)));
+  }
+
+  void handle_read(const boost::asio::error& error, size_t bytes_transferred)
+  {
+    if (!error)
+    {
+      boost::asio::async_write(socket_,
+          boost::asio::buffer(data_, bytes_transferred),
+          make_custom_alloc_handler(allocator_,
+            boost::bind(&session::handle_write,
+              shared_from_this(),
+              boost::asio::placeholders::error)));
+    }
+  }
+
+  void handle_write(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      socket_.async_read_some(boost::asio::buffer(data_),
+          make_custom_alloc_handler(allocator_,
+            boost::bind(&session::handle_read,
+              shared_from_this(),
+              boost::asio::placeholders::error,
+              boost::asio::placeholders::bytes_transferred)));
+    }
+  }
+
+private:
+  // The socket used to communicate with the client.
+  tcp::socket socket_;
+
+  // Buffer used to store data received from the client.
+  boost::array<char, 1024> data_;
+
+  // The allocator to use for handler-based custom memory allocation.
+  handler_allocator allocator_;
+};
+
+typedef boost::shared_ptr<session> session_ptr;
+
+class server
+{
+public:
+  server(boost::asio::io_service& io_service, short port)
+    : io_service_(io_service),
+      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
+  {
+    session_ptr new_session(new session(io_service_));
+    acceptor_.async_accept(new_session->socket(),
+        boost::bind(&server::handle_accept, this, new_session,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(session_ptr new_session, const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      new_session->start();
+      new_session.reset(new session(io_service_));
+      acceptor_.async_accept(new_session->socket(),
+          boost::bind(&server::handle_accept, this, new_session,
+            boost::asio::placeholders::error));
+    }
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  tcp::acceptor acceptor_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: server <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server s(io_service, atoi(argv[1]));
+
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/buffers/Jamfile b/example/buffers/Jamfile
new file mode 100644
index 0000000000..16a045c2f1
--- /dev/null
+++ b/example/buffers/Jamfile
@@ -0,0 +1,25 @@
+subproject libs/asio/example/buffers ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe server
+  : reference_counted.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/buffers/reference_counted.cpp b/example/buffers/reference_counted.cpp
new file mode 100644
index 0000000000..f35c0fe42c
--- /dev/null
+++ b/example/buffers/reference_counted.cpp
@@ -0,0 +1,118 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/shared_ptr.hpp>
+#include <vector>
+
+using boost::asio::ip::tcp;
+
+// A reference-counted non-modifiable buffer class.
+class shared_const_buffer
+{
+public:
+  // Construct from a std::string.
+  explicit shared_const_buffer(const std::string& data)
+    : data_(new std::vector<char>(data.begin(), data.end())),
+      buffer_(boost::asio::buffer(*data_))
+  {
+  }
+
+  // Implement the Const_Buffers concept.
+  typedef boost::asio::const_buffer value_type;
+  typedef const boost::asio::const_buffer* const_iterator;
+  const boost::asio::const_buffer* begin() const { return &buffer_; }
+  const boost::asio::const_buffer* end() const { return &buffer_ + 1; }
+
+private:
+  boost::shared_ptr<std::vector<char> > data_;
+  boost::asio::const_buffer buffer_;
+};
+
+class session
+  : public boost::enable_shared_from_this<session>
+{
+public:
+  session(boost::asio::io_service& io_service)
+    : socket_(io_service)
+  {
+  }
+
+  tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  void start()
+  {
+    using namespace std; // For time_t, time and ctime.
+    time_t now = time(0);
+    shared_const_buffer buffer(ctime(&now));
+    boost::asio::async_write(socket_, buffer,
+        boost::bind(&session::handle_write, shared_from_this()));
+  }
+
+  void handle_write()
+  {
+  }
+
+private:
+  // The socket used to communicate with the client.
+  tcp::socket socket_;
+};
+
+typedef boost::shared_ptr<session> session_ptr;
+
+class server
+{
+public:
+  server(boost::asio::io_service& io_service, short port)
+    : io_service_(io_service),
+      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
+  {
+    session_ptr new_session(new session(io_service_));
+    acceptor_.async_accept(new_session->socket(),
+        boost::bind(&server::handle_accept, this, new_session,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(session_ptr new_session, const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      new_session->start();
+      new_session.reset(new session(io_service_));
+      acceptor_.async_accept(new_session->socket(),
+          boost::bind(&server::handle_accept, this, new_session,
+            boost::asio::placeholders::error));
+    }
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  tcp::acceptor acceptor_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: reference_counted <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server s(io_service, atoi(argv[1]));
+
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/chat/Jamfile b/example/chat/Jamfile
new file mode 100644
index 0000000000..0cc5bf7802
--- /dev/null
+++ b/example/chat/Jamfile
@@ -0,0 +1,38 @@
+subproject libs/asio/example/chat ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe chat_client
+  : <lib>@boost/libs/thread/build/boost_thread
+    chat_client.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe chat_server
+  : <lib>@boost/libs/thread/build/boost_thread
+    chat_server.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/chat/chat_client.cpp b/example/chat/chat_client.cpp
new file mode 100644
index 0000000000..57876fba70
--- /dev/null
+++ b/example/chat/chat_client.cpp
@@ -0,0 +1,181 @@
+#include <cstdlib>
+#include <deque>
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include "chat_message.hpp"
+
+using boost::asio::ip::tcp;
+
+typedef std::deque<chat_message> chat_message_queue;
+
+class chat_client
+{
+public:
+  chat_client(boost::asio::io_service& io_service,
+      tcp::resolver::iterator endpoint_iterator)
+    : io_service_(io_service),
+      socket_(io_service)
+  {
+    tcp::endpoint endpoint = *endpoint_iterator;
+    socket_.async_connect(endpoint,
+        boost::bind(&chat_client::handle_connect, this,
+          boost::asio::placeholders::error, ++endpoint_iterator));
+  }
+
+  void write(const chat_message& msg)
+  {
+    io_service_.post(boost::bind(&chat_client::do_write, this, msg));
+  }
+
+  void close()
+  {
+    io_service_.post(boost::bind(&chat_client::do_close, this));
+  }
+
+private:
+
+  void handle_connect(const boost::asio::error& error,
+      tcp::resolver::iterator endpoint_iterator)
+  {
+    if (!error)
+    {
+      boost::asio::async_read(socket_,
+          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
+          boost::bind(&chat_client::handle_read_header, this,
+            boost::asio::placeholders::error));
+    }
+    else if (endpoint_iterator != tcp::resolver::iterator())
+    {
+      socket_.close();
+      tcp::endpoint endpoint = *endpoint_iterator;
+      socket_.async_connect(endpoint,
+          boost::bind(&chat_client::handle_connect, this,
+            boost::asio::placeholders::error, ++endpoint_iterator));
+    }
+  }
+
+  void handle_read_header(const boost::asio::error& error)
+  {
+    if (!error && read_msg_.decode_header())
+    {
+      boost::asio::async_read(socket_,
+          boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
+          boost::bind(&chat_client::handle_read_body, this,
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      do_close();
+    }
+  }
+
+  void handle_read_body(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      std::cout.write(read_msg_.body(), read_msg_.body_length());
+      std::cout << "\n";
+      boost::asio::async_read(socket_,
+          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
+          boost::bind(&chat_client::handle_read_header, this,
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      do_close();
+    }
+  }
+
+  void do_write(chat_message msg)
+  {
+    bool write_in_progress = !write_msgs_.empty();
+    write_msgs_.push_back(msg);
+    if (!write_in_progress)
+    {
+      boost::asio::async_write(socket_,
+          boost::asio::buffer(write_msgs_.front().data(),
+            write_msgs_.front().length()),
+          boost::bind(&chat_client::handle_write, this,
+            boost::asio::placeholders::error));
+    }
+  }
+
+  void handle_write(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      write_msgs_.pop_front();
+      if (!write_msgs_.empty())
+      {
+        boost::asio::async_write(socket_,
+            boost::asio::buffer(write_msgs_.front().data(),
+              write_msgs_.front().length()),
+            boost::bind(&chat_client::handle_write, this,
+              boost::asio::placeholders::error));
+      }
+    }
+    else
+    {
+      do_close();
+    }
+  }
+
+  void do_close()
+  {
+    socket_.close();
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  tcp::socket socket_;
+  chat_message read_msg_;
+  chat_message_queue write_msgs_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 3)
+    {
+      std::cerr << "Usage: chat_client <host> <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    tcp::resolver resolver(io_service);
+    tcp::resolver::query query(argv[1], argv[2]);
+    tcp::resolver::iterator iterator = resolver.resolve(query);
+
+    chat_client c(io_service, iterator);
+
+    boost::thread t(boost::bind(&boost::asio::io_service::run, &io_service));
+
+    char line[chat_message::max_body_length + 1];
+    while (std::cin.getline(line, chat_message::max_body_length + 1))
+    {
+      using namespace std; // For strlen and memcpy.
+      chat_message msg;
+      msg.body_length(strlen(line));
+      memcpy(msg.body(), line, msg.body_length());
+      msg.encode_header();
+      c.write(msg);
+    }
+
+    c.close();
+    t.join();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/chat/chat_message.hpp b/example/chat/chat_message.hpp
new file mode 100644
index 0000000000..156765275b
--- /dev/null
+++ b/example/chat/chat_message.hpp
@@ -0,0 +1,83 @@
+#ifndef CHAT_MESSAGE_HPP
+#define CHAT_MESSAGE_HPP
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+class chat_message
+{
+public:
+  enum { header_length = 4 };
+  enum { max_body_length = 512 };
+
+  chat_message()
+    : body_length_(0)
+  {
+  }
+
+  const char* data() const
+  {
+    return data_;
+  }
+
+  char* data()
+  {
+    return data_;
+  }
+
+  size_t length() const
+  {
+    return header_length + body_length_;
+  }
+
+  const char* body() const
+  {
+    return data_ + header_length;
+  }
+
+  char* body()
+  {
+    return data_ + header_length;
+  }
+
+  size_t body_length() const
+  {
+    return body_length_;
+  }
+
+  void body_length(size_t length)
+  {
+    body_length_ = length;
+    if (body_length_ > max_body_length)
+      body_length_ = max_body_length;
+  }
+
+  bool decode_header()
+  {
+    using namespace std; // For strncat and atoi.
+    char header[header_length + 1] = "";
+    strncat(header, data_, header_length);
+    body_length_ = atoi(header);
+    if (body_length_ > max_body_length)
+    {
+      body_length_ = 0;
+      return false;
+    }
+    return true;
+  }
+
+  void encode_header()
+  {
+    using namespace std; // For sprintf and memcpy.
+    char header[header_length + 1] = "";
+    sprintf(header, "%4d", body_length_);
+    memcpy(data_, header, header_length);
+  }
+
+private:
+  char data_[header_length + max_body_length];
+  size_t body_length_;
+};
+
+#endif // CHAT_MESSAGE_HPP
diff --git a/example/chat/chat_server.cpp b/example/chat/chat_server.cpp
new file mode 100644
index 0000000000..dafb733afc
--- /dev/null
+++ b/example/chat/chat_server.cpp
@@ -0,0 +1,237 @@
+#include <algorithm>
+#include <cstdlib>
+#include <deque>
+#include <iostream>
+#include <list>
+#include <set>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/asio.hpp>
+#include "chat_message.hpp"
+
+using boost::asio::ip::tcp;
+
+//----------------------------------------------------------------------
+
+typedef std::deque<chat_message> chat_message_queue;
+
+//----------------------------------------------------------------------
+
+class chat_participant
+{
+public:
+  virtual ~chat_participant() {}
+  virtual void deliver(const chat_message& msg) = 0;
+};
+
+typedef boost::shared_ptr<chat_participant> chat_participant_ptr;
+
+//----------------------------------------------------------------------
+
+class chat_room
+{
+public:
+  void join(chat_participant_ptr participant)
+  {
+    participants_.insert(participant);
+    std::for_each(recent_msgs_.begin(), recent_msgs_.end(),
+        boost::bind(&chat_participant::deliver, participant, _1));
+  }
+
+  void leave(chat_participant_ptr participant)
+  {
+    participants_.erase(participant);
+  }
+
+  void deliver(const chat_message& msg)
+  {
+    recent_msgs_.push_back(msg);
+    while (recent_msgs_.size() > max_recent_msgs)
+      recent_msgs_.pop_front();
+
+    std::for_each(participants_.begin(), participants_.end(),
+        boost::bind(&chat_participant::deliver, _1, boost::ref(msg)));
+  }
+
+private:
+  std::set<chat_participant_ptr> participants_;
+  enum { max_recent_msgs = 100 };
+  chat_message_queue recent_msgs_;
+};
+
+//----------------------------------------------------------------------
+
+class chat_session
+  : public chat_participant,
+    public boost::enable_shared_from_this<chat_session>
+{
+public:
+  chat_session(boost::asio::io_service& io_service, chat_room& room)
+    : socket_(io_service),
+      room_(room)
+  {
+  }
+
+  tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  void start()
+  {
+    room_.join(shared_from_this());
+    boost::asio::async_read(socket_,
+        boost::asio::buffer(read_msg_.data(), chat_message::header_length),
+        boost::bind(
+          &chat_session::handle_read_header, shared_from_this(),
+          boost::asio::placeholders::error));
+  }
+
+  void deliver(const chat_message& msg)
+  {
+    bool write_in_progress = !write_msgs_.empty();
+    write_msgs_.push_back(msg);
+    if (!write_in_progress)
+    {
+      boost::asio::async_write(socket_,
+          boost::asio::buffer(write_msgs_.front().data(),
+            write_msgs_.front().length()),
+          boost::bind(&chat_session::handle_write, shared_from_this(),
+            boost::asio::placeholders::error));
+    }
+  }
+
+  void handle_read_header(const boost::asio::error& error)
+  {
+    if (!error && read_msg_.decode_header())
+    {
+      boost::asio::async_read(socket_,
+          boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
+          boost::bind(&chat_session::handle_read_body, shared_from_this(),
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      room_.leave(shared_from_this());
+    }
+  }
+
+  void handle_read_body(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      room_.deliver(read_msg_);
+      boost::asio::async_read(socket_,
+          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
+          boost::bind(&chat_session::handle_read_header, shared_from_this(),
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      room_.leave(shared_from_this());
+    }
+  }
+
+  void handle_write(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      write_msgs_.pop_front();
+      if (!write_msgs_.empty())
+      {
+        boost::asio::async_write(socket_,
+            boost::asio::buffer(write_msgs_.front().data(),
+              write_msgs_.front().length()),
+            boost::bind(&chat_session::handle_write, shared_from_this(),
+              boost::asio::placeholders::error));
+      }
+    }
+    else
+    {
+      room_.leave(shared_from_this());
+    }
+  }
+
+private:
+  tcp::socket socket_;
+  chat_room& room_;
+  chat_message read_msg_;
+  chat_message_queue write_msgs_;
+};
+
+typedef boost::shared_ptr<chat_session> chat_session_ptr;
+
+//----------------------------------------------------------------------
+
+class chat_server
+{
+public:
+  chat_server(boost::asio::io_service& io_service,
+      const tcp::endpoint& endpoint)
+    : io_service_(io_service),
+      acceptor_(io_service, endpoint)
+  {
+    chat_session_ptr new_session(new chat_session(io_service_, room_));
+    acceptor_.async_accept(new_session->socket(),
+        boost::bind(&chat_server::handle_accept, this, new_session,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(chat_session_ptr session, const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      session->start();
+      chat_session_ptr new_session(new chat_session(io_service_, room_));
+      acceptor_.async_accept(new_session->socket(),
+          boost::bind(&chat_server::handle_accept, this, new_session,
+            boost::asio::placeholders::error));
+    }
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  tcp::acceptor acceptor_;
+  chat_room room_;
+};
+
+typedef boost::shared_ptr<chat_server> chat_server_ptr;
+typedef std::list<chat_server_ptr> chat_server_list;
+
+//----------------------------------------------------------------------
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc < 2)
+    {
+      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    chat_server_list servers;
+    for (int i = 1; i < argc; ++i)
+    {
+      using namespace std; // For atoi.
+      tcp::endpoint endpoint(tcp::v4(), atoi(argv[i]));
+      chat_server_ptr server(new chat_server(io_service, endpoint));
+      servers.push_back(server);
+    }
+
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/echo/Jamfile b/example/echo/Jamfile
new file mode 100644
index 0000000000..54a561f1eb
--- /dev/null
+++ b/example/echo/Jamfile
@@ -0,0 +1,55 @@
+subproject libs/asio/example/echo ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+template asio_echo_example
+  : <lib>@boost/libs/thread/build/boost_thread
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe async_tcp_echo_server
+  : <template>asio_echo_example
+    async_tcp_echo_server.cpp
+  ;
+
+exe async_udp_echo_server
+  : <template>asio_echo_example
+    async_udp_echo_server.cpp
+  ;
+
+exe blocking_tcp_echo_client
+  : <template>asio_echo_example
+    blocking_tcp_echo_client.cpp
+  ;
+
+exe blocking_tcp_echo_server
+  : <template>asio_echo_example
+    blocking_tcp_echo_server.cpp
+  ;
+
+exe blocking_udp_echo_client
+  : <template>asio_echo_example
+    blocking_udp_echo_client.cpp
+  ;
+
+exe blocking_udp_echo_server
+  : <template>asio_echo_example
+    blocking_udp_echo_server.cpp
+  ;
diff --git a/example/echo/async_tcp_echo_server.cpp b/example/echo/async_tcp_echo_server.cpp
new file mode 100644
index 0000000000..9547f429fb
--- /dev/null
+++ b/example/echo/async_tcp_echo_server.cpp
@@ -0,0 +1,126 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+class session
+{
+public:
+  session(boost::asio::io_service& io_service)
+    : socket_(io_service)
+  {
+  }
+
+  tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  void start()
+  {
+    socket_.async_read_some(boost::asio::buffer(data_, max_length),
+        boost::bind(&session::handle_read, this,
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+  }
+
+  void handle_read(const boost::asio::error& error, size_t bytes_transferred)
+  {
+    if (!error)
+    {
+      boost::asio::async_write(socket_,
+          boost::asio::buffer(data_, bytes_transferred),
+          boost::bind(&session::handle_write, this,
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      delete this;
+    }
+  }
+
+  void handle_write(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      socket_.async_read_some(boost::asio::buffer(data_, max_length),
+          boost::bind(&session::handle_read, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+    else
+    {
+      delete this;
+    }
+  }
+
+private:
+  tcp::socket socket_;
+  enum { max_length = 1024 };
+  char data_[max_length];
+};
+
+class server
+{
+public:
+  server(boost::asio::io_service& io_service, short port)
+    : io_service_(io_service),
+      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
+  {
+    session* new_session = new session(io_service_);
+    acceptor_.async_accept(new_session->socket(),
+        boost::bind(&server::handle_accept, this, new_session,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(session* new_session, const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      new_session->start();
+      new_session = new session(io_service_);
+      acceptor_.async_accept(new_session->socket(),
+          boost::bind(&server::handle_accept, this, new_session,
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      delete new_session;
+    }
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  tcp::acceptor acceptor_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: async_tcp_echo_server <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server s(io_service, atoi(argv[1]));
+
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/echo/async_udp_echo_server.cpp b/example/echo/async_udp_echo_server.cpp
new file mode 100644
index 0000000000..25ba06842b
--- /dev/null
+++ b/example/echo/async_udp_echo_server.cpp
@@ -0,0 +1,86 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::udp;
+
+class server
+{
+public:
+  server(boost::asio::io_service& io_service, short port)
+    : io_service_(io_service),
+      socket_(io_service, udp::endpoint(udp::v4(), port))
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(data_, max_length), sender_endpoint_,
+        boost::bind(&server::handle_receive_from, this,
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+  }
+
+  void handle_receive_from(const boost::asio::error& error, size_t bytes_recvd)
+  {
+    if (!error && bytes_recvd > 0)
+    {
+      socket_.async_send_to(
+          boost::asio::buffer(data_, bytes_recvd), sender_endpoint_,
+          boost::bind(&server::handle_send_to, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+    else
+    {
+      socket_.async_receive_from(
+          boost::asio::buffer(data_, max_length), sender_endpoint_,
+          boost::bind(&server::handle_receive_from, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+  }
+
+  void handle_send_to(const boost::asio::error& error, size_t bytes_sent)
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(data_, max_length), sender_endpoint_,
+        boost::bind(&server::handle_receive_from, this,
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  udp::socket socket_;
+  udp::endpoint sender_endpoint_;
+  enum { max_length = 1024 };
+  char data_[max_length];
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: async_udp_echo_server <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server s(io_service, atoi(argv[1]));
+
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/echo/blocking_tcp_echo_client.cpp b/example/echo/blocking_tcp_echo_client.cpp
new file mode 100644
index 0000000000..a46317a1e0
--- /dev/null
+++ b/example/echo/blocking_tcp_echo_client.cpp
@@ -0,0 +1,53 @@
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+enum { max_length = 1024 };
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 3)
+    {
+      std::cerr << "Usage: blocking_tcp_echo_client <host> <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    tcp::resolver resolver(io_service);
+    tcp::resolver::query query(tcp::v4(), argv[1], argv[2]);
+    tcp::resolver::iterator iterator = resolver.resolve(query);
+
+    tcp::socket s(io_service);
+    s.connect(*iterator);
+
+    using namespace std; // For strlen.
+    std::cout << "Enter message: ";
+    char request[max_length];
+    std::cin.getline(request, max_length);
+    size_t request_length = strlen(request);
+    boost::asio::write(s, boost::asio::buffer(request, request_length));
+
+    char reply[max_length];
+    size_t reply_length = boost::asio::read(s,
+        boost::asio::buffer(reply, request_length));
+    std::cout << "Reply is: ";
+    std::cout.write(reply, reply_length);
+    std::cout << "\n";
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/echo/blocking_tcp_echo_server.cpp b/example/echo/blocking_tcp_echo_server.cpp
new file mode 100644
index 0000000000..dbe9929fb2
--- /dev/null
+++ b/example/echo/blocking_tcp_echo_server.cpp
@@ -0,0 +1,79 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/smart_ptr.hpp>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+
+using boost::asio::ip::tcp;
+
+const int max_length = 1024;
+
+typedef boost::shared_ptr<tcp::socket> socket_ptr;
+
+void session(socket_ptr sock)
+{
+  try
+  {
+    for (;;)
+    {
+      char data[max_length];
+
+      boost::asio::error error;
+      size_t length = sock->read_some(
+          boost::asio::buffer(data), boost::asio::assign_error(error));
+      if (error == boost::asio::error::eof)
+        break; // Connection closed cleanly by peer.
+      else if (error)
+        throw error; // Some other error.
+
+      boost::asio::write(*sock, boost::asio::buffer(data, length));
+    }
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "Error in thread: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception in thread: " << e.what() << "\n";
+  }
+}
+
+void server(boost::asio::io_service& io_service, short port)
+{
+  tcp::acceptor a(io_service, tcp::endpoint(tcp::v4(), port));
+  for (;;)
+  {
+    socket_ptr sock(new tcp::socket(io_service));
+    a.accept(*sock);
+    boost::thread t(boost::bind(session, sock));
+  }
+}
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: blocking_tcp_echo_server <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server(io_service, atoi(argv[1]));
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/echo/blocking_udp_echo_client.cpp b/example/echo/blocking_udp_echo_client.cpp
new file mode 100644
index 0000000000..4d8f29458f
--- /dev/null
+++ b/example/echo/blocking_udp_echo_client.cpp
@@ -0,0 +1,53 @@
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::udp;
+
+enum { max_length = 1024 };
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 3)
+    {
+      std::cerr << "Usage: blocking_udp_echo_client <host> <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    udp::socket s(io_service, udp::endpoint(udp::v4(), 0));
+
+    udp::resolver resolver(io_service);
+    udp::resolver::query query(udp::v4(), argv[1], argv[2]);
+    udp::resolver::iterator iterator = resolver.resolve(query);
+
+    using namespace std; // For strlen.
+    std::cout << "Enter message: ";
+    char request[max_length];
+    std::cin.getline(request, max_length);
+    size_t request_length = strlen(request);
+    s.send_to(boost::asio::buffer(request, request_length), *iterator);
+
+    char reply[max_length];
+    udp::endpoint sender_endpoint;
+    size_t reply_length = s.receive_from(
+        boost::asio::buffer(reply, max_length), sender_endpoint);
+    std::cout << "Reply is: ";
+    std::cout.write(reply, reply_length);
+    std::cout << "\n";
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/echo/blocking_udp_echo_server.cpp b/example/echo/blocking_udp_echo_server.cpp
new file mode 100644
index 0000000000..067a87fed6
--- /dev/null
+++ b/example/echo/blocking_udp_echo_server.cpp
@@ -0,0 +1,47 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::udp;
+
+enum { max_length = 1024 };
+
+void server(boost::asio::io_service& io_service, short port)
+{
+  udp::socket sock(io_service, udp::endpoint(udp::v4(), port));
+  for (;;)
+  {
+    char data[max_length];
+    udp::endpoint sender_endpoint;
+    size_t length = sock.receive_from(
+        boost::asio::buffer(data, max_length), sender_endpoint);
+    sock.send_to(boost::asio::buffer(data, length), sender_endpoint);
+  }
+}
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: blocking_udp_echo_server <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server(io_service, atoi(argv[1]));
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/http/server/Jamfile b/example/http/server/Jamfile
new file mode 100644
index 0000000000..a9bbcbf620
--- /dev/null
+++ b/example/http/server/Jamfile
@@ -0,0 +1,34 @@
+subproject libs/asio/example/http/server ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe http_server
+  : <lib>@boost/libs/thread/build/boost_thread
+    connection.cpp
+    connection_manager.cpp
+    mime_types.cpp
+    posix_main.cpp
+    reply.cpp
+    request_handler.cpp
+    request_parser.cpp
+    server.cpp
+    win_main.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/http/server/connection.cpp b/example/http/server/connection.cpp
new file mode 100644
index 0000000000..f6cad9e944
--- /dev/null
+++ b/example/http/server/connection.cpp
@@ -0,0 +1,82 @@
+#include "connection.hpp"
+#include <vector>
+#include <boost/bind.hpp>
+#include "connection_manager.hpp"
+#include "request_handler.hpp"
+
+namespace http {
+namespace server {
+
+connection::connection(boost::asio::io_service& io_service,
+    connection_manager& manager, request_handler& handler)
+  : socket_(io_service),
+    connection_manager_(manager),
+    request_handler_(handler)
+{
+}
+
+boost::asio::ip::tcp::socket& connection::socket()
+{
+  return socket_;
+}
+
+void connection::start()
+{
+  socket_.async_read_some(boost::asio::buffer(buffer_),
+      boost::bind(&connection::handle_read, shared_from_this(),
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred));
+}
+
+void connection::stop()
+{
+  socket_.close();
+}
+
+void connection::handle_read(const boost::asio::error& e,
+    std::size_t bytes_transferred)
+{
+  if (!e)
+  {
+    boost::tribool result;
+    boost::tie(result, boost::tuples::ignore) = request_parser_.parse(
+        request_, buffer_.data(), buffer_.data() + bytes_transferred);
+
+    if (result)
+    {
+      request_handler_.handle_request(request_, reply_);
+      boost::asio::async_write(socket_, reply_.to_buffers(),
+          boost::bind(&connection::handle_write, shared_from_this(),
+            boost::asio::placeholders::error));
+    }
+    else if (!result)
+    {
+      reply_ = reply::stock_reply(reply::bad_request);
+      boost::asio::async_write(socket_, reply_.to_buffers(),
+          boost::bind(&connection::handle_write, shared_from_this(),
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      socket_.async_read_some(boost::asio::buffer(buffer_),
+          boost::bind(&connection::handle_read, shared_from_this(),
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+  }
+  else if (e != boost::asio::error::operation_aborted)
+  {
+    connection_manager_.stop(shared_from_this());
+  }
+}
+
+void connection::handle_write(const boost::asio::error& e)
+{
+  if (e != boost::asio::error::operation_aborted)
+  {
+    connection_manager_.stop(shared_from_this());
+  }
+}
+
+} // namespace server
+} // namespace http
diff --git a/example/http/server/connection.hpp b/example/http/server/connection.hpp
new file mode 100644
index 0000000000..09abf8457e
--- /dev/null
+++ b/example/http/server/connection.hpp
@@ -0,0 +1,72 @@
+#ifndef HTTP_CONNECTION_HPP
+#define HTTP_CONNECTION_HPP
+
+#include <boost/asio.hpp>
+#include <boost/array.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include "reply.hpp"
+#include "request.hpp"
+#include "request_handler.hpp"
+#include "request_parser.hpp"
+
+namespace http {
+namespace server {
+
+class connection_manager;
+
+/// Represents a single connection from a client.
+class connection
+  : public boost::enable_shared_from_this<connection>,
+    private boost::noncopyable
+{
+public:
+  /// Construct a connection with the given io_service.
+  explicit connection(boost::asio::io_service& io_service,
+      connection_manager& manager, request_handler& handler);
+
+  /// Get the socket associated with the connection.
+  boost::asio::ip::tcp::socket& socket();
+
+  /// Start the first asynchronous operation for the connection.
+  void start();
+
+  /// Stop all asynchronous operations associated with the connection.
+  void stop();
+
+private:
+  /// Handle completion of a read operation.
+  void handle_read(const boost::asio::error& e, std::size_t bytes_transferred);
+
+  /// Handle completion of a write operation.
+  void handle_write(const boost::asio::error& e);
+
+  /// Socket for the connection.
+  boost::asio::ip::tcp::socket socket_;
+
+  /// The manager for this connection.
+  connection_manager& connection_manager_;
+
+  /// The handler used to process the incoming request.
+  request_handler& request_handler_;
+
+  /// Buffer for incoming data.
+  boost::array<char, 8192> buffer_;
+
+  /// The incoming request.
+  request request_;
+
+  /// The parser for the incoming request.
+  request_parser request_parser_;
+
+  /// The reply to be sent back to the client.
+  reply reply_;
+};
+
+typedef boost::shared_ptr<connection> connection_ptr;
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_CONNECTION_HPP
diff --git a/example/http/server/connection_manager.cpp b/example/http/server/connection_manager.cpp
new file mode 100644
index 0000000000..5ecbe8960a
--- /dev/null
+++ b/example/http/server/connection_manager.cpp
@@ -0,0 +1,28 @@
+#include "connection_manager.hpp"
+#include <algorithm>
+#include <boost/bind.hpp>
+
+namespace http {
+namespace server {
+
+void connection_manager::start(connection_ptr c)
+{
+  connections_.insert(c);
+  c->start();
+}
+
+void connection_manager::stop(connection_ptr c)
+{
+  connections_.erase(c);
+  c->stop();
+}
+
+void connection_manager::stop_all()
+{
+  std::for_each(connections_.begin(), connections_.end(),
+      boost::bind(&connection::stop, _1));
+  connections_.clear();
+}
+
+} // namespace server
+} // namespace http
diff --git a/example/http/server/connection_manager.hpp b/example/http/server/connection_manager.hpp
new file mode 100644
index 0000000000..471b08e49b
--- /dev/null
+++ b/example/http/server/connection_manager.hpp
@@ -0,0 +1,34 @@
+#ifndef HTTP_CONNECTION_MANAGER_HPP
+#define HTTP_CONNECTION_MANAGER_HPP
+
+#include <set>
+#include <boost/noncopyable.hpp>
+#include "connection.hpp"
+
+namespace http {
+namespace server {
+
+/// Manages open connections so that they may be cleanly stopped when the server
+/// needs to shut down.
+class connection_manager
+  : private boost::noncopyable
+{
+public:
+  /// Add the specified connection to the manager and start it.
+  void start(connection_ptr c);
+
+  /// Stop the specified connection.
+  void stop(connection_ptr c);
+
+  /// Stop all connections.
+  void stop_all();
+
+private:
+  /// The managed connections.
+  std::set<connection_ptr> connections_;
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_CONNECTION_MANAGER_HPP
diff --git a/example/http/server/header.hpp b/example/http/server/header.hpp
new file mode 100644
index 0000000000..690a9c90a0
--- /dev/null
+++ b/example/http/server/header.hpp
@@ -0,0 +1,18 @@
+#ifndef HTTP_HEADER_HPP
+#define HTTP_HEADER_HPP
+
+#include <string>
+
+namespace http {
+namespace server {
+
+struct header
+{
+  std::string name;
+  std::string value;
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_HEADER_HPP
diff --git a/example/http/server/mime_types.cpp b/example/http/server/mime_types.cpp
new file mode 100644
index 0000000000..9a928c7b61
--- /dev/null
+++ b/example/http/server/mime_types.cpp
@@ -0,0 +1,36 @@
+#include "mime_types.hpp"
+
+namespace http {
+namespace server {
+namespace mime_types {
+
+struct mapping
+{
+  const char* extension;
+  const char* mime_type;
+} mappings[] =
+{
+  { "gif", "image/gif" },
+  { "htm", "text/html" },
+  { "html", "text/html" },
+  { "jpg", "image/jpeg" },
+  { "png", "image/png" },
+  { 0, 0 } // Marks end of list.
+};
+
+std::string extension_to_type(const std::string& extension)
+{
+  for (mapping* m = mappings; m->extension; ++m)
+  {
+    if (m->extension == extension)
+    {
+      return m->mime_type;
+    }
+  }
+
+  return "text/plain";
+}
+
+} // namespace mime_types
+} // namespace server
+} // namespace http
diff --git a/example/http/server/mime_types.hpp b/example/http/server/mime_types.hpp
new file mode 100644
index 0000000000..f5156a1635
--- /dev/null
+++ b/example/http/server/mime_types.hpp
@@ -0,0 +1,17 @@
+#ifndef HTTP_MIME_TYPES_HPP
+#define HTTP_MIME_TYPES_HPP
+
+#include <string>
+
+namespace http {
+namespace server {
+namespace mime_types {
+
+/// Convert a file extension into a MIME type.
+std::string extension_to_type(const std::string& extension);
+
+} // namespace mime_types
+} // namespace server
+} // namespace http
+
+#endif // HTTP_MIME_TYPES_HPP
diff --git a/example/http/server/posix_main.cpp b/example/http/server/posix_main.cpp
new file mode 100644
index 0000000000..c96aa856c8
--- /dev/null
+++ b/example/http/server/posix_main.cpp
@@ -0,0 +1,67 @@
+#include <iostream>
+#include <string>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+#include "server.hpp"
+
+#if !defined(_WIN32)
+
+#include <pthread.h>
+#include <signal.h>
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    // Check command line arguments.
+    if (argc != 4)
+    {
+      std::cerr << "Usage: http_server <address> <port> <doc_root>\n";
+      std::cerr << "  For IPv4, try:\n";
+      std::cerr << "    receiver 0.0.0.0 80 .\n";
+      std::cerr << "  For IPv6, try:\n";
+      std::cerr << "    receiver 0::0 80 .\n";
+      return 1;
+    }
+
+    // Block all signals for background thread.
+    sigset_t new_mask;
+    sigfillset(&new_mask);
+    sigset_t old_mask;
+    pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask);
+
+    // Run server in background thread.
+    http::server::server s(argv[1], argv[2], argv[3]);
+    boost::thread t(boost::bind(&http::server::server::run, &s));
+
+    // Restore previous signals.
+    pthread_sigmask(SIG_SETMASK, &old_mask, 0);
+
+    // Wait for signal indicating time to shut down.
+    sigset_t wait_mask;
+    sigemptyset(&wait_mask);
+    sigaddset(&wait_mask, SIGINT);
+    sigaddset(&wait_mask, SIGQUIT);
+    sigaddset(&wait_mask, SIGTERM);
+    pthread_sigmask(SIG_BLOCK, &wait_mask, 0);
+    int sig = 0;
+    sigwait(&wait_mask, &sig);
+
+    // Stop the server.
+    s.stop();
+    t.join();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "asio error: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
+
+#endif // !defined(_WIN32)
diff --git a/example/http/server/reply.cpp b/example/http/server/reply.cpp
new file mode 100644
index 0000000000..4314b413b9
--- /dev/null
+++ b/example/http/server/reply.cpp
@@ -0,0 +1,246 @@
+#include "reply.hpp"
+#include <string>
+#include <boost/lexical_cast.hpp>
+
+namespace http {
+namespace server {
+
+namespace status_strings {
+
+const std::string ok =
+  "HTTP/1.0 200 OK\r\n";
+const std::string created =
+  "HTTP/1.0 201 Created\r\n";
+const std::string accepted =
+  "HTTP/1.0 202 Accepted\r\n";
+const std::string no_content =
+  "HTTP/1.0 204 No Content\r\n";
+const std::string multiple_choices =
+  "HTTP/1.0 300 Multiple Choices\r\n";
+const std::string moved_permanently =
+  "HTTP/1.0 301 Moved Permanently\r\n";
+const std::string moved_temporarily =
+  "HTTP/1.0 302 Moved Temporarily\r\n";
+const std::string not_modified =
+  "HTTP/1.0 304 Not Modified\r\n";
+const std::string bad_request =
+  "HTTP/1.0 400 Bad Request\r\n";
+const std::string unauthorized =
+  "HTTP/1.0 401 Unauthorized\r\n";
+const std::string forbidden =
+  "HTTP/1.0 403 Forbidden\r\n";
+const std::string not_found =
+  "HTTP/1.0 404 Not Found\r\n";
+const std::string internal_server_error =
+  "HTTP/1.0 500 Internal Server Error\r\n";
+const std::string not_implemented =
+  "HTTP/1.0 501 Not Implemented\r\n";
+const std::string bad_gateway =
+  "HTTP/1.0 502 Bad Gateway\r\n";
+const std::string service_unavailable =
+  "HTTP/1.0 503 Service Unavailable\r\n";
+
+boost::asio::const_buffer to_buffer(reply::status_type status)
+{
+  switch (status)
+  {
+  case reply::ok:
+    return boost::asio::buffer(ok);
+  case reply::created:
+    return boost::asio::buffer(created);
+  case reply::accepted:
+    return boost::asio::buffer(accepted);
+  case reply::no_content:
+    return boost::asio::buffer(no_content);
+  case reply::multiple_choices:
+    return boost::asio::buffer(multiple_choices);
+  case reply::moved_permanently:
+    return boost::asio::buffer(moved_permanently);
+  case reply::moved_temporarily:
+    return boost::asio::buffer(moved_temporarily);
+  case reply::not_modified:
+    return boost::asio::buffer(not_modified);
+  case reply::bad_request:
+    return boost::asio::buffer(bad_request);
+  case reply::unauthorized:
+    return boost::asio::buffer(unauthorized);
+  case reply::forbidden:
+    return boost::asio::buffer(forbidden);
+  case reply::not_found:
+    return boost::asio::buffer(not_found);
+  case reply::internal_server_error:
+    return boost::asio::buffer(internal_server_error);
+  case reply::not_implemented:
+    return boost::asio::buffer(not_implemented);
+  case reply::bad_gateway:
+    return boost::asio::buffer(bad_gateway);
+  case reply::service_unavailable:
+    return boost::asio::buffer(service_unavailable);
+  default:
+    return boost::asio::buffer(internal_server_error);
+  }
+}
+
+} // namespace status_strings
+
+namespace misc_strings {
+
+const char name_value_separator[] = { ':', ' ' };
+const char crlf[] = { '\r', '\n' };
+
+} // namespace misc_strings
+
+std::vector<boost::asio::const_buffer> reply::to_buffers()
+{
+  std::vector<boost::asio::const_buffer> buffers;
+  buffers.push_back(status_strings::to_buffer(status));
+  for (std::size_t i = 0; i < headers.size(); ++i)
+  {
+    header& h = headers[i];
+    buffers.push_back(boost::asio::buffer(h.name));
+    buffers.push_back(boost::asio::buffer(misc_strings::name_value_separator));
+    buffers.push_back(boost::asio::buffer(h.value));
+    buffers.push_back(boost::asio::buffer(misc_strings::crlf));
+  }
+  buffers.push_back(boost::asio::buffer(misc_strings::crlf));
+  buffers.push_back(boost::asio::buffer(content));
+  return buffers;
+}
+
+namespace stock_replies {
+
+const char ok[] = "";
+const char created[] =
+  "<html>"
+  "<head><title>Created</title></head>"
+  "<body><h1>201 Created</h1></body>"
+  "</html>";
+const char accepted[] =
+  "<html>"
+  "<head><title>Accepted</title></head>"
+  "<body><h1>202 Accepted</h1></body>"
+  "</html>";
+const char no_content[] =
+  "<html>"
+  "<head><title>No Content</title></head>"
+  "<body><h1>204 Content</h1></body>"
+  "</html>";
+const char multiple_choices[] =
+  "<html>"
+  "<head><title>Multiple Choices</title></head>"
+  "<body><h1>300 Multiple Choices</h1></body>"
+  "</html>";
+const char moved_permanently[] =
+  "<html>"
+  "<head><title>Moved Permanently</title></head>"
+  "<body><h1>301 Moved Permanently</h1></body>"
+  "</html>";
+const char moved_temporarily[] =
+  "<html>"
+  "<head><title>Moved Temporarily</title></head>"
+  "<body><h1>302 Moved Temporarily</h1></body>"
+  "</html>";
+const char not_modified[] =
+  "<html>"
+  "<head><title>Not Modified</title></head>"
+  "<body><h1>304 Not Modified</h1></body>"
+  "</html>";
+const char bad_request[] =
+  "<html>"
+  "<head><title>Bad Request</title></head>"
+  "<body><h1>400 Bad Request</h1></body>"
+  "</html>";
+const char unauthorized[] =
+  "<html>"
+  "<head><title>Unauthorized</title></head>"
+  "<body><h1>401 Unauthorized</h1></body>"
+  "</html>";
+const char forbidden[] =
+  "<html>"
+  "<head><title>Forbidden</title></head>"
+  "<body><h1>403 Forbidden</h1></body>"
+  "</html>";
+const char not_found[] =
+  "<html>"
+  "<head><title>Not Found</title></head>"
+  "<body><h1>404 Not Found</h1></body>"
+  "</html>";
+const char internal_server_error[] =
+  "<html>"
+  "<head><title>Internal Server Error</title></head>"
+  "<body><h1>500 Internal Server Error</h1></body>"
+  "</html>";
+const char not_implemented[] =
+  "<html>"
+  "<head><title>Not Implemented</title></head>"
+  "<body><h1>501 Not Implemented</h1></body>"
+  "</html>";
+const char bad_gateway[] =
+  "<html>"
+  "<head><title>Bad Gateway</title></head>"
+  "<body><h1>502 Bad Gateway</h1></body>"
+  "</html>";
+const char service_unavailable[] =
+  "<html>"
+  "<head><title>Service Unavailable</title></head>"
+  "<body><h1>503 Service Unavailable</h1></body>"
+  "</html>";
+
+std::string to_string(reply::status_type status)
+{
+  switch (status)
+  {
+  case reply::ok:
+    return ok;
+  case reply::created:
+    return created;
+  case reply::accepted:
+    return accepted;
+  case reply::no_content:
+    return no_content;
+  case reply::multiple_choices:
+    return multiple_choices;
+  case reply::moved_permanently:
+    return moved_permanently;
+  case reply::moved_temporarily:
+    return moved_temporarily;
+  case reply::not_modified:
+    return not_modified;
+  case reply::bad_request:
+    return bad_request;
+  case reply::unauthorized:
+    return unauthorized;
+  case reply::forbidden:
+    return forbidden;
+  case reply::not_found:
+    return not_found;
+  case reply::internal_server_error:
+    return internal_server_error;
+  case reply::not_implemented:
+    return not_implemented;
+  case reply::bad_gateway:
+    return bad_gateway;
+  case reply::service_unavailable:
+    return service_unavailable;
+  default:
+    return internal_server_error;
+  }
+}
+
+} // namespace stock_replies
+
+reply reply::stock_reply(reply::status_type status)
+{
+  reply rep;
+  rep.status = status;
+  rep.content = stock_replies::to_string(status);
+  rep.headers.resize(2);
+  rep.headers[0].name = "Content-Length";
+  rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
+  rep.headers[1].name = "Content-Type";
+  rep.headers[1].value = "text/html";
+  return rep;
+}
+
+} // namespace server
+} // namespace http
diff --git a/example/http/server/reply.hpp b/example/http/server/reply.hpp
new file mode 100644
index 0000000000..178b0895f9
--- /dev/null
+++ b/example/http/server/reply.hpp
@@ -0,0 +1,54 @@
+#ifndef HTTP_REPLY_HPP
+#define HTTP_REPLY_HPP
+
+#include <string>
+#include <vector>
+#include <boost/asio.hpp>
+#include "header.hpp"
+
+namespace http {
+namespace server {
+
+/// A reply to be sent to a client.
+struct reply
+{
+  /// The status of the reply.
+  enum status_type
+  {
+    ok = 200,
+    created = 201,
+    accepted = 202,
+    no_content = 204,
+    multiple_choices = 300,
+    moved_permanently = 301,
+    moved_temporarily = 302,
+    not_modified = 304,
+    bad_request = 400,
+    unauthorized = 401,
+    forbidden = 403,
+    not_found = 404,
+    internal_server_error = 500,
+    not_implemented = 501,
+    bad_gateway = 502,
+    service_unavailable = 503
+  } status;
+
+  /// The headers to be included in the reply.
+  std::vector<header> headers;
+
+  /// The content to be sent in the reply.
+  std::string content;
+
+  /// Convert the reply into a vector of buffers. The buffers do not own the
+  /// underlying memory blocks, therefore the reply object must remain valid and
+  /// not be changed until the write operation has completed.
+  std::vector<boost::asio::const_buffer> to_buffers();
+
+  /// Get a stock reply.
+  static reply stock_reply(status_type status);
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_REPLY_HPP
diff --git a/example/http/server/request.hpp b/example/http/server/request.hpp
new file mode 100644
index 0000000000..efe5ab2aa8
--- /dev/null
+++ b/example/http/server/request.hpp
@@ -0,0 +1,24 @@
+#ifndef HTTP_REQUEST_HPP
+#define HTTP_REQUEST_HPP
+
+#include <string>
+#include <vector>
+#include "header.hpp"
+
+namespace http {
+namespace server {
+
+/// A request received from a client.
+struct request
+{
+  std::string method;
+  std::string uri;
+  int http_version_major;
+  int http_version_minor;
+  std::vector<header> headers;
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_REQUEST_HPP
diff --git a/example/http/server/request_handler.cpp b/example/http/server/request_handler.cpp
new file mode 100644
index 0000000000..028b5d5e34
--- /dev/null
+++ b/example/http/server/request_handler.cpp
@@ -0,0 +1,107 @@
+#include "request_handler.hpp"
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <boost/lexical_cast.hpp>
+#include "mime_types.hpp"
+#include "reply.hpp"
+#include "request.hpp"
+
+namespace http {
+namespace server {
+
+request_handler::request_handler(const std::string& doc_root)
+  : doc_root_(doc_root)
+{
+}
+
+void request_handler::handle_request(const request& req, reply& rep)
+{
+  // Decode url to path.
+  std::string request_path;
+  if (!url_decode(req.uri, request_path))
+  {
+    rep = reply::stock_reply(reply::bad_request);
+    return;
+  }
+
+  // Request path must be absolute and not contain "..".
+  if (request_path.empty() || request_path[0] != '/'
+      || request_path.find("..") != std::string::npos)
+  {
+    rep = reply::stock_reply(reply::bad_request);
+    return;
+  }
+
+  // If path ends in slash (i.e. is a directory) then add "index.html".
+  if (request_path[request_path.size() - 1] == '/')
+  {
+    request_path += "index.html";
+  }
+
+  // Determine the file extension.
+  std::size_t last_slash_pos = request_path.find_last_of("/");
+  std::size_t last_dot_pos = request_path.find_last_of(".");
+  std::string extension;
+  if (last_dot_pos != std::string::npos && last_dot_pos > last_slash_pos)
+  {
+    extension = request_path.substr(last_dot_pos + 1);
+  }
+
+  // Open the file to send back.
+  std::string full_path = doc_root_ + "/" + request_path;
+  std::ifstream is(full_path.c_str(), std::ios::in | std::ios::binary);
+  if (!is)
+  {
+    rep = reply::stock_reply(reply::not_found);
+    return;
+  }
+
+  // Fill out the reply to be sent to the client.
+  rep.status = reply::ok;
+  char buf[512];
+  while (is.read(buf, sizeof(buf)).gcount() > 0)
+    rep.content.append(buf, is.gcount());
+  rep.headers.resize(2);
+  rep.headers[0].name = "Content-Length";
+  rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
+  rep.headers[1].name = "Content-Type";
+  rep.headers[1].value = mime_types::extension_to_type(extension);
+}
+
+bool request_handler::url_decode(const std::string& in, std::string& out)
+{
+  out.clear();
+  out.reserve(in.size());
+  for (std::size_t i = 0; i < in.size(); ++i)
+  {
+    if (in[i] == '%')
+    {
+      if (i + 3 < in.size())
+      {
+        int value;
+        std::istringstream is(in.substr(i + 1, 2));
+        if (is >> std::hex >> value)
+        {
+          out += static_cast<char>(value);
+        }
+        else
+        {
+          return false;
+        }
+      }
+      else
+      {
+        return false;
+      }
+    }
+    else
+    {
+      out += in[i];
+    }
+  }
+  return true;
+}
+
+} // namespace server
+} // namespace http
diff --git a/example/http/server/request_handler.hpp b/example/http/server/request_handler.hpp
new file mode 100644
index 0000000000..9743bdf97a
--- /dev/null
+++ b/example/http/server/request_handler.hpp
@@ -0,0 +1,36 @@
+#ifndef HTTP_REQUEST_HANDLER_HPP
+#define HTTP_REQUEST_HANDLER_HPP
+
+#include <string>
+#include <boost/noncopyable.hpp>
+
+namespace http {
+namespace server {
+
+struct reply;
+struct request;
+
+/// The common handler for all incoming requests.
+class request_handler
+  : private boost::noncopyable
+{
+public:
+  /// Construct with a directory containing files to be served.
+  explicit request_handler(const std::string& doc_root);
+
+  /// Handle a request and produce a reply.
+  void handle_request(const request& req, reply& rep);
+
+private:
+  /// The directory containing the files to be served.
+  std::string doc_root_;
+
+  /// Perform URL-decoding on a string. Returns false if the encoding was
+  /// invalid.
+  static bool url_decode(const std::string& in, std::string& out);
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_REQUEST_HANDLER_HPP
diff --git a/example/http/server/request_parser.cpp b/example/http/server/request_parser.cpp
new file mode 100644
index 0000000000..1c86b53339
--- /dev/null
+++ b/example/http/server/request_parser.cpp
@@ -0,0 +1,316 @@
+#include "request_parser.hpp"
+#include "request.hpp"
+
+namespace http {
+namespace server {
+
+request_parser::request_parser()
+  : state_(method_start)
+{
+}
+
+void request_parser::reset()
+{
+  state_ = method_start;
+}
+
+boost::tribool request_parser::consume(request& req, char input)
+{
+  switch (state_)
+  {
+  case method_start:
+    if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      state_ = method;
+      req.method.push_back(input);
+      return boost::indeterminate;
+    }
+  case method:
+    if (input == ' ')
+    {
+      state_ = uri;
+      return boost::indeterminate;
+    }
+    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.method.push_back(input);
+      return boost::indeterminate;
+    }
+  case uri_start:
+    if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      state_ = uri;
+      req.uri.push_back(input);
+      return boost::indeterminate;
+    }
+  case uri:
+    if (input == ' ')
+    {
+      state_ = http_version_h;
+      return boost::indeterminate;
+    }
+    else if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.uri.push_back(input);
+      return boost::indeterminate;
+    }
+  case http_version_h:
+    if (input == 'H')
+    {
+      state_ = http_version_t_1;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_t_1:
+    if (input == 'T')
+    {
+      state_ = http_version_t_2;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_t_2:
+    if (input == 'T')
+    {
+      state_ = http_version_p;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_p:
+    if (input == 'P')
+    {
+      state_ = http_version_slash;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_slash:
+    if (input == '/')
+    {
+      req.http_version_major = 0;
+      req.http_version_minor = 0;
+      state_ = http_version_major_start;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_major_start:
+    if (is_digit(input))
+    {
+      req.http_version_major = req.http_version_major * 10 + input - '0';
+      state_ = http_version_major;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_major:
+    if (input == '.')
+    {
+      state_ = http_version_minor_start;
+      return boost::indeterminate;
+    }
+    else if (is_digit(input))
+    {
+      req.http_version_major = req.http_version_major * 10 + input - '0';
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_minor_start:
+    if (is_digit(input))
+    {
+      req.http_version_minor = req.http_version_minor * 10 + input - '0';
+      state_ = http_version_minor;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case http_version_minor:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_1;
+      return boost::indeterminate;
+    }
+    else if (is_digit(input))
+    {
+      req.http_version_minor = req.http_version_minor * 10 + input - '0';
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case expecting_newline_1:
+    if (input == '\n')
+    {
+      state_ = header_line_start;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case header_line_start:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_3;
+      return boost::indeterminate;
+    }
+    else if (!req.headers.empty() && (input == ' ' || input == '\t'))
+    {
+      state_ = header_lws;
+      return boost::indeterminate;
+    }
+    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.headers.push_back(header());
+      req.headers.back().name.push_back(input);
+      state_ = header_name;
+      return boost::indeterminate;
+    }
+  case header_lws:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_2;
+      return boost::indeterminate;
+    }
+    else if (input == ' ' || input == '\t')
+    {
+      return boost::indeterminate;
+    }
+    else if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      state_ = header_value;
+      req.headers.back().value.push_back(input);
+      return boost::indeterminate;
+    }
+  case header_name:
+    if (input == ':')
+    {
+      state_ = space_before_header_value;
+      return boost::indeterminate;
+    }
+    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.headers.back().name.push_back(input);
+      return boost::indeterminate;
+    }
+  case space_before_header_value:
+    if (input == ' ')
+    {
+      state_ = header_value;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case header_value:
+    if (input == '\r')
+    {
+      state_ = expecting_newline_2;
+      return boost::indeterminate;
+    }
+    else if (is_ctl(input))
+    {
+      return false;
+    }
+    else
+    {
+      req.headers.back().value.push_back(input);
+      return boost::indeterminate;
+    }
+  case expecting_newline_2:
+    if (input == '\n')
+    {
+      state_ = header_line_start;
+      return boost::indeterminate;
+    }
+    else
+    {
+      return false;
+    }
+  case expecting_newline_3:
+    return (input == '\n');
+  default:
+    return false;
+  }
+}
+
+bool request_parser::is_char(int c)
+{
+  return c >= 0 && c <= 127;
+}
+
+bool request_parser::is_ctl(int c)
+{
+  return c >= 0 && c <= 31 || c == 127;
+}
+
+bool request_parser::is_tspecial(int c)
+{
+  switch (c)
+  {
+  case '(': case ')': case '<': case '>': case '@':
+  case ',': case ';': case ':': case '\\': case '"':
+  case '/': case '[': case ']': case '?': case '=':
+  case '{': case '}': case ' ': case '\t':
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool request_parser::is_digit(int c)
+{
+  return c >= '0' && c <= '9';
+}
+
+} // namespace server
+} // namespace http
diff --git a/example/http/server/request_parser.hpp b/example/http/server/request_parser.hpp
new file mode 100644
index 0000000000..4f4baa9b14
--- /dev/null
+++ b/example/http/server/request_parser.hpp
@@ -0,0 +1,86 @@
+#ifndef HTTP_REQUEST_PARSER_HPP
+#define HTTP_REQUEST_PARSER_HPP
+
+#include <boost/logic/tribool.hpp>
+#include <boost/tuple/tuple.hpp>
+
+namespace http {
+namespace server {
+
+struct request;
+
+/// Parser for incoming requests.
+class request_parser
+{
+public:
+  /// Construct ready to parse the request method.
+  request_parser();
+
+  /// Reset to initial parser state.
+  void reset();
+
+  /// Parse some data. The tribool return value is true when a complete request
+  /// has been parsed, false if the data is invalid, indeterminate when more
+  /// data is required. The InputIterator return value indicates how much of the
+  /// input has been consumed.
+  template <typename InputIterator>
+  boost::tuple<boost::tribool, InputIterator> parse(request& req,
+      InputIterator begin, InputIterator end)
+  {
+    while (begin != end)
+    {
+      boost::tribool result = consume(req, *begin++);
+      if (result || !result)
+        return boost::make_tuple(result, begin);
+    }
+    boost::tribool result = boost::indeterminate;
+    return boost::make_tuple(result, begin);
+  }
+
+private:
+  /// Handle the next character of input.
+  boost::tribool consume(request& req, char input);
+
+  /// Check if a byte is an HTTP character.
+  static bool is_char(int c);
+
+  /// Check if a byte is an HTTP control character.
+  static bool is_ctl(int c);
+
+  /// Check if a byte is defined as an HTTP tspecial character.
+  static bool is_tspecial(int c);
+
+  /// Check if a byte is a digit.
+  static bool is_digit(int c);
+
+  /// The current state of the parser.
+  enum state
+  {
+    method_start,
+    method,
+    uri_start,
+    uri,
+    http_version_h,
+    http_version_t_1,
+    http_version_t_2,
+    http_version_p,
+    http_version_slash,
+    http_version_major_start,
+    http_version_major,
+    http_version_minor_start,
+    http_version_minor,
+    expecting_newline_1,
+    header_line_start,
+    header_lws,
+    header_name,
+    space_before_header_value,
+    header_value,
+    expecting_newline_2,
+    expecting_newline_3
+  } state_;
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_REQUEST_PARSER_HPP
diff --git a/example/http/server/server.cpp b/example/http/server/server.cpp
new file mode 100644
index 0000000000..4b86547277
--- /dev/null
+++ b/example/http/server/server.cpp
@@ -0,0 +1,68 @@
+#include "server.hpp"
+#include <boost/bind.hpp>
+
+namespace http {
+namespace server {
+
+server::server(const std::string& address, const std::string& port,
+    const std::string& doc_root)
+  : io_service_(),
+    acceptor_(io_service_),
+    connection_manager_(),
+    new_connection_(new connection(io_service_,
+          connection_manager_, request_handler_)),
+    request_handler_(doc_root)
+{
+  // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
+  boost::asio::ip::tcp::resolver resolver(io_service_);
+  boost::asio::ip::tcp::resolver::query query(address, port);
+  boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
+  acceptor_.open(endpoint.protocol());
+  acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+  acceptor_.bind(endpoint);
+  acceptor_.listen();
+  acceptor_.async_accept(new_connection_->socket(),
+      boost::bind(&server::handle_accept, this,
+        boost::asio::placeholders::error));
+}
+
+void server::run()
+{
+  // The io_service::run() call will block until all asynchronous operations
+  // have finished. While the server is running, there is always at least one
+  // asynchronous operation outstanding: the asynchronous accept call waiting
+  // for new incoming connections.
+  io_service_.run();
+}
+
+void server::stop()
+{
+  // Post a call to the stop function so that server::stop() is safe to call
+  // from any thread.
+  io_service_.post(boost::bind(&server::handle_stop, this));
+}
+
+void server::handle_accept(const boost::asio::error& e)
+{
+  if (!e)
+  {
+    connection_manager_.start(new_connection_);
+    new_connection_.reset(new connection(io_service_,
+          connection_manager_, request_handler_));
+    acceptor_.async_accept(new_connection_->socket(),
+        boost::bind(&server::handle_accept, this,
+          boost::asio::placeholders::error));
+  }
+}
+
+void server::handle_stop()
+{
+  // The server is stopped by cancelling all outstanding asynchronous
+  // operations. Once all operations have finished the io_service::run() call
+  // will exit.
+  acceptor_.close();
+  connection_manager_.stop_all();
+}
+
+} // namespace server
+} // namespace http
diff --git a/example/http/server/server.hpp b/example/http/server/server.hpp
new file mode 100644
index 0000000000..76464dec64
--- /dev/null
+++ b/example/http/server/server.hpp
@@ -0,0 +1,56 @@
+#ifndef HTTP_SERVER_HPP
+#define HTTP_SERVER_HPP
+
+#include <boost/asio.hpp>
+#include <string>
+#include <boost/noncopyable.hpp>
+#include "connection.hpp"
+#include "connection_manager.hpp"
+#include "request_handler.hpp"
+
+namespace http {
+namespace server {
+
+/// The top-level class of the HTTP server.
+class server
+  : private boost::noncopyable
+{
+public:
+  /// Construct the server to listen on the specified TCP address and port, and
+  /// serve up files from the given directory.
+  explicit server(const std::string& address, const std::string& port,
+      const std::string& doc_root);
+
+  /// Run the server's io_service loop.
+  void run();
+
+  /// Stop the server.
+  void stop();
+
+private:
+  /// Handle completion of an asynchronous accept operation.
+  void handle_accept(const boost::asio::error& e);
+
+  /// Handle a request to stop the server.
+  void handle_stop();
+
+  /// The io_service used to perform asynchronous operations.
+  boost::asio::io_service io_service_;
+
+  /// Acceptor used to listen for incoming connections.
+  boost::asio::ip::tcp::acceptor acceptor_;
+
+  /// The connection manager which owns all live connections.
+  connection_manager connection_manager_;
+
+  /// The next connection to be accepted.
+  connection_ptr new_connection_;
+
+  /// The handler for all incoming requests.
+  request_handler request_handler_;
+};
+
+} // namespace server
+} // namespace http
+
+#endif // HTTP_SERVER_HPP
diff --git a/example/http/server/win_main.cpp b/example/http/server/win_main.cpp
new file mode 100644
index 0000000000..017125bb7f
--- /dev/null
+++ b/example/http/server/win_main.cpp
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <string>
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include "server.hpp"
+
+#if defined(_WIN32)
+
+boost::function0<void> console_ctrl_function;
+
+BOOL WINAPI console_ctrl_handler(DWORD ctrl_type)
+{
+  switch (ctrl_type)
+  {
+  case CTRL_C_EVENT:
+  case CTRL_BREAK_EVENT:
+  case CTRL_CLOSE_EVENT:
+  case CTRL_SHUTDOWN_EVENT:
+    console_ctrl_function();
+    return TRUE;
+  default:
+    return FALSE;
+  }
+}
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    // Check command line arguments.
+    if (argc != 4)
+    {
+      std::cerr << "Usage: http_server <address> <port> <doc_root>\n";
+      std::cerr << "  For IPv4, try:\n";
+      std::cerr << "    receiver 0.0.0.0 80 .\n";
+      std::cerr << "  For IPv6, try:\n";
+      std::cerr << "    receiver 0::0 80 .\n";
+      return 1;
+    }
+
+    // Initialise server.
+    http::server::server s(argv[1], argv[2], argv[3]);
+
+    // Set console control handler to allow server to be stopped.
+    console_ctrl_function = boost::bind(&http::server::server::stop, &s);
+    SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
+
+    // Run the server until stopped.
+    s.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "asio error: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
+
+#endif // defined(_WIN32)
diff --git a/example/iostreams/Jamfile b/example/iostreams/Jamfile
new file mode 100644
index 0000000000..26fffb2de8
--- /dev/null
+++ b/example/iostreams/Jamfile
@@ -0,0 +1,36 @@
+subproject libs/asio/example/iostreams ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe daytime_client
+  : daytime_client.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe daytime_server
+  : daytime_server.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/iostreams/daytime_client.cpp b/example/iostreams/daytime_client.cpp
new file mode 100644
index 0000000000..e58077e56f
--- /dev/null
+++ b/example/iostreams/daytime_client.cpp
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <string>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: daytime_client <host>" << std::endl;
+      return 1;
+    }
+
+    tcp::iostream s(argv[1], "daytime");
+    std::string line;
+    std::getline(s, line);
+    std::cout << line << std::endl;
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cout << e << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/iostreams/daytime_server.cpp b/example/iostreams/daytime_server.cpp
new file mode 100644
index 0000000000..899ebabc07
--- /dev/null
+++ b/example/iostreams/daytime_server.cpp
@@ -0,0 +1,37 @@
+#include <ctime>
+#include <iostream>
+#include <string>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+std::string make_daytime_string()
+{
+  using namespace std; // For time_t, time and ctime;
+  time_t now = time(0);
+  return ctime(&now);
+}
+
+int main()
+{
+  try
+  {
+    boost::asio::io_service io_service;
+
+    tcp::endpoint endpoint(tcp::v4(), 13);
+    tcp::acceptor acceptor(io_service, endpoint);
+
+    for (;;)
+    {
+      tcp::iostream stream;
+      acceptor.accept(*stream.rdbuf());
+      stream << make_daytime_string();
+    }
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/multicast/Jamfile b/example/multicast/Jamfile
new file mode 100644
index 0000000000..349458d5fe
--- /dev/null
+++ b/example/multicast/Jamfile
@@ -0,0 +1,36 @@
+subproject libs/asio/example/multicast ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe receiver
+  : receiver.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe sender
+  : sender.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/multicast/receiver.cpp b/example/multicast/receiver.cpp
new file mode 100644
index 0000000000..6a27491001
--- /dev/null
+++ b/example/multicast/receiver.cpp
@@ -0,0 +1,82 @@
+#include <iostream>
+#include <string>
+#include <boost/asio.hpp>
+#include "boost/bind.hpp"
+
+const short multicast_port = 30001;
+
+class receiver
+{
+public:
+  receiver(boost::asio::io_service& io_service,
+      const boost::asio::ip::address& listen_address,
+      const boost::asio::ip::address& multicast_address)
+    : socket_(io_service)
+  {
+    // Create the socket so that multiple may be bound to the same address.
+    boost::asio::ip::udp::endpoint listen_endpoint(
+        listen_address, multicast_port);
+    socket_.open(listen_endpoint.protocol());
+    socket_.set_option(boost::asio::ip::udp::socket::reuse_address(true));
+    socket_.bind(listen_endpoint);
+
+    // Join the multicast group.
+    socket_.set_option(
+        boost::asio::ip::multicast::join_group(multicast_address));
+
+    socket_.async_receive_from(
+        boost::asio::buffer(data_, max_length), sender_endpoint_,
+        boost::bind(&receiver::handle_receive_from, this,
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+  }
+
+  void handle_receive_from(const boost::asio::error& error, size_t bytes_recvd)
+  {
+    if (!error)
+    {
+      std::cout.write(data_, bytes_recvd);
+      std::cout << std::endl;
+
+      socket_.async_receive_from(
+          boost::asio::buffer(data_, max_length), sender_endpoint_,
+          boost::bind(&receiver::handle_receive_from, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+  }
+
+private:
+  boost::asio::ip::udp::socket socket_;
+  boost::asio::ip::udp::endpoint sender_endpoint_;
+  enum { max_length = 1024 };
+  char data_[max_length];
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 3)
+    {
+      std::cerr << "Usage: receiver <listen_address> <multicast_address>\n";
+      std::cerr << "  For IPv4, try:\n";
+      std::cerr << "    receiver 0.0.0.0 239.255.0.1\n";
+      std::cerr << "  For IPv6, try:\n";
+      std::cerr << "    receiver 0::0 ff31::8000:1234\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+    receiver r(io_service,
+        boost::asio::ip::address::from_string(argv[1]),
+        boost::asio::ip::address::from_string(argv[2]));
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/multicast/sender.cpp b/example/multicast/sender.cpp
new file mode 100644
index 0000000000..92a3cfaccf
--- /dev/null
+++ b/example/multicast/sender.cpp
@@ -0,0 +1,93 @@
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <boost/asio.hpp>
+#include "boost/bind.hpp"
+#include "boost/date_time/posix_time/posix_time_types.hpp"
+
+const short multicast_port = 30001;
+const int max_message_count = 10;
+
+class sender
+{
+public:
+  sender(boost::asio::io_service& io_service,
+      const boost::asio::ip::address& multicast_address)
+    : endpoint_(multicast_address, multicast_port),
+      socket_(io_service, endpoint_.protocol()),
+      timer_(io_service),
+      message_count_(0)
+  {
+    std::ostringstream os;
+    os << "Message " << message_count_++;
+    message_ = os.str();
+
+    socket_.async_send_to(
+        boost::asio::buffer(message_), endpoint_,
+        boost::bind(&sender::handle_send_to, this,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_send_to(const boost::asio::error& error)
+  {
+    if (!error && message_count_ < max_message_count)
+    {
+      timer_.expires_from_now(boost::posix_time::seconds(1));
+      timer_.async_wait(
+          boost::bind(&sender::handle_timeout, this,
+            boost::asio::placeholders::error));
+    }
+  }
+
+  void handle_timeout(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      std::ostringstream os;
+      os << "Message " << message_count_++;
+      message_ = os.str();
+
+      socket_.async_send_to(
+          boost::asio::buffer(message_), endpoint_,
+          boost::bind(&sender::handle_send_to, this,
+            boost::asio::placeholders::error));
+    }
+  }
+
+private:
+  boost::asio::ip::udp::endpoint endpoint_;
+  boost::asio::ip::udp::socket socket_;
+  boost::asio::deadline_timer timer_;
+  int message_count_;
+  std::string message_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: sender <multicast_address>\n";
+      std::cerr << "  For IPv4, try:\n";
+      std::cerr << "    sender 239.255.0.1\n";
+      std::cerr << "  For IPv6, try:\n";
+      std::cerr << "    sender ff31::8000:1234\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+    sender s(io_service, boost::asio::ip::address::from_string(argv[1]));
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/serialization/Jamfile b/example/serialization/Jamfile
new file mode 100644
index 0000000000..a5d740e9e5
--- /dev/null
+++ b/example/serialization/Jamfile
@@ -0,0 +1,38 @@
+subproject libs/asio/example/serialization ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe client
+  : <lib>@boost/libs/serialization/build/boost_serialization
+    client.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe server
+  : <lib>@boost/libs/serialization/build/boost_serialization
+    server.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/serialization/client.cpp b/example/serialization/client.cpp
new file mode 100644
index 0000000000..3948c134d6
--- /dev/null
+++ b/example/serialization/client.cpp
@@ -0,0 +1,126 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <iostream>
+#include <vector>
+#include "connection.hpp" // Must come before boost/serialization headers.
+#include <boost/serialization/vector.hpp>
+#include "stock.hpp"
+
+namespace s11n_example {
+
+/// Downloads stock quote information from a server.
+class client
+{
+public:
+  /// Constructor starts the asynchronous connect operation.
+  client(boost::asio::io_service& io_service,
+      const std::string& host, const std::string& service)
+    : connection_(io_service)
+  {
+    // Resolve the host name into an IP address.
+    boost::asio::ip::tcp::resolver resolver(io_service);
+    boost::asio::ip::tcp::resolver::query query(host, service);
+    boost::asio::ip::tcp::resolver::iterator endpoint_iterator =
+      resolver.resolve(query);
+    boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
+
+    // Start an asynchronous connect operation.
+    connection_.socket().async_connect(endpoint,
+        boost::bind(&client::handle_connect, this,
+          boost::asio::placeholders::error, ++endpoint_iterator));
+  }
+
+  /// Handle completion of a connect operation.
+  void handle_connect(const boost::asio::error& e,
+      boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
+  {
+    if (!e)
+    {
+      // Successfully established connection. Start operation to read the list
+      // of stocks. The connection::async_read() function will automatically
+      // decode the data that is read from the underlying socket.
+      connection_.async_read(stocks_,
+          boost::bind(&client::handle_read, this,
+            boost::asio::placeholders::error));
+    }
+    else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
+    {
+      // Try the next endpoint.
+      connection_.socket().close();
+      boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
+      connection_.socket().async_connect(endpoint,
+          boost::bind(&client::handle_connect, this,
+            boost::asio::placeholders::error, ++endpoint_iterator));
+    }
+    else
+    {
+      // An error occurred. Log it and return. Since we are not starting a new
+      // operation the io_service will run out of work to do and the client will
+      // exit.
+      std::cerr << e << std::endl;
+    }
+  }
+
+  /// Handle completion of a read operation.
+  void handle_read(const boost::asio::error& e)
+  {
+    if (!e)
+    {
+      // Print out the data that was received.
+      for (std::size_t i = 0; i < stocks_.size(); ++i)
+      {
+        std::cout << "Stock number " << i << "\n";
+        std::cout << "  code: " << stocks_[i].code << "\n";
+        std::cout << "  name: " << stocks_[i].name << "\n";
+        std::cout << "  open_price: " << stocks_[i].open_price << "\n";
+        std::cout << "  high_price: " << stocks_[i].high_price << "\n";
+        std::cout << "  low_price: " << stocks_[i].low_price << "\n";
+        std::cout << "  last_price: " << stocks_[i].last_price << "\n";
+        std::cout << "  buy_price: " << stocks_[i].buy_price << "\n";
+        std::cout << "  buy_quantity: " << stocks_[i].buy_quantity << "\n";
+        std::cout << "  sell_price: " << stocks_[i].sell_price << "\n";
+        std::cout << "  sell_quantity: " << stocks_[i].sell_quantity << "\n";
+      }
+    }
+    else
+    {
+      // An error occurred.
+      std::cerr << e << std::endl;
+    }
+
+    // Since we are not starting a new operation the io_service will run out of
+    // work to do and the client will exit.
+  }
+
+private:
+  /// The connection to the server.
+  connection connection_;
+
+  /// The data received from the server.
+  std::vector<stock> stocks_;
+};
+
+} // namespace s11n_example
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    // Check command line arguments.
+    if (argc != 3)
+    {
+      std::cerr << "Usage: client <host> <port>" << std::endl;
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+    s11n_example::client client(io_service, argv[1], argv[2]);
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/serialization/connection.hpp b/example/serialization/connection.hpp
new file mode 100644
index 0000000000..2a1bbe35ac
--- /dev/null
+++ b/example/serialization/connection.hpp
@@ -0,0 +1,174 @@
+#ifndef SERIALIZATION_CONNECTION_HPP
+#define SERIALIZATION_CONNECTION_HPP
+
+#include <boost/asio.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <iomanip>
+#include <string>
+#include <sstream>
+#include <vector>
+
+namespace s11n_example {
+
+/// The connection class provides serialization primitives on top of a socket.
+/**
+ * Each message sent using this class consists of:
+ * @li An 8-byte header containing the length of the serialized data in
+ * hexadecimal.
+ * @li The serialized data.
+ */
+class connection
+{
+public:
+  /// Constructor.
+  connection(boost::asio::io_service& io_service)
+    : socket_(io_service)
+  {
+  }
+
+  /// Get the underlying socket. Used for making a connection or for accepting
+  /// an incoming connection.
+  boost::asio::ip::tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  /// Asynchronously write a data structure to the socket.
+  template <typename T, typename Handler>
+  void async_write(const T& t, Handler handler)
+  {
+    // Serialize the data first so we know how large it is.
+    std::ostringstream archive_stream;
+    boost::archive::text_oarchive archive(archive_stream);
+    archive << t;
+    outbound_data_ = archive_stream.str();
+
+    // Format the header.
+    std::ostringstream header_stream;
+    header_stream << std::setw(header_length)
+      << std::hex << outbound_data_.size();
+    if (!header_stream || header_stream.str().size() != header_length)
+    {
+      // Something went wrong, inform the caller.
+      boost::asio::error error(boost::asio::error::invalid_argument);
+      socket_.io_service().post(boost::bind(handler, error));
+      return;
+    }
+    outbound_header_ = header_stream.str();
+
+    // Write the serialized data to the socket. We use "gather-write" to send
+    // both the header and the data in a single write operation.
+    std::vector<boost::asio::const_buffer> buffers;
+    buffers.push_back(boost::asio::buffer(outbound_header_));
+    buffers.push_back(boost::asio::buffer(outbound_data_));
+    boost::asio::async_write(socket_, buffers, handler);
+  }
+
+  /// Asynchronously read a data structure from the socket.
+  template <typename T, typename Handler>
+  void async_read(T& t, Handler handler)
+  {
+    // Issue a read operation to read exactly the number of bytes in a header.
+    void (connection::*f)(const boost::asio::error&, T&, boost::tuple<Handler>)
+      = &connection::handle_read_header<T, Handler>;
+    boost::asio::async_read(socket_, boost::asio::buffer(inbound_header_),
+        boost::bind(f,
+          this, boost::asio::placeholders::error, boost::ref(t),
+          boost::make_tuple(handler)));
+  }
+
+  /// Handle a completed read of a message header. The handler is passed using
+  /// a tuple since boost::bind seems to have trouble binding a function object
+  /// created using boost::bind as a parameter.
+  template <typename T, typename Handler>
+  void handle_read_header(const boost::asio::error& e, T& t,
+      boost::tuple<Handler> handler)
+  {
+    if (e)
+    {
+      boost::get<0>(handler)(e);
+    }
+    else
+    {
+      // Determine the length of the serialized data.
+      std::istringstream is(std::string(inbound_header_, header_length));
+      std::size_t inbound_data_size = 0;
+      if (!(is >> std::hex >> inbound_data_size))
+      {
+        // Header doesn't seem to be valid. Inform the caller.
+        boost::asio::error error(boost::asio::error::invalid_argument);
+        boost::get<0>(handler)(error);
+        return;
+      }
+
+      // Start an asynchronous call to receive the data.
+      inbound_data_.resize(inbound_data_size);
+      void (connection::*f)(const boost::asio::error&, T&, boost::tuple<Handler>)
+        = &connection::handle_read_data<T, Handler>;
+      boost::asio::async_read(socket_, boost::asio::buffer(inbound_data_),
+        boost::bind(f, this,
+          boost::asio::placeholders::error, boost::ref(t), handler));
+    }
+  }
+
+  /// Handle a completed read of message data.
+  template <typename T, typename Handler>
+  void handle_read_data(const boost::asio::error& e, T& t,
+      boost::tuple<Handler> handler)
+  {
+    if (e)
+    {
+      boost::get<0>(handler)(e);
+    }
+    else
+    {
+      // Extract the data structure from the data just received.
+      try
+      {
+        std::string archive_data(&inbound_data_[0], inbound_data_.size());
+        std::istringstream archive_stream(archive_data);
+        boost::archive::text_iarchive archive(archive_stream);
+        archive >> t;
+      }
+      catch (std::exception& e)
+      {
+        // Unable to decode data.
+        boost::asio::error error(boost::asio::error::invalid_argument);
+        boost::get<0>(handler)(error);
+        return;
+      }
+
+      // Inform caller that data has been received ok.
+      boost::get<0>(handler)(e);
+    }
+  }
+
+private:
+  /// The underlying socket.
+  boost::asio::ip::tcp::socket socket_;
+
+  /// The size of a fixed length header.
+  enum { header_length = 8 };
+
+  /// Holds an outbound header.
+  std::string outbound_header_;
+
+  /// Holds the outbound data.
+  std::string outbound_data_;
+
+  /// Holds an inbound header.
+  char inbound_header_[header_length];
+
+  /// Holds the inbound data.
+  std::vector<char> inbound_data_;
+};
+
+typedef boost::shared_ptr<connection> connection_ptr;
+
+} // namespace s11n_example
+
+#endif // SERIALIZATION_CONNECTION_HPP
diff --git a/example/serialization/server.cpp b/example/serialization/server.cpp
new file mode 100644
index 0000000000..968981b3da
--- /dev/null
+++ b/example/serialization/server.cpp
@@ -0,0 +1,120 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/lexical_cast.hpp>
+#include <iostream>
+#include <vector>
+#include "connection.hpp" // Must come before boost/serialization headers.
+#include <boost/serialization/vector.hpp>
+#include "stock.hpp"
+
+namespace s11n_example {
+
+/// Serves stock quote information to any client that connects to it.
+class server
+{
+public:
+  /// Constructor opens the acceptor and starts waiting for the first incoming
+  /// connection.
+  server(boost::asio::io_service& io_service, unsigned short port)
+    : acceptor_(io_service,
+        boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
+  {
+    // Create the data to be sent to each client.
+    stock s;
+    s.code = "ABC";
+    s.name = "A Big Company";
+    s.open_price = 4.56;
+    s.high_price = 5.12;
+    s.low_price = 4.33;
+    s.last_price = 4.98;
+    s.buy_price = 4.96;
+    s.buy_quantity = 1000;
+    s.sell_price = 4.99;
+    s.sell_quantity = 2000;
+    stocks_.push_back(s);
+    s.code = "DEF";
+    s.name = "Developer Entertainment Firm";
+    s.open_price = 20.24;
+    s.high_price = 22.88;
+    s.low_price = 19.50;
+    s.last_price = 19.76;
+    s.buy_price = 19.72;
+    s.buy_quantity = 34000;
+    s.sell_price = 19.85;
+    s.sell_quantity = 45000;
+    stocks_.push_back(s);
+
+    // Start an accept operation for a new connection.
+    connection_ptr new_conn(new connection(acceptor_.io_service()));
+    acceptor_.async_accept(new_conn->socket(),
+        boost::bind(&server::handle_accept, this,
+          boost::asio::placeholders::error, new_conn));
+  }
+
+  /// Handle completion of a accept operation.
+  void handle_accept(const boost::asio::error& e, connection_ptr conn)
+  {
+    if (!e)
+    {
+      // Successfully accepted a new connection. Send the list of stocks to the
+      // client. The connection::async_write() function will automatically
+      // serialize the data structure for us.
+      conn->async_write(stocks_,
+          boost::bind(&server::handle_write, this,
+            boost::asio::placeholders::error, conn));
+
+      // Start an accept operation for a new connection.
+      connection_ptr new_conn(new connection(acceptor_.io_service()));
+      acceptor_.async_accept(new_conn->socket(),
+          boost::bind(&server::handle_accept, this,
+            boost::asio::placeholders::error, new_conn));
+    }
+    else
+    {
+      // An error occurred. Log it and return. Since we are not starting a new
+      // accept operation the io_service will run out of work to do and the
+      // server will exit.
+      std::cerr << e << std::endl;
+    }
+  }
+
+  /// Handle completion of a write operation.
+  void handle_write(const boost::asio::error& e, connection_ptr conn)
+  {
+    // Nothing to do. The socket will be closed automatically when the last
+    // reference to the connection object goes away.
+  }
+
+private:
+  /// The acceptor object used to accept incoming socket connections.
+  boost::asio::ip::tcp::acceptor acceptor_;
+
+  /// The data to be sent to each client.
+  std::vector<stock> stocks_;
+};
+
+} // namespace s11n_example
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    // Check command line arguments.
+    if (argc != 2)
+    {
+      std::cerr << "Usage: server <port>" << std::endl;
+      return 1;
+    }
+    unsigned short port = boost::lexical_cast<unsigned short>(argv[1]);
+
+    boost::asio::io_service io_service;
+    s11n_example::server server(io_service, port);
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/serialization/stock.hpp b/example/serialization/stock.hpp
new file mode 100644
index 0000000000..77c3266667
--- /dev/null
+++ b/example/serialization/stock.hpp
@@ -0,0 +1,40 @@
+#ifndef SERIALIZATION_STOCK_HPP
+#define SERIALIZATION_STOCK_HPP
+
+#include <string>
+
+namespace s11n_example {
+
+/// Structure to hold information about a single stock.
+struct stock
+{
+  std::string code;
+  std::string name;
+  double open_price;
+  double high_price;
+  double low_price;
+  double last_price;
+  double buy_price;
+  int buy_quantity;
+  double sell_price;
+  int sell_quantity;
+
+  template <typename Archive>
+  void serialize(Archive& ar, const unsigned int version)
+  {
+    ar & code;
+    ar & name;
+    ar & open_price;
+    ar & high_price;
+    ar & low_price;
+    ar & last_price;
+    ar & buy_price;
+    ar & buy_quantity;
+    ar & sell_price;
+    ar & sell_quantity;
+  }
+};
+
+} // namespace s11n_example
+
+#endif // SERIALIZATION_STOCK_HPP
diff --git a/example/services/Jamfile b/example/services/Jamfile
new file mode 100644
index 0000000000..0bf65ee0fd
--- /dev/null
+++ b/example/services/Jamfile
@@ -0,0 +1,26 @@
+subproject libs/asio/example/services ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe daytime_client
+  : <lib>@boost/libs/thread/build/boost_thread
+    daytime_client.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/services/basic_logger.hpp b/example/services/basic_logger.hpp
new file mode 100644
index 0000000000..ada4da4f39
--- /dev/null
+++ b/example/services/basic_logger.hpp
@@ -0,0 +1,73 @@
+#ifndef SERVICES_BASIC_LOGGER_HPP
+#define SERVICES_BASIC_LOGGER_HPP
+
+#include <boost/asio.hpp>
+#include <boost/noncopyable.hpp>
+#include <string>
+
+namespace services {
+
+/// Class to provide simple logging functionality. Use the services::logger
+/// typedef.
+template <typename Service>
+class basic_logger
+  : private boost::noncopyable
+{
+public:
+  /// The type of the service that will be used to provide timer operations.
+  typedef Service service_type;
+
+  /// The native implementation type of the timer.
+  typedef typename service_type::impl_type impl_type;
+
+  /// Constructor.
+  /**
+   * This constructor creates a logger.
+   *
+   * @param io_service The io_service object used to locate the logger service.
+   *
+   * @param identifier An identifier for this logger.
+   */
+  explicit basic_logger(boost::asio::io_service& io_service,
+      const std::string& identifier)
+    : service_(boost::asio::use_service<Service>(io_service)),
+      impl_(service_.null())
+  {
+    service_.create(impl_, identifier);
+  }
+
+  /// Destructor.
+  ~basic_logger()
+  {
+    service_.destroy(impl_);
+  }
+
+  /// Get the io_service associated with the object.
+  boost::asio::io_service& io_service()
+  {
+    return service_.io_service();
+  }
+
+  /// Set the output file for all logger instances.
+  void use_file(const std::string& file)
+  {
+    service_.use_file(impl_, file);
+  }
+
+  /// Log a message.
+  void log(const std::string& message)
+  {
+    service_.log(impl_, message);
+  }
+
+private:
+  /// The backend service implementation.
+  service_type& service_;
+
+  /// The underlying native implementation.
+  impl_type impl_;
+};
+
+} // namespace services
+
+#endif // SERVICES_BASIC_LOGGER_HPP
diff --git a/example/services/daytime_client.cpp b/example/services/daytime_client.cpp
new file mode 100644
index 0000000000..bcda3893cf
--- /dev/null
+++ b/example/services/daytime_client.cpp
@@ -0,0 +1,85 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <iostream>
+#include "logger.hpp"
+#include "stream_socket_service.hpp"
+
+typedef boost::asio::basic_stream_socket<boost::asio::ip::tcp,
+    services::stream_socket_service<boost::asio::ip::tcp> > debug_stream_socket;
+
+char read_buffer[1024];
+
+void read_handler(const boost::asio::error& e,
+    std::size_t bytes_transferred, debug_stream_socket* s)
+{
+  if (!e)
+  {
+    std::cout.write(read_buffer, bytes_transferred);
+
+    s->async_read_some(boost::asio::buffer(read_buffer),
+        boost::bind(read_handler, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, s));
+  }
+}
+
+void connect_handler(const boost::asio::error& e, debug_stream_socket* s,
+    boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
+{
+  if (!e)
+  {
+    s->async_read_some(boost::asio::buffer(read_buffer),
+        boost::bind(read_handler, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, s));
+  }
+  else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
+  {
+    s->close();
+    boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
+    s->async_connect(endpoint,
+        boost::bind(connect_handler,
+          boost::asio::placeholders::error, s, ++endpoint_iterator));
+  }
+  else
+  {
+    std::cerr << e << std::endl;
+  }
+}
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: daytime_client <host>" << std::endl;
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    // Set the name of the file that all logger instances will use.
+    services::logger logger(io_service, "");
+    logger.use_file("log.txt");
+
+    // Resolve the address corresponding to the given host.
+    boost::asio::ip::tcp::resolver resolver(io_service);
+    boost::asio::ip::tcp::resolver::query query(argv[1], "daytime");
+    boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
+    boost::asio::ip::tcp::endpoint endpoint = *iterator;
+
+    // Start an asynchronous connect.
+    debug_stream_socket socket(io_service);
+    socket.async_connect(endpoint,
+        boost::bind(connect_handler,
+          boost::asio::placeholders::error, &socket, ++iterator));
+
+    // Run the io_service until all operations have finished.
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/services/logger.hpp b/example/services/logger.hpp
new file mode 100644
index 0000000000..203fa9bdc8
--- /dev/null
+++ b/example/services/logger.hpp
@@ -0,0 +1,14 @@
+#ifndef SERVICES_LOGGER_HPP
+#define SERVICES_LOGGER_HPP
+
+#include "basic_logger.hpp"
+#include "logger_service.hpp"
+
+namespace services {
+
+/// Typedef for typical logger usage.
+typedef basic_logger<logger_service> logger;
+
+} // namespace services
+
+#endif // SERVICES_LOGGER_HPP
diff --git a/example/services/logger_service.hpp b/example/services/logger_service.hpp
new file mode 100644
index 0000000000..2b7a99660a
--- /dev/null
+++ b/example/services/logger_service.hpp
@@ -0,0 +1,133 @@
+#ifndef SERVICES_LOGGER_SERVICE_HPP
+#define SERVICES_LOGGER_SERVICE_HPP
+
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+namespace services {
+
+/// Service implementation for the logger.
+class logger_service
+  : public boost::asio::io_service::service
+{
+public:
+  /// The backend implementation of a logger.
+  struct logger_impl
+  {
+    explicit logger_impl(const std::string& id) : identifier(id) {}
+    std::string identifier;
+  };
+
+  /// The type for an implementation of the logger.
+  typedef logger_impl* impl_type;
+
+  /// Constructor creates a thread to run a private io_service.
+  logger_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      work_io_service_(),
+      work_(new boost::asio::io_service::work(work_io_service_)),
+      work_thread_(new boost::thread(
+            boost::bind(&boost::asio::io_service::run, &work_io_service_)))
+  {
+  }
+
+  /// Destructor shuts down the private io_service.
+  ~logger_service()
+  {
+    /// Indicate that we have finished with the private io_service. Its
+    /// io_service::run() function will exit once all other work has completed.
+    work_.reset();
+    if (work_thread_)
+      work_thread_->join();
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Return a null logger implementation.
+  impl_type null() const
+  {
+    return 0;
+  }
+
+  /// Create a new logger implementation.
+  void create(impl_type& impl, const std::string& identifier)
+  {
+    impl = new logger_impl(identifier);
+  }
+
+  /// Destroy a logger implementation.
+  void destroy(impl_type& impl)
+  {
+    delete impl;
+    impl = null();
+  }
+
+  /// Set the output file for the logger. The current implementation sets the
+  /// output file for all logger instances, and so the impl parameter is not
+  /// actually needed. It is retained here to illustrate how service functions
+  /// are typically defined.
+  void use_file(impl_type& impl, const std::string& file)
+  {
+    // Pass the work of opening the file to the background thread.
+    work_io_service_.post(boost::bind(
+          &logger_service::use_file_impl, this, file));
+  }
+
+  /// Log a message.
+  void log(impl_type& impl, const std::string& message)
+  {
+    // Format the text to be logged.
+    std::ostringstream os;
+    os << boost::posix_time::microsec_clock::universal_time();
+    os << " - " << impl->identifier << " - " << message;
+
+    // Pass the work of opening the file to the background thread.
+    work_io_service_.post(boost::bind(
+          &logger_service::log_impl, this, os.str()));
+  }
+
+private:
+  /// Helper function used to open the output file from within the private
+  /// io_service's thread.
+  void use_file_impl(const std::string& file)
+  {
+    ofstream_.close();
+    ofstream_.clear();
+    ofstream_.open(file.c_str());
+  }
+
+  /// Helper function used to log a message from within the private io_service's
+  /// thread.
+  void log_impl(const std::string& text)
+  {
+    ofstream_ << text << std::endl;
+  }
+
+  /// Private io_service used for performing logging operations.
+  boost::asio::io_service work_io_service_;
+
+  /// Work for the private io_service to perform. If we do not give the
+  /// io_service some work to do then the io_service::run() function will exit
+  /// immediately.
+  boost::scoped_ptr<boost::asio::io_service::work> work_;
+
+  /// Thread used for running the work io_service's run loop.
+  boost::scoped_ptr<boost::thread> work_thread_;
+
+  /// The file to which log messages will be written.
+  std::ofstream ofstream_;
+};
+
+} // namespace services
+
+#endif // SERVICES_LOGGER_SERVICE_HPP
diff --git a/example/services/stream_socket_service.hpp b/example/services/stream_socket_service.hpp
new file mode 100644
index 0000000000..3763071201
--- /dev/null
+++ b/example/services/stream_socket_service.hpp
@@ -0,0 +1,314 @@
+#ifndef SERVICES_STREAM_SOCKET_SERVICE_HPP
+#define SERVICES_STREAM_SOCKET_SERVICE_HPP
+
+#include <boost/asio.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/lexical_cast.hpp>
+#include "logger.hpp"
+
+namespace services {
+
+/// Debugging stream socket service that wraps the normal stream socket service.
+template <typename Protocol>
+class stream_socket_service
+  : public boost::asio::io_service::service
+{
+private:
+  /// The type of the wrapped stream socket service.
+  typedef boost::asio::stream_socket_service<Protocol> service_impl_type;
+
+public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// The implementation type of a stream socket.
+  typedef typename service_impl_type::implementation_type implementation_type;
+
+  /// The native type of a stream socket.
+  typedef typename service_impl_type::native_type native_type;
+
+  /// Construct a new stream socket service for the specified io_service.
+  explicit stream_socket_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service)),
+      logger_(io_service, "stream_socket")
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new stream socket implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a stream socket implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Open a new stream socket implementation.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const protocol_type& protocol,
+      Error_Handler error_handler)
+  {
+    logger_.log("Opening new socket");
+    service_impl_.open(impl, protocol, error_handler);
+  }
+
+  /// Open a stream socket from an existing native socket.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const native_type& native_socket,
+      Error_Handler error_handler)
+  {
+    logger_.log("Opening native socket");
+    service_impl_.open(impl, native_socket, error_handler);
+  }
+
+  /// Close a stream socket implementation.
+  template <typename Error_Handler>
+  void close(implementation_type& impl, Error_Handler error_handler)
+  {
+    logger_.log("Closing socket");
+    service_impl_.close(impl, error_handler);
+  }
+
+  /// Bind the stream socket to the specified local endpoint.
+  template <typename Error_Handler>
+  void bind(implementation_type& impl, const endpoint_type& endpoint,
+      Error_Handler error_handler)
+  {
+    logger_.log("Binding socket");
+    service_impl_.bind(impl, endpoint, error_handler);
+  }
+
+  /// Connect the stream socket to the specified endpoint.
+  template <typename Error_Handler>
+  void connect(implementation_type& impl, const endpoint_type& peer_endpoint,
+      Error_Handler error_handler)
+  {
+    logger_.log("Connecting socket to " +
+        boost::lexical_cast<std::string>(peer_endpoint));
+    service_impl_.connect(impl, peer_endpoint, error_handler);
+  }
+
+  /// Handler to wrap asynchronous connect completion.
+  template <typename Handler>
+  class connect_handler
+  {
+  public:
+    connect_handler(Handler h, logger& l)
+      : handler_(h),
+        logger_(l)
+    {
+    }
+
+    void operator()(const boost::asio::error& e)
+    {
+      if (e)
+      {
+        std::string msg = "Asynchronous connect failed: ";
+        msg += e.what();
+        logger_.log(msg);
+      }
+      else
+      {
+        logger_.log("Asynchronous connect succeeded");
+      }
+
+      handler_(e);
+    }
+
+  private:
+    Handler handler_;
+    logger& logger_;
+  };
+
+  /// Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, Handler handler)
+  {
+    logger_.log("Starting asynchronous connect to " +
+        boost::lexical_cast<std::string>(peer_endpoint));
+    service_impl_.async_connect(impl, peer_endpoint, 
+        connect_handler<Handler>(handler, logger_));
+  }
+
+  /// Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void set_option(implementation_type& impl, const Option& option,
+      Error_Handler error_handler)
+  {
+    logger_.log("Setting socket option");
+    service_impl_.set_option(impl, option, error_handler);
+  }
+
+  /// Get a socket option.
+  template <typename Option, typename Error_Handler>
+  void get_option(const implementation_type& impl, Option& option,
+      Error_Handler error_handler) const
+  {
+    logger_.log("Getting socket option");
+    service_impl_.get_option(impl, option, error_handler);
+  }
+
+  /// Perform an IO control command on the socket.
+  template <typename IO_Control_Command, typename Error_Handler>
+  void io_control(implementation_type& impl, IO_Control_Command& command,
+      Error_Handler error_handler)
+  {
+    logger_.log("Performing IO control command on socket");
+    service_impl_.io_control(impl, command, error_handler);
+  }
+
+  /// Get the local endpoint.
+  template <typename Error_Handler>
+  void local_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    logger_.log("Getting socket's local endpoint");
+    return service_impl_.local_endpoint(impl, error_handler);
+  }
+
+  /// Get the remote endpoint.
+  template <typename Error_Handler>
+  endpoint_type remote_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    logger_.log("Getting socket's remote endpoint");
+    return service_impl_.remote_endpoint(impl, error_handler);
+  }
+
+  /// Disable sends or receives on the socket.
+  template <typename Error_Handler>
+  void shutdown(implementation_type& impl,
+      boost::asio::socket_base::shutdown_type what, Error_Handler error_handler)
+  {
+    logger_.log("Shutting down socket");
+    service_impl_.shutdown(impl, what, error_handler);
+  }
+
+  /// Send the given data to the peer.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send(implementation_type& impl, const Const_Buffers& buffers,
+      boost::asio::socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    logger_.log("Sending data on socket");
+    return service_impl_.send(impl, buffers, flags, error_handler);
+  }
+
+  /// Handler to wrap asynchronous send completion.
+  template <typename Handler>
+  class send_handler
+  {
+  public:
+    send_handler(Handler h, logger& l)
+      : handler_(h),
+        logger_(l)
+    {
+    }
+
+    void operator()(const boost::asio::error& e, std::size_t bytes_transferred)
+    {
+      if (e)
+      {
+        std::string msg = "Asynchronous send failed: ";
+        msg += e.what();
+        logger_.log(msg);
+      }
+      else
+      {
+        logger_.log("Asynchronous send succeeded");
+      }
+
+      handler_(e, bytes_transferred);
+    }
+
+  private:
+    Handler handler_;
+    logger& logger_;
+  };
+
+  /// Start an asynchronous send.
+  template <typename Const_Buffers, typename Handler>
+  void async_send(implementation_type& impl, const Const_Buffers& buffers,
+      boost::asio::socket_base::message_flags flags, Handler handler)
+  {
+    logger_.log("Starting asynchronous send");
+    service_impl_.async_send(impl, buffers, flags,
+        send_handler<Handler>(handler, logger_));
+  }
+
+  /// Receive some data from the peer.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      boost::asio::socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    logger_.log("Receiving data on socket");
+    return service_impl_.receive(impl, buffers, flags, error_handler);
+  }
+
+  /// Handler to wrap asynchronous receive completion.
+  template <typename Handler>
+  class receive_handler
+  {
+  public:
+    receive_handler(Handler h, logger& l)
+      : handler_(h),
+        logger_(l)
+    {
+    }
+
+    void operator()(const boost::asio::error& e, std::size_t bytes_transferred)
+    {
+      if (e)
+      {
+        std::string msg = "Asynchronous receive failed: ";
+        msg += e.what();
+        logger_.log(msg);
+      }
+      else
+      {
+        logger_.log("Asynchronous receive succeeded");
+      }
+
+      handler_(e, bytes_transferred);
+    }
+
+  private:
+    Handler handler_;
+    logger& logger_;
+  };
+
+  /// Start an asynchronous receive.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      boost::asio::socket_base::message_flags flags, Handler handler)
+  {
+    logger_.log("Starting asynchronous receive");
+    service_impl_.async_receive(impl, buffers, flags,
+        receive_handler<Handler>(handler, logger_));
+  }
+
+private:
+  /// The wrapped stream socket service.
+  service_impl_type& service_impl_;
+
+  /// The logger used for writing debug messages.
+  logger logger_;
+};
+
+} // namespace services
+
+#endif // SERVICES_STREAM_SOCKET_SERVICE_HPP
diff --git a/example/ssl/Jamfile b/example/ssl/Jamfile
new file mode 100644
index 0000000000..41a1b8c2d7
--- /dev/null
+++ b/example/ssl/Jamfile
@@ -0,0 +1,40 @@
+subproject libs/asio/example/ssl ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+exe client
+  : client.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <find-library>ssl
+    <find-library>crypto
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe server
+  : server.cpp
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <find-library>ssl
+    <find-library>crypto
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
diff --git a/example/ssl/README b/example/ssl/README
new file mode 100644
index 0000000000..85a4a4da0d
--- /dev/null
+++ b/example/ssl/README
@@ -0,0 +1 @@
+The passphrase for both the CA and server private keys is "test".
diff --git a/example/ssl/ca.pem b/example/ssl/ca.pem
new file mode 100644
index 0000000000..45de7742b2
--- /dev/null
+++ b/example/ssl/ca.pem
@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIB7TCCAVYCCQCxKhAUH1ygCDANBgkqhkiG9w0BAQUFADA7MQswCQYDVQQGEwJB
+VTEMMAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxDTALBgNVBAoTBGFzaW8w
+HhcNMDUxMTAyMTk0ODU1WhcNMTUxMTAyMTk0ODU1WjA7MQswCQYDVQQGEwJBVTEM
+MAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxDTALBgNVBAoTBGFzaW8wgZ8w
+DQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMkNbM2RjFdm48Wy1nBA3+exfJL5fR6H
+guRFu/7MKf6pQZGRqhzxIWYRoYQDx16BggHwqFVVls5hgoQF0fUqoHfE8MLGwr6m
+T6rIYBrIAGnH8eMhfwMNy4I0emkoWI+grEXlw54IUSijh8LokLWorElyGuPmxhn3
+IgZkgGe8dCQTAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAdpHw+r3X4NwzKn9nQs3h
+mQK2WeH6DVQ1r7fWqEq1Lq10qBdobbjDRE9jpezWdGMThbYtle6/8wHUJeq189PR
+XwZWyRvnfcI+pqX832yNRh24Ujwuv3wlx3JOVByybCoJc05N1THaHo0Q7j//8HsX
+VS/RFHuq3muy47cV9gbsCIw=
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,EC6C715D9BC7AFF2
+
+bBOh4F/Ouq2cpaWYUqCvpVVTAkptsHCkUFZpjqruGMw1pQ6BY2eBzuHHNgOV+8BI
+4Md8LcvD9oRmkigXp10I6ELkPpvTqK5S/9iJBlR/XgYjuj2PkdLiT2t4dWrJP9Rq
+NdjybhKV0qqB/WiBKoSI/n0mYDxmrrHjmPAXi3BnivyQiUry42hs+Izxlkyt///D
+bDzkW/LqiMDwxOu9mCsxdN/iiFgKsPQBxvLbdG3p1GyERrnB85DeewYGF9fzp1Nz
+CXWQiPqEkf3arqgKBIjK+TDfmDluL7+nOyhSp0j9Rh1zba8ffmYZNXXLt0ludVdm
+8zbwqjbX6u4BZ+pSpnURFBp9um0TlxhpJ5F3q5ZyUa7l4tTlw37V8UkFP8KmBbuc
+PDnjbdlD5BtAbR/b/dDSAhU2y7aftcTsZCu22UOLQqWOm6jMk943ZfmG93rCeKNL
+qa4OPXsICSNqKivF0Ovyw5U7ODsFj0UTD8/VY+JWLz/bmJdpsBCNlkfQHGtTahfq
+QY4mG0K+cWmUiGvcWcU1pjI4e551dR05wNDmyfJMHHVzn2VnCrxKSKGEtJOMcyzi
+E42zQkGlYWVJyqDFHfxCe+1GJLJvW2oYGUUY/++XDzvxITT6Lq3wb1MGisoaC1Q7
+523SXpzVIU+FLlWxewrSnZOyTe13lgNK4OVnuRqz/LQExjfwUXtgqQkRp6A8jTmC
+6LWEaXQ6kC7QmwX0VQgtNi74ZMMrBsaxywaE+3oEibeJiXbVJCHDo3RufA9AJnpF
+HUmTFTnoBr4f8AUxN0Eyb5Yg16pzOBI5o4EzjKzJ4D0=
+-----END RSA PRIVATE KEY-----
diff --git a/example/ssl/client.cpp b/example/ssl/client.cpp
new file mode 100644
index 0000000000..69acbec918
--- /dev/null
+++ b/example/ssl/client.cpp
@@ -0,0 +1,135 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
+
+enum { max_length = 1024 };
+
+class client
+{
+public:
+  client(boost::asio::io_service& io_service, boost::asio::ssl::context& context,
+      boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
+    : socket_(io_service, context)
+  {
+    boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
+    socket_.lowest_layer().async_connect(endpoint,
+        boost::bind(&client::handle_connect, this,
+          boost::asio::placeholders::error, ++endpoint_iterator));
+  }
+
+  void handle_connect(const boost::asio::error& error,
+      boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
+  {
+    if (!error)
+    {
+      socket_.async_handshake(boost::asio::ssl::stream_base::client,
+          boost::bind(&client::handle_handshake, this,
+            boost::asio::placeholders::error));
+    }
+    else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
+    {
+      socket_.lowest_layer().close();
+      boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
+      socket_.lowest_layer().async_connect(endpoint,
+          boost::bind(&client::handle_connect, this,
+            boost::asio::placeholders::error, ++endpoint_iterator));
+    }
+    else
+    {
+      std::cout << "Connect failed: " << error << "\n";
+    }
+  }
+
+  void handle_handshake(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      std::cout << "Enter message: ";
+      std::cin.getline(request_, max_length);
+      size_t request_length = strlen(request_);
+
+      boost::asio::async_write(socket_,
+          boost::asio::buffer(request_, request_length),
+          boost::bind(&client::handle_write, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+    else
+    {
+      std::cout << "Handshake failed: " << error << "\n";
+    }
+  }
+
+  void handle_write(const boost::asio::error& error, size_t bytes_transferred)
+  {
+    if (!error)
+    {
+      boost::asio::async_read(socket_,
+          boost::asio::buffer(reply_, bytes_transferred),
+          boost::bind(&client::handle_read, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+    else
+    {
+      std::cout << "Write failed: " << error << "\n";
+    }
+  }
+
+  void handle_read(const boost::asio::error& error, size_t bytes_transferred)
+  {
+    if (!error)
+    {
+      std::cout << "Reply: ";
+      std::cout.write(reply_, bytes_transferred);
+      std::cout << "\n";
+    }
+    else
+    {
+      std::cout << "Read failed: " << error << "\n";
+    }
+  }
+
+private:
+  boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_;
+  char request_[max_length];
+  char reply_[max_length];
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 3)
+    {
+      std::cerr << "Usage: client <host> <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    boost::asio::ip::tcp::resolver resolver(io_service);
+    boost::asio::ip::tcp::resolver::query query(argv[1], argv[2]);
+    boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
+
+    boost::asio::ssl::context ctx(io_service, boost::asio::ssl::context::sslv23);
+    ctx.set_verify_mode(boost::asio::ssl::context::verify_peer);
+    ctx.load_verify_file("ca.pem");
+
+    client c(io_service, ctx, iterator);
+
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/ssl/dh512.pem b/example/ssl/dh512.pem
new file mode 100644
index 0000000000..14c53b2a21
--- /dev/null
+++ b/example/ssl/dh512.pem
@@ -0,0 +1,12 @@
+Diffie-Hellman-Parameters: (512 bit)
+    prime:
+        00:a0:bc:d0:c2:c3:a8:c7:a5:62:13:cd:f0:63:39:
+        ea:85:e0:f7:ca:00:8a:57:ec:12:dd:92:2b:20:70:
+        38:6c:03:60:b1:19:e3:0b:e9:d3:05:f1:1b:cc:8c:
+        9c:1a:30:3e:91:de:db:17:a7:19:cf:da:a0:2d:ee:
+        ef:35:95:8b:4b
+    generator: 5 (0x5)
+-----BEGIN DH PARAMETERS-----
+MEYCQQCgvNDCw6jHpWITzfBjOeqF4PfKAIpX7BLdkisgcDhsA2CxGeML6dMF8RvM
+jJwaMD6R3tsXpxnP2qAt7u81lYtLAgEF
+-----END DH PARAMETERS-----
diff --git a/example/ssl/server.cpp b/example/ssl/server.cpp
new file mode 100644
index 0000000000..6482d307e8
--- /dev/null
+++ b/example/ssl/server.cpp
@@ -0,0 +1,152 @@
+#include <cstdlib>
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
+
+typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_socket;
+
+class session
+{
+public:
+  session(boost::asio::io_service& io_service, boost::asio::ssl::context& context)
+    : socket_(io_service, context)
+  {
+  }
+
+  ssl_socket::lowest_layer_type& socket()
+  {
+    return socket_.lowest_layer();
+  }
+
+  void start()
+  {
+    socket_.async_handshake(boost::asio::ssl::stream_base::server,
+        boost::bind(&session::handle_handshake, this,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_handshake(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      socket_.async_read_some(boost::asio::buffer(data_, max_length),
+          boost::bind(&session::handle_read, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+    else
+    {
+      delete this;
+    }
+  }
+
+  void handle_read(const boost::asio::error& error, size_t bytes_transferred)
+  {
+    if (!error)
+    {
+      boost::asio::async_write(socket_,
+          boost::asio::buffer(data_, bytes_transferred),
+          boost::bind(&session::handle_write, this,
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      delete this;
+    }
+  }
+
+  void handle_write(const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      socket_.async_read_some(boost::asio::buffer(data_, max_length),
+          boost::bind(&session::handle_read, this,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+    }
+    else
+    {
+      delete this;
+    }
+  }
+
+private:
+  ssl_socket socket_;
+  enum { max_length = 1024 };
+  char data_[max_length];
+};
+
+class server
+{
+public:
+  server(boost::asio::io_service& io_service, unsigned short port)
+    : io_service_(io_service),
+      acceptor_(io_service,
+          boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
+      context_(io_service, boost::asio::ssl::context::sslv23)
+  {
+    context_.set_options(
+        boost::asio::ssl::context::default_workarounds
+        | boost::asio::ssl::context::no_sslv2
+        | boost::asio::ssl::context::single_dh_use);
+    context_.use_certificate_chain_file("server.pem");
+    context_.use_private_key_file("server.pem", boost::asio::ssl::context::pem);
+    context_.use_tmp_dh_file("dh512.pem");
+
+    session* new_session = new session(io_service_, context_);
+    acceptor_.async_accept(new_session->socket(),
+        boost::bind(&server::handle_accept, this, new_session,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(session* new_session, const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      new_session->start();
+      new_session = new session(io_service_, context_);
+      acceptor_.async_accept(new_session->socket(),
+          boost::bind(&server::handle_accept, this, new_session,
+            boost::asio::placeholders::error));
+    }
+    else
+    {
+      delete new_session;
+    }
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+  boost::asio::ip::tcp::acceptor acceptor_;
+  boost::asio::ssl::context context_;
+};
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: server <port>\n";
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    using namespace std; // For atoi.
+    server s(io_service, atoi(argv[1]));
+
+    io_service.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/ssl/server.pem b/example/ssl/server.pem
new file mode 100644
index 0000000000..5b2052d9e2
--- /dev/null
+++ b/example/ssl/server.pem
@@ -0,0 +1,44 @@
+-----BEGIN CERTIFICATE-----
+MIIB/jCCAWcCCQDlADUqOr8YCTANBgkqhkiG9w0BAQUFADA7MQswCQYDVQQGEwJB
+VTEMMAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxDTALBgNVBAoTBGFzaW8w
+HhcNMDUxMTAyMTk1MjMzWhcNMTUxMTAyMTk1MjMzWjBMMQswCQYDVQQGEwJBVTEM
+MAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxDTALBgNVBAoTBGFzaW8xDzAN
+BgNVBAsTBnNlcnZlcjCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxAkg4iw5
+X8pXhJ8GfjGRKVOClt/EI9ypQMqWQSRH0pGDFlIOQzsfhqsCyp/xcfCwPBvfMIeE
+IzYiZ5kH6YD9EfHmIA6hsd1i3layCpeiA2VXrUXsvL8Y3fUt1/3IAR+pmVI4XGas
+lCb0zs1n0K08v9AWBkVE5rirA5an263Sd+kCAwEAATANBgkqhkiG9w0BAQUFAAOB
+gQBzFX/efrhGVzfK4Ue+/7Og44r7OLzQepSyQavFhp+t3PX1hy4ifneTnqMyME8w
+WuB94G/gtST9ECVHRKUuBn4xT1rz5DO20h3VSAzTirkSFQPdWunyBbIva0Hsf6pF
+287CA1cM106X0Vs4dv2F2u0zSszYfOysAM1pIPcxdyboXA==
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,9A7CF9C13224C492
+
+w00sJ2/d79LRI+9LRsnQkBZwIo/NbprFtN3SVqcUAtncqowl9BnKZnQ2csnj8KZA
+STAL+PZAyJQTiJfJxecCkB8Tu4/apFe2V9/PxUirJzGtJ9FHBAjLgmpK4yWwSCMq
+txyy8hjm8ggR8SQNJ1Jf+O6uGotillq02TJ0RluRrhukkfevClXTfCl3ngGI3D1q
+v5dFZrU2r2pGpkxCxI8SoQCCaH6l/plR9IhKl1/cz9chiXUFmAb4kMazneZaFmiu
+B8AJMQcFDfKttdKmkxY1qdQI9bOKw2YSZT6aASZTHD84hDloQRdgok8VO1YBKfzj
+0jEYnaYuXZGD+h38giABPV0iTY7aC0RdcyP63ZQH95KXtSLGBfUHEOvR4jR4uLu9
+3Qfw4j1/HzmCrXVZNyGswwagVuVcvmBuHwGmnxMaWCGIC1CODf8X5BG4V932Akpl
+mCeQyLdkXHehZvSV1OCwxGko0FjVwnKIOplyMqCVpeDNwuddH02zo5h+kBSrTg0m
+XEMlVMAadS9vgwLCLL1GKeVpYT3jNbgDfUrXC6udycgGdYA6QtmeuiZ3Lv37TQ8K
+LD7ono+XsT38XvlKRqbPrlHNae+PRLudKWHsgrZg2MckyEpG/x9dygru561p1Dns
+Bm17CVkQUIZyAPXQB6/UmxPbJYsChiQXxy3/4U2eZLVVkHRP7gPWBnFjNoyd5OBw
+G+psOVLNgCnFh+z4NO5CB4mVNtrR1NAH6IFhnlrip4YFRk3XPHVlkrxn6fHeEDGE
+eVB3XJcgsGnVQCvF5vsymZWZ722xgLPkK8iG3QLayoM4c9RlrKMwwA==
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIB7TCCAVYCCQCxKhAUH1ygCDANBgkqhkiG9w0BAQUFADA7MQswCQYDVQQGEwJB
+VTEMMAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxDTALBgNVBAoTBGFzaW8w
+HhcNMDUxMTAyMTk0ODU1WhcNMTUxMTAyMTk0ODU1WjA7MQswCQYDVQQGEwJBVTEM
+MAoGA1UECBMDTlNXMQ8wDQYDVQQHEwZTeWRuZXkxDTALBgNVBAoTBGFzaW8wgZ8w
+DQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMkNbM2RjFdm48Wy1nBA3+exfJL5fR6H
+guRFu/7MKf6pQZGRqhzxIWYRoYQDx16BggHwqFVVls5hgoQF0fUqoHfE8MLGwr6m
+T6rIYBrIAGnH8eMhfwMNy4I0emkoWI+grEXlw54IUSijh8LokLWorElyGuPmxhn3
+IgZkgGe8dCQTAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAdpHw+r3X4NwzKn9nQs3h
+mQK2WeH6DVQ1r7fWqEq1Lq10qBdobbjDRE9jpezWdGMThbYtle6/8wHUJeq189PR
+XwZWyRvnfcI+pqX832yNRh24Ujwuv3wlx3JOVByybCoJc05N1THaHo0Q7j//8HsX
+VS/RFHuq3muy47cV9gbsCIw=
+-----END CERTIFICATE-----
diff --git a/example/timeouts/Jamfile b/example/timeouts/Jamfile
new file mode 100644
index 0000000000..7c5c47a3d7
--- /dev/null
+++ b/example/timeouts/Jamfile
@@ -0,0 +1,45 @@
+subproject libs/asio/example/timeouts ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+template asio_timeouts_example
+  : <lib>@boost/libs/thread/build/boost_thread
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe accept_timeout
+  : <template>asio_timeouts_example
+    accept_timeout.cpp
+  ;
+
+exe connect_timeout
+  : <template>asio_timeouts_example
+    connect_timeout.cpp
+  ;
+
+exe datagram_receive_timeout
+  : <template>asio_timeouts_example
+    datagram_receive_timeout.cpp
+  ;
+
+exe stream_receive_timeout
+  : <template>asio_timeouts_example
+    stream_receive_timeout.cpp
+  ;
diff --git a/example/timeouts/accept_timeout.cpp b/example/timeouts/accept_timeout.cpp
new file mode 100644
index 0000000000..e317504c87
--- /dev/null
+++ b/example/timeouts/accept_timeout.cpp
@@ -0,0 +1,67 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <iostream>
+
+using namespace boost::asio;
+
+class accept_handler
+{
+public:
+  accept_handler(io_service& ios)
+    : io_service_(ios),
+      timer_(ios),
+      acceptor_(ios, ip::tcp::endpoint(ip::tcp::v4(), 32123)),
+      socket_(ios)
+  {
+    acceptor_.async_accept(socket_,
+        boost::bind(&accept_handler::handle_accept, this,
+          boost::asio::placeholders::error));
+
+    timer_.expires_from_now(boost::posix_time::seconds(5));
+    timer_.async_wait(boost::bind(&accept_handler::close, this));
+  }
+
+  void handle_accept(const error& err)
+  {
+    if (err)
+    {
+      std::cout << "Accept error: " << err << "\n";
+    }
+    else
+    {
+      std::cout << "Successful accept\n";
+    }
+  }
+
+  void close()
+  {
+    acceptor_.close();
+  }
+
+private:
+  io_service& io_service_;
+  deadline_timer timer_;
+  ip::tcp::acceptor acceptor_;
+  ip::tcp::socket socket_;
+};
+
+int main()
+{
+  try
+  {
+    io_service ios;
+    accept_handler ah(ios);
+    ios.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "Exception: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/timeouts/connect_timeout.cpp b/example/timeouts/connect_timeout.cpp
new file mode 100644
index 0000000000..dc7dd5191a
--- /dev/null
+++ b/example/timeouts/connect_timeout.cpp
@@ -0,0 +1,78 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <iostream>
+
+using namespace boost::asio;
+
+class connect_handler
+{
+public:
+  connect_handler(io_service& ios)
+    : io_service_(ios),
+      timer_(ios),
+      socket_(ios)
+  {
+    socket_.async_connect(
+        ip::tcp::endpoint(ip::address_v4::loopback(), 32123),
+        boost::bind(&connect_handler::handle_connect, this,
+          boost::asio::placeholders::error));
+
+    timer_.expires_from_now(boost::posix_time::seconds(5));
+    timer_.async_wait(boost::bind(&connect_handler::close, this));
+  }
+
+  void handle_connect(const error& err)
+  {
+    if (err)
+    {
+      std::cout << "Connect error: " << err << "\n";
+    }
+    else
+    {
+      std::cout << "Successful connection\n";
+    }
+  }
+
+  void close()
+  {
+    socket_.close();
+  }
+
+private:
+  io_service& io_service_;
+  deadline_timer timer_;
+  ip::tcp::socket socket_;
+};
+
+int main()
+{
+  try
+  {
+    io_service ios;
+    ip::tcp::acceptor a(ios, ip::tcp::endpoint(ip::tcp::v4(), 32123), 1);
+
+    // Make lots of connections so that at least some of them will block.
+    connect_handler ch1(ios);
+    connect_handler ch2(ios);
+    connect_handler ch3(ios);
+    connect_handler ch4(ios);
+    connect_handler ch5(ios);
+    connect_handler ch6(ios);
+    connect_handler ch7(ios);
+    connect_handler ch8(ios);
+    connect_handler ch9(ios);
+
+    ios.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "Exception: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/timeouts/datagram_receive_timeout.cpp b/example/timeouts/datagram_receive_timeout.cpp
new file mode 100644
index 0000000000..908ed33a16
--- /dev/null
+++ b/example/timeouts/datagram_receive_timeout.cpp
@@ -0,0 +1,70 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <iostream>
+
+using namespace boost::asio;
+
+class datagram_handler
+{
+public:
+  datagram_handler(io_service& ios)
+    : io_service_(ios),
+      timer_(ios),
+      socket_(ios, ip::udp::endpoint(ip::udp::v4(), 32124))
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(data_, max_length), sender_endpoint_,
+        boost::bind(&datagram_handler::handle_receive_from, this,
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+
+    timer_.expires_from_now(boost::posix_time::seconds(5));
+    timer_.async_wait(boost::bind(&datagram_handler::close, this));
+  }
+
+  void handle_receive_from(const error& err, size_t length)
+  {
+    if (err)
+    {
+      std::cout << "Receive error: " << err << "\n";
+    }
+    else
+    {
+      std::cout << "Successful receive\n";
+    }
+  }
+
+  void close()
+  {
+    socket_.close();
+  }
+
+private:
+  io_service& io_service_;
+  deadline_timer timer_;
+  ip::udp::socket socket_;
+  ip::udp::endpoint sender_endpoint_;
+  enum { max_length = 512 };
+  char data_[max_length];
+};
+
+int main()
+{
+  try
+  {
+    io_service ios;
+    datagram_handler dh(ios);
+    ios.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "Exception: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/timeouts/stream_receive_timeout.cpp b/example/timeouts/stream_receive_timeout.cpp
new file mode 100644
index 0000000000..ee4c2dde64
--- /dev/null
+++ b/example/timeouts/stream_receive_timeout.cpp
@@ -0,0 +1,94 @@
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <iostream>
+
+using namespace boost::asio;
+
+class stream_handler
+{
+public:
+  stream_handler(io_service& ios)
+    : io_service_(ios),
+      timer_(ios),
+      acceptor_(ios, ip::tcp::endpoint(ip::tcp::v4(), 32123)),
+      socket_(ios)
+  {
+    acceptor_.async_accept(socket_,
+        boost::bind(&stream_handler::handle_accept, this,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(const error& err)
+  {
+    if (err)
+    {
+      std::cout << "Accept error: " << err << "\n";
+    }
+    else
+    {
+      std::cout << "Successful accept\n";
+
+      socket_.async_read_some(boost::asio::buffer(buf_, sizeof(buf_)),
+          boost::bind(&stream_handler::handle_recv, this,
+            boost::asio::placeholders::error));
+      timer_.expires_from_now(boost::posix_time::seconds(5));
+      timer_.async_wait(boost::bind(&stream_handler::close, this));
+    }
+  }
+
+  void handle_recv(const error& err)
+  {
+    if (err)
+    {
+      std::cout << "Receive error: " << err << "\n";
+    }
+    else
+    {
+      std::cout << "Successful receive\n";
+    }
+  }
+
+  void close()
+  {
+    socket_.close();
+  }
+
+private:
+  io_service& io_service_;
+  deadline_timer timer_;
+  ip::tcp::acceptor acceptor_;
+  ip::tcp::socket socket_;
+  char buf_[1024];
+};
+
+void connect_handler()
+{
+  std::cout << "Successful connect\n";
+}
+
+int main()
+{
+  try
+  {
+    io_service ios;
+
+    stream_handler sh(ios);
+
+    ip::tcp::socket s(ios);
+    s.async_connect(ip::tcp::endpoint(ip::address_v4::loopback(), 32123),
+        boost::bind(connect_handler));
+
+    ios.run();
+  }
+  catch (boost::asio::error& e)
+  {
+    std::cerr << "Exception: " << e << "\n";
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << "Exception: " << e.what() << "\n";
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/Jamfile b/example/tutorial/Jamfile
new file mode 100644
index 0000000000..4aa489c578
--- /dev/null
+++ b/example/tutorial/Jamfile
@@ -0,0 +1,38 @@
+subproject libs/asio/example/tutorial ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+template asio_tutorial
+  : <lib>@boost/libs/thread/build/boost_thread
+  : <include>$(BOOST_ROOT)
+    <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+exe timer1 : <template>asio_tutorial timer1/timer.cpp ;
+exe timer2 : <template>asio_tutorial timer2/timer.cpp ;
+exe timer3 : <template>asio_tutorial timer3/timer.cpp ;
+exe timer4 : <template>asio_tutorial timer4/timer.cpp ;
+exe timer5 : <template>asio_tutorial timer5/timer.cpp ;
+exe daytime1_client : <template>asio_tutorial daytime1/client.cpp ;
+exe daytime2_server : <template>asio_tutorial daytime2/server.cpp ;
+exe daytime3_server : <template>asio_tutorial daytime3/server.cpp ;
+exe daytime4_client : <template>asio_tutorial daytime4/client.cpp ;
+exe daytime5_server : <template>asio_tutorial daytime5/server.cpp ;
+exe daytime6_server : <template>asio_tutorial daytime6/server.cpp ;
+exe daytime7_server : <template>asio_tutorial daytime7/server.cpp ;
diff --git a/example/tutorial/daytime1/client.cpp b/example/tutorial/daytime1/client.cpp
new file mode 100644
index 0000000000..25e524117d
--- /dev/null
+++ b/example/tutorial/daytime1/client.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <boost/array.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: client <host>" << std::endl;
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    tcp::resolver resolver(io_service);
+    tcp::resolver::query query(argv[1], "daytime");
+    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
+    tcp::resolver::iterator end;
+
+    tcp::socket socket(io_service);
+    boost::asio::error error = boost::asio::error::host_not_found;
+    while (error && endpoint_iterator != end)
+    {
+      socket.close();
+      socket.connect(*endpoint_iterator++, boost::asio::assign_error(error));
+    }
+    if (error)
+      throw error;
+
+    for (;;)
+    {
+      boost::array<char, 128> buf;
+      boost::asio::error error;
+
+      size_t len = socket.read_some(
+          boost::asio::buffer(buf), boost::asio::assign_error(error));
+
+      if (error == boost::asio::error::eof)
+        break; // Connection closed cleanly by peer.
+      else if (error)
+        throw error; // Some other error.
+
+      std::cout.write(buf.data(), len);
+    }
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/daytime2/server.cpp b/example/tutorial/daytime2/server.cpp
new file mode 100644
index 0000000000..a710176c7c
--- /dev/null
+++ b/example/tutorial/daytime2/server.cpp
@@ -0,0 +1,40 @@
+#include <ctime>
+#include <iostream>
+#include <string>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+std::string make_daytime_string()
+{
+  using namespace std; // For time_t, time and ctime;
+  time_t now = time(0);
+  return ctime(&now);
+}
+
+int main()
+{
+  try
+  {
+    boost::asio::io_service io_service;
+
+    tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 13));
+
+    for (;;)
+    {
+      tcp::socket socket(io_service);
+      acceptor.accept(socket);
+
+      std::string message = make_daytime_string();
+
+      boost::asio::write(socket, boost::asio::buffer(message),
+          boost::asio::transfer_all(), boost::asio::ignore_error());
+    }
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/daytime3/server.cpp b/example/tutorial/daytime3/server.cpp
new file mode 100644
index 0000000000..189ba63876
--- /dev/null
+++ b/example/tutorial/daytime3/server.cpp
@@ -0,0 +1,106 @@
+#include <ctime>
+#include <iostream>
+#include <string>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+
+std::string make_daytime_string()
+{
+  using namespace std; // For time_t, time and ctime;
+  time_t now = time(0);
+  return ctime(&now);
+}
+
+class tcp_connection
+  : public boost::enable_shared_from_this<tcp_connection>
+{
+public:
+  typedef boost::shared_ptr<tcp_connection> pointer;
+
+  static pointer create(boost::asio::io_service& io_service)
+  {
+    return pointer(new tcp_connection(io_service));
+  }
+
+  tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  void start()
+  {
+    message_ = make_daytime_string();
+
+    boost::asio::async_write(socket_, boost::asio::buffer(message_),
+        boost::bind(&tcp_connection::handle_write, shared_from_this(),
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+  }
+
+private:
+  tcp_connection(boost::asio::io_service& io_service)
+    : socket_(io_service)
+  {
+  }
+
+  void handle_write(const boost::asio::error& /*error*/,
+      size_t /*bytes_transferred*/)
+  {
+  }
+
+  tcp::socket socket_;
+  std::string message_;
+};
+
+class tcp_server
+{
+public:
+  tcp_server(boost::asio::io_service& io_service)
+    : acceptor_(io_service, tcp::endpoint(tcp::v4(), 13))
+  {
+    start_accept();
+  }
+
+private:
+  void start_accept()
+  {
+    tcp_connection::pointer new_connection =
+      tcp_connection::create(acceptor_.io_service());
+
+    acceptor_.async_accept(new_connection->socket(),
+        boost::bind(&tcp_server::handle_accept, this, new_connection,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(tcp_connection::pointer new_connection,
+      const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      new_connection->start();
+      start_accept();
+    }
+  }
+
+  tcp::acceptor acceptor_;
+};
+
+int main()
+{
+  try
+  {
+    boost::asio::io_service io_service;
+    tcp_server server(io_service);
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/daytime4/client.cpp b/example/tutorial/daytime4/client.cpp
new file mode 100644
index 0000000000..c95042b3ea
--- /dev/null
+++ b/example/tutorial/daytime4/client.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <boost/array.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::udp;
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    if (argc != 2)
+    {
+      std::cerr << "Usage: client <host>" << std::endl;
+      return 1;
+    }
+
+    boost::asio::io_service io_service;
+
+    udp::resolver resolver(io_service);
+    udp::resolver::query query(udp::v4(), argv[1], "daytime");
+    udp::endpoint receiver_endpoint = *resolver.resolve(query);
+
+    udp::socket socket(io_service);
+    socket.open(udp::v4());
+
+    boost::array<char, 1> send_buf  = { 0 };
+    socket.send_to(boost::asio::buffer(send_buf), receiver_endpoint);
+
+    boost::array<char, 128> recv_buf;
+    udp::endpoint sender_endpoint;
+    size_t len = socket.receive_from(
+        boost::asio::buffer(recv_buf), sender_endpoint);
+
+    std::cout.write(recv_buf.data(), len);
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/daytime5/server.cpp b/example/tutorial/daytime5/server.cpp
new file mode 100644
index 0000000000..ce3fe824ff
--- /dev/null
+++ b/example/tutorial/daytime5/server.cpp
@@ -0,0 +1,47 @@
+#include <ctime>
+#include <iostream>
+#include <string>
+#include <boost/array.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::udp;
+
+std::string make_daytime_string()
+{
+  using namespace std; // For time_t, time and ctime;
+  time_t now = time(0);
+  return ctime(&now);
+}
+
+int main()
+{
+  try
+  {
+    boost::asio::io_service io_service;
+
+    udp::socket socket(io_service, udp::endpoint(udp::v4(), 13));
+
+    for (;;)
+    {
+      boost::array<char, 1> recv_buf;
+      udp::endpoint remote_endpoint;
+      boost::asio::error error;
+      socket.receive_from(boost::asio::buffer(recv_buf),
+          remote_endpoint, 0, boost::asio::assign_error(error));
+
+      if (error && error != boost::asio::error::message_size)
+        throw error;
+
+      std::string message = make_daytime_string();
+
+      socket.send_to(boost::asio::buffer(message),
+          remote_endpoint, 0, boost::asio::ignore_error());
+    }
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/daytime6/server.cpp b/example/tutorial/daytime6/server.cpp
new file mode 100644
index 0000000000..571a3a285c
--- /dev/null
+++ b/example/tutorial/daytime6/server.cpp
@@ -0,0 +1,78 @@
+#include <ctime>
+#include <iostream>
+#include <string>
+#include <boost/array.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::udp;
+
+std::string make_daytime_string()
+{
+  using namespace std; // For time_t, time and ctime;
+  time_t now = time(0);
+  return ctime(&now);
+}
+
+class udp_server
+{
+public:
+  udp_server(boost::asio::io_service& io_service)
+    : socket_(io_service, udp::endpoint(udp::v4(), 13))
+  {
+    start_receive();
+  }
+
+private:
+  void start_receive()
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(recv_buffer_), remote_endpoint_,
+        boost::bind(&udp_server::handle_receive, this,
+          boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred));
+  }
+
+  void handle_receive(const boost::asio::error& error,
+      std::size_t /*bytes_transferred*/)
+  {
+    if (!error || error == boost::asio::error::message_size)
+    {
+      boost::shared_ptr<std::string> message(
+          new std::string(make_daytime_string()));
+
+      socket_.async_send_to(boost::asio::buffer(*message), remote_endpoint_,
+          boost::bind(&udp_server::handle_send, this, message,
+            boost::asio::placeholders::error,
+            boost::asio::placeholders::bytes_transferred));
+
+      start_receive();
+    }
+  }
+
+  void handle_send(boost::shared_ptr<std::string> /*message*/,
+      const boost::asio::error& /*error*/, std::size_t /*bytes_transferred*/)
+  {
+  }
+
+  udp::socket socket_;
+  udp::endpoint remote_endpoint_;
+  boost::array<char, 1> recv_buffer_;
+};
+
+int main()
+{
+  try
+  {
+    boost::asio::io_service io_service;
+    udp_server server(io_service);
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/daytime7/server.cpp b/example/tutorial/daytime7/server.cpp
new file mode 100644
index 0000000000..f062db0309
--- /dev/null
+++ b/example/tutorial/daytime7/server.cpp
@@ -0,0 +1,147 @@
+#include <ctime>
+#include <iostream>
+#include <string>
+#include <boost/array.hpp>
+#include <boost/bind.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/asio.hpp>
+
+using boost::asio::ip::tcp;
+using boost::asio::ip::udp;
+
+std::string make_daytime_string()
+{
+  using namespace std; // For time_t, time and ctime;
+  time_t now = time(0);
+  return ctime(&now);
+}
+
+class tcp_connection
+  : public boost::enable_shared_from_this<tcp_connection>
+{
+public:
+  typedef boost::shared_ptr<tcp_connection> pointer;
+
+  static pointer create(boost::asio::io_service& io_service)
+  {
+    return pointer(new tcp_connection(io_service));
+  }
+
+  tcp::socket& socket()
+  {
+    return socket_;
+  }
+
+  void start()
+  {
+    message_ = make_daytime_string();
+
+    boost::asio::async_write(socket_, boost::asio::buffer(message_),
+        boost::bind(&tcp_connection::handle_write, shared_from_this()));
+  }
+
+private:
+  tcp_connection(boost::asio::io_service& io_service)
+    : socket_(io_service)
+  {
+  }
+
+  void handle_write()
+  {
+  }
+
+  tcp::socket socket_;
+  std::string message_;
+};
+
+class tcp_server
+{
+public:
+  tcp_server(boost::asio::io_service& io_service)
+    : acceptor_(io_service, tcp::endpoint(tcp::v4(), 13))
+  {
+    start_accept();
+  }
+
+private:
+  void start_accept()
+  {
+    tcp_connection::pointer new_connection =
+      tcp_connection::create(acceptor_.io_service());
+
+    acceptor_.async_accept(new_connection->socket(),
+        boost::bind(&tcp_server::handle_accept, this, new_connection,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_accept(tcp_connection::pointer new_connection,
+      const boost::asio::error& error)
+  {
+    if (!error)
+    {
+      new_connection->start();
+      start_accept();
+    }
+  }
+
+  tcp::acceptor acceptor_;
+};
+
+class udp_server
+{
+public:
+  udp_server(boost::asio::io_service& io_service)
+    : socket_(io_service, udp::endpoint(udp::v4(), 13))
+  {
+    start_receive();
+  }
+
+private:
+  void start_receive()
+  {
+    socket_.async_receive_from(
+        boost::asio::buffer(recv_buffer_), remote_endpoint_,
+        boost::bind(&udp_server::handle_receive, this,
+          boost::asio::placeholders::error));
+  }
+
+  void handle_receive(const boost::asio::error& error)
+  {
+    if (!error || error == boost::asio::error::message_size)
+    {
+      boost::shared_ptr<std::string> message(
+          new std::string(make_daytime_string()));
+
+      socket_.async_send_to(boost::asio::buffer(*message), remote_endpoint_,
+          boost::bind(&udp_server::handle_send, this, message));
+
+      start_receive();
+    }
+  }
+
+  void handle_send(boost::shared_ptr<std::string> /*message*/)
+  {
+  }
+
+  udp::socket socket_;
+  udp::endpoint remote_endpoint_;
+  boost::array<char, 1> recv_buffer_;
+};
+
+int main()
+{
+  try
+  {
+    boost::asio::io_service io_service;
+    tcp_server server1(io_service);
+    udp_server server2(io_service);
+    io_service.run();
+  }
+  catch (std::exception& e)
+  {
+    std::cerr << e.what() << std::endl;
+  }
+
+  return 0;
+}
diff --git a/example/tutorial/timer1/timer.cpp b/example/tutorial/timer1/timer.cpp
new file mode 100644
index 0000000000..bc86837c6c
--- /dev/null
+++ b/example/tutorial/timer1/timer.cpp
@@ -0,0 +1,15 @@
+#include <iostream>
+#include <boost/asio.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+int main()
+{
+  boost::asio::io_service io;
+
+  boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
+  t.wait();
+
+  std::cout << "Hello, world!\n";
+
+  return 0;
+}
diff --git a/example/tutorial/timer2/timer.cpp b/example/tutorial/timer2/timer.cpp
new file mode 100644
index 0000000000..a7c25b8d68
--- /dev/null
+++ b/example/tutorial/timer2/timer.cpp
@@ -0,0 +1,20 @@
+#include <iostream>
+#include <boost/asio.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+void print(const boost::asio::error& /*e*/)
+{
+  std::cout << "Hello, world!\n";
+}
+
+int main()
+{
+  boost::asio::io_service io;
+
+  boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
+  t.async_wait(print);
+
+  io.run();
+
+  return 0;
+}
diff --git a/example/tutorial/timer3/timer.cpp b/example/tutorial/timer3/timer.cpp
new file mode 100644
index 0000000000..69d2242746
--- /dev/null
+++ b/example/tutorial/timer3/timer.cpp
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+void print(const boost::asio::error& /*e*/,
+    boost::asio::deadline_timer* t, int* count)
+{
+  if (*count < 5)
+  {
+    std::cout << *count << "\n";
+    ++(*count);
+
+    t->expires_at(t->expires_at() + boost::posix_time::seconds(1));
+    t->async_wait(boost::bind(print,
+          boost::asio::placeholders::error, t, count));
+  }
+}
+
+int main()
+{
+  boost::asio::io_service io;
+
+  int count = 0;
+  boost::asio::deadline_timer t(io, boost::posix_time::seconds(1));
+  t.async_wait(boost::bind(print,
+        boost::asio::placeholders::error, &t, &count));
+
+  io.run();
+
+  std::cout << "Final count is " << count << "\n";
+
+  return 0;
+}
diff --git a/example/tutorial/timer4/timer.cpp b/example/tutorial/timer4/timer.cpp
new file mode 100644
index 0000000000..2d0db71416
--- /dev/null
+++ b/example/tutorial/timer4/timer.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+class printer
+{
+public:
+  printer(boost::asio::io_service& io)
+    : timer_(io, boost::posix_time::seconds(1)),
+      count_(0)
+  {
+    timer_.async_wait(boost::bind(&printer::print, this));
+  }
+
+  ~printer()
+  {
+    std::cout << "Final count is " << count_ << "\n";
+  }
+
+  void print()
+  {
+    if (count_ < 5)
+    {
+      std::cout << count_ << "\n";
+      ++count_;
+
+      timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
+      timer_.async_wait(boost::bind(&printer::print, this));
+    }
+  }
+
+private:
+  boost::asio::deadline_timer timer_;
+  int count_;
+};
+
+int main()
+{
+  boost::asio::io_service io;
+  printer p(io);
+  io.run();
+
+  return 0;
+}
diff --git a/example/tutorial/timer5/timer.cpp b/example/tutorial/timer5/timer.cpp
new file mode 100644
index 0000000000..2bc881ac63
--- /dev/null
+++ b/example/tutorial/timer5/timer.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+class printer
+{
+public:
+  printer(boost::asio::io_service& io)
+    : strand_(io),
+      timer1_(io, boost::posix_time::seconds(1)),
+      timer2_(io, boost::posix_time::seconds(1)),
+      count_(0)
+  {
+    timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, this)));
+    timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, this)));
+  }
+
+  ~printer()
+  {
+    std::cout << "Final count is " << count_ << "\n";
+  }
+
+  void print1()
+  {
+    if (count_ < 10)
+    {
+      std::cout << "Timer 1: " << count_ << "\n";
+      ++count_;
+
+      timer1_.expires_at(timer1_.expires_at() + boost::posix_time::seconds(1));
+      timer1_.async_wait(strand_.wrap(boost::bind(&printer::print1, this)));
+    }
+  }
+
+  void print2()
+  {
+    if (count_ < 10)
+    {
+      std::cout << "Timer 2: " << count_ << "\n";
+      ++count_;
+
+      timer2_.expires_at(timer2_.expires_at() + boost::posix_time::seconds(1));
+      timer2_.async_wait(strand_.wrap(boost::bind(&printer::print2, this)));
+    }
+  }
+
+private:
+  boost::asio::strand strand_;
+  boost::asio::deadline_timer timer1_;
+  boost::asio::deadline_timer timer2_;
+  int count_;
+};
+
+int main()
+{
+  boost::asio::io_service io;
+  printer p(io);
+  boost::thread t(boost::bind(&boost::asio::io_service::run, &io));
+  io.run();
+  t.join();
+
+  return 0;
+}
diff --git a/include/boost/asio.hpp b/include/boost/asio.hpp
new file mode 100644
index 0000000000..d718d18ccc
--- /dev/null
+++ b/include/boost/asio.hpp
@@ -0,0 +1,71 @@
+//
+// asio.hpp
+// ~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_HPP
+#define BOOST_ASIO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/basic_datagram_socket.hpp>
+#include <boost/asio/basic_deadline_timer.hpp>
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/basic_resolver.hpp>
+#include <boost/asio/basic_socket_acceptor.hpp>
+#include <boost/asio/basic_socket_iostream.hpp>
+#include <boost/asio/basic_socketbuf.hpp>
+#include <boost/asio/basic_strand.hpp>
+#include <boost/asio/basic_stream_socket.hpp>
+#include <boost/asio/basic_streambuf.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/buffered_read_stream_fwd.hpp>
+#include <boost/asio/buffered_read_stream.hpp>
+#include <boost/asio/buffered_stream_fwd.hpp>
+#include <boost/asio/buffered_stream.hpp>
+#include <boost/asio/buffered_write_stream_fwd.hpp>
+#include <boost/asio/buffered_write_stream.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/datagram_socket_service.hpp>
+#include <boost/asio/deadline_timer_service.hpp>
+#include <boost/asio/deadline_timer.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/handler_alloc_hook.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+#include <boost/asio/ip/address_v6.hpp>
+#include <boost/asio/ip/basic_endpoint.hpp>
+#include <boost/asio/ip/basic_resolver_entry.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/ip/host_name.hpp>
+#include <boost/asio/ip/multicast.hpp>
+#include <boost/asio/ip/resolver_query_base.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/ip/udp.hpp>
+#include <boost/asio/is_read_buffered.hpp>
+#include <boost/asio/is_write_buffered.hpp>
+#include <boost/asio/placeholders.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/read_until.hpp>
+#include <boost/asio/resolver_service.hpp>
+#include <boost/asio/socket_acceptor_service.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/asio/strand_service.hpp>
+#include <boost/asio/stream_socket_service.hpp>
+#include <boost/asio/streambuf.hpp>
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/time_traits.hpp>
+#include <boost/asio/write.hpp>
+
+#endif // BOOST_ASIO_HPP
diff --git a/include/boost/asio/basic_datagram_socket.hpp b/include/boost/asio/basic_datagram_socket.hpp
new file mode 100644
index 0000000000..bb8fc9929a
--- /dev/null
+++ b/include/boost/asio/basic_datagram_socket.hpp
@@ -0,0 +1,802 @@
+//
+// basic_datagram_socket.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
+#define BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_socket.hpp>
+#include <boost/asio/datagram_socket_service.hpp>
+#include <boost/asio/error_handler.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides datagram-oriented socket functionality.
+/**
+ * The basic_datagram_socket class template provides asynchronous and blocking
+ * datagram-oriented socket functionality.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Error_Source.
+ */
+template <typename Protocol,
+    typename Service = datagram_socket_service<Protocol> >
+class basic_datagram_socket
+  : public basic_socket<Protocol, Service>
+{
+public:
+  /// The native representation of a socket.
+  typedef typename Service::native_type native_type;
+
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// Construct a basic_datagram_socket without opening it.
+  /**
+   * 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
+   * to dispatch handlers for any asynchronous operations performed on the
+   * socket.
+   */
+  explicit basic_datagram_socket(boost::asio::io_service& io_service)
+    : basic_socket<Protocol, Service>(io_service)
+  {
+  }
+
+  /// Construct and open a basic_datagram_socket.
+  /**
+   * This constructor creates and opens a datagram socket.
+   *
+   * @param io_service The io_service object that the datagram socket will use
+   * to dispatch handlers for any asynchronous operations performed on the
+   * socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_datagram_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol)
+    : basic_socket<Protocol, Service>(io_service, protocol)
+  {
+  }
+
+  /// Construct a basic_datagram_socket, opening it and binding it to the given
+  /// local endpoint.
+  /**
+   * This constructor creates a datagram socket and automatically opens it bound
+   * to the specified endpoint on the local machine. The protocol used is the
+   * protocol associated with the given endpoint.
+   *
+   * @param io_service The io_service object that the datagram 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 datagram
+   * socket will be bound.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_datagram_socket(boost::asio::io_service& io_service,
+      const endpoint_type& endpoint)
+    : basic_socket<Protocol, Service>(io_service, endpoint)
+  {
+  }
+
+  /// Construct a basic_datagram_socket on an existing native 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
+   * to dispatch handlers for any asynchronous operations performed on the
+   * socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @param native_socket The new underlying socket implementation.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_datagram_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol, const native_type& native_socket)
+    : basic_socket<Protocol, Service>(io_service, protocol, native_socket)
+  {
+  }
+
+  /// Send some data on a connected socket.
+  /**
+   * This function is used to send data on the datagram socket. The function
+   * call will block until the data has been sent successfully or an error
+   * occurs.
+   *
+   * @param buffers One ore more data buffers to be sent on the socket.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note The send operation can only be used with a connected socket. Use
+   * the send_to function to send data on an unconnected datagram socket.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code socket.send(boost::asio::buffer(data, size)); @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers>
+  std::size_t send(const Const_Buffers& buffers)
+  {
+    return this->service.send(this->implementation, buffers, 0, throw_error());
+  }
+
+  /// Send some data on a connected socket.
+  /**
+   * This function is used to send data on the datagram socket. The function
+   * call will block until the data has been sent successfully or an error
+   * occurs.
+   *
+   * @param buffers One ore more data buffers to be sent on the socket.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note The send operation can only be used with a connected socket. Use
+   * the send_to function to send data on an unconnected datagram socket.
+   */
+  template <typename Const_Buffers>
+  std::size_t send(const Const_Buffers& buffers,
+      socket_base::message_flags flags)
+  {
+    return this->service.send(this->implementation, buffers, flags,
+        throw_error());
+  }
+
+  /// Send some data on a connected socket.
+  /**
+   * This function is used to send data on the datagram socket. The function
+   * call will block until the data has been sent successfully or an error
+   * occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes sent.
+   *
+   * @note The send operation can only be used with a connected socket. Use
+   * the send_to function to send data on an unconnected datagram socket.
+   */
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send(const Const_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return this->service.send(this->implementation, buffers, flags,
+        error_handler);
+  }
+
+  /// Start an asynchronous send on a connected socket.
+  /**
+   * This function is used to send data on the datagram socket. The function
+   * call will block until the data has been sent successfully or an error
+   * occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket. Although
+   * the buffers object may be copied as necessary, ownership of the underlying
+   * memory blocks is retained by the caller, which must guarantee that they
+   * remain valid until the handler is called.
+   *
+   * @param handler The handler to be called when the send operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes sent.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * socket.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.async_send(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers, typename Handler>
+  void async_send(const Const_Buffers& buffers, Handler handler)
+  {
+    this->service.async_send(this->implementation, buffers, 0, handler);
+  }
+
+  /// Start an asynchronous send on a connected socket.
+  /**
+   * This function is used to send data on the datagram socket. The function
+   * call will block until the data has been sent successfully or an error
+   * occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket. Although
+   * the buffers object may be copied as necessary, ownership of the underlying
+   * memory blocks is retained by the caller, which must guarantee that they
+   * remain valid until the handler is called.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param handler The handler to be called when the send operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes sent.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * socket.
+   */
+  template <typename Const_Buffers, typename Handler>
+  void async_send(const Const_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    this->service.async_send(this->implementation, buffers, flags, handler);
+  }
+
+  /// Send a datagram to the specified endpoint.
+  /**
+   * This function is used to send a datagram to the specified remote endpoint.
+   * The function call will block until the data has been sent successfully or
+   * an error occurs.
+   *
+   * @param buffers One or more data buffers to be sent to the remote endpoint.
+   *
+   * @param destination The remote endpoint to which the data will be sent.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * boost::asio::ipv4::udp::endpoint destination(12345, "1.2.3.4");
+   * socket.send_to(boost::asio::buffer(data, size), destination);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers>
+  std::size_t send_to(const Const_Buffers& buffers,
+      const endpoint_type& destination)
+  {
+    return this->service.send_to(this->implementation, buffers, destination, 0,
+        throw_error());
+  }
+
+  /// Send a datagram to the specified endpoint.
+  /**
+   * This function is used to send a datagram to the specified remote endpoint.
+   * The function call will block until the data has been sent successfully or
+   * an error occurs.
+   *
+   * @param buffers One or more data buffers to be sent to the remote endpoint.
+   *
+   * @param destination The remote endpoint to which the data will be sent.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  template <typename Const_Buffers>
+  std::size_t send_to(const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags)
+  {
+    return this->service.send_to(this->implementation, buffers, destination,
+        flags, throw_error());
+  }
+
+  /// Send a datagram to the specified endpoint.
+  /**
+   * This function is used to send a datagram to the specified remote endpoint.
+   * The function call will block until the data has been sent successfully or
+   * an error occurs.
+   *
+   * @param buffers One or more data buffers to be sent to the remote endpoint.
+   *
+   * @param destination The remote endpoint to which the data will be sent.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes sent.
+   */
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send_to(const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    return this->service.send_to(this->implementation, buffers, destination,
+        flags, error_handler);
+  }
+
+  /// Start an asynchronous send.
+  /**
+   * This function is used to asynchronously send a datagram to the specified
+   * remote endpoint. The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be sent to the remote endpoint.
+   * 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 destination The remote endpoint to which the data will be sent.
+   * Copies will be made of the endpoint as required.
+   *
+   * @param handler The handler to be called when the send operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes sent.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * boost::asio::ipv4::udp::endpoint destination(12345, "1.2.3.4");
+   * socket.async_send_to(
+   *     boost::asio::buffer(data, size), destination, handler);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers, typename Handler>
+  void async_send_to(const Const_Buffers& buffers,
+      const endpoint_type& destination, Handler handler)
+  {
+    this->service.async_send_to(this->implementation, buffers, destination, 0,
+        handler);
+  }
+
+  /// Start an asynchronous send.
+  /**
+   * This function is used to asynchronously send a datagram to the specified
+   * remote endpoint. The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be sent to the remote endpoint.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param destination The remote endpoint to which the data will be sent.
+   * Copies will be made of the endpoint as required.
+   *
+   * @param handler The handler to be called when the send operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes sent.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   */
+  template <typename Const_Buffers, typename Handler>
+  void async_send_to(const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Handler handler)
+  {
+    this->service.async_send_to(this->implementation, buffers, destination,
+        flags, handler);
+  }
+
+  /// Receive some data on a connected socket.
+  /**
+   * This function is used to receive data on the datagram socket. The function
+   * call will block until data has been received successfully or an error
+   * occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note The receive operation can only be used with a connected socket. Use
+   * the receive_from function to receive data on an unconnected datagram
+   * socket.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code socket.receive(boost::asio::buffer(data, size)); @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t receive(const Mutable_Buffers& buffers)
+  {
+    return this->service.receive(this->implementation, buffers, 0,
+        throw_error());
+  }
+
+  /// Receive some data on a connected socket.
+  /**
+   * This function is used to receive data on the datagram socket. The function
+   * call will block until data has been received successfully or an error
+   * occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note The receive operation can only be used with a connected socket. Use
+   * the receive_from function to receive data on an unconnected datagram
+   * socket.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t receive(const Mutable_Buffers& buffers,
+      socket_base::message_flags flags)
+  {
+    return this->service.receive(this->implementation, buffers, flags,
+        throw_error());
+  }
+
+  /// Receive some data on a connected socket.
+  /**
+   * This function is used to receive data on the datagram socket. The function
+   * call will block until data has been received successfully or an error
+   * occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes received.
+   *
+   * @note The receive operation can only be used with a connected socket. Use
+   * the receive_from function to receive data on an unconnected datagram
+   * socket.
+   */
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive(const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return this->service.receive(this->implementation, buffers, flags,
+        error_handler);
+  }
+
+  /// Start an asynchronous receive on a connected socket.
+  /**
+   * This function is used to asynchronously receive data from the datagram
+   * socket. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param handler The handler to be called when the receive operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes received.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * datagram socket.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.async_receive(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(const Mutable_Buffers& buffers, Handler handler)
+  {
+    this->service.async_receive(this->implementation, buffers, 0, handler);
+  }
+
+  /// Start an asynchronous receive on a connected socket.
+  /**
+   * This function is used to asynchronously receive data from the datagram
+   * socket. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @param handler The handler to be called when the receive operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes received.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * datagram socket.
+   */
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    this->service.async_receive(this->implementation, buffers, flags, handler);
+  }
+
+  /// Receive a datagram with the endpoint of the sender.
+  /**
+   * This function is used to receive a datagram. The function call will block
+   * until data has been received successfully or an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param sender_endpoint An endpoint object that receives the endpoint of
+   * the remote sender of the datagram.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * boost::asio::ipv4::udp::endpoint sender_endpoint;
+   * socket.receive_from(
+   *     boost::asio::buffer(data, size), sender_endpoint);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t receive_from(const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint)
+  {
+    return this->service.receive_from(this->implementation, buffers,
+        sender_endpoint, 0, throw_error());
+  }
+  
+  /// Receive a datagram with the endpoint of the sender.
+  /**
+   * This function is used to receive a datagram. The function call will block
+   * until data has been received successfully or an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param sender_endpoint An endpoint object that receives the endpoint of
+   * the remote sender of the datagram.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t receive_from(const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags)
+  {
+    return this->service.receive_from(this->implementation, buffers,
+        sender_endpoint, flags, throw_error());
+  }
+  
+  /// Receive a datagram with the endpoint of the sender.
+  /**
+   * This function is used to receive a datagram. The function call will block
+   * until data has been received successfully or an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param sender_endpoint An endpoint object that receives the endpoint of
+   * the remote sender of the datagram.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes received.
+   */
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive_from(const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    return this->service.receive_from(this->implementation, buffers,
+        sender_endpoint, flags, error_handler);
+  }
+
+  /// Start an asynchronous receive.
+  /**
+   * This function is used to asynchronously receive a datagram. The function
+   * call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param sender_endpoint An endpoint object that receives the endpoint of
+   * the remote sender of the datagram. Ownership of the sender_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 receive operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes received.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code socket.async_receive_from(
+   *     boost::asio::buffer(data, size), 0, sender_endpoint, handler); @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive_from(const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint, Handler handler)
+  {
+    this->service.async_receive_from(this->implementation, buffers,
+        sender_endpoint, 0, handler);
+  }
+
+  /// Start an asynchronous receive.
+  /**
+   * This function is used to asynchronously receive a datagram. The function
+   * call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param sender_endpoint An endpoint object that receives the endpoint of
+   * the remote sender of the datagram. Ownership of the sender_endpoint object
+   * is retained by the caller, which must guarantee that it is valid until the
+   * handler is called.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @param handler The handler to be called when the receive operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes received.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   */
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive_from(const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags,
+      Handler handler)
+  {
+    this->service.async_receive_from(this->implementation, buffers,
+        sender_endpoint, flags, handler);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
diff --git a/include/boost/asio/basic_deadline_timer.hpp b/include/boost/asio/basic_deadline_timer.hpp
new file mode 100644
index 0000000000..e0bc65c856
--- /dev/null
+++ b/include/boost/asio/basic_deadline_timer.hpp
@@ -0,0 +1,311 @@
+//
+// basic_deadline_timer.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
+#define BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/deadline_timer_service.hpp>
+#include <boost/asio/error.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides waitable timer functionality.
+/**
+ * The basic_deadline_timer class template provides the ability to perform a
+ * blocking or asynchronous wait for a timer to expire.
+ *
+ * Most applications will use the boost::asio::deadline_timer typedef.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Error_Source.
+ *
+ * @sa @ref deadline_timer_reset
+ *
+ * @par Examples:
+ * Performing a blocking wait:
+ * @code
+ * // Construct a timer without setting an expiry time.
+ * boost::asio::deadline_timer timer(io_service);
+ *
+ * // Set an expiry time relative to now.
+ * timer.expires_from_now(boost::posix_time::seconds(5));
+ *
+ * // Wait for the timer to expire.
+ * timer.wait();
+ * @endcode
+ *
+ * @par 
+ * Performing an asynchronous wait:
+ * @code
+ * void handler(const boost::asio::error& error)
+ * {
+ *   if (!error)
+ *   {
+ *     // Timer expired.
+ *   }
+ * }
+ *
+ * ...
+ *
+ * // Construct a timer with an absolute expiry time.
+ * boost::asio::deadline_timer timer(io_service,
+ *     boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
+ *
+ * // Start an asynchronous wait.
+ * timer.async_wait(handler);
+ * @endcode
+ */
+template <typename Time_Type,
+    typename Time_Traits = boost::asio::time_traits<Time_Type>,
+    typename Service = deadline_timer_service<Time_Type, Time_Traits> >
+class basic_deadline_timer
+  : public basic_io_object<Service>
+{
+public:
+  /// The type used for reporting errors.
+  typedef boost::asio::error error_type;
+
+  /// The time traits type.
+  typedef Time_Traits traits_type;
+
+  /// The time type.
+  typedef typename traits_type::time_type time_type;
+
+  /// The duration type.
+  typedef typename traits_type::duration_type duration_type;
+
+  /// 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.
+   *
+   * @param io_service The io_service object that the timer will use to dispatch
+   * handlers for any asynchronous operations performed on the timer.
+   */
+  explicit basic_deadline_timer(boost::asio::io_service& io_service)
+    : basic_io_object<Service>(io_service)
+  {
+  }
+
+  /// Constructor to set a particular expiry time as an absolute time.
+  /**
+   * This constructor creates a timer and sets the expiry time.
+   *
+   * @param io_service The io_service 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(boost::asio::io_service& io_service,
+      const time_type& expiry_time)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.expires_at(this->implementation, expiry_time);
+  }
+
+  /// Constructor to set a particular expiry time relative to now.
+  /**
+   * This constructor creates a timer and sets the expiry time.
+   *
+   * @param io_service The io_service 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(boost::asio::io_service& io_service,
+      const duration_type& expiry_time)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.expires_from_now(this->implementation, expiry_time);
+  }
+
+  /// 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
+   * be invoked with the boost::asio::error::operation_aborted error code.
+   *
+   * Cancelling the timer does not change the expiry time.
+   *
+   * @return The number of asynchronous operations that were cancelled.
+   */
+  std::size_t cancel()
+  {
+    return this->service.cancel(this->implementation);
+  }
+
+  /// 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_type expires_at() const
+  {
+    return this->service.expires_at(this->implementation);
+  }
+
+  /// 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
+   * be invoked with the boost::asio::error::operation_aborted error code.
+   *
+   * See @ref deadline_timer_reset for more information on altering the expiry
+   * time of an active timer.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   *
+   * @return The number of asynchronous operations that were cancelled.
+   */
+  std::size_t expires_at(const time_type& expiry_time)
+  {
+    return this->service.expires_at(this->implementation, expiry_time);
+  }
+
+  /// 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_type expires_from_now() const
+  {
+    return this->service.expires_from_now(this->implementation);
+  }
+
+  /// 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 boost::asio::error::operation_aborted error code.
+   *
+   * See @ref deadline_timer_reset for more information on altering the expiry
+   * time of an active timer.
+   *
+   * @param expiry_time The expiry time to be used for the timer.
+   *
+   * @return The number of asynchronous operations that were cancelled.
+   */
+  std::size_t expires_from_now(const duration_type& expiry_time)
+  {
+    return this->service.expires_from_now(this->implementation, expiry_time);
+  }
+
+  /// Perform a blocking wait on the timer.
+  /**
+   * This function is used to wait for the timer to expire. This function
+   * blocks and does not return until the timer has expired.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  void wait()
+  {
+    this->service.wait(this->implementation);
+  }
+
+  /// Start an asynchronous wait on the timer.
+  /**
+   * This function may be used to initiate an asynchronous wait against the
+   * timer. 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 The timer has expired.
+   *
+   * @li The timer was cancelled, in which case the handler is passed the error
+   * code boost::asio::error::operation_aborted.
+   *
+   * @param handler The handler to be called when the timer expires. Copies
+   * will be made of the handler as required. The function signature of the
+   * handler must be:
+   * @code void handler(
+   *   const boost::asio::error& 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
+   * boost::asio::io_service::post().
+   */
+  template <typename Handler>
+  void async_wait(Handler handler)
+  {
+    this->service.async_wait(this->implementation, handler);
+  }
+};
+
+/**
+ * @page deadline_timer_reset Changing an active deadline_timer's expiry time
+ *
+ * Changing the expiry time of a timer while there are pending asynchronous
+ * waits causes those wait operations to be cancelled. To ensure that the action
+ * associated with the timer is performed only once, use something like this:
+ * used:
+ *
+ * @code
+ * void on_some_event()
+ * {
+ *   if (my_timer.expires_from_now(seconds(5)) > 0)
+ *   {
+ *     // We managed to cancel the timer. Start new asynchronous wait.
+ *     my_timer.async_wait(on_timeout);
+ *   }
+ *   else
+ *   {
+ *     // Too late, timer has already expired!
+ *   }
+ * }
+ *
+ * void on_timeout(const boost::asio::error& e)
+ * {
+ *   if (e != boost::asio::error::operation_aborted)
+ *   {
+ *     // Timer was not cancelled, take necessary action.
+ *   }
+ * }
+ * @endcode
+ *
+ * @li The boost::asio::basic_deadline_timer::expires_from_now() 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
+ * executed. If it returns 1 then the wait handler was successfully cancelled.
+ *
+ * @li If a wait handler is cancelled, the boost::asio::error passed to it
+ * contains the value boost::asio::error::operation_aborted.
+ *
+ * @sa boost::asio::basic_deadline_timer
+ */
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
diff --git a/include/boost/asio/basic_io_object.hpp b/include/boost/asio/basic_io_object.hpp
new file mode 100644
index 0000000000..01daec194c
--- /dev/null
+++ b/include/boost/asio/basic_io_object.hpp
@@ -0,0 +1,77 @@
+//
+// basic_io_object.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_IO_OBJECT_HPP
+#define BOOST_ASIO_BASIC_IO_OBJECT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Base class for all I/O objects.
+template <typename Service>
+class basic_io_object
+  : private noncopyable
+{
+public:
+  /// The type of the service that will be used to provide I/O operations.
+  typedef Service service_type;
+
+  /// The underlying implementation type of I/O object.
+  typedef typename service_type::implementation_type implementation_type;
+
+  /// Construct a basic_io_object.
+  explicit basic_io_object(boost::asio::io_service& io_service)
+    : service(boost::asio::use_service<Service>(io_service))
+  {
+    service.construct(implementation);
+  }
+
+  /// Get the io_service associated with the object.
+  /**
+   * This function may be used to obtain the io_service object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_service object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  boost::asio::io_service& io_service()
+  {
+    return service.owner();
+  }
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~basic_io_object()
+  {
+    service.destroy(implementation);
+  }
+
+  // The backend service implementation.
+  service_type& service;
+
+  // The underlying native implementation.
+  implementation_type implementation;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_IO_OBJECT_HPP
diff --git a/include/boost/asio/basic_resolver.hpp b/include/boost/asio/basic_resolver.hpp
new file mode 100644
index 0000000000..3c321189fd
--- /dev/null
+++ b/include/boost/asio/basic_resolver.hpp
@@ -0,0 +1,254 @@
+//
+// basic_resolver.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_RESOLVER_HPP
+#define BOOST_ASIO_BASIC_RESOLVER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/resolver_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides endpoint resolution functionality.
+/**
+ * The basic_resolver class template provides the ability to resolve a query
+ * to a list of endpoints.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Error_Source.
+ */
+template <typename Protocol, typename Service = resolver_service<Protocol> >
+class basic_resolver
+  : public basic_io_object<Service>
+{
+public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// The query type.
+  typedef typename Protocol::resolver_query query;
+
+  /// The iterator type.
+  typedef typename Protocol::resolver_iterator iterator;
+
+  /// The type used for reporting errors.
+  typedef boost::asio::error error_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.
+   */
+  explicit basic_resolver(boost::asio::io_service& io_service)
+    : basic_io_object<Service>(io_service)
+  {
+  }
+
+  /// Cancel any asynchronous operations that are waiting on the resolver.
+  /**
+   * This function forces the completion of any pending asynchronous
+   * operations on the host resolver. The handler for each cancelled operation
+   * will be invoked with the boost::asio::error::operation_aborted error code.
+   */
+  void cancel()
+  {
+    return this->service.cancel(this->implementation);
+  }
+
+  /// Resolve 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.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * @note A successful call to this function is guaranteed to return at least
+   * one entry.
+   */
+  iterator resolve(const query& q)
+  {
+    return this->service.resolve(this->implementation, q, throw_error());
+  }
+
+  /// Resolve 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 default constructed iterator if an error
+   * occurs.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * @note A successful call to this function is guaranteed to return at least
+   * one entry.
+   */
+  template <typename Error_Handler>
+  iterator resolve(const query& q, Error_Handler error_handler)
+  {
+    return this->service.resolve(this->implementation, q, error_handler);
+  }
+
+  /// Asynchronously resolve a query to a list of entries.
+  /**
+   * This function is used to asynchronously resolve a query into a list of
+   * endpoint entries.
+   *
+   * @param q A query object that determines what endpoints will be returned.
+   *
+   * @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 boost::asio::error& error,   // Result of operation.
+   *   resolver::iterator iterator // Forward-only iterator that can be used to
+   *                               // traverse the list of endpoint entries.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * @note A successful resolve operation is guaranteed to pass at least one
+   * entry to the handler.
+   */
+  template <typename Handler>
+  void async_resolve(const query& q, Handler handler)
+  {
+    return this->service.async_resolve(this->implementation, q, handler);
+  }
+
+  /// Resolve an endpoint to a list of entries.
+  /**
+   * This function is used to resolve an endpoint into a list of endpoint
+   * entries.
+   *
+   * @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.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * @note A successful call to this function is guaranteed to return at least
+   * one entry.
+   */
+  iterator resolve(const endpoint_type& e)
+  {
+    return this->service.resolve(this->implementation, e, throw_error());
+  }
+
+  /// Resolve an endpoint to a list of entries.
+  /**
+   * This function is used to resolve an endpoint into a list of endpoint
+   * entries.
+   *
+   * @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 default constructed iterator if an error
+   * occurs.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * @note A successful call to this function is guaranteed to return at least
+   * one entry.
+   */
+  template <typename Error_Handler>
+  iterator resolve(const endpoint_type& e, Error_Handler error_handler)
+  {
+    return this->service.resolve(this->implementation, e, error_handler);
+  }
+
+  /// Asynchronously resolve an endpoint to a list of entries.
+  /**
+   * This function is used to asynchronously resolve an endpoint into a list of
+   * endpoint entries.
+   *
+   * @param e An endpoint object that determines what endpoints will be
+   * returned.
+   *
+   * @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 boost::asio::error& error,   // Result of operation.
+   *   resolver::iterator iterator // Forward-only iterator that can be used to
+   *                               // traverse the list of endpoint entries.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @note A default constructed iterator represents the end of the list.
+   *
+   * @note A successful resolve operation is guaranteed to pass at least one
+   * entry to the handler.
+   */
+  template <typename Handler>
+  void async_resolve(const endpoint_type& e, Handler handler)
+  {
+    return this->service.async_resolve(this->implementation, e, handler);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_RESOLVER_HPP
diff --git a/include/boost/asio/basic_socket.hpp b/include/boost/asio/basic_socket.hpp
new file mode 100644
index 0000000000..327d14cf7b
--- /dev/null
+++ b/include/boost/asio/basic_socket.hpp
@@ -0,0 +1,884 @@
+//
+// basic_socket.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_SOCKET_HPP
+#define BOOST_ASIO_BASIC_SOCKET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/socket_base.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides socket functionality.
+/**
+ * The basic_socket class template provides functionality that is common to both
+ * stream-oriented and datagram-oriented sockets.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Error_Source, IO_Object.
+ */
+template <typename Protocol, typename Service>
+class basic_socket
+  : public basic_io_object<Service>,
+    public socket_base
+{
+public:
+  /// The native representation of a socket.
+  typedef typename Service::native_type native_type;
+
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// The type used for reporting errors.
+  typedef boost::asio::error error_type;
+
+  /// A basic_socket is always the lowest layer.
+  typedef basic_socket<Protocol, Service> lowest_layer_type;
+
+  /// 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
+   * dispatch handlers for any asynchronous operations performed on the socket.
+   */
+  explicit basic_socket(boost::asio::io_service& io_service)
+    : basic_io_object<Service>(io_service)
+  {
+  }
+
+  /// Construct and open a basic_socket.
+  /**
+   * This constructor creates and opens a socket.
+   *
+   * @param io_service The io_service 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 boost::asio::error Thrown on failure.
+   */
+  basic_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.open(this->implementation, protocol, throw_error());
+  }
+
+  /// Construct a basic_socket, opening it and binding it to the given local
+  /// endpoint.
+  /**
+   * This constructor creates a socket and automatically opens it bound to the
+   * specified endpoint on the local machine. The protocol used is the protocol
+   * associated with the given endpoint.
+   *
+   * @param io_service The io_service object that the 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
+   * be bound.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_socket(boost::asio::io_service& io_service,
+      const endpoint_type& endpoint)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.open(this->implementation, endpoint.protocol(),
+        throw_error());
+    this->service.bind(this->implementation, endpoint, throw_error());
+  }
+
+  /// Construct a basic_socket on an existing native 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
+   * dispatch handlers for any asynchronous operations performed on the socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @param native_socket A native socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol, const native_type& native_socket)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.assign(this->implementation, protocol, native_socket,
+        throw_error());
+  }
+
+  /// Get a reference to the lowest layer.
+  /**
+   * This function returns a reference to the lowest layer in a stack of
+   * layers. Since a basic_socket 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;
+  }
+
+  /// Open the socket using the specified protocol.
+  /**
+   * This function opens the socket so that it will use the specified protocol.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * socket.open(boost::asio::ipv4::tcp());
+   * @endcode
+   */
+  void open(const protocol_type& protocol = protocol_type())
+  {
+    this->service.open(this->implementation, protocol, throw_error());
+  }
+
+  /// Open the socket using the specified protocol.
+  /**
+   * This function opens the socket so that it will use the specified protocol.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * boost::asio::error error;
+   * socket.open(boost::asio::ipv4::tcp(), boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void open(const protocol_type& protocol, Error_Handler error_handler)
+  {
+    this->service.open(this->implementation, protocol, error_handler);
+  }
+
+  /// Assign an existing native socket to the socket.
+  /*
+   * This function opens the socket to hold an existing native socket.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @param native_socket A native socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  void assign(const protocol_type& protocol, const native_type& native_socket)
+  {
+    this->service.assign(this->implementation, protocol, native_socket,
+        throw_error());
+  }
+
+  /// Assign an existing native socket to the socket.
+  /*
+   * This function opens the socket to hold an existing native socket.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @param native_socket A native socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void assign(const protocol_type& protocol, const native_type& native_socket,
+      Error_Handler error_handler)
+  {
+    this->service.assign(this->implementation, protocol, native_socket,
+        error_handler);
+  }
+
+  /// Close the socket.
+  /**
+   * This function is used to close the socket. Any asynchronous send, receive
+   * or connect operations will be cancelled immediately, and will complete
+   * with the boost::asio::error::operation_aborted error.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  void close()
+  {
+    this->service.close(this->implementation, throw_error());
+  }
+
+  /// Close the socket.
+  /**
+   * This function is used to close the socket. Any asynchronous send, receive
+   * or connect operations will be cancelled immediately, and will complete
+   * with the boost::asio::error::operation_aborted error.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::error error;
+   * socket.close(boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void close(Error_Handler error_handler)
+  {
+    this->service.close(this->implementation, error_handler);
+  }
+
+  /// Get the native socket representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * socket. This is intended to allow access to native socket functionality
+   * that is not otherwise provided.
+   */
+  native_type native()
+  {
+    return this->service.native(this->implementation);
+  }
+
+  /// Bind the socket to the given local endpoint.
+  /**
+   * This function binds the socket to the specified endpoint on the local
+   * machine.
+   *
+   * @param endpoint An endpoint on the local machine to which the socket will
+   * be bound.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * socket.open(boost::asio::ipv4::tcp());
+   * socket.bind(boost::asio::ipv4::tcp::endpoint(12345));
+   * @endcode
+   */
+  void bind(const endpoint_type& endpoint)
+  {
+    this->service.bind(this->implementation, endpoint, throw_error());
+  }
+
+  /// Bind the socket to the given local endpoint.
+  /**
+   * This function binds the socket to the specified endpoint on the local
+   * machine.
+   *
+   * @param endpoint An endpoint on the local machine to which the socket will
+   * be bound.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * socket.open(boost::asio::ipv4::tcp());
+   * boost::asio::error error;
+   * socket.bind(boost::asio::ipv4::tcp::endpoint(12345),
+   *     boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void bind(const endpoint_type& endpoint, Error_Handler error_handler)
+  {
+    this->service.bind(this->implementation, endpoint, error_handler);
+  }
+
+  /// Connect the socket to the specified endpoint.
+  /**
+   * This function is used to connect a socket to the specified remote endpoint.
+   * The function call will block until the connection is successfully made or
+   * an error occurs.
+   *
+   * The socket is automatically opened if it is not already open. If the
+   * connect fails, and the socket was automatically opened, the socket is
+   * returned to the closed state.
+   *
+   * @param peer_endpoint The remote endpoint to which the socket will be
+   * connected.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * boost::asio::ipv4::tcp::endpoint endpoint(12345, "1.2.3.4");
+   * socket.connect(endpoint);
+   * @endcode
+   */
+  void connect(const endpoint_type& peer_endpoint)
+  {
+    this->service.connect(this->implementation, peer_endpoint, throw_error());
+  }
+
+  /// Connect the socket to the specified endpoint.
+  /**
+   * This function is used to connect a socket to the specified remote endpoint.
+   * The function call will block until the connection is successfully made or
+   * an error occurs.
+   *
+   * The socket is automatically opened if it is not already open. If the
+   * connect fails, and the socket was automatically opened, the socket is
+   * returned to the closed state.
+   *
+   * @param peer_endpoint The remote endpoint to which the socket will be
+   * connected.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * boost::asio::ipv4::tcp::endpoint endpoint(12345, "1.2.3.4");
+   * boost::asio::error error;
+   * socket.connect(endpoint, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void connect(const endpoint_type& peer_endpoint, Error_Handler error_handler)
+  {
+    this->service.connect(this->implementation, peer_endpoint, error_handler);
+  }
+
+  /// Start an asynchronous connect.
+  /**
+   * This function is used to asynchronously connect a socket to the specified
+   * remote endpoint. The function call always returns immediately.
+   *
+   * The socket is automatically opened if it is not already open. If the
+   * connect fails, and the socket was automatically opened, the socket is
+   * returned to the closed state.
+   *
+   * @param peer_endpoint The remote endpoint to which the socket will be
+   * connected. Copies will be made of the endpoint object as required.
+   *
+   * @param handler The handler to be called when the connection operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& 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
+   * boost::asio::io_service::post().
+   *
+   * @par Example:
+   * @code
+   * void connect_handler(const boost::asio::error& error)
+   * {
+   *   if (!error)
+   *   {
+   *     // Connect succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * boost::asio::ipv4::tcp::endpoint endpoint(12345, "1.2.3.4");
+   * socket.async_connect(endpoint, connect_handler);
+   * @endcode
+   */
+  template <typename Handler>
+  void async_connect(const endpoint_type& peer_endpoint, Handler handler)
+  {
+    this->service.async_connect(this->implementation, peer_endpoint, handler);
+  }
+
+  /// Set an option on the socket.
+  /**
+   * This function is used to set an option on the socket.
+   *
+   * @param option The new option value to be set on the socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::broadcast @n
+   * boost::asio::socket_base::do_not_route @n
+   * boost::asio::socket_base::keep_alive @n
+   * boost::asio::socket_base::linger @n
+   * boost::asio::socket_base::receive_buffer_size @n
+   * boost::asio::socket_base::receive_low_watermark @n
+   * boost::asio::socket_base::reuse_address @n
+   * boost::asio::socket_base::send_buffer_size @n
+   * boost::asio::socket_base::send_low_watermark @n
+   * boost::asio::ipv4::multicast::add_membership @n
+   * boost::asio::ipv4::multicast::drop_membership @n
+   * boost::asio::ipv4::multicast::enable_loopback @n
+   * boost::asio::ipv4::multicast::outbound_interface @n
+   * boost::asio::ipv4::multicast::time_to_live @n
+   * boost::asio::ipv4::tcp::no_delay
+   *
+   * @par Example:
+   * Setting the IPPROTO_TCP/TCP_NODELAY option:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::no_delay option(true);
+   * socket.set_option(option);
+   * @endcode
+   */
+  template <typename Socket_Option>
+  void set_option(const Socket_Option& option)
+  {
+    this->service.set_option(this->implementation, option, throw_error());
+  }
+
+  /// Set an option on the socket.
+  /**
+   * This function is used to set an option on the socket.
+   *
+   * @param option The new option value to be set on the socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::broadcast @n
+   * boost::asio::socket_base::do_not_route @n
+   * boost::asio::socket_base::keep_alive @n
+   * boost::asio::socket_base::linger @n
+   * boost::asio::socket_base::receive_buffer_size @n
+   * boost::asio::socket_base::receive_low_watermark @n
+   * boost::asio::socket_base::reuse_address @n
+   * boost::asio::socket_base::send_buffer_size @n
+   * boost::asio::socket_base::send_low_watermark @n
+   * boost::asio::ipv4::multicast::add_membership @n
+   * boost::asio::ipv4::multicast::drop_membership @n
+   * boost::asio::ipv4::multicast::enable_loopback @n
+   * boost::asio::ipv4::multicast::outbound_interface @n
+   * boost::asio::ipv4::multicast::time_to_live @n
+   * boost::asio::ipv4::tcp::no_delay
+   *
+   * @par Example:
+   * Setting the IPPROTO_TCP/TCP_NODELAY option:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::no_delay option(true);
+   * boost::asio::error error;
+   * socket.set_option(option, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Socket_Option, typename Error_Handler>
+  void set_option(const Socket_Option& option, Error_Handler error_handler)
+  {
+    this->service.set_option(this->implementation, option, error_handler);
+  }
+
+  /// Get an option from the socket.
+  /**
+   * This function is used to get the current value of an option on the socket.
+   *
+   * @param option The option value to be obtained from the socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::broadcast @n
+   * boost::asio::socket_base::do_not_route @n
+   * boost::asio::socket_base::keep_alive @n
+   * boost::asio::socket_base::linger @n
+   * boost::asio::socket_base::receive_buffer_size @n
+   * boost::asio::socket_base::receive_low_watermark @n
+   * boost::asio::socket_base::reuse_address @n
+   * boost::asio::socket_base::send_buffer_size @n
+   * boost::asio::socket_base::send_low_watermark @n
+   * boost::asio::ipv4::multicast::add_membership @n
+   * boost::asio::ipv4::multicast::drop_membership @n
+   * boost::asio::ipv4::multicast::enable_loopback @n
+   * boost::asio::ipv4::multicast::outbound_interface @n
+   * boost::asio::ipv4::multicast::time_to_live @n
+   * boost::asio::ipv4::tcp::no_delay
+   *
+   * @par Example:
+   * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::socket::keep_alive option;
+   * socket.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   */
+  template <typename Socket_Option>
+  void get_option(Socket_Option& option) const
+  {
+    this->service.get_option(this->implementation, option, throw_error());
+  }
+
+  /// Get an option from the socket.
+  /**
+   * This function is used to get the current value of an option on the socket.
+   *
+   * @param option The option value to be obtained from the socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::broadcast @n
+   * boost::asio::socket_base::do_not_route @n
+   * boost::asio::socket_base::keep_alive @n
+   * boost::asio::socket_base::linger @n
+   * boost::asio::socket_base::receive_buffer_size @n
+   * boost::asio::socket_base::receive_low_watermark @n
+   * boost::asio::socket_base::reuse_address @n
+   * boost::asio::socket_base::send_buffer_size @n
+   * boost::asio::socket_base::send_low_watermark @n
+   * boost::asio::ipv4::multicast::add_membership @n
+   * boost::asio::ipv4::multicast::drop_membership @n
+   * boost::asio::ipv4::multicast::enable_loopback @n
+   * boost::asio::ipv4::multicast::outbound_interface @n
+   * boost::asio::ipv4::multicast::time_to_live @n
+   * boost::asio::ipv4::tcp::no_delay
+   *
+   * @par Example:
+   * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::socket::keep_alive option;
+   * boost::asio::error error;
+   * socket.get_option(option, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * bool is_set = option.get();
+   * @endcode
+   */
+  template <typename Socket_Option, typename Error_Handler>
+  void get_option(Socket_Option& option, Error_Handler error_handler) const
+  {
+    this->service.get_option(this->implementation, option, error_handler);
+  }
+
+  /// Perform an IO control command on the socket.
+  /**
+   * This function is used to execute an IO control command on the socket.
+   *
+   * @param command The IO control command to be performed on the socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @sa IO_Control_Command @n
+   * boost::asio::socket_base::bytes_readable @n
+   * boost::asio::socket_base::non_blocking_io
+   *
+   * @par Example:
+   * Getting the number of bytes ready to read:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::socket::bytes_readable command;
+   * socket.io_control(command);
+   * std::size_t bytes_readable = command.get();
+   * @endcode
+   */
+  template <typename IO_Control_Command>
+  void io_control(IO_Control_Command& command)
+  {
+    this->service.io_control(this->implementation, command, throw_error());
+  }
+
+  /// Perform an IO control command on the socket.
+  /**
+   * This function is used to execute an IO control command on the socket.
+   *
+   * @param command The IO control command to be performed on the socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @sa IO_Control_Command @n
+   * boost::asio::socket_base::bytes_readable @n
+   * boost::asio::socket_base::non_blocking_io
+   *
+   * @par Example:
+   * Getting the number of bytes ready to read:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::socket::bytes_readable command;
+   * boost::asio::error error;
+   * socket.io_control(command, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * std::size_t bytes_readable = command.get();
+   * @endcode
+   */
+  template <typename IO_Control_Command, typename Error_Handler>
+  void io_control(IO_Control_Command& command, Error_Handler error_handler)
+  {
+    this->service.io_control(this->implementation, command, error_handler);
+  }
+
+  /// Get the local endpoint of the socket.
+  /**
+   * This function is used to obtain the locally bound endpoint of the socket.
+   *
+   * @returns An object that represents the local endpoint of the socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::endpoint endpoint = socket.local_endpoint();
+   * @endcode
+   */
+  endpoint_type local_endpoint() const
+  {
+    return this->service.local_endpoint(this->implementation, throw_error());
+  }
+
+  /// Get the local endpoint of the socket.
+  /**
+   * This function is used to obtain the locally bound endpoint of the socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @returns An object that represents the local endpoint of the socket.
+   * Returns a default-constructed endpoint object if an error occurred and the
+   * error handler did not throw an exception.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::error error;
+   * boost::asio::ipv4::tcp::endpoint endpoint
+   *   = socket.local_endpoint(boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  endpoint_type local_endpoint(Error_Handler error_handler) const
+  {
+    return this->service.local_endpoint(this->implementation, error_handler);
+  }
+
+  /// Get the remote endpoint of the socket.
+  /**
+   * This function is used to obtain the remote endpoint of the socket.
+   *
+   * @returns An object that represents the remote endpoint of the socket.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::endpoint endpoint = socket.remote_endpoint();
+   * @endcode
+   */
+  endpoint_type remote_endpoint() const
+  {
+    return this->service.remote_endpoint(this->implementation, throw_error());
+  }
+
+  /// Get the remote endpoint of the socket.
+  /**
+   * This function is used to obtain the remote endpoint of the socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @returns An object that represents the remote endpoint of the socket.
+   * Returns a default-constructed endpoint object if an error occurred and the
+   * error handler did not throw an exception.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::error error;
+   * boost::asio::ipv4::tcp::endpoint endpoint
+   *   = socket.remote_endpoint(boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  endpoint_type remote_endpoint(Error_Handler error_handler) const
+  {
+    return this->service.remote_endpoint(this->implementation, error_handler);
+  }
+
+  /// Disable sends or receives on the socket.
+  /**
+   * This function is used to disable send operations, receive operations, or
+   * both.
+   *
+   * @param what Determines what types of operation will no longer be allowed.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * Shutting down the send side of the socket:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * socket.shutdown(boost::asio::ipv4::tcp::socket::shutdown_send);
+   * @endcode
+   */
+  void shutdown(shutdown_type what)
+  {
+    this->service.shutdown(this->implementation, what, throw_error());
+  }
+
+  /// Disable sends or receives on the socket.
+  /**
+   * This function is used to disable send operations, receive operations, or
+   * both.
+   *
+   * @param what Determines what types of operation will no longer be allowed.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * Shutting down the send side of the socket:
+   * @code
+   * boost::asio::ipv4::tcp::socket socket(io_service);
+   * ...
+   * boost::asio::error error;
+   * socket.shutdown(boost::asio::ipv4::tcp::socket::shutdown_send,
+   *     boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void shutdown(shutdown_type what, Error_Handler error_handler)
+  {
+    this->service.shutdown(this->implementation, what, error_handler);
+  }
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~basic_socket()
+  {
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_SOCKET_HPP
diff --git a/include/boost/asio/basic_socket_acceptor.hpp b/include/boost/asio/basic_socket_acceptor.hpp
new file mode 100644
index 0000000000..435b30a5ee
--- /dev/null
+++ b/include/boost/asio/basic_socket_acceptor.hpp
@@ -0,0 +1,816 @@
+//
+// basic_socket_acceptor.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
+#define BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/basic_socket.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/socket_acceptor_service.hpp>
+#include <boost/asio/socket_base.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides the ability to accept new connections.
+/**
+ * The basic_socket_acceptor class template is used for accepting new socket
+ * connections.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Error_Source.
+ *
+ * @par Example:
+ * Opening a socket acceptor with the SO_REUSEADDR option enabled:
+ * @code
+ * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+ * boost::asio::ipv4::tcp::endpoint endpoint(port);
+ * acceptor.open(endpoint.protocol());
+ * acceptor.set_option(boost::asio::ipv4::tcp::acceptor::reuse_address(true));
+ * acceptor.bind(endpoint);
+ * acceptor.listen();
+ * @endcode
+ */
+template <typename Protocol,
+    typename Service = socket_acceptor_service<Protocol> >
+class basic_socket_acceptor
+  : public basic_io_object<Service>,
+    public socket_base
+{
+public:
+  /// The native representation of an acceptor.
+  typedef typename Service::native_type native_type;
+
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// The type used for reporting errors.
+  typedef boost::asio::error error_type;
+
+  /// Construct an acceptor without opening it.
+  /**
+   * This constructor creates an acceptor without opening it to listen for new
+   * 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
+   * dispatch handlers for any asynchronous operations performed on the
+   * acceptor.
+   */
+  explicit basic_socket_acceptor(boost::asio::io_service& io_service)
+    : basic_io_object<Service>(io_service)
+  {
+  }
+
+  /// Construct an open acceptor.
+  /**
+   * This constructor creates an acceptor and automatically opens it.
+   *
+   * @param io_service The io_service object that the acceptor will use to
+   * dispatch handlers for any asynchronous operations performed on the
+   * acceptor.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_socket_acceptor(boost::asio::io_service& io_service,
+      const protocol_type& protocol)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.open(this->implementation, protocol, throw_error());
+  }
+
+  /// Construct an acceptor opened on the given endpoint.
+  /**
+   * 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
+   * dispatch handlers for any asynchronous operations performed on the
+   * acceptor.
+   *
+   * @param endpoint An endpoint on the local machine on which the acceptor
+   * will listen for new connections.
+   *
+   * @param listen_backlog The maximum length of the queue of pending
+   * connections. A value of 0 means use the default queue length.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note This constructor is equivalent to the following code:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * acceptor.open(endpoint.protocol());
+   * acceptor.bind(endpoint);
+   * acceptor.listen(listen_backlog);
+   * @endcode
+   */
+  basic_socket_acceptor(boost::asio::io_service& io_service,
+      const endpoint_type& endpoint, int listen_backlog = 0)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.open(this->implementation, endpoint.protocol(),
+        throw_error());
+    this->service.bind(this->implementation, endpoint, throw_error());
+    this->service.listen(this->implementation, listen_backlog, throw_error());
+  }
+
+  /// Construct a basic_socket_acceptor on an existing native 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
+   * dispatch handlers for any asynchronous operations performed on the
+   * acceptor.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @param native_acceptor A native acceptor.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_socket_acceptor(boost::asio::io_service& io_service,
+      const protocol_type& protocol, const native_type& native_acceptor)
+    : basic_io_object<Service>(io_service)
+  {
+    this->service.assign(this->implementation, protocol, native_acceptor,
+        throw_error());
+  }
+
+  /// Open the acceptor using the specified protocol.
+  /**
+   * This function opens the socket acceptor so that it will use the specified
+   * protocol.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * acceptor.open(boost::asio::ipv4::tcp());
+   * @endcode
+   */
+  void open(const protocol_type& protocol = protocol_type())
+  {
+    this->service.open(this->implementation, protocol, throw_error());
+  }
+
+  /// Open the acceptor using the specified protocol.
+  /**
+   * This function opens the socket acceptor so that it will use the specified
+   * protocol.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * boost::asio::error error;
+   * acceptor.open(boost::asio::ipv4::tcp(), boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void open(const protocol_type& protocol, Error_Handler error_handler)
+  {
+    this->service.open(this->implementation, protocol, error_handler);
+  }
+
+  /// Assigns an existing native acceptor to the acceptor.
+  /*
+   * This function opens the acceptor to hold an existing native acceptor.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @param native_acceptor A native acceptor.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  void assign(const protocol_type& protocol, const native_type& native_acceptor)
+  {
+    this->service.assign(this->implementation, protocol, native_acceptor,
+        throw_error());
+  }
+
+  /// Assigns an existing native acceptor to the acceptor.
+  /*
+   * This function opens the acceptor to hold an existing native acceptor.
+   *
+   * @param protocol An object specifying which protocol is to be used.
+   *
+   * @param native_acceptor A native acceptor.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void assign(const protocol_type& protocol, const native_type& native_acceptor,
+      Error_Handler error_handler)
+  {
+    this->service.assign(this->implementation, protocol, native_acceptor,
+        error_handler);
+  }
+
+  /// Bind the acceptor to the given local endpoint.
+  /**
+   * This function binds the socket acceptor to the specified endpoint on the
+   * local machine.
+   *
+   * @param endpoint An endpoint on the local machine to which the socket
+   * acceptor will be bound.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * acceptor.open(boost::asio::ipv4::tcp());
+   * acceptor.bind(boost::asio::ipv4::tcp::endpoint(12345));
+   * @endcode
+   */
+  void bind(const endpoint_type& endpoint)
+  {
+    this->service.bind(this->implementation, endpoint, throw_error());
+  }
+
+  /// Bind the acceptor to the given local endpoint.
+  /**
+   * This function binds the socket acceptor to the specified endpoint on the
+   * local machine.
+   *
+   * @param endpoint An endpoint on the local machine to which the socket
+   * acceptor will be bound.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * acceptor.open(boost::asio::ipv4::tcp());
+   * boost::asio::error error;
+   * acceptor.bind(boost::asio::ipv4::tcp::endpoint(12345),
+   *     boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void bind(const endpoint_type& endpoint, Error_Handler error_handler)
+  {
+    this->service.bind(this->implementation, endpoint, error_handler);
+  }
+
+  /// Place the acceptor into the state where it will listen for new
+  /// connections.
+  /**
+   * This function puts the socket acceptor into the state where it may accept
+   * new connections.
+   *
+   * @param backlog The maximum length of the queue of pending connections. A
+   * value of 0 means use the default queue length.
+   */
+  void listen(int backlog = 0)
+  {
+    this->service.listen(this->implementation, backlog, throw_error());
+  }
+
+  /// Place the acceptor into the state where it will listen for new
+  /// connections.
+  /**
+   * This function puts the socket acceptor into the state where it may accept
+   * new connections.
+   *
+   * @param backlog The maximum length of the queue of pending connections. A
+   * value of 0 means use the default queue length.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::error error;
+   * acceptor.listen(0, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void listen(int backlog, Error_Handler error_handler)
+  {
+    this->service.listen(this->implementation, backlog, error_handler);
+  }
+
+  /// Close the acceptor.
+  /**
+   * This function is used to close the acceptor. Any asynchronous accept
+   * operations will be cancelled immediately.
+   *
+   * A subsequent call to open() is required before the acceptor can again be
+   * used to again perform socket accept operations.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  void close()
+  {
+    this->service.close(this->implementation, throw_error());
+  }
+
+  /// Close the acceptor.
+  /**
+   * This function is used to close the acceptor. Any asynchronous accept
+   * operations will be cancelled immediately.
+   *
+   * A subsequent call to open() is required before the acceptor can again be
+   * used to again perform socket accept operations.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::error error;
+   * acceptor.close(boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  void close(Error_Handler error_handler)
+  {
+    this->service.close(this->implementation, error_handler);
+  }
+
+  /// Get the native acceptor representation.
+  /**
+   * This function may be used to obtain the underlying representation of the
+   * acceptor. This is intended to allow access to native acceptor functionality
+   * that is not otherwise provided.
+   */
+  native_type native()
+  {
+    return this->service.native(this->implementation);
+  }
+
+  /// Set an option on the acceptor.
+  /**
+   * This function is used to set an option on the acceptor.
+   *
+   * @param option The new option value to be set on the acceptor.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::reuse_address
+   * boost::asio::socket_base::enable_connection_aborted
+   *
+   * @par Example:
+   * Setting the SOL_SOCKET/SO_REUSEADDR option:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::acceptor::reuse_address option(true);
+   * acceptor.set_option(option);
+   * @endcode
+   */
+  template <typename Option>
+  void set_option(const Option& option)
+  {
+    this->service.set_option(this->implementation, option, throw_error());
+  }
+
+  /// Set an option on the acceptor.
+  /**
+   * This function is used to set an option on the acceptor.
+   *
+   * @param option The new option value to be set on the acceptor.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::reuse_address
+   * boost::asio::socket_base::enable_connection_aborted
+   *
+   * @par Example:
+   * Setting the SOL_SOCKET/SO_REUSEADDR option:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::acceptor::reuse_address option(true);
+   * boost::asio::error error;
+   * acceptor.set_option(option, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Option, typename Error_Handler>
+  void set_option(const Option& option, Error_Handler error_handler)
+  {
+    this->service.set_option(this->implementation, option, error_handler);
+  }
+
+  /// Get an option from the acceptor.
+  /**
+   * This function is used to get the current value of an option on the
+   * acceptor.
+   *
+   * @param option The option value to be obtained from the acceptor.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::reuse_address
+   *
+   * @par Example:
+   * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::acceptor::reuse_address option;
+   * acceptor.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   */
+  template <typename Option>
+  void get_option(Option& option)
+  {
+    this->service.get_option(this->implementation, option, throw_error());
+  }
+
+  /// Get an option from the acceptor.
+  /**
+   * This function is used to get the current value of an option on the
+   * acceptor.
+   *
+   * @param option The option value to be obtained from the acceptor.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @sa Socket_Option @n
+   * boost::asio::socket_base::reuse_address
+   *
+   * @par Example:
+   * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::acceptor::reuse_address option;
+   * boost::asio::error error;
+   * acceptor.get_option(option, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * bool is_set = option.get();
+   * @endcode
+   */
+  template <typename Option, typename Error_Handler>
+  void get_option(Option& option, Error_Handler error_handler)
+  {
+    this->service.get_option(this->implementation, option, error_handler);
+  }
+
+  /// Get the local endpoint of the acceptor.
+  /**
+   * This function is used to obtain the locally bound endpoint of the acceptor.
+   *
+   * @returns An object that represents the local endpoint of the acceptor.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::ipv4::tcp::endpoint endpoint = acceptor.local_endpoint();
+   * @endcode
+   */
+  endpoint_type local_endpoint() const
+  {
+    return this->service.local_endpoint(this->implementation, throw_error());
+  }
+
+  /// Get the local endpoint of the acceptor.
+  /**
+   * This function is used to obtain the locally bound endpoint of the acceptor.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @returns An object that represents the local endpoint of the acceptor.
+   * Returns a default-constructed endpoint object if an error occurred and the
+   * error handler did not throw an exception.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::error error;
+   * boost::asio::ipv4::tcp::endpoint endpoint
+   *   = acceptor.local_endpoint(boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Error_Handler>
+  endpoint_type local_endpoint(Error_Handler error_handler) const
+  {
+    return this->service.local_endpoint(this->implementation, error_handler);
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer into the
+   * given socket. The function call will block until a new connection has been
+   * accepted successfully or an error occurs.
+   *
+   * @param peer The socket into which the new connection will be accepted.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::stream_socket socket;
+   * acceptor.accept(socket);
+   * @endcode
+   */
+  template <typename Socket_Service>
+  void accept(basic_socket<protocol_type, Socket_Service>& peer)
+  {
+    this->service.accept(this->implementation, peer, throw_error());
+  }
+
+  /// Accept a new connection.
+  /**
+   * This function is used to accept a new connection from a peer into the
+   * given socket. The function call will block until a new connection has been
+   * accepted successfully or an error occurs.
+   *
+   * @param peer The socket into which the new connection will be accepted.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::stream_socket socket;
+   * boost::asio::error error;
+   * acceptor.accept(socket, boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Socket_Service, typename Error_Handler>
+  void accept(basic_socket<protocol_type, Socket_Service>& peer,
+      Error_Handler error_handler)
+  {
+    this->service.accept(this->implementation, peer, error_handler);
+  }
+
+  /// Start an asynchronous accept.
+  /**
+   * This function is used to asynchronously accept a new connection into a
+   * socket. The function call always returns immediately.
+   *
+   * @param peer The socket into which the new connection will be accepted.
+   * Ownership of the peer 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 boost::asio::error& 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
+   * boost::asio::io_service::post().
+   *
+   * @par Example:
+   * @code
+   * void accept_handler(const boost::asio::error& error)
+   * {
+   *   if (!error)
+   *   {
+   *     // Accept succeeded.
+   *   }
+   * }
+   *
+   * ...
+   *
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::stream_socket socket;
+   * acceptor.async_accept(socket, accept_handler);
+   * @endcode
+   */
+  template <typename Socket_Service, typename Handler>
+  void async_accept(basic_socket<protocol_type, Socket_Service>& peer,
+      Handler handler)
+  {
+    this->service.async_accept(this->implementation, peer, handler);
+  }
+
+  /// Accept a new connection and obtain the endpoint of the peer
+  /**
+   * This function is used to accept a new connection from a peer into the
+   * given socket, and additionally provide the endpoint of the remote peer.
+   * The function call will block until a new connection has been accepted
+   * successfully or an error occurs.
+   *
+   * @param peer The socket into which the new connection will be accepted.
+   *
+   * @param peer_endpoint An endpoint object which will receive the endpoint of
+   * the remote peer.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::stream_socket socket;
+   * boost::asio::ipv4::tcp::endpoint endpoint;
+   * acceptor.accept_endpoint(socket, endpoint);
+   * @endcode
+   */
+  template <typename Socket_Service>
+  void accept_endpoint(basic_socket<protocol_type, Socket_Service>& peer,
+      endpoint_type& peer_endpoint)
+  {
+    this->service.accept_endpoint(this->implementation, peer, peer_endpoint,
+        throw_error());
+  }
+
+  /// Accept a new connection and obtain the endpoint of the peer
+  /**
+   * This function is used to accept a new connection from a peer into the
+   * given socket, and additionally provide the endpoint of the remote peer.
+   * The function call will block until a new connection has been accepted
+   * successfully or an error occurs.
+   *
+   * @param peer The socket into which the new connection will be accepted.
+   *
+   * @param peer_endpoint An endpoint object which will receive the endpoint of
+   * the remote peer.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ipv4::tcp::acceptor acceptor(io_service);
+   * ...
+   * boost::asio::stream_socket socket;
+   * boost::asio::ipv4::tcp::endpoint endpoint;
+   * boost::asio::error error;
+   * acceptor.accept_endpoint(socket, endpoint,
+   *     boost::asio::assign_error(error));
+   * if (error)
+   * {
+   *   // An error occurred.
+   * }
+   * @endcode
+   */
+  template <typename Socket_Service, typename Error_Handler>
+  void accept_endpoint(basic_socket<protocol_type, Socket_Service>& peer,
+      endpoint_type& peer_endpoint, Error_Handler error_handler)
+  {
+    this->service.accept_endpoint(this->implementation, peer, peer_endpoint,
+        error_handler);
+  }
+
+  /// Start an asynchronous accept.
+  /**
+   * This function is used to asynchronously accept a new connection into a
+   * socket, and additionally obtain the endpoint of the remote peer. The
+   * function call always returns immediately.
+   *
+   * @param peer The socket into which the new connection will be accepted.
+   * Ownership of the peer object is retained by the caller, which must
+   * guarantee that it is valid until the handler is called.
+   *
+   * @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 boost::asio::error& 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
+   * boost::asio::io_service::post().
+   */
+  template <typename Socket_Service, typename Handler>
+  void async_accept_endpoint(basic_socket<protocol_type, Socket_Service>& peer,
+      endpoint_type& peer_endpoint, Handler handler)
+  {
+    this->service.async_accept_endpoint(this->implementation, peer,
+        peer_endpoint, handler);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
diff --git a/include/boost/asio/basic_socket_iostream.hpp b/include/boost/asio/basic_socket_iostream.hpp
new file mode 100644
index 0000000000..4fd9312cfd
--- /dev/null
+++ b/include/boost/asio/basic_socket_iostream.hpp
@@ -0,0 +1,156 @@
+//
+// basic_socket_iostream.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
+#define BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/utility/base_from_member.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_socketbuf.hpp>
+#include <boost/asio/stream_socket_service.hpp>
+
+#if !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
+#define BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY 5
+#endif // !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
+
+// A macro that should expand to:
+//   template < typename T1, ..., typename Tn >
+//   explicit basic_socket_iostream( T1 x1, ..., Tn xn )
+//     : basic_iostream<char>(&this->boost::base_from_member<
+//         basic_socketbuf<Protocol, Service> >::member)
+//   {
+//     try
+//     {
+//       rdbuf()->connect ( x1, ..., xn );
+//     }
+//     catch (boost::asio::error&)
+//     {
+//       this->setstate(std::ios_base::failbit);
+//       if (this->exceptions() & std::ios_base::failbit)
+//         throw;
+//     }
+//   }
+// This macro should only persist within this file.
+
+#define BOOST_ASIO_PRIVATE_CTR_DEF( z, n, data ) \
+  template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
+  explicit basic_socket_iostream( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
+    : std::basic_iostream<char>(&this->boost::base_from_member< \
+        basic_socketbuf<Protocol, Service> >::member) \
+  { \
+    try \
+    { \
+      rdbuf()->connect( BOOST_PP_ENUM_PARAMS(n, x) ); \
+    } \
+    catch (boost::asio::error&) \
+    { \
+      this->setstate(std::ios_base::failbit); \
+      if (this->exceptions() & std::ios_base::failbit) \
+        throw; \
+    } \
+  } \
+  /**/
+
+// A macro that should expand to:
+//   template < typename T1, ..., typename Tn >
+//   void connect( T1 x1, ..., Tn xn )
+//   {
+//     try
+//     {
+//       rdbuf()->connect ( x1, ..., xn );
+//     }
+//     catch (boost::asio::error&)
+//     {
+//       this->setstate(std::ios_base::failbit);
+//       if (this->exceptions() & std::ios_base::failbit)
+//         throw;
+//     }
+//   }
+// This macro should only persist within this file.
+
+#define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
+  template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
+  void connect( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
+  { \
+    try \
+    { \
+      rdbuf()->connect( BOOST_PP_ENUM_PARAMS(n, x) ); \
+    } \
+    catch (boost::asio::error&) \
+    { \
+      this->setstate(std::ios_base::failbit); \
+      if (this->exceptions() & std::ios_base::failbit) \
+        throw; \
+    } \
+  } \
+  /**/
+
+namespace boost {
+namespace asio {
+
+/// Iostream interface for a socket.
+template <typename Protocol,
+    typename Service = stream_socket_service<Protocol> >
+class basic_socket_iostream
+  : public boost::base_from_member<basic_socketbuf<Protocol, Service> >,
+    public std::basic_iostream<char>
+{
+public:
+  /// Construct a basic_socket_iostream without establishing a connection.
+  basic_socket_iostream()
+    : std::basic_iostream<char>(&this->boost::base_from_member<
+        basic_socketbuf<Protocol, Service> >::member)
+  {
+  }
+
+  BOOST_PP_REPEAT_FROM_TO(
+      1, BOOST_PP_INC(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY),
+      BOOST_ASIO_PRIVATE_CTR_DEF, _ )
+
+  BOOST_PP_REPEAT_FROM_TO(
+      1, BOOST_PP_INC(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY),
+      BOOST_ASIO_PRIVATE_CONNECT_DEF, _ )
+
+  /// Close the connection.
+  void close()
+  {
+    rdbuf()->close();
+  }
+
+  /// Return a pointer to the underlying streambuf.
+  basic_socketbuf<Protocol, Service>* rdbuf() const
+  {
+    return const_cast<basic_socketbuf<Protocol, Service>*>(
+        &this->boost::base_from_member<
+          basic_socketbuf<Protocol, Service> >::member);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#undef BOOST_ASIO_PRIVATE_CTR_DEF
+#undef BOOST_ASIO_PRIVATE_CONNECT_DEF
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
diff --git a/include/boost/asio/basic_socketbuf.hpp b/include/boost/asio/basic_socketbuf.hpp
new file mode 100644
index 0000000000..77745c1b55
--- /dev/null
+++ b/include/boost/asio/basic_socketbuf.hpp
@@ -0,0 +1,260 @@
+//
+// basic_socketbuf.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_SOCKETBUF_HPP
+#define BOOST_ASIO_BASIC_SOCKETBUF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <streambuf>
+#include <boost/array.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/utility/base_from_member.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_socket.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/stream_socket_service.hpp>
+
+#if !defined(BOOST_ASIO_SOCKETBUF_MAX_ARITY)
+#define BOOST_ASIO_SOCKETBUF_MAX_ARITY 5
+#endif // !defined(BOOST_ASIO_SOCKETBUF_MAX_ARITY)
+
+// A macro that should expand to:
+//   template < typename T1, ..., typename Tn >
+//   explicit basic_socketbuf( T1 x1, ..., Tn xn )
+//     : basic_socket<Protocol, Service>(
+//         boost::base_from_member<io_service>::member)
+//   {
+//     init_buffers();
+//     typedef typename Protocol::resolver_query resolver_query;
+//     resolver_query query( x1, ..., xn );
+//     resolve_and_connect(query);
+//   }
+// This macro should only persist within this file.
+
+#define BOOST_ASIO_PRIVATE_CTR_DEF( z, n, data ) \
+  template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
+  explicit basic_socketbuf( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
+    : basic_socket<Protocol, Service>( \
+        boost::base_from_member<io_service>::member) \
+  { \
+    init_buffers(); \
+    typedef typename Protocol::resolver_query resolver_query; \
+    resolver_query query( BOOST_PP_ENUM_PARAMS(n, x) ); \
+    resolve_and_connect(query); \
+  } \
+  /**/
+
+// A macro that should expand to:
+//   template < typename T1, ..., typename Tn >
+//   void connect( T1 x1, ..., Tn xn )
+//   {
+//     this->basic_socket<Protocol, Service>::close();
+//     init_buffers();
+//     typedef typename Protocol::resolver_query resolver_query;
+//     resolver_query query( x1, ..., xn );
+//     resolve_and_connect(query);
+//   }
+// This macro should only persist within this file.
+
+#define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
+  template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
+  void connect( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
+  { \
+    this->basic_socket<Protocol, Service>::close(); \
+    init_buffers(); \
+    typedef typename Protocol::resolver_query resolver_query; \
+    resolver_query query( BOOST_PP_ENUM_PARAMS(n, x) ); \
+    resolve_and_connect(query); \
+  } \
+  /**/
+
+namespace boost {
+namespace asio {
+
+/// Iostream streambuf for a socket.
+template <typename Protocol,
+    typename Service = stream_socket_service<Protocol> >
+class basic_socketbuf
+  : public std::streambuf,
+    private boost::base_from_member<io_service>,
+    public basic_socket<Protocol, Service>
+{
+public:
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// Construct a basic_socketbuf without establishing a connection.
+  basic_socketbuf()
+    : basic_socket<Protocol, Service>(
+        boost::base_from_member<boost::asio::io_service>::member)
+  {
+    init_buffers();
+  }
+
+  /// Establish a connection to the specified endpoint.
+  explicit basic_socketbuf(const endpoint_type& endpoint)
+    : basic_socket<Protocol, Service>(
+        boost::base_from_member<boost::asio::io_service>::member)
+  {
+    init_buffers();
+    this->basic_socket<Protocol, Service>::connect(endpoint);
+  }
+
+  BOOST_PP_REPEAT_FROM_TO(
+      1, BOOST_PP_INC(BOOST_ASIO_SOCKETBUF_MAX_ARITY),
+      BOOST_ASIO_PRIVATE_CTR_DEF, _ )
+
+  /// Destructor flushes buffered data.
+  ~basic_socketbuf()
+  {
+    sync();
+  }
+
+  /// Establish a connection to the specified endpoint.
+  void connect(const endpoint_type& endpoint)
+  {
+    this->basic_socket<Protocol, Service>::close();
+    init_buffers();
+    this->basic_socket<Protocol, Service>::connect(endpoint);
+  }
+
+  BOOST_PP_REPEAT_FROM_TO(
+      1, BOOST_PP_INC(BOOST_ASIO_SOCKETBUF_MAX_ARITY),
+      BOOST_ASIO_PRIVATE_CONNECT_DEF, _ )
+
+  /// Close the connection.
+  void close()
+  {
+    sync();
+    this->basic_socket<Protocol, Service>::close();
+    init_buffers();
+  }
+
+protected:
+  int_type underflow()
+  {
+    if (gptr() == egptr())
+    {
+      boost::asio::error error;
+      std::size_t bytes_transferred = this->service.receive(
+          this->implementation,
+          boost::asio::buffer(boost::asio::buffer(get_buffer_) + putback_max),
+          0, boost::asio::assign_error(error));
+      if (error)
+      {
+        if (error != boost::asio::error::eof)
+          throw error;
+        return traits_type::eof();
+      }
+      setg(get_buffer_.begin(), get_buffer_.begin() + putback_max,
+          get_buffer_.begin() + putback_max + bytes_transferred);
+      return traits_type::to_int_type(*gptr());
+    }
+    else
+    {
+      return traits_type::eof();
+    }
+  }
+
+  int_type overflow(int_type c)
+  {
+    if (!traits_type::eq_int_type(c, traits_type::eof()))
+    {
+      if (pptr() == epptr())
+      {
+        boost::asio::const_buffer buffer =
+          boost::asio::buffer(pbase(), pptr() - pbase());
+        while (boost::asio::buffer_size(buffer) > 0)
+        {
+          std::size_t bytes_transferred = this->service.send(
+              this->implementation, boost::asio::buffer(buffer),
+              0, boost::asio::throw_error());
+          buffer = buffer + bytes_transferred;
+        }
+        setp(put_buffer_.begin(), put_buffer_.end());
+      }
+
+      *pptr() = traits_type::to_char_type(c);
+      pbump(1);
+      return c;
+    }
+
+    return traits_type::not_eof(c);
+  }
+
+  int sync()
+  {
+    boost::asio::const_buffer buffer =
+      boost::asio::buffer(pbase(), pptr() - pbase());
+    while (boost::asio::buffer_size(buffer) > 0)
+    {
+      std::size_t bytes_transferred = this->service.send(
+          this->implementation, boost::asio::buffer(buffer),
+          0, boost::asio::throw_error());
+      buffer = buffer + bytes_transferred;
+    }
+    setp(put_buffer_.begin(), put_buffer_.end());
+    return 0;
+  }
+
+private:
+  void init_buffers()
+  {
+    setg(get_buffer_.begin(),
+        get_buffer_.begin() + putback_max,
+        get_buffer_.begin() + putback_max);
+    setp(put_buffer_.begin(), put_buffer_.end());
+  }
+
+  void resolve_and_connect(const typename Protocol::resolver_query& query)
+  {
+    typedef typename Protocol::resolver resolver_type;
+    typedef typename Protocol::resolver_iterator iterator_type;
+    resolver_type resolver(
+        boost::base_from_member<boost::asio::io_service>::member);
+    iterator_type iterator = resolver.resolve(query);
+    boost::asio::error error(boost::asio::error::host_not_found);
+    while (error && iterator != iterator_type())
+    {
+      this->basic_socket<Protocol, Service>::close();
+      this->basic_socket<Protocol, Service>::connect(
+          *iterator, boost::asio::assign_error(error));
+      ++iterator;
+    }
+    if (error)
+      throw error;
+  }
+
+  enum { putback_max = 8 };
+  enum { buffer_size = 512 };
+  boost::array<char, buffer_size> get_buffer_;
+  boost::array<char, buffer_size> put_buffer_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#undef BOOST_ASIO_PRIVATE_CTR_DEF
+#undef BOOST_ASIO_PRIVATE_CONNECT_DEF
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_SOCKETBUF_HPP
diff --git a/include/boost/asio/basic_strand.hpp b/include/boost/asio/basic_strand.hpp
new file mode 100644
index 0000000000..ab33032cdb
--- /dev/null
+++ b/include/boost/asio/basic_strand.hpp
@@ -0,0 +1,144 @@
+//
+// basic_strand.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_STRAND_HPP
+#define BOOST_ASIO_BASIC_STRAND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_io_object.hpp>
+#include <boost/asio/strand_service.hpp>
+#include <boost/asio/detail/wrapped_handler.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides serialised handler execution.
+/**
+ * The basic_strand class template provides the ability to post and dispatch
+ * handlers with the guarantee that none of those handlers will execute
+ * concurrently.
+ *
+ * Most applications will use the boost::asio::strand typedef.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Dispatcher.
+ */
+template <typename Service = strand_service>
+class basic_strand
+  : public basic_io_object<Service>
+{
+public:
+  /// 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.
+   */
+  explicit basic_strand(boost::asio::io_service& io_service)
+    : basic_io_object<Service>(io_service)
+  {
+  }
+
+  /// 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 only one handler executed through this
+   * strand will be invoked at a time. The handler may be executed inside this
+   * function if the guarantee can be met.
+   *
+   * 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
+   */
+  template <typename Handler>
+  void dispatch(Handler handler)
+  {
+    this->service.dispatch(this->implementation, handler);
+  }
+
+  /// 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 only one handler executed through this
+   * strand will be invoked at a time. 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
+   */
+  template <typename Handler>
+  void post(Handler handler)
+  {
+    this->service.post(this->implementation, handler);
+  }
+
+  /// 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<basic_strand<Service>, Handler>
+#endif
+  wrap(Handler handler)
+  {
+    return detail::wrapped_handler<
+        basic_strand<Service>,
+        Handler>(*this, handler);
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_STRAND_HPP
diff --git a/include/boost/asio/basic_stream_socket.hpp b/include/boost/asio/basic_stream_socket.hpp
new file mode 100644
index 0000000000..06644005e8
--- /dev/null
+++ b/include/boost/asio/basic_stream_socket.hpp
@@ -0,0 +1,818 @@
+//
+// basic_stream_socket.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
+#define BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_socket.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/stream_socket_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Provides stream-oriented socket functionality.
+/**
+ * The basic_stream_socket class template provides asynchronous and blocking
+ * stream-oriented socket functionality.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Read_Stream, Async_Write_Stream, Error_Source, IO_Object, Stream,
+ * Sync_Read_Stream, Sync_Write_Stream.
+ */
+template <typename Protocol,
+    typename Service = stream_socket_service<Protocol> >
+class basic_stream_socket
+  : public basic_socket<Protocol, Service>
+{
+public:
+  /// The native representation of a socket.
+  typedef typename Service::native_type native_type;
+
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// Construct a basic_stream_socket without opening it.
+  /**
+   * This constructor creates a stream socket without opening it. The socket
+   * needs to be opened and then connected or accepted before data can be sent
+   * or received on it.
+   *
+   * @param io_service The io_service object that the stream socket will use to
+   * dispatch handlers for any asynchronous operations performed on the socket.
+   */
+  explicit basic_stream_socket(boost::asio::io_service& io_service)
+    : basic_socket<Protocol, Service>(io_service)
+  {
+  }
+
+  /// Construct and open a 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
+   * dispatch handlers for any asynchronous operations performed on the socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_stream_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol)
+    : basic_socket<Protocol, Service>(io_service, protocol)
+  {
+  }
+
+  /// Construct a basic_stream_socket, opening it and binding it to the given
+  /// local endpoint.
+  /**
+   * This constructor creates a stream socket and automatically opens it bound
+   * to the specified endpoint on the local machine. The protocol used is the
+   * protocol associated with the given endpoint.
+   *
+   * @param io_service The io_service object that the 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
+   * socket will be bound.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_stream_socket(boost::asio::io_service& io_service,
+      const endpoint_type& endpoint)
+    : basic_socket<Protocol, Service>(io_service, endpoint)
+  {
+  }
+
+  /// Construct a basic_stream_socket on an existing native 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
+   * dispatch handlers for any asynchronous operations performed on the socket.
+   *
+   * @param protocol An object specifying protocol parameters to be used.
+   *
+   * @param native_socket The new underlying socket implementation.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  basic_stream_socket(boost::asio::io_service& io_service,
+      const protocol_type& protocol, const native_type& native_socket)
+    : basic_socket<Protocol, Service>(io_service, protocol, native_socket)
+  {
+  }
+
+  /// Send some data on the socket.
+  /**
+   * This function is used to send data on the stream socket. The function
+   * call will block until one or more bytes of the data has been sent
+   * successfully, or an until error occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note The send operation may not transmit all of the data to the peer.
+   * Consider using the @ref write function if you need to ensure that all data
+   * is written before the blocking operation completes.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.send(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers>
+  std::size_t send(const Const_Buffers& buffers)
+  {
+    return this->service.send(this->implementation, buffers, 0, throw_error());
+  }
+
+  /// Send some data on the socket.
+  /**
+   * This function is used to send data on the stream socket. The function
+   * call will block until one or more bytes of the data has been sent
+   * successfully, or an until error occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @returns The number of bytes sent.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @note The send operation may not transmit all of the data to the peer.
+   * Consider using the @ref write function if you need to ensure that all data
+   * is written before the blocking operation completes.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.send(boost::asio::buffer(data, size), 0);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers>
+  std::size_t send(const Const_Buffers& buffers,
+      socket_base::message_flags flags)
+  {
+    return this->service.send(this->implementation, buffers, flags,
+        throw_error());
+  }
+
+  /// Send some data on the socket.
+  /**
+   * This function is used to send data on the stream socket. The function
+   * call will block until one or more bytes of the data has been sent
+   * successfully, or an until error occurs.
+   *
+   * @param buffers One or more data buffers to be sent on the socket.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes sent. Returns 0 if an error occurred and the
+   * error handler did not throw an exception.
+   *
+   * @note The send operation may not transmit all of the data to the peer.
+   * Consider using the @ref write function if you need to ensure that all data
+   * is written before the blocking operation completes.
+   */
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send(const Const_Buffers& buffers,
+      socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    return this->service.send(this->implementation, buffers, flags,
+        error_handler);
+  }
+
+  /// Start an asynchronous send.
+  /**
+   * This function is used to asynchronously send data on the stream socket.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be sent on the socket. Although
+   * the buffers object may be copied as necessary, ownership of the underlying
+   * memory blocks is retained by the caller, which must guarantee that they
+   * remain valid until the handler is called.
+   *
+   * @param handler The handler to be called when the send operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes sent.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.async_send(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers, typename Handler>
+  void async_send(const Const_Buffers& buffers, Handler handler)
+  {
+    this->service.async_send(this->implementation, buffers, 0, handler);
+  }
+
+  /// Start an asynchronous send.
+  /**
+   * This function is used to asynchronously send data on the stream socket.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be sent on the socket. Although
+   * the buffers object may be copied as necessary, ownership of the underlying
+   * memory blocks is retained by the caller, which must guarantee that they
+   * remain valid until the handler is called.
+   *
+   * @param flags Flags specifying how the send call is to be made.
+   *
+   * @param handler The handler to be called when the send operation completes.
+   * Copies will be made of the handler as required. The function signature of
+   * the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes sent.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * data is written before the asynchronous operation completes.
+   *
+   * @par Example:
+   * To send a single data buffer use the @ref buffer function as follows:
+   * @code
+   * socket.async_send(boost::asio::buffer(data, size), 0, handler);
+   * @endcode
+   * See the @ref buffer documentation for information on sending multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Const_Buffers, typename Handler>
+  void async_send(const Const_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    this->service.async_send(this->implementation, buffers, flags, handler);
+  }
+
+  /// Receive some data on the socket.
+  /**
+   * This function is used to receive data on the stream socket. The function
+   * call will block until one or more bytes of data has been received
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::asio::error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The receive operation may not receive all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that the
+   * requested amount of data is read before the blocking operation completes.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.receive(boost::asio::buffer(data, size));
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t receive(const Mutable_Buffers& buffers)
+  {
+    return this->service.receive(this->implementation, buffers, 0,
+        throw_error());
+  }
+
+  /// Receive some data on the socket.
+  /**
+   * This function is used to receive data on the stream socket. The function
+   * call will block until one or more bytes of data has been received
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @returns The number of bytes received.
+   *
+   * @throws boost::asio::error Thrown on failure. An error code of
+   * boost::asio::error::eof indicates that the connection was closed by the
+   * peer.
+   *
+   * @note The receive operation may not receive all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that the
+   * requested amount of data is read before the blocking operation completes.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.receive(boost::asio::buffer(data, size), 0);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t receive(const Mutable_Buffers& buffers,
+      socket_base::message_flags flags)
+  {
+    return this->service.receive(this->implementation, buffers, flags,
+        throw_error());
+  }
+
+  /// Receive some data on a connected socket.
+  /**
+   * This function is used to receive data on the stream socket. The function
+   * call will block until one or more bytes of data has been received
+   * successfully, or until an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @returns The number of bytes received. Returns 0 if an error occurred and
+   * the error handler did not throw an exception.
+   *
+   * @note The receive operation may not receive all of the requested number of
+   * bytes. Consider using the @ref read function if you need to ensure that the
+   * requested amount of data is read before the blocking operation completes.
+   */
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive(const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return this->service.receive(this->implementation, buffers, flags,
+        error_handler);
+  }
+
+  /// Start an asynchronous receive.
+  /**
+   * This function is used to asynchronously receive data from the stream
+   * socket. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param handler The handler to be called when the receive operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes received.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * that the requested amount of data is received before the asynchronous
+   * operation completes.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.async_receive(boost::asio::buffer(data, size), handler);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(const Mutable_Buffers& buffers, Handler handler)
+  {
+    this->service.async_receive(this->implementation, buffers, 0, handler);
+  }
+
+  /// Start an asynchronous receive.
+  /**
+   * This function is used to asynchronously receive data from the stream
+   * socket. The function call always returns immediately.
+   *
+   * @param buffers One or more buffers into which the data will be received.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param flags Flags specifying how the receive call is to be made.
+   *
+   * @param handler The handler to be called when the receive operation
+   * completes. Copies will be made of the handler as required. The function
+   * signature of the handler must be:
+   * @code void handler(
+   *   const boost::asio::error& error,     // Result of operation.
+   *   std::size_t bytes_transferred // Number of bytes received.
+   * ); @endcode
+   * Regardless of whether the asynchronous operation completes immediately or
+   * not, the handler will not be invoked from within this function. Invocation
+   * of the handler will be performed in a manner equivalent to using
+   * boost::asio::io_service::post().
+   *
+   * @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
+   * that the requested amount of data is received before the asynchronous
+   * operation completes.
+   *
+   * @par Example:
+   * To receive into a single data buffer use the @ref buffer function as
+   * follows:
+   * @code
+   * socket.async_receive(boost::asio::buffer(data, size), 0, handler);
+   * @endcode
+   * See the @ref buffer documentation for information on receiving into
+   * multiple buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    this->service.async_receive(this->implementation, buffers, flags, handler);
+  }
+
+  /// Write some data to the socket.
+  /**
+   * This function is used to write data to the stream socket. 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 socket.
+   *
+   * @returns The number of bytes written.
+   *
+   * @throws boost::asio::error Thrown on failure. An error code of
+   * boost::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
+   * socket.write_some(boost::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 Const_Buffers>
+  std::size_t write_some(const Const_Buffers& buffers)
+  {
+    return this->service.send(this->implementation, buffers, 0, throw_error());
+  }
+
+  /// Write some data to the socket.
+  /**
+   * This function is used to write data to the stream socket. 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 socket.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred and
+   * the error handler did not throw an exception.
+   *
+   * @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 Const_Buffers, typename Error_Handler>
+  std::size_t write_some(const Const_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return this->service.send(this->implementation, buffers, 0, error_handler);
+  }
+
+  /// Start an asynchronous write.
+  /**
+   * This function is used to asynchronously write data to the stream socket.
+   * The function call always returns immediately.
+   *
+   * @param buffers One or more data buffers to be written to the socket.
+   * Although the buffers object may be copied as necessary, ownership of the
+   * underlying memory blocks is retained by the caller, which must guarantee
+   * that they remain valid until the handler is called.
+   *
+   * @param 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 boost::asio::error& 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
+   * boost::asio::io_service::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
+   * socket.async_write_some(boost::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 Const_Buffers, typename Handler>
+  void async_write_some(const Const_Buffers& buffers, Handler handler)
+  {
+    this->service.async_send(this->implementation, buffers, 0, handler);
+  }
+
+  /// Read some data from the socket.
+  /**
+   * This function is used to read data from the stream socket. 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 boost::asio::error Thrown on failure. An error code of
+   * boost::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
+   * socket.read_some(boost::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 Mutable_Buffers>
+  std::size_t read_some(const Mutable_Buffers& buffers)
+  {
+    return this->service.receive(this->implementation, buffers, 0,
+        throw_error());
+  }
+
+  /// Read some data from the socket.
+  /**
+   * This function is used to read data from the stream socket. 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred and the
+   * error handler did not throw an exception.
+   *
+   * @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 Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(const Mutable_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return this->service.receive(this->implementation, buffers, 0,
+        error_handler);
+  }
+
+  /// Start an asynchronous read.
+  /**
+   * This function is used to asynchronously read data from the stream socket.
+   * 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 boost::asio::error& 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
+   * boost::asio::io_service::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
+   * socket.async_read_some(boost::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 Mutable_Buffers, typename Handler>
+  void async_read_some(const Mutable_Buffers& buffers, Handler handler)
+  {
+    this->service.async_receive(this->implementation, buffers, 0, handler);
+  }
+
+  /// Peek at the incoming data on the stream socket.
+  /**
+   * This function is used to peek at the incoming data on the stream socket,
+   * without removing it from the input queue. The function call will block
+   * until data has been read successfully or an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @returns The number of bytes read.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   *
+   * @par Example:
+   * To peek using a single data buffer use the @ref buffer function as
+   * follows:
+   * @code socket.peek(boost::asio::buffer(data, size)); @endcode
+   * See the @ref buffer documentation for information on using multiple
+   * buffers in one go, and how to use it with arrays, boost::array or
+   * std::vector.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t peek(const Mutable_Buffers& buffers)
+  {
+    return this->service.receive(this->implementation, buffers,
+        socket_base::message_peek, throw_error());
+  }
+
+  /// Peek at the incoming data on the stream socket.
+  /**
+   * This function is used to peek at the incoming data on the stream socket,
+   * without removing it from the input queue. The function call will block
+   * until data has been read successfully or an error occurs.
+   *
+   * @param buffers One or more buffers into which the data will be read.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred and the
+   * error handler did not throw an exception.
+   */
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return this->service.receive(this->implementation, buffers,
+        socket_base::message_peek, error_handler);
+  }
+
+  /// 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 socket without blocking.
+   *
+   * @returns The number of bytes of data that can be read without blocking.
+   *
+   * @throws boost::asio::error Thrown on failure.
+   */
+  std::size_t in_avail()
+  {
+    socket_base::bytes_readable command;
+    this->service.io_control(this->implementation, command, throw_error());
+    return command.get();
+  }
+
+  /// 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 socket without blocking.
+   *
+   * @param error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @returns The number of bytes of data that can be read without blocking.
+   */
+  template <typename Error_Handler>
+  std::size_t in_avail(Error_Handler error_handler)
+  {
+    socket_base::bytes_readable command;
+    this->service.io_control(this->implementation, command, error_handler);
+    return command.get();
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
diff --git a/include/boost/asio/basic_streambuf.hpp b/include/boost/asio/basic_streambuf.hpp
new file mode 100644
index 0000000000..f684864698
--- /dev/null
+++ b/include/boost/asio/basic_streambuf.hpp
@@ -0,0 +1,421 @@
+//
+// basic_streambuf.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BASIC_STREAMBUF_HPP
+#define BOOST_ASIO_BASIC_STREAMBUF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <streambuf>
+#include <vector>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Automatically resizable buffer class based on std::streambuf.
+template <typename Allocator = std::allocator<char> >
+class basic_streambuf
+  : public std::streambuf,
+    private noncopyable
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// The type used to represent the get area as a list of buffers.
+  typedef implementation_defined const_buffers_type;
+
+  /// The type used to represent the put area as a list of buffers.
+  typedef implementation_defined mutable_buffers_type;
+#else
+  typedef boost::asio::const_buffer_container_1 const_buffers_type;
+  typedef boost::asio::mutable_buffer_container_1 mutable_buffers_type;
+#endif
+
+  /// Construct a buffer with a specified maximum size.
+  explicit basic_streambuf(
+      std::size_t max_size = (std::numeric_limits<std::size_t>::max)(),
+      const Allocator& allocator = Allocator())
+    : max_size_(max_size),
+      buffer_(allocator)
+  {
+    std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
+    buffer_.resize((std::max<std::size_t>)(pend, 1));
+    setg(&buffer_[0], &buffer_[0], &buffer_[0]);
+    setp(&buffer_[0], &buffer_[0] + pend);
+  }
+
+  /// Move the start of the get area by the specified number of characters.
+  void sbump(std::streamsize n)
+  {
+    while (n > 0)
+    {
+      sbumpc();
+      --n;
+    }
+  }
+
+  /// Move the start of the put area by the specified number of characters.
+  void spbump(std::streamsize n)
+  {
+    if (pptr() + n > epptr())
+      n = epptr() - pptr();
+    pbump(n);
+  }
+
+  /// Move the start of the put area by one character, returning the character
+  /// that was just moved into the get area.
+  int_type spbumpc()
+  {
+    if (pptr() == epptr())
+    {
+      return traits_type::eof();
+    }
+
+    int_type c = traits_type::to_int_type(*pptr());
+    pbump(1);
+    return c;
+  }
+
+  /// Return the size of the get area in characters.
+  std::size_t slength() const
+  {
+    return pptr() - gptr();
+  }
+
+  /// Get a list of buffers that represents the get area.
+  const_buffers_type sbuffers() const
+  {
+    return boost::asio::buffer(boost::asio::const_buffer(gptr(),
+          (pptr() - gptr()) * sizeof(char_type)));
+  }
+
+  /// Get a list of buffers that represents the put area, with the given size.
+  mutable_buffers_type spbuffers(std::size_t size)
+  {
+    reserve(size);
+    return boost::asio::buffer(boost::asio::mutable_buffer(
+          pptr(), size * sizeof(char_type)));
+  }
+
+protected:
+  enum { buffer_delta = 128 };
+
+  int_type underflow()
+  {
+    if (gptr() < pptr())
+    {
+      setg(&buffer_[0], gptr(), pptr());
+      return traits_type::to_int_type(*gptr());
+    }
+    else
+    {
+      return traits_type::eof();
+    }
+  }
+
+  int_type overflow(int_type c)
+  {
+    if (!traits_type::eq_int_type(c, traits_type::eof()))
+    {
+      if (pptr() == epptr())
+      {
+        std::size_t buffer_size = pptr() - gptr();
+        if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
+        {
+          reserve(max_size_ - buffer_size);
+        }
+        else
+        {
+          reserve(buffer_delta);
+        }
+      }
+
+      *pptr() = traits_type::to_char_type(c);
+      pbump(1);
+      return c;
+    }
+
+    return traits_type::not_eof(c);
+  }
+
+  void reserve(std::size_t n)
+  {
+    // Get current stream positions as offsets.
+    std::size_t gnext = gptr() - &buffer_[0];
+    std::size_t gend = egptr() - &buffer_[0];
+    std::size_t pnext = pptr() - &buffer_[0];
+    std::size_t pend = epptr() - &buffer_[0];
+
+    // Check if there is already enough space in the put area.
+    if (n <= pend - pnext)
+    {
+      return;
+    }
+
+    // Shift existing contents of get area to start of buffer.
+    if (gnext > 0)
+    {
+      std::rotate(&buffer_[0], &buffer_[0] + gnext, &buffer_[0] + pend);
+      gend -= gnext;
+      pnext -= gnext;
+    }
+
+    // Ensure buffer is large enough to hold at least the specified size.
+    if (n > pend - pnext)
+    {
+      if (n <= max_size_ & pnext <= max_size_ - n)
+      {
+        buffer_.resize((std::max<std::size_t>)(pnext + n, 1));
+      }
+      else
+      {
+        throw std::length_error("boost::asio::streambuf too long");
+      }
+    }
+
+    // Update stream positions.
+    setg(&buffer_[0], &buffer_[0], &buffer_[0] + gend);
+    setp(&buffer_[0] + pnext, &buffer_[0] + pnext + n);
+  }
+
+private:
+  std::size_t max_size_;
+  std::vector<char_type, Allocator> buffer_;
+};
+
+template <typename Sync_Read_Stream, typename Allocator,
+    typename Completion_Condition, typename Error_Handler>
+std::size_t read(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    Completion_Condition completion_condition, Error_Handler error_handler)
+{
+  std::size_t total_transferred = 0;
+  for (;;)
+  {
+    typename Sync_Read_Stream::error_type e;
+    std::size_t bytes_transferred = s.read_some(
+        b.spbuffers(512), assign_error(e));
+    b.spbump(bytes_transferred);
+    total_transferred += bytes_transferred;
+    if (completion_condition(e, total_transferred))
+    {
+      error_handler(e);
+      return total_transferred;
+    }
+  }
+  typename Sync_Read_Stream::error_type e;
+  error_handler(e);
+  return total_transferred;
+}
+
+template <typename Sync_Read_Stream, typename Allocator>
+inline std::size_t read(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b)
+{
+  return read(s, b, transfer_all(), throw_error());
+}
+
+template <typename Sync_Read_Stream, typename Allocator,
+    typename Completion_Condition>
+inline std::size_t read(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    Completion_Condition completion_condition)
+{
+  return read(s, b, completion_condition, throw_error());
+}
+
+namespace detail
+{
+  template <typename Async_Read_Stream, typename Allocator,
+      typename Completion_Condition, typename Handler>
+  class read_streambuf_handler
+  {
+  public:
+    read_streambuf_handler(Async_Read_Stream& stream,
+        basic_streambuf<Allocator>& streambuf,
+        Completion_Condition completion_condition, Handler handler)
+      : stream_(stream),
+        streambuf_(streambuf),
+        total_transferred_(0),
+        completion_condition_(completion_condition),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const typename Async_Read_Stream::error_type& e,
+        std::size_t bytes_transferred)
+    {
+      total_transferred_ += bytes_transferred;
+      streambuf_.spbump(bytes_transferred);
+      if (completion_condition_(e, total_transferred_))
+      {
+        stream_.io_service().dispatch(
+            detail::bind_handler(handler_, e, total_transferred_));
+      }
+      else
+      {
+        stream_.async_read_some(streambuf_.spbuffers(512), *this);
+      }
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        read_streambuf_handler<Async_Read_Stream, Allocator,
+          Completion_Condition, Handler>* this_handler)
+    {
+      return boost_asio_handler_alloc_helpers::allocate(
+          size, &this_handler->handler_);
+    }
+
+    friend void asio_handler_deallocate(void* pointer, std::size_t size,
+        read_streambuf_handler<Async_Read_Stream, Allocator,
+          Completion_Condition, Handler>* this_handler)
+    {
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer, size, &this_handler->handler_);
+    }
+
+  private:
+    Async_Read_Stream& stream_;
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    std::size_t total_transferred_;
+    Completion_Condition completion_condition_;
+    Handler handler_;
+  };
+} // namespace detail
+
+template <typename Async_Read_Stream, typename Allocator,
+    typename Completion_Condition, typename Handler>
+inline void async_read(Async_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    Completion_Condition completion_condition, Handler handler)
+{
+  s.async_read_some(b.spbuffers(512),
+      detail::read_streambuf_handler<Async_Read_Stream, Allocator,
+        Completion_Condition, Handler>(
+          s, b, completion_condition, handler));
+}
+
+template <typename Async_Read_Stream, typename Allocator, typename Handler>
+inline void async_read(Async_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, Handler handler)
+{
+  async_read(s, b, transfer_all(), handler);
+}
+
+template <typename Sync_Write_Stream, typename Allocator,
+    typename Completion_Condition, typename Error_Handler>
+std::size_t write(Sync_Write_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    Completion_Condition completion_condition, Error_Handler error_handler)
+{
+  typename Sync_Write_Stream::error_type error;
+  std::size_t bytes_transferred = write(s, b.sbuffers(),
+      completion_condition, boost::asio::assign_error(error));
+  b.sbump(bytes_transferred);
+  error_handler(error);
+  return bytes_transferred;
+}
+
+template <typename Sync_Write_Stream, typename Allocator>
+inline std::size_t write(Sync_Write_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b)
+{
+  return write(s, b, transfer_all(), throw_error());
+}
+
+template <typename Sync_Write_Stream, typename Allocator,
+    typename Completion_Condition>
+inline std::size_t write(Sync_Write_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    Completion_Condition completion_condition)
+{
+  return write(s, b, completion_condition, throw_error());
+}
+
+namespace detail
+{
+  template <typename Async_Write_Stream, typename Allocator, typename Handler>
+  class write_streambuf_handler
+  {
+  public:
+    write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
+        Handler handler)
+      : streambuf_(streambuf),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const typename Async_Write_Stream::error_type& e,
+        std::size_t bytes_transferred)
+    {
+      streambuf_.sbump(bytes_transferred);
+      handler_(e, bytes_transferred);
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        write_streambuf_handler<Async_Write_Stream,
+          Allocator, Handler>* this_handler)
+    {
+      return boost_asio_handler_alloc_helpers::allocate(
+          size, &this_handler->handler_);
+    }
+
+    friend void asio_handler_deallocate(void* pointer, std::size_t size,
+        write_streambuf_handler<Async_Write_Stream,
+          Allocator, Handler>* this_handler)
+    {
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer, size, &this_handler->handler_);
+    }
+
+  private:
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    Handler handler_;
+  };
+} // namespace detail
+
+template <typename Async_Write_Stream, typename Allocator,
+  typename Completion_Condition, typename Handler>
+inline void async_write(Async_Write_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b,
+    Completion_Condition completion_condition, Handler handler)
+{
+  async_write(s, b.sbuffers(),
+      detail::write_streambuf_handler<Async_Write_Stream, Allocator, Handler>(
+        b, handler));
+}
+
+template <typename Async_Write_Stream, typename Allocator, typename Handler>
+inline void async_write(Async_Write_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, Handler handler)
+{
+  async_write(s, b, transfer_all(), handler);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BASIC_STREAMBUF_HPP
diff --git a/include/boost/asio/buffer.hpp b/include/boost/asio/buffer.hpp
new file mode 100644
index 0000000000..0d8edcb365
--- /dev/null
+++ b/include/boost/asio/buffer.hpp
@@ -0,0 +1,641 @@
+//
+// buffer.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFER_HPP
+#define BOOST_ASIO_BUFFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/array.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <string>
+#include <vector>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+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
+ * be modified. It does not own the underlying data, and so is cheap to copy or
+ * assign.
+ */
+class mutable_buffer
+{
+public:
+  /// Construct an empty buffer.
+  mutable_buffer()
+    : data_(0),
+      size_(0)
+  {
+  }
+
+  /// Construct a buffer to represent a given memory range.
+  mutable_buffer(void* data, std::size_t size)
+    : data_(data),
+      size_(size)
+  {
+  }
+
+private:
+  friend void* boost::asio::detail::buffer_cast_helper(
+      const mutable_buffer& b);
+  friend std::size_t boost::asio::detail::buffer_size_helper(
+      const mutable_buffer& b);
+
+  void* data_;
+  std::size_t size_;
+};
+
+namespace detail {
+
+inline void* buffer_cast_helper(const mutable_buffer& b)
+{
+  return b.data_;
+}
+
+inline std::size_t buffer_size_helper(const mutable_buffer& b)
+{
+  return b.size_;
+}
+
+} // namespace detail
+
+/// Cast a non-modifiable buffer to a specified pointer to POD type.
+/**
+ * @relates mutable_buffer
+ */
+template <typename Pointer_To_Pod_Type>
+inline Pointer_To_Pod_Type buffer_cast(const mutable_buffer& b)
+{
+  return static_cast<Pointer_To_Pod_Type>(detail::buffer_cast_helper(b));
+}
+
+/// Get the number of bytes in a non-modifiable buffer.
+/**
+ * @relates mutable_buffer
+ */
+inline std::size_t buffer_size(const mutable_buffer& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_buffer
+ */
+inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
+{
+  if (start > buffer_size(b))
+    return mutable_buffer();
+  char* new_data = buffer_cast<char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return mutable_buffer(new_data, new_size);
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_buffer
+ */
+inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
+{
+  if (start > buffer_size(b))
+    return mutable_buffer();
+  char* new_data = buffer_cast<char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return mutable_buffer(new_data, new_size);
+}
+
+/// Adapts a single modifiable buffer so that it meets the requirements of the
+/// Mutable_Buffers concept.
+class mutable_buffer_container_1
+  : public mutable_buffer
+{
+public:
+  /// The type for each element in the list of buffers.
+  typedef mutable_buffer value_type;
+
+  /// A random-access iterator type that may be used to read elements.
+  typedef const mutable_buffer* const_iterator;
+
+  /// Construct to represent a single modifiable buffer.
+  explicit mutable_buffer_container_1(const mutable_buffer& b)
+    : mutable_buffer(b)
+  {
+  }
+
+  /// Get a random-access iterator to the first element.
+  const_iterator begin() const
+  {
+    return this;
+  }
+
+  /// Get a random-access iterator for one past the last element.
+  const_iterator end() const
+  {
+    return begin() + 1;
+  }
+};
+
+/// Holds a buffer that cannot be modified.
+/**
+ * The const_buffer class provides a safe representation of a buffer that cannot
+ * be modified. It does not own the underlying data, and so is cheap to copy or
+ * assign.
+ */
+class const_buffer
+{
+public:
+  /// Construct an empty buffer.
+  const_buffer()
+    : data_(0),
+      size_(0)
+  {
+  }
+
+  /// Construct a buffer to represent a given memory range.
+  const_buffer(const void* data, std::size_t size)
+    : data_(data),
+      size_(size)
+  {
+  }
+
+  /// Construct a non-modifiable buffer from a modifiable one.
+  const_buffer(const mutable_buffer& b)
+    : data_(boost::asio::detail::buffer_cast_helper(b)),
+      size_(boost::asio::detail::buffer_size_helper(b))
+  {
+  }
+
+private:
+  friend const void* boost::asio::detail::buffer_cast_helper(
+      const const_buffer& b);
+  friend std::size_t boost::asio::detail::buffer_size_helper(
+      const const_buffer& b);
+
+  const void* data_;
+  std::size_t size_;
+};
+
+namespace detail {
+
+inline const void* buffer_cast_helper(const const_buffer& b)
+{
+  return b.data_;
+}
+
+inline std::size_t buffer_size_helper(const const_buffer& b)
+{
+  return b.size_;
+}
+
+} // namespace detail
+
+/// Cast a non-modifiable buffer to a specified pointer to POD type.
+/**
+ * @relates const_buffer
+ */
+template <typename Pointer_To_Pod_Type>
+inline Pointer_To_Pod_Type buffer_cast(const const_buffer& b)
+{
+  return static_cast<Pointer_To_Pod_Type>(detail::buffer_cast_helper(b));
+}
+
+/// Get the number of bytes in a non-modifiable buffer.
+/**
+ * @relates const_buffer
+ */
+inline std::size_t buffer_size(const const_buffer& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_buffer
+ */
+inline const_buffer operator+(const const_buffer& b, std::size_t start)
+{
+  if (start > buffer_size(b))
+    return const_buffer();
+  const char* new_data = buffer_cast<const char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return const_buffer(new_data, new_size);
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_buffer
+ */
+inline const_buffer operator+(std::size_t start, const const_buffer& b)
+{
+  if (start > buffer_size(b))
+    return const_buffer();
+  const char* new_data = buffer_cast<const char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return const_buffer(new_data, new_size);
+}
+
+/// Adapts a single non-modifiable buffer so that it meets the requirements of
+/// the Const_Buffers concept.
+class const_buffer_container_1
+  : public const_buffer
+{
+public:
+  /// The type for each element in the list of buffers.
+  typedef const_buffer value_type;
+
+  /// A random-access iterator type that may be used to read elements.
+  typedef const const_buffer* const_iterator;
+
+  /// Construct to represent a single non-modifiable buffer.
+  explicit const_buffer_container_1(const const_buffer& b)
+    : const_buffer(b)
+  {
+  }
+
+  /// Get a random-access iterator to the first element.
+  const_iterator begin() const
+  {
+    return this;
+  }
+
+  /// Get a random-access iterator for one past the last element.
+  const_iterator end() const
+  {
+    return begin() + 1;
+  }
+};
+
+/** @defgroup buffer boost::asio::buffer
+ *
+ * @brief The boost::asio::buffer function is used to create a buffer object to
+ * represent raw memory, an array of POD elements, or a vector of POD elements.
+ *
+ * The simplest use case involves reading or writing a single buffer of a
+ * specified size:
+ *
+ * @code sock.write(boost::asio::buffer(data, size)); @endcode
+ *
+ * In the above example, the return value of boost::asio::buffer meets the
+ * requirements of the Const_Buffers concept so that it may be directly passed
+ * to the socket's write function. A buffer created for modifiable memory also
+ * meets the requirements of the Mutable_Buffers concept.
+ *
+ * An individual buffer may be created from a builtin array, std::vector or
+ * boost::array of POD elements. This helps prevent buffer overruns by
+ * automatically determining the size of the buffer:
+ *
+ * @code char d1[128];
+ * size_t bytes_transferred = sock.read(boost::asio::buffer(d1));
+ *
+ * std::vector<char> d2(128);
+ * bytes_transferred = sock.read(boost::asio::buffer(d2));
+ *
+ * boost::array<char, 128> d3;
+ * bytes_transferred = sock.read(boost::asio::buffer(d3)); @endcode
+ *
+ * To read or write using multiple buffers (i.e. scatter-gather I/O), multiple
+ * buffer objects may be assigned into a container that supports the
+ * Mutable_Buffers (for read) or Const_Buffers (for write) concepts:
+ *
+ * @code
+ * char d1[128];
+ * std::vector<char> d2(128);
+ * boost::array<char, 128> d3;
+ *
+ * boost::array<mutable_buffer, 3> bufs1 = {
+ *   boost::asio::buffer(d1),
+ *   boost::asio::buffer(d2),
+ *   boost::asio::buffer(d3) };
+ * bytes_transferred = sock.read(bufs1);
+ *
+ * std::vector<const_buffer> bufs2;
+ * bufs2.push_back(boost::asio::buffer(d1));
+ * bufs2.push_back(boost::asio::buffer(d2));
+ * bufs2.push_back(boost::asio::buffer(d3));
+ * bytes_transferred = sock.write(bufs2); @endcode
+ */
+/*@{*/
+
+/// Create a new modifiable buffer from an existing buffer.
+inline mutable_buffer_container_1 buffer(const mutable_buffer& b)
+{
+  return mutable_buffer_container_1(b);
+}
+
+/// Create a new modifiable buffer from an existing buffer.
+inline mutable_buffer_container_1 buffer(const mutable_buffer& b,
+    std::size_t max_size_in_bytes)
+{
+  return mutable_buffer_container_1(
+      mutable_buffer(buffer_cast<void*>(b),
+        buffer_size(b) < max_size_in_bytes
+        ? buffer_size(b) : max_size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer from an existing buffer.
+inline const_buffer_container_1 buffer(const const_buffer& b)
+{
+  return const_buffer_container_1(b);
+}
+
+/// Create a new non-modifiable buffer from an existing buffer.
+inline const_buffer_container_1 buffer(const const_buffer& b,
+    std::size_t max_size_in_bytes)
+{
+  return const_buffer_container_1(
+      const_buffer(buffer_cast<const void*>(b),
+        buffer_size(b) < max_size_in_bytes
+        ? buffer_size(b) : max_size_in_bytes));
+}
+
+/// Create a new modifiable buffer that represents the given memory range.
+inline mutable_buffer_container_1 buffer(void* data, std::size_t size_in_bytes)
+{
+  return mutable_buffer_container_1(mutable_buffer(data, size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer that represents the given memory range.
+inline const_buffer_container_1 buffer(const void* data,
+    std::size_t size_in_bytes)
+{
+  return const_buffer_container_1(const_buffer(data, size_in_bytes));
+}
+
+/// Create a new modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline mutable_buffer_container_1 buffer(Pod_Type (&data)[N])
+{
+  return mutable_buffer_container_1(mutable_buffer(data, N * sizeof(Pod_Type)));
+}
+ 
+/// Create a new modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline mutable_buffer_container_1 buffer(Pod_Type (&data)[N],
+    std::size_t max_size_in_bytes)
+{
+  return mutable_buffer_container_1(
+      mutable_buffer(data,
+        N * sizeof(Pod_Type) < max_size_in_bytes
+        ? N * sizeof(Pod_Type) : max_size_in_bytes));
+}
+ 
+/// Create a new non-modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline const_buffer_container_1 buffer(const Pod_Type (&data)[N])
+{
+  return const_buffer_container_1(const_buffer(data, N * sizeof(Pod_Type)));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline const_buffer_container_1 buffer(const Pod_Type (&data)[N],
+    std::size_t max_size_in_bytes)
+{
+  return const_buffer_container_1(
+      const_buffer(data,
+        N * sizeof(Pod_Type) < max_size_in_bytes
+        ? N * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+// Borland C++ thinks the overloads:
+//
+//   unspecified buffer(boost::array<Pod_Type, N>& array ...);
+//
+// and
+//
+//   unspecified buffer(boost::array<const Pod_Type, N>& array ...);
+//
+// are ambiguous. This will be worked around by using a buffer_types traits
+// class that contains typedefs for the appropriate buffer and container
+// classes, based on whether Pod_Type is const or non-const.
+
+namespace detail {
+
+template <bool IsConst>
+struct buffer_types_base;
+
+template <>
+struct buffer_types_base<false>
+{
+  typedef mutable_buffer buffer_type;
+  typedef mutable_buffer_container_1 container_type;
+};
+
+template <>
+struct buffer_types_base<true>
+{
+  typedef const_buffer buffer_type;
+  typedef const_buffer_container_1 container_type;
+};
+
+template <typename Pod_Type>
+struct buffer_types
+  : public buffer_types_base<boost::is_const<Pod_Type>::value>
+{
+};
+
+} // namespace detail
+
+template <typename Pod_Type, std::size_t N>
+inline typename detail::buffer_types<Pod_Type>::container_type
+buffer(boost::array<Pod_Type, N>& data)
+{
+  typedef typename boost::asio::detail::buffer_types<Pod_Type>::buffer_type
+    buffer_type;
+  typedef typename boost::asio::detail::buffer_types<Pod_Type>::container_type
+    container_type;
+  return container_type(
+      buffer_type(data.c_array(), data.size() * sizeof(Pod_Type)));
+}
+
+template <typename Pod_Type, std::size_t N>
+inline typename detail::buffer_types<Pod_Type>::container_type
+buffer(boost::array<Pod_Type, N>& data, std::size_t max_size_in_bytes)
+{
+  typedef typename boost::asio::detail::buffer_types<Pod_Type>::buffer_type
+    buffer_type;
+  typedef typename boost::asio::detail::buffer_types<Pod_Type>::container_type
+    container_type;
+  return container_type(
+      buffer_type(data.c_array(),
+        data.size() * sizeof(Pod_Type) < max_size_in_bytes
+        ? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+#else // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+/// Create a new modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline mutable_buffer_container_1 buffer(boost::array<Pod_Type, N>& data)
+{
+  return mutable_buffer_container_1(
+      mutable_buffer(data.c_array(), data.size() * sizeof(Pod_Type)));
+}
+
+/// Create a new modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline mutable_buffer_container_1 buffer(boost::array<Pod_Type, N>& data,
+    std::size_t max_size_in_bytes)
+{
+  return mutable_buffer_container_1(
+      mutable_buffer(data.c_array(),
+        data.size() * sizeof(Pod_Type) < max_size_in_bytes
+        ? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline const_buffer_container_1 buffer(boost::array<const Pod_Type, N>& data)
+{
+  return const_buffer_container_1(
+      const_buffer(data.data(), data.size() * sizeof(Pod_Type)));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline const_buffer_container_1 buffer(boost::array<const Pod_Type, N>& data,
+    std::size_t max_size_in_bytes)
+{
+  return const_buffer_container_1(
+      const_buffer(data.data(),
+        data.size() * sizeof(Pod_Type) < max_size_in_bytes
+        ? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline const_buffer_container_1 buffer(const boost::array<Pod_Type, N>& data)
+{
+  return const_buffer_container_1(
+      const_buffer(data.data(), data.size() * sizeof(Pod_Type)));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD array.
+template <typename Pod_Type, std::size_t N>
+inline const_buffer_container_1 buffer(const boost::array<Pod_Type, N>& data,
+    std::size_t max_size_in_bytes)
+{
+  return const_buffer_container_1(
+      const_buffer(data.data(),
+        data.size() * sizeof(Pod_Type) < max_size_in_bytes
+        ? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+/// Create a new modifiable buffer that represents the given POD vector.
+/**
+ * @note The buffer is invalidated by any vector operation that would also
+ * invalidate iterators.
+ */
+template <typename Pod_Type, typename Allocator>
+inline mutable_buffer_container_1 buffer(std::vector<Pod_Type, Allocator>& data)
+{
+  return mutable_buffer_container_1(
+      mutable_buffer(&data[0], data.size() * sizeof(Pod_Type)));
+}
+
+/// Create a new modifiable buffer that represents the given POD vector.
+/**
+ * @note The buffer is invalidated by any vector operation that would also
+ * invalidate iterators.
+ */
+template <typename Pod_Type, typename Allocator>
+inline mutable_buffer_container_1 buffer(std::vector<Pod_Type, Allocator>& data,
+    std::size_t max_size_in_bytes)
+{
+  return mutable_buffer_container_1(
+      mutable_buffer(&data[0],
+        data.size() * sizeof(Pod_Type) < max_size_in_bytes
+        ? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD vector.
+/**
+ * @note The buffer is invalidated by any vector operation that would also
+ * invalidate iterators.
+ */
+template <typename Pod_Type, typename Allocator>
+inline const_buffer_container_1 buffer(
+    const std::vector<Pod_Type, Allocator>& data)
+{
+  return const_buffer_container_1(
+      const_buffer(&data[0], data.size() * sizeof(Pod_Type)));
+}
+
+/// Create a new non-modifiable buffer that represents the given POD vector.
+/**
+ * @note The buffer is invalidated by any vector operation that would also
+ * invalidate iterators.
+ */
+template <typename Pod_Type, typename Allocator>
+inline const_buffer_container_1 buffer(
+    const std::vector<Pod_Type, Allocator>& data, std::size_t max_size_in_bytes)
+{
+  return const_buffer_container_1(
+      const_buffer(&data[0],
+        data.size() * sizeof(Pod_Type) < max_size_in_bytes
+        ? data.size() * sizeof(Pod_Type) : max_size_in_bytes));
+}
+
+/// Create a new non-modifiable buffer that represents the given string.
+/**
+ * @note The buffer is invalidated by any non-const operation called on the
+ * given string object.
+ */
+inline const_buffer_container_1 buffer(const std::string& data)
+{
+  return const_buffer_container_1(const_buffer(data.data(), data.size()));
+}
+
+/// Create a new non-modifiable buffer that represents the given string.
+/**
+ * @note The buffer is invalidated by any non-const operation called on the
+ * given string object.
+ */
+inline const_buffer_container_1 buffer(const std::string& data,
+    std::size_t max_size_in_bytes)
+{
+  return const_buffer_container_1(
+      const_buffer(data.data(),
+        data.size() < max_size_in_bytes
+        ? data.size() : max_size_in_bytes));
+}
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFER_HPP
diff --git a/include/boost/asio/buffered_read_stream.hpp b/include/boost/asio/buffered_read_stream.hpp
new file mode 100644
index 0000000000..401da29777
--- /dev/null
+++ b/include/boost/asio/buffered_read_stream.hpp
@@ -0,0 +1,409 @@
+//
+// buffered_read_stream.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERED_READ_STREAM_HPP
+#define BOOST_ASIO_BUFFERED_READ_STREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <cstring>
+#include <boost/config.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffered_read_stream_fwd.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_resize_guard.hpp>
+#include <boost/asio/detail/buffered_stream_storage.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Adds buffering to the read-related operations of a stream.
+/**
+ * The buffered_read_stream class template can be used to add buffering to the
+ * synchronous and asynchronous read operations of a stream.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Async_Read_Stream, Async_Write_Stream, Error_Source, Stream,
+ * Sync_Read_Stream, Sync_Write_Stream.
+ */
+template <typename Stream>
+class buffered_read_stream
+  : private noncopyable
+{
+public:
+  /// The type of the next layer.
+  typedef typename boost::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 used for reporting errors.
+  typedef typename next_layer_type::error_type error_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The default buffer size.
+  static const std::size_t default_buffer_size = implementation_defined;
+#else
+  BOOST_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
+#endif
+
+  /// Construct, passing the specified argument to initialise the next layer.
+  template <typename Arg>
+  explicit buffered_read_stream(Arg& a)
+    : next_layer_(a),
+      storage_(default_buffer_size)
+  {
+  }
+
+  /// Construct, passing the specified argument to initialise the next layer.
+  template <typename Arg>
+  buffered_read_stream(Arg& a, std::size_t buffer_size)
+    : next_layer_(a),
+      storage_(buffer_size)
+  {
+  }
+
+  /// Get a reference to the next layer.
+  next_layer_type& next_layer()
+  {
+    return next_layer_;
+  }
+
+  /// Get a reference to the lowest layer.
+  lowest_layer_type& lowest_layer()
+  {
+    return next_layer_.lowest_layer();
+  }
+
+  /// Get the io_service associated with the object.
+  boost::asio::io_service& io_service()
+  {
+    return next_layer_.io_service();
+  }
+
+  /// Close the stream.
+  void close()
+  {
+    next_layer_.close();
+  }
+
+  /// Close the stream.
+  template <typename Error_Handler>
+  void close(Error_Handler error_handler)
+  {
+    next_layer_.close(error_handler);
+  }
+
+  /// Write the given data to the stream. Returns the number of bytes written.
+  /// Throws an exception on failure.
+  template <typename Const_Buffers>
+  std::size_t write_some(const Const_Buffers& buffers)
+  {
+    return next_layer_.write_some(buffers);
+  }
+
+  /// Write the given data to the stream. Returns the number of bytes written,
+  /// or 0 if an error occurred and the error handler did not throw.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t write_some(const Const_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return next_layer_.write_some(buffers, error_handler);
+  }
+
+  /// Start an asynchronous write. The data being written must be valid for the
+  /// lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_write_some(const Const_Buffers& buffers, Handler handler)
+  {
+    next_layer_.async_write_some(buffers, handler);
+  }
+
+  /// Fill the buffer with some data. Returns the number of bytes placed in the
+  /// buffer as a result of the operation. Throws an exception on failure.
+  std::size_t fill()
+  {
+    detail::buffer_resize_guard<detail::buffered_stream_storage>
+      resize_guard(storage_);
+    std::size_t previous_size = storage_.size();
+    storage_.resize(storage_.capacity());
+    storage_.resize(previous_size + next_layer_.read_some(buffer(
+            storage_.data() + previous_size,
+            storage_.size() - previous_size)));
+    resize_guard.commit();
+    return storage_.size() - previous_size;
+  }
+
+  /// Fill the buffer with some data. Returns the number of bytes placed in the
+  /// buffer as a result of the operation, or 0 if an error occurred and the
+  /// error handler did not throw.
+  template <typename Error_Handler>
+  std::size_t fill(Error_Handler error_handler)
+  {
+    detail::buffer_resize_guard<detail::buffered_stream_storage>
+      resize_guard(storage_);
+    std::size_t previous_size = storage_.size();
+    storage_.resize(storage_.capacity());
+    storage_.resize(previous_size + next_layer_.read_some(buffer(
+            storage_.data() + previous_size,
+            storage_.size() - previous_size),
+          error_handler));
+    resize_guard.commit();
+    return storage_.size() - previous_size;
+  }
+
+  template <typename Handler>
+  class fill_handler
+  {
+  public:
+    fill_handler(boost::asio::io_service& io_service,
+        detail::buffered_stream_storage& storage,
+        std::size_t previous_size, Handler handler)
+      : io_service_(io_service),
+        storage_(storage),
+        previous_size_(previous_size),
+        handler_(handler)
+    {
+    }
+
+    template <typename Error>
+    void operator()(const Error& e, std::size_t bytes_transferred)
+    {
+      storage_.resize(previous_size_ + bytes_transferred);
+      io_service_.dispatch(detail::bind_handler(
+            handler_, e, bytes_transferred));
+    }
+
+  private:
+    boost::asio::io_service& io_service_;
+    detail::buffered_stream_storage& storage_;
+    std::size_t previous_size_;
+    Handler handler_;
+  };
+
+  /// Start an asynchronous fill.
+  template <typename Handler>
+  void async_fill(Handler handler)
+  {
+    std::size_t previous_size = storage_.size();
+    storage_.resize(storage_.capacity());
+    next_layer_.async_read_some(
+        buffer(
+          storage_.data() + previous_size,
+          storage_.size() - previous_size),
+        fill_handler<Handler>(io_service(), storage_, previous_size, handler));
+  }
+
+  /// Read some data from the stream. Returns the number of bytes read. Throws
+  /// an exception on failure.
+  template <typename Mutable_Buffers>
+  std::size_t read_some(const Mutable_Buffers& buffers)
+  {
+    if (storage_.empty())
+      fill();
+    return copy(buffers);
+  }
+
+  /// Read some data from the stream. Returns the number of bytes read or 0 if
+  /// an error occurred and the error handler did not throw an exception.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(const Mutable_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    if (storage_.empty() && !fill(error_handler))
+      return 0;
+    return copy(buffers);
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  class read_some_handler
+  {
+  public:
+    read_some_handler(boost::asio::io_service& io_service,
+        detail::buffered_stream_storage& storage,
+        const Mutable_Buffers& buffers, Handler handler)
+      : io_service_(io_service),
+        storage_(storage),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const error_type& e, std::size_t)
+    {
+      if (e || storage_.empty())
+      {
+        std::size_t length = 0;
+        io_service_.dispatch(detail::bind_handler(handler_, e, length));
+      }
+      else
+      {
+        using namespace std; // For memcpy.
+
+        std::size_t bytes_avail = storage_.size();
+        std::size_t bytes_copied = 0;
+
+        typename Mutable_Buffers::const_iterator iter = buffers_.begin();
+        typename Mutable_Buffers::const_iterator end = buffers_.end();
+        for (; iter != end && bytes_avail > 0; ++iter)
+        {
+          std::size_t max_length = buffer_size(*iter);
+          std::size_t length = (max_length < bytes_avail)
+            ? max_length : bytes_avail;
+          memcpy(buffer_cast<void*>(*iter),
+              storage_.data() + bytes_copied, length);
+          bytes_copied += length;
+          bytes_avail -= length;
+        }
+
+        storage_.consume(bytes_copied);
+        io_service_.dispatch(detail::bind_handler(handler_, e, bytes_copied));
+      }
+    }
+
+  private:
+    boost::asio::io_service& io_service_;
+    detail::buffered_stream_storage& storage_;
+    Mutable_Buffers buffers_;
+    Handler handler_;
+  };
+
+  /// Start an asynchronous read. The buffer into which the data will be read
+  /// must be valid for the lifetime of the asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_read_some(const Mutable_Buffers& buffers, Handler handler)
+  {
+    if (storage_.empty())
+    {
+      async_fill(read_some_handler<Mutable_Buffers, Handler>(
+            io_service(), storage_, buffers, handler));
+    }
+    else
+    {
+      std::size_t length = copy(buffers);
+      io_service().post(detail::bind_handler(handler, 0, length));
+    }
+  }
+
+  /// Peek at the incoming data on the stream. Returns the number of bytes read.
+  /// Throws an exception on failure.
+  template <typename Mutable_Buffers>
+  std::size_t peek(const Mutable_Buffers& buffers)
+  {
+    if (storage_.empty())
+      fill();
+    return peek_copy(buffers);
+  }
+
+  /// Peek at the incoming data on the stream. Returns the number of bytes read,
+  /// or 0 if an error occurred and the error handler did not throw.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    if (storage_.empty() && !fill(error_handler))
+      return 0;
+    return peek_copy(buffers);
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  std::size_t in_avail()
+  {
+    return storage_.size();
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  template <typename Error_Handler>
+  std::size_t in_avail(Error_Handler error_handler)
+  {
+    return storage_.size();
+  }
+
+private:
+  /// Copy data out of the internal buffer to the specified target buffer.
+  /// Returns the number of bytes copied.
+  template <typename Mutable_Buffers>
+  std::size_t copy(const Mutable_Buffers& buffers)
+  {
+    using namespace std; // For memcpy.
+
+    std::size_t bytes_avail = storage_.size();
+    std::size_t bytes_copied = 0;
+
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    for (; iter != end && bytes_avail > 0; ++iter)
+    {
+      std::size_t max_length = buffer_size(*iter);
+      std::size_t length = (max_length < bytes_avail)
+        ? max_length : bytes_avail;
+      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
+      bytes_copied += length;
+      bytes_avail -= length;
+    }
+
+    storage_.consume(bytes_copied);
+    return bytes_copied;
+  }
+
+  /// Copy data from the internal buffer to the specified target buffer, without
+  /// removing the data from the internal buffer. Returns the number of bytes
+  /// copied.
+  template <typename Mutable_Buffers>
+  std::size_t peek_copy(const Mutable_Buffers& buffers)
+  {
+    using namespace std; // For memcpy.
+
+    std::size_t bytes_avail = storage_.size();
+    std::size_t bytes_copied = 0;
+
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    for (; iter != end && bytes_avail > 0; ++iter)
+    {
+      std::size_t max_length = buffer_size(*iter);
+      std::size_t length = (max_length < bytes_avail)
+        ? max_length : bytes_avail;
+      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
+      bytes_copied += length;
+      bytes_avail -= length;
+    }
+
+    return bytes_copied;
+  }
+
+  /// The next layer.
+  Stream next_layer_;
+
+  // The data in the buffer.
+  detail::buffered_stream_storage storage_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERED_READ_STREAM_HPP
diff --git a/include/boost/asio/buffered_read_stream_fwd.hpp b/include/boost/asio/buffered_read_stream_fwd.hpp
new file mode 100644
index 0000000000..07109fc387
--- /dev/null
+++ b/include/boost/asio/buffered_read_stream_fwd.hpp
@@ -0,0 +1,31 @@
+//
+// buffered_read_stream_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
+#define BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Stream>
+class buffered_read_stream;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
diff --git a/include/boost/asio/buffered_stream.hpp b/include/boost/asio/buffered_stream.hpp
new file mode 100644
index 0000000000..a8380da3a0
--- /dev/null
+++ b/include/boost/asio/buffered_stream.hpp
@@ -0,0 +1,251 @@
+//
+// buffered_stream.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERED_STREAM_HPP
+#define BOOST_ASIO_BUFFERED_STREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffered_read_stream.hpp>
+#include <boost/asio/buffered_write_stream.hpp>
+#include <boost/asio/buffered_stream_fwd.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Adds buffering to the read- and write-related operations of a stream.
+/**
+ * The buffered_stream class template can be used to add buffering to the
+ * synchronous and asynchronous read and write operations of a stream.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Async_Read_Stream, Async_Write_Stream, Error_Source, Stream,
+ * Sync_Read_Stream, Sync_Write_Stream.
+ */
+template <typename Stream>
+class buffered_stream
+  : private noncopyable
+{
+public:
+  /// The type of the next layer.
+  typedef typename boost::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 used for reporting errors.
+  typedef typename next_layer_type::error_type error_type;
+
+  /// Construct, passing the specified argument to initialise the next layer.
+  template <typename Arg>
+  explicit buffered_stream(Arg& a)
+    : inner_stream_impl_(a),
+      stream_impl_(inner_stream_impl_)
+  {
+  }
+
+  /// Construct, passing the specified argument to initialise the next layer.
+  template <typename Arg>
+  explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
+      std::size_t write_buffer_size)
+    : inner_stream_impl_(a, write_buffer_size),
+      stream_impl_(inner_stream_impl_, read_buffer_size)
+  {
+  }
+
+  /// Get a reference to the next layer.
+  next_layer_type& next_layer()
+  {
+    return stream_impl_.next_layer().next_layer();
+  }
+
+  /// Get a reference to the lowest layer.
+  lowest_layer_type& lowest_layer()
+  {
+    return stream_impl_.lowest_layer();
+  }
+
+  /// Get the io_service associated with the object.
+  boost::asio::io_service& io_service()
+  {
+    return stream_impl_.io_service();
+  }
+
+  /// Close the stream.
+  void close()
+  {
+    stream_impl_.close();
+  }
+
+  /// Close the stream.
+  template <typename Error_Handler>
+  void close(Error_Handler error_handler)
+  {
+    stream_impl_.close(error_handler);
+  }
+
+  /// Flush all data from the buffer to the next layer. Returns the number of
+  /// bytes written to the next layer on the last write operation. Throws an
+  /// exception on failure.
+  std::size_t flush()
+  {
+    return stream_impl_.next_layer().flush();
+  }
+
+  /// Flush all data from the buffer to the next layer. Returns the number of
+  /// bytes written to the next layer on the last write operation, or 0 if an
+  /// error occurred and the error handler did not throw.
+  template <typename Error_Handler>
+  std::size_t flush(Error_Handler error_handler)
+  {
+    return stream_impl_.next_layer().flush(error_handler);
+  }
+
+  /// Start an asynchronous flush.
+  template <typename Handler>
+  void async_flush(Handler handler)
+  {
+    return stream_impl_.next_layer().async_flush(handler);
+  }
+
+  /// Write the given data to the stream. Returns the number of bytes written.
+  /// Throws an exception on failure.
+  template <typename Const_Buffers>
+  std::size_t write_some(const Const_Buffers& buffers)
+  {
+    return stream_impl_.write_some(buffers);
+  }
+
+  /// Write the given data to the stream. Returns the number of bytes written,
+  /// or 0 if an error occurred and the error handler did not throw.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t write_some(const Const_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return stream_impl_.write_some(buffers, error_handler);
+  }
+
+  /// Start an asynchronous write. The data being written must be valid for the
+  /// lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_write_some(const Const_Buffers& buffers, Handler handler)
+  {
+    stream_impl_.async_write_some(buffers, handler);
+  }
+
+  /// Fill the buffer with some data. Returns the number of bytes placed in the
+  /// buffer as a result of the operation. Throws an exception on failure.
+  std::size_t fill()
+  {
+    return stream_impl_.fill();
+  }
+
+  /// Fill the buffer with some data. Returns the number of bytes placed in the
+  /// buffer as a result of the operation, or 0 if an error occurred and the
+  /// error handler did not throw.
+  template <typename Error_Handler>
+  std::size_t fill(Error_Handler error_handler)
+  {
+    return stream_impl_.fill(error_handler);
+  }
+
+  /// Start an asynchronous fill.
+  template <typename Handler>
+  void async_fill(Handler handler)
+  {
+    stream_impl_.async_fill(handler);
+  }
+
+  /// Read some data from the stream. Returns the number of bytes read. Throws
+  /// an exception on failure.
+  template <typename Mutable_Buffers>
+  std::size_t read_some(const Mutable_Buffers& buffers)
+  {
+    return stream_impl_.read_some(buffers);
+  }
+
+  /// Read some data from the stream. Returns the number of bytes read or 0 if
+  /// an error occurred and the error handler did not throw an exception.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(const Mutable_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return stream_impl_.read_some(buffers, error_handler);
+  }
+
+  /// Start an asynchronous read. The buffer into which the data will be read
+  /// must be valid for the lifetime of the asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_read_some(const Mutable_Buffers& buffers, Handler handler)
+  {
+    stream_impl_.async_read_some(buffers, handler);
+  }
+
+  /// Peek at the incoming data on the stream. Returns the number of bytes read.
+  /// Throws an exception on failure.
+  template <typename Mutable_Buffers>
+  std::size_t peek(const Mutable_Buffers& buffers)
+  {
+    return stream_impl_.peek(buffers);
+  }
+
+  /// Peek at the incoming data on the stream. Returns the number of bytes read,
+  /// or 0 if an error occurred and the error handler did not throw.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return stream_impl_.peek(buffers, error_handler);
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  std::size_t in_avail()
+  {
+    return stream_impl_.in_avail();
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  template <typename Error_Handler>
+  std::size_t in_avail(Error_Handler error_handler)
+  {
+    return stream_impl_.in_avail(error_handler);
+  }
+
+private:
+  // The buffered write stream.
+  typedef buffered_write_stream<Stream> write_stream_type;
+  write_stream_type inner_stream_impl_;
+
+  // The buffered read stream.
+  typedef buffered_read_stream<write_stream_type&> read_stream_type;
+  read_stream_type stream_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERED_STREAM_HPP
diff --git a/include/boost/asio/buffered_stream_fwd.hpp b/include/boost/asio/buffered_stream_fwd.hpp
new file mode 100644
index 0000000000..b20c4f0498
--- /dev/null
+++ b/include/boost/asio/buffered_stream_fwd.hpp
@@ -0,0 +1,31 @@
+//
+// buffered_stream_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
+#define BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Stream>
+class buffered_stream;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
diff --git a/include/boost/asio/buffered_write_stream.hpp b/include/boost/asio/buffered_write_stream.hpp
new file mode 100644
index 0000000000..4e66a3d972
--- /dev/null
+++ b/include/boost/asio/buffered_write_stream.hpp
@@ -0,0 +1,364 @@
+//
+// buffered_write_stream.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
+#define BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <cstring>
+#include <boost/config.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffered_write_stream_fwd.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffered_stream_storage.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Adds buffering to the write-related operations of a stream.
+/**
+ * The buffered_write_stream class template can be used to add buffering to the
+ * synchronous and asynchronous write operations of a stream.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Async_Object, Async_Read_Stream, Async_Write_Stream, Error_Source, Stream,
+ * Sync_Read_Stream, Sync_Write_Stream.
+ */
+template <typename Stream>
+class buffered_write_stream
+  : private noncopyable
+{
+public:
+  /// The type of the next layer.
+  typedef typename boost::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 used for reporting errors.
+  typedef typename next_layer_type::error_type error_type;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// The default buffer size.
+  static const std::size_t default_buffer_size = implementation_defined;
+#else
+  BOOST_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
+#endif
+
+  /// Construct, passing the specified argument to initialise the next layer.
+  template <typename Arg>
+  explicit buffered_write_stream(Arg& a)
+    : next_layer_(a),
+      storage_(default_buffer_size)
+  {
+  }
+
+  /// Construct, passing the specified argument to initialise the next layer.
+  template <typename Arg>
+  buffered_write_stream(Arg& a, std::size_t buffer_size)
+    : next_layer_(a),
+      storage_(buffer_size)
+  {
+  }
+
+  /// Get a reference to the next layer.
+  next_layer_type& next_layer()
+  {
+    return next_layer_;
+  }
+
+  /// Get a reference to the lowest layer.
+  lowest_layer_type& lowest_layer()
+  {
+    return next_layer_.lowest_layer();
+  }
+
+  /// Get the io_service associated with the object.
+  boost::asio::io_service& io_service()
+  {
+    return next_layer_.io_service();
+  }
+
+  /// Close the stream.
+  void close()
+  {
+    next_layer_.close();
+  }
+
+  /// Close the stream.
+  template <typename Error_Handler>
+  void close(Error_Handler error_handler)
+  {
+    next_layer_.close(error_handler);
+  }
+
+  /// Flush all data from the buffer to the next layer. Returns the number of
+  /// bytes written to the next layer on the last write operation. Throws an
+  /// exception on failure.
+  std::size_t flush()
+  {
+    std::size_t bytes_written = write(next_layer_,
+        buffer(storage_.data(), storage_.size()));
+    storage_.consume(bytes_written);
+    return bytes_written;
+  }
+
+  /// Flush all data from the buffer to the next layer. Returns the number of
+  /// bytes written to the next layer on the last write operation, or 0 if an
+  /// error occurred and the error handler did not throw.
+  template <typename Error_Handler>
+  std::size_t flush(Error_Handler error_handler)
+  {
+    std::size_t bytes_written = write(next_layer_,
+        buffer(storage_.data(), storage_.size()),
+        transfer_all(), error_handler);
+    storage_.consume(bytes_written);
+    return bytes_written;
+  }
+
+  template <typename Handler>
+  class flush_handler
+  {
+  public:
+    flush_handler(boost::asio::io_service& io_service,
+        detail::buffered_stream_storage& storage, Handler handler)
+      : io_service_(io_service),
+        storage_(storage),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const error_type& e, std::size_t bytes_written)
+    {
+      storage_.consume(bytes_written);
+      io_service_.dispatch(detail::bind_handler(handler_, e, bytes_written));
+    }
+
+  private:
+    boost::asio::io_service& io_service_;
+    detail::buffered_stream_storage& storage_;
+    Handler handler_;
+  };
+
+  /// Start an asynchronous flush.
+  template <typename Handler>
+  void async_flush(Handler handler)
+  {
+    async_write(next_layer_, buffer(storage_.data(), storage_.size()),
+        flush_handler<Handler>(io_service(), storage_, handler));
+  }
+
+  /// Write the given data to the stream. Returns the number of bytes written.
+  /// Throws an exception on failure.
+  template <typename Const_Buffers>
+  std::size_t write_some(const Const_Buffers& buffers)
+  {
+    if (storage_.size() == storage_.capacity())
+      flush();
+    return copy(buffers);
+  }
+
+  /// Write the given data to the stream. Returns the number of bytes written,
+  /// or 0 if an error occurred and the error handler did not throw.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t write_some(const Const_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    if (storage_.size() == storage_.capacity() && !flush(error_handler))
+      return 0;
+    return copy(buffers);
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  class write_some_handler
+  {
+  public:
+    write_some_handler(boost::asio::io_service& io_service,
+        detail::buffered_stream_storage& storage,
+        const Const_Buffers& buffers, Handler handler)
+      : io_service_(io_service),
+        storage_(storage),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const error_type& e, std::size_t)
+    {
+      if (e)
+      {
+        std::size_t length = 0;
+        io_service_.dispatch(detail::bind_handler(handler_, e, length));
+      }
+      else
+      {
+        using namespace std; // For memcpy.
+
+        std::size_t orig_size = storage_.size();
+        std::size_t space_avail = storage_.capacity() - orig_size;
+        std::size_t bytes_copied = 0;
+
+        typename Const_Buffers::const_iterator iter = buffers_.begin();
+        typename Const_Buffers::const_iterator end = buffers_.end();
+        for (; iter != end && space_avail > 0; ++iter)
+        {
+          std::size_t bytes_avail = buffer_size(*iter);
+          std::size_t length = (bytes_avail < space_avail)
+            ? bytes_avail : space_avail;
+          storage_.resize(orig_size + bytes_copied + length);
+          memcpy(storage_.data() + orig_size + bytes_copied,
+              buffer_cast<const void*>(*iter), length);
+          bytes_copied += length;
+          space_avail -= length;
+        }
+
+        io_service_.dispatch(detail::bind_handler(handler_, e, bytes_copied));
+      }
+    }
+
+  private:
+    boost::asio::io_service& io_service_;
+    detail::buffered_stream_storage& storage_;
+    Const_Buffers buffers_;
+    Handler handler_;
+  };
+
+  /// Start an asynchronous write. The data being written must be valid for the
+  /// lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_write_some(const Const_Buffers& buffers, Handler handler)
+  {
+    if (storage_.size() == storage_.capacity())
+    {
+      async_flush(write_some_handler<Const_Buffers, Handler>(
+            io_service(), storage_, buffers, handler));
+    }
+    else
+    {
+      std::size_t bytes_copied = copy(buffers);
+      io_service().post(detail::bind_handler(handler, 0, bytes_copied));
+    }
+  }
+
+  /// Read some data from the stream. Returns the number of bytes read. Throws
+  /// an exception on failure.
+  template <typename Mutable_Buffers>
+  std::size_t read_some(const Mutable_Buffers& buffers)
+  {
+    return next_layer_.read_some(buffers);
+  }
+
+  /// Read some data from the stream. Returns the number of bytes read or 0 if
+  /// an error occurred and the error handler did not throw an exception.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(const Mutable_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return next_layer_.read_some(buffers, error_handler);
+  }
+
+  /// Start an asynchronous read. The buffer into which the data will be read
+  /// must be valid for the lifetime of the asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_read_some(const Mutable_Buffers& buffers, Handler handler)
+  {
+    next_layer_.async_read_some(buffers, handler);
+  }
+
+  /// Peek at the incoming data on the stream. Returns the number of bytes read.
+  /// Throws an exception on failure.
+  template <typename Mutable_Buffers>
+  std::size_t peek(const Mutable_Buffers& buffers)
+  {
+    return next_layer_.peek(buffers);
+  }
+
+  /// Peek at the incoming data on the stream. Returns the number of bytes read,
+  /// or 0 if an error occurred and the error handler did not throw.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return next_layer_.peek(buffers, error_handler);
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  std::size_t in_avail()
+  {
+    return next_layer_.in_avail();
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  template <typename Error_Handler>
+  std::size_t in_avail(Error_Handler error_handler)
+  {
+    return next_layer_.in_avail(error_handler);
+  }
+
+private:
+  /// Copy data into the internal buffer from the specified source buffer.
+  /// Returns the number of bytes copied.
+  template <typename Const_Buffers>
+  std::size_t copy(const Const_Buffers& buffers)
+  {
+    using namespace std; // For memcpy.
+
+    std::size_t orig_size = storage_.size();
+    std::size_t space_avail = storage_.capacity() - orig_size;
+    std::size_t bytes_copied = 0;
+
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    for (; iter != end && space_avail > 0; ++iter)
+    {
+      std::size_t bytes_avail = buffer_size(*iter);
+      std::size_t length = (bytes_avail < space_avail)
+        ? bytes_avail : space_avail;
+      storage_.resize(orig_size + bytes_copied + length);
+      memcpy(storage_.data() + orig_size + bytes_copied,
+          buffer_cast<const void*>(*iter), length);
+      bytes_copied += length;
+      space_avail -= length;
+    }
+
+    return bytes_copied;
+  }
+
+  /// The next layer.
+  Stream next_layer_;
+
+  // The data in the buffer.
+  detail::buffered_stream_storage storage_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
diff --git a/include/boost/asio/buffered_write_stream_fwd.hpp b/include/boost/asio/buffered_write_stream_fwd.hpp
new file mode 100644
index 0000000000..a8c033d6da
--- /dev/null
+++ b/include/boost/asio/buffered_write_stream_fwd.hpp
@@ -0,0 +1,31 @@
+//
+// buffered_write_stream_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
+#define BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Stream>
+class buffered_write_stream;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
diff --git a/include/boost/asio/completion_condition.hpp b/include/boost/asio/completion_condition.hpp
new file mode 100644
index 0000000000..8795f7256f
--- /dev/null
+++ b/include/boost/asio/completion_condition.hpp
@@ -0,0 +1,103 @@
+//
+// completion_condition.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_COMPLETION_CONDITION_HPP
+#define BOOST_ASIO_COMPLETION_CONDITION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace detail {
+
+class transfer_all_t
+{
+public:
+  typedef bool result_type;
+
+  template <typename Error>
+  bool operator()(const Error& err, std::size_t)
+  {
+    return !!err;
+  }
+};
+
+class transfer_at_least_t
+{
+public:
+  typedef bool result_type;
+
+  explicit transfer_at_least_t(std::size_t minimum)
+    : minimum_(minimum)
+  {
+  }
+
+  template <typename Error>
+  bool operator()(const Error& err, std::size_t bytes_transferred)
+  {
+    return !!err || bytes_transferred >= minimum_;
+  }
+
+private:
+  std::size_t minimum_;
+};
+
+} // namespace detail
+
+/**
+ * @defgroup completion_condition Completion Condition Function Objects
+ *
+ * Function objects used for determining when a read or write operation should
+ * complete.
+ */
+/*@{*/
+
+/// Return a completion condition function object that indicates that a read or
+/// write operation should continue until all of the data has been transferred,
+/// or until an error occurs.
+#if defined(GENERATING_DOCUMENTATION)
+unspecified transfer_all();
+#else
+inline detail::transfer_all_t transfer_all()
+{
+  return detail::transfer_all_t();
+}
+#endif
+
+/// Return a completion condition function object that indicates that a read or
+/// write operation should continue until a minimum number of bytes has been
+/// transferred, or until an error occurs.
+#if defined(GENERATING_DOCUMENTATION)
+unspecified transfer_at_least(std::size_t minimum);
+#else
+inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
+{
+  return detail::transfer_at_least_t(minimum);
+}
+#endif
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_COMPLETION_CONDITION_HPP
diff --git a/include/boost/asio/datagram_socket_service.hpp b/include/boost/asio/datagram_socket_service.hpp
new file mode 100644
index 0000000000..1ce4837db2
--- /dev/null
+++ b/include/boost/asio/datagram_socket_service.hpp
@@ -0,0 +1,290 @@
+//
+// datagram_socket_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/kqueue_reactor.hpp>
+#include <boost/asio/detail/select_reactor.hpp>
+#include <boost/asio/detail/reactive_socket_service.hpp>
+#include <boost/asio/detail/win_iocp_socket_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a datagram socket.
+template <typename Protocol>
+class datagram_socket_service
+  : public boost::asio::io_service::service
+{
+public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+private:
+  // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_EPOLL)
+  typedef detail::reactive_socket_service<
+      Protocol, detail::epoll_reactor<false> > service_impl_type;
+#elif defined(BOOST_ASIO_HAS_KQUEUE)
+  typedef detail::reactive_socket_service<
+      Protocol, detail::kqueue_reactor<false> > service_impl_type;
+#else
+  typedef detail::reactive_socket_service<
+      Protocol, detail::select_reactor<false> > service_impl_type;
+#endif
+
+public:
+  /// The type of a datagram socket.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_type;
+#else
+  typedef typename service_impl_type::native_type native_type;
+#endif
+
+  /// Construct a new datagram socket service for the specified io_service.
+  explicit datagram_socket_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new datagram socket implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a datagram socket implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  // Open a new datagram socket implementation.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const protocol_type& protocol,
+      Error_Handler error_handler)
+  {
+    if (protocol.type() == SOCK_DGRAM)
+      service_impl_.open(impl, protocol, error_handler);
+    else
+      error_handler(boost::asio::error(boost::asio::error::invalid_argument));
+  }
+
+  /// Assign an existing native socket to a datagram socket.
+  template <typename Error_Handler>
+  void assign(implementation_type& impl, const protocol_type& protocol,
+      const native_type& native_socket, Error_Handler error_handler)
+  {
+    service_impl_.assign(impl, protocol, native_socket, error_handler);
+  }
+
+  /// Close a datagram socket implementation.
+  template <typename Error_Handler>
+  void close(implementation_type& impl, Error_Handler error_handler)
+  {
+    service_impl_.close(impl, error_handler);
+  }
+
+  /// Get the native socket implementation.
+  native_type native(implementation_type& impl)
+  {
+    return service_impl_.native(impl);
+  }
+
+  // Bind the datagram socket to the specified local endpoint.
+  template <typename Error_Handler>
+  void bind(implementation_type& impl, const endpoint_type& endpoint,
+      Error_Handler error_handler)
+  {
+    service_impl_.bind(impl, endpoint, error_handler);
+  }
+
+  /// Connect the datagram socket to the specified endpoint.
+  template <typename Error_Handler>
+  void connect(implementation_type& impl, const endpoint_type& peer_endpoint,
+      Error_Handler error_handler)
+  {
+    service_impl_.connect(impl, peer_endpoint, error_handler);
+  }
+
+  /// Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, Handler handler)
+  {
+    service_impl_.async_connect(impl, peer_endpoint, handler);
+  }
+
+  /// Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void set_option(implementation_type& impl, const Option& option,
+      Error_Handler error_handler)
+  {
+    service_impl_.set_option(impl, option, error_handler);
+  }
+
+  /// Get a socket option.
+  template <typename Option, typename Error_Handler>
+  void get_option(const implementation_type& impl, Option& option,
+      Error_Handler error_handler) const
+  {
+    service_impl_.get_option(impl, option, error_handler);
+  }
+
+  /// Perform an IO control command on the socket.
+  template <typename IO_Control_Command, typename Error_Handler>
+  void io_control(implementation_type& impl, IO_Control_Command& command,
+      Error_Handler error_handler)
+  {
+    service_impl_.io_control(impl, command, error_handler);
+  }
+
+  /// Get the local endpoint.
+  template <typename Error_Handler>
+  endpoint_type local_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    endpoint_type endpoint;
+    service_impl_.get_local_endpoint(impl, endpoint, error_handler);
+    return endpoint;
+  }
+
+  /// Get the remote endpoint.
+  template <typename Error_Handler>
+  endpoint_type remote_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    endpoint_type endpoint;
+    service_impl_.get_remote_endpoint(impl, endpoint, error_handler);
+    return endpoint;
+  }
+
+  /// Disable sends or receives on the socket.
+  template <typename Error_Handler>
+  void shutdown(implementation_type& impl, socket_base::shutdown_type what,
+      Error_Handler error_handler)
+  {
+    service_impl_.shutdown(impl, what, error_handler);
+  }
+
+  /// Send the given data to the peer.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return service_impl_.send(impl, buffers, flags, error_handler);
+  }
+
+  /// Start an asynchronous send.
+  template <typename Const_Buffers, typename Handler>
+  void async_send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    service_impl_.async_send(impl, buffers, flags, handler);
+  }
+
+  /// Send a datagram to the specified endpoint.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send_to(implementation_type& impl, const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    return service_impl_.send_to(impl, buffers, destination, flags,
+        error_handler);
+  }
+
+  /// Start an asynchronous send.
+  template <typename Const_Buffers, typename Handler>
+  void async_send_to(implementation_type& impl, const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Handler handler)
+  {
+    service_impl_.async_send_to(impl, buffers, destination, flags, handler);
+  }
+
+  /// Receive some data from the peer.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return service_impl_.receive(impl, buffers, flags, error_handler);
+  }
+
+  /// Start an asynchronous receive.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    service_impl_.async_receive(impl, buffers, flags, handler);
+  }
+
+  /// Receive a datagram with the endpoint of the sender.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive_from(implementation_type& impl,
+      const Mutable_Buffers& buffers, endpoint_type& sender_endpoint,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return service_impl_.receive_from(impl, buffers, sender_endpoint, flags,
+        error_handler);
+  }
+
+  /// Start an asynchronous receive that will get the endpoint of the sender.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive_from(implementation_type& impl,
+      const Mutable_Buffers& buffers, endpoint_type& sender_endpoint,
+      socket_base::message_flags flags, Handler handler)
+  {
+    service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
+        handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
diff --git a/include/boost/asio/deadline_timer.hpp b/include/boost/asio/deadline_timer.hpp
new file mode 100644
index 0000000000..c92e011107
--- /dev/null
+++ b/include/boost/asio/deadline_timer.hpp
@@ -0,0 +1,39 @@
+//
+// deadline_timer.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DEADLINE_TIMER_HPP
+#define BOOST_ASIO_DEADLINE_TIMER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp> // Must come before posix_time.
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_deadline_timer.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of timer.
+typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DEADLINE_TIMER_HPP
diff --git a/include/boost/asio/deadline_timer_service.hpp b/include/boost/asio/deadline_timer_service.hpp
new file mode 100644
index 0000000000..976a6a0ec7
--- /dev/null
+++ b/include/boost/asio/deadline_timer_service.hpp
@@ -0,0 +1,154 @@
+//
+// deadline_timer_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
+#define BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/time_traits.hpp>
+#include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/kqueue_reactor.hpp>
+#include <boost/asio/detail/select_reactor.hpp>
+#include <boost/asio/detail/reactive_deadline_timer_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a timer.
+template <typename Time_Type,
+    typename Time_Traits = boost::asio::time_traits<Time_Type> >
+class deadline_timer_service
+  : public boost::asio::io_service::service
+{
+public:
+  /// The time traits type.
+  typedef Time_Traits traits_type;
+
+  /// The time type.
+  typedef typename traits_type::time_type time_type;
+
+  /// The duration type.
+  typedef typename traits_type::duration_type duration_type;
+
+private:
+  // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::reactive_deadline_timer_service<
+    traits_type, detail::select_reactor<true> > service_impl_type;
+#elif defined(BOOST_ASIO_HAS_EPOLL)
+  typedef detail::reactive_deadline_timer_service<
+    traits_type, detail::epoll_reactor<false> > service_impl_type;
+#elif defined(BOOST_ASIO_HAS_KQUEUE)
+  typedef detail::reactive_deadline_timer_service<
+    traits_type, detail::kqueue_reactor<false> > service_impl_type;
+#else
+  typedef detail::reactive_deadline_timer_service<
+    traits_type, detail::select_reactor<false> > service_impl_type;
+#endif
+
+public:
+  /// The implementation type of the deadline timer.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// Construct a new timer service for the specified io_service.
+  explicit deadline_timer_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new timer implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a timer implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Cancel any asynchronous wait operations associated with the timer.
+  std::size_t cancel(implementation_type& impl)
+  {
+    return service_impl_.cancel(impl);
+  }
+
+  /// 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);
+  }
+
+  /// Set the expiry time for the timer as an absolute time.
+  std::size_t expires_at(implementation_type& impl,
+      const time_type& expiry_time)
+  {
+    return service_impl_.expires_at(impl, expiry_time);
+  }
+
+  /// 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);
+  }
+
+  /// Set the expiry time for the timer relative to now.
+  std::size_t expires_from_now(implementation_type& impl,
+      const duration_type& expiry_time)
+  {
+    return service_impl_.expires_from_now(impl, expiry_time);
+  }
+
+  // Perform a blocking wait on the timer.
+  void wait(implementation_type& impl)
+  {
+    service_impl_.wait(impl);
+  }
+
+  // Start an asynchronous wait on the timer.
+  template <typename Handler>
+  void async_wait(implementation_type& impl, Handler handler)
+  {
+    service_impl_.async_wait(impl, handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
diff --git a/include/boost/asio/detail/bind_handler.hpp b/include/boost/asio/detail/bind_handler.hpp
new file mode 100644
index 0000000000..47af5d6ca5
--- /dev/null
+++ b/include/boost/asio/detail/bind_handler.hpp
@@ -0,0 +1,288 @@
+//
+// bind.hpp
+// ~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BIND_HPP
+#define BOOST_ASIO_DETAIL_BIND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler, typename Arg1>
+class binder1
+{
+public:
+  binder1(Handler handler, Arg1 arg1)
+    : handler_(handler),
+      arg1_(arg1)
+  {
+  }
+
+  void operator()()
+  {
+    handler_(arg1_);
+  }
+
+  void operator()() const
+  {
+    handler_(arg1_);
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      binder1<Handler, Arg1>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, &this_handler->handler_);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      binder1<Handler, Arg1>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, &this_handler->handler_);
+  }
+
+private:
+  Handler handler_;
+  Arg1 arg1_;
+};
+
+template <typename Handler, typename Arg1>
+binder1<Handler, Arg1> bind_handler(Handler handler, Arg1 arg1)
+{
+  return binder1<Handler, Arg1>(handler, arg1);
+}
+
+template <typename Handler, typename Arg1, typename Arg2>
+class binder2
+{
+public:
+  binder2(Handler handler, Arg1 arg1, Arg2 arg2)
+    : handler_(handler),
+      arg1_(arg1),
+      arg2_(arg2)
+  {
+  }
+
+  void operator()()
+  {
+    handler_(arg1_, arg2_);
+  }
+
+  void operator()() const
+  {
+    handler_(arg1_, arg2_);
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      binder2<Handler, Arg1, Arg2>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, &this_handler->handler_);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      binder2<Handler, Arg1, Arg2>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, &this_handler->handler_);
+  }
+
+private:
+  Handler handler_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+};
+
+template <typename Handler, typename Arg1, typename Arg2>
+binder2<Handler, Arg1, Arg2> bind_handler(Handler handler, Arg1 arg1,
+    Arg2 arg2)
+{
+  return binder2<Handler, Arg1, Arg2>(handler, arg1, arg2);
+}
+
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
+class binder3
+{
+public:
+  binder3(Handler handler, Arg1 arg1, Arg2 arg2, Arg3 arg3)
+    : handler_(handler),
+      arg1_(arg1),
+      arg2_(arg2),
+      arg3_(arg3)
+  {
+  }
+
+  void operator()()
+  {
+    handler_(arg1_, arg2_, arg3_);
+  }
+
+  void operator()() const
+  {
+    handler_(arg1_, arg2_, arg3_);
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, &this_handler->handler_);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, &this_handler->handler_);
+  }
+
+private:
+  Handler handler_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
+binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler, Arg1 arg1,
+    Arg2 arg2, Arg3 arg3)
+{
+  return binder3<Handler, Arg1, Arg2, Arg3>(handler, arg1, arg2, arg3);
+}
+
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4>
+class binder4
+{
+public:
+  binder4(Handler handler, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
+    : handler_(handler),
+      arg1_(arg1),
+      arg2_(arg2),
+      arg3_(arg3),
+      arg4_(arg4)
+  {
+  }
+
+  void operator()()
+  {
+    handler_(arg1_, arg2_, arg3_, arg4_);
+  }
+
+  void operator()() const
+  {
+    handler_(arg1_, arg2_, arg3_, arg4_);
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, &this_handler->handler_);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, &this_handler->handler_);
+  }
+
+private:
+  Handler handler_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+  Arg4 arg4_;
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4>
+binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(Handler handler,
+    Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
+{
+  return binder4<Handler, Arg1, Arg2, Arg3, Arg4>(handler, arg1, arg2, arg3,
+      arg4);
+}
+
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Arg5>
+class binder5
+{
+public:
+  binder5(Handler handler, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4,
+      Arg5 arg5)
+    : handler_(handler),
+      arg1_(arg1),
+      arg2_(arg2),
+      arg3_(arg3),
+      arg4_(arg4),
+      arg5_(arg5)
+  {
+  }
+
+  void operator()()
+  {
+    handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
+  }
+
+  void operator()() const
+  {
+    handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, &this_handler->handler_);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, &this_handler->handler_);
+  }
+
+private:
+  Handler handler_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+  Arg3 arg3_;
+  Arg4 arg4_;
+  Arg5 arg5_;
+};
+
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Arg5>
+binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(Handler handler,
+    Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
+{
+  return binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>(handler, arg1, arg2,
+      arg3, arg4, arg5);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BIND_HPP
diff --git a/include/boost/asio/detail/buffer_resize_guard.hpp b/include/boost/asio/detail/buffer_resize_guard.hpp
new file mode 100644
index 0000000000..23184dd2e9
--- /dev/null
+++ b/include/boost/asio/detail/buffer_resize_guard.hpp
@@ -0,0 +1,72 @@
+//
+// buffer_resize_guard.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
+#define BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <limits>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper class to manage buffer resizing in an exception safe way.
+template <typename Buffer>
+class buffer_resize_guard
+{
+public:
+  // Constructor.
+  buffer_resize_guard(Buffer& buffer)
+    : buffer_(buffer),
+      old_size_(buffer.size())
+  {
+  }
+
+  // Destructor rolls back the buffer resize unless commit was called.
+  ~buffer_resize_guard()
+  {
+    if (old_size_
+        != std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION())
+    {
+      buffer_.resize(old_size_);
+    }
+  }
+
+  // Commit the resize transaction.
+  void commit()
+  {
+    old_size_
+      = std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION();
+  }
+
+private:
+  // The buffer being managed.
+  Buffer& buffer_;
+
+  // The size of the buffer at the time the guard was constructed.
+  size_t old_size_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
diff --git a/include/boost/asio/detail/buffered_stream_storage.hpp b/include/boost/asio/detail/buffered_stream_storage.hpp
new file mode 100644
index 0000000000..c29d210c78
--- /dev/null
+++ b/include/boost/asio/detail/buffered_stream_storage.hpp
@@ -0,0 +1,129 @@
+//
+// buffered_stream_storage.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
+#define BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <vector>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class buffered_stream_storage
+{
+public:
+  // The type of the bytes stored in the buffer.
+  typedef unsigned char byte_type;
+
+  // The type used for offsets into the buffer.
+  typedef std::size_t size_type;
+
+  // Constructor.
+  explicit buffered_stream_storage(std::size_t capacity)
+    : begin_offset_(0),
+      end_offset_(0),
+      buffer_(capacity)
+  {
+  }
+
+  /// Clear the buffer.
+  void clear()
+  {
+    begin_offset_ = 0;
+    end_offset_ = 0;
+  }
+
+  // Return a pointer to the beginning of the unread data.
+  byte_type* data()
+  {
+    return &buffer_[0] + begin_offset_;
+  }
+
+  // Return a pointer to the beginning of the unread data.
+  const byte_type* data() const
+  {
+    return &buffer_[0] + begin_offset_;
+  }
+
+  // Is there no unread data in the buffer.
+  bool empty() const
+  {
+    return begin_offset_ == end_offset_;
+  }
+
+  // Return the amount of unread data the is in the buffer.
+  size_type size() const
+  {
+    return end_offset_ - begin_offset_;
+  }
+
+  // Resize the buffer to the specified length.
+  void resize(size_type length)
+  {
+    assert(length <= capacity());
+    if (begin_offset_ + length <= capacity())
+    {
+      end_offset_ = begin_offset_ + length;
+    }
+    else
+    {
+      using namespace std; // For memmove.
+      memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
+      end_offset_ = length;
+      begin_offset_ = 0;
+    }
+  }
+
+  // Return the maximum size for data in the buffer.
+  size_type capacity() const
+  {
+    return buffer_.size();
+  }
+
+  // Consume multiple bytes from the beginning of the buffer.
+  void consume(size_type count)
+  {
+    assert(begin_offset_ + count <= end_offset_);
+    begin_offset_ += count;
+    if (empty())
+      clear();
+  }
+
+private:
+  // The offset to the beginning of the unread data.
+  size_type begin_offset_;
+
+  // The offset to the end of the unread data.
+  size_type end_offset_;
+  
+  // The data in the buffer.
+  std::vector<byte_type> buffer_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
diff --git a/include/boost/asio/detail/call_stack.hpp b/include/boost/asio/detail/call_stack.hpp
new file mode 100644
index 0000000000..2de37715da
--- /dev/null
+++ b/include/boost/asio/detail/call_stack.hpp
@@ -0,0 +1,92 @@
+//
+// call_stack.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_CALL_STACK_HPP
+#define BOOST_ASIO_DETAIL_CALL_STACK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/tss_ptr.hpp>
+
+namespace boost {
+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.
+template <typename Owner>
+class call_stack
+{
+public:
+  // Context class automatically pushes an owner on to the stack.
+  class context
+    : private noncopyable
+  {
+  public:
+    // Push the owner on to the stack.
+    explicit context(Owner* d)
+      : owner_(d),
+        next_(call_stack<Owner>::top_)
+    {
+      call_stack<Owner>::top_ = this;
+    }
+
+    // Pop the owner from the stack.
+    ~context()
+    {
+      call_stack<Owner>::top_ = next_;
+    }
+
+  private:
+    friend class call_stack<Owner>;
+
+    // The owner associated with the context.
+    Owner* owner_;
+
+    // The next element in the stack.
+    context* next_;
+  };
+
+  friend class context;
+
+  // Determine whether the specified owner is on the stack.
+  static bool contains(Owner* d)
+  {
+    context* elem = top_;
+    while (elem)
+    {
+      if (elem->owner_ == d)
+        return true;
+      elem = elem->next_;
+    }
+    return false;
+  }
+
+private:
+  // The top of the stack of calls for the current thread.
+  static tss_ptr<context> top_;
+};
+
+template <typename Owner>
+tss_ptr<typename call_stack<Owner>::context>
+call_stack<Owner>::top_;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_CALL_STACK_HPP
diff --git a/include/boost/asio/detail/const_buffers_iterator.hpp b/include/boost/asio/detail/const_buffers_iterator.hpp
new file mode 100644
index 0000000000..f66569e482
--- /dev/null
+++ b/include/boost/asio/detail/const_buffers_iterator.hpp
@@ -0,0 +1,152 @@
+//
+// const_buffers_iterator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_CONST_BUFFERS_ITERATOR_HPP
+#define BOOST_ASIO_DETAIL_CONST_BUFFERS_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// A proxy iterator for a sub-range in a list of buffers.
+template <typename Const_Buffers>
+class const_buffers_iterator
+  : public boost::iterator_facade<const_buffers_iterator<Const_Buffers>,
+        const char, boost::bidirectional_traversal_tag>
+{
+public:
+  // Default constructor creates an iterator in an undefined state.
+  const_buffers_iterator()
+  {
+  }
+
+  // Create an iterator for the specified position.
+  const_buffers_iterator(const Const_Buffers& buffers, std::size_t position)
+    : begin_(buffers.begin()),
+      current_(buffers.begin()),
+      end_(buffers.end()),
+      position_(0)
+  {
+    while (current_ != end_)
+    {
+      current_buffer_ = *current_;
+      std::size_t buffer_size = boost::asio::buffer_size(current_buffer_);
+      if (position - position_ < buffer_size)
+      {
+        current_buffer_position_ = position - position_;
+        position_ = position;
+        return;
+      }
+      position_ += buffer_size;
+      ++current_;
+    }
+    current_buffer_ = boost::asio::const_buffer();
+    current_buffer_position_ = 0;
+  }
+
+  std::size_t position() const
+  {
+    return position_;
+  }
+
+private:
+  friend class boost::iterator_core_access;
+
+  void increment()
+  {
+    if (current_ == end_)
+      return;
+
+    ++position_;
+
+    ++current_buffer_position_;
+    if (current_buffer_position_ != boost::asio::buffer_size(current_buffer_))
+      return;
+
+    ++current_;
+    current_buffer_position_ = 0;
+    while (current_ != end_)
+    {
+      current_buffer_ = *current_;
+      if (boost::asio::buffer_size(current_buffer_) > 0)
+        return;
+      ++current_;
+    }
+  }
+
+  void decrement()
+  {
+    if (position_ == 0)
+      return;
+
+    --position_;
+
+    if (current_buffer_position_ != 0)
+    {
+      --current_buffer_position_;
+      return;
+    }
+
+    typename Const_Buffers::const_iterator iter = current_;
+    while (iter != begin_)
+    {
+      --iter;
+      boost::asio::const_buffer buffer = *iter;
+      std::size_t buffer_size = boost::asio::buffer_size(buffer);
+      if (buffer_size > 0)
+      {
+        current_ = iter;
+        current_buffer_ = buffer;
+        current_buffer_position_ = buffer_size - 1;
+        return;
+      }
+    }
+  }
+
+  bool equal(const const_buffers_iterator& other) const
+  {
+    return position_ == other.position_;
+  }
+
+  const char& dereference() const
+  {
+    return boost::asio::buffer_cast<const char*>(
+        current_buffer_)[current_buffer_position_];
+  }
+
+  boost::asio::const_buffer current_buffer_;
+  std::size_t current_buffer_position_;
+  typename Const_Buffers::const_iterator begin_;
+  typename Const_Buffers::const_iterator current_;
+  typename Const_Buffers::const_iterator end_;
+  std::size_t position_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_CONST_BUFFERS_ITERATOR_HPP
diff --git a/include/boost/asio/detail/consuming_buffers.hpp b/include/boost/asio/detail/consuming_buffers.hpp
new file mode 100644
index 0000000000..08a6910723
--- /dev/null
+++ b/include/boost/asio/detail/consuming_buffers.hpp
@@ -0,0 +1,198 @@
+//
+// consuming_buffers.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
+#define BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <algorithm>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+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
+  : public boost::iterator_facade<
+        consuming_buffers_iterator<Buffer, Buffer_Iterator>,
+        const Buffer,
+        boost::forward_traversal_tag>
+{
+public:
+  // Default constructor creates an end iterator.
+  consuming_buffers_iterator()
+    : at_end_(true)
+  {
+  }
+
+  // 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)
+    : at_end_(at_end),
+      first_(first),
+      begin_remainder_(begin_remainder),
+      end_remainder_(end_remainder)
+  {
+  }
+
+private:
+  friend class boost::iterator_core_access;
+
+  void increment()
+  {
+    if (!at_end_)
+    {
+      if (begin_remainder_ == end_remainder_)
+        at_end_ = true;
+      else
+        first_ = *begin_remainder_++;
+    }
+  }
+
+  bool equal(const consuming_buffers_iterator& other) const
+  {
+    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
+  {
+    return first_;
+  }
+
+  bool at_end_;
+  Buffer first_;
+  Buffer_Iterator begin_remainder_;
+  Buffer_Iterator end_remainder_;
+};
+
+// A proxy for a sub-range in a list of buffers.
+template <typename Buffer, typename Buffers>
+class consuming_buffers
+{
+public:
+  // The type for each element in the list of buffers.
+  typedef Buffer value_type;
+
+  // A forward-only iterator type that may be used to read elements.
+  typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
+    const_iterator;
+
+  // Construct to represent the entire list of buffers.
+  consuming_buffers(const Buffers& buffers)
+    : buffers_(buffers),
+      at_end_(buffers_.begin() == buffers_.end()),
+      first_(*buffers_.begin()),
+      begin_remainder_(buffers_.begin())
+  {
+    if (!at_end_)
+      ++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())
+  {
+    typename Buffers::const_iterator first = other.buffers_.begin();
+    typename Buffers::const_iterator second = other.begin_remainder_;
+    std::advance(begin_remainder_, std::distance(first, second));
+  }
+
+  // Assignment operator.
+  consuming_buffers& operator=(const consuming_buffers& other)
+  {
+    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));
+    return *this;
+  }
+
+  // Get a forward-only iterator to the first element.
+  const_iterator begin() const
+  {
+    return const_iterator(at_end_, first_, begin_remainder_, buffers_.end());
+  }
+
+  // Get a forward-only iterator for one past the last element.
+  const_iterator end() const
+  {
+    return const_iterator();
+  }
+
+  // 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;
+      }
+    }
+
+    // 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_++;
+    }
+  }
+
+private:
+  Buffers buffers_;
+  bool at_end_;
+  Buffer first_;
+  typename Buffers::const_iterator begin_remainder_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
diff --git a/include/boost/asio/detail/epoll_reactor.hpp b/include/boost/asio/detail/epoll_reactor.hpp
new file mode 100644
index 0000000000..5902384771
--- /dev/null
+++ b/include/boost/asio/detail/epoll_reactor.hpp
@@ -0,0 +1,570 @@
+//
+// epoll_reactor.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
+#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/epoll_reactor_fwd.hpp>
+
+#if defined(BOOST_ASIO_HAS_EPOLL)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <vector>
+#include <sys/epoll.h>
+#include <boost/config.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/hash_map.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/task_io_service.hpp>
+#include <boost/asio/detail/thread.hpp>
+#include <boost/asio/detail/reactor_op_queue.hpp>
+#include <boost/asio/detail/reactor_timer_queue.hpp>
+#include <boost/asio/detail/select_interrupter.hpp>
+#include <boost/asio/detail/signal_blocker.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <bool Own_Thread>
+class epoll_reactor
+  : public boost::asio::io_service::service
+{
+public:
+  // Constructor.
+  epoll_reactor(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      mutex_(),
+      epoll_fd_(do_epoll_create()),
+      wait_in_progress_(false),
+      interrupter_(),
+      read_op_queue_(),
+      write_op_queue_(),
+      except_op_queue_(),
+      pending_cancellations_(),
+      stop_thread_(false),
+      thread_(0),
+      shutdown_(false)
+  {
+    // Start the reactor's internal thread only if needed.
+    if (Own_Thread)
+    {
+      boost::asio::detail::signal_blocker sb;
+      thread_ = new boost::asio::detail::thread(
+          bind_handler(&epoll_reactor::call_run_thread, this));
+    }
+
+    // Add the interrupter's descriptor to epoll.
+    epoll_event ev = { 0, { 0 } };
+    ev.events = EPOLLIN | EPOLLERR;
+    ev.data.fd = interrupter_.read_descriptor();
+    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
+  }
+
+  // Destructor.
+  ~epoll_reactor()
+  {
+    shutdown_service();
+    close(epoll_fd_);
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    shutdown_ = true;
+    stop_thread_ = true;
+    lock.unlock();
+
+    if (thread_)
+    {
+      interrupter_.interrupt();
+      thread_->join();
+      delete thread_;
+      thread_ = 0;
+    }
+
+    read_op_queue_.destroy_operations();
+    write_op_queue_.destroy_operations();
+    except_op_queue_.destroy_operations();
+    timer_queue_.destroy_timers();
+  }
+
+  // Register a socket with the reactor. Returns 0 on success, system error
+  // code on failure.
+  int register_descriptor(socket_type descriptor)
+  {
+    // No need to lock according to epoll documentation.
+
+    epoll_event ev = { 0, { 0 } };
+    ev.events = 0;
+    ev.data.fd = descriptor;
+    int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
+    if (result != 0)
+      return errno;
+    return 0;
+  }
+
+  // Start a new read operation. The handler object will be invoked when the
+  // given descriptor is ready to be read, or an error has occurred.
+  template <typename Handler>
+  void start_read_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (!read_op_queue_.has_operation(descriptor))
+      if (handler(0))
+        return;
+
+    if (read_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      epoll_event ev = { 0, { 0 } };
+      ev.events = EPOLLIN | EPOLLERR | EPOLLHUP;
+      if (write_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLOUT;
+      if (except_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLPRI;
+      ev.data.fd = descriptor;
+
+      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+      if (result != 0)
+      {
+        int error = errno;
+        read_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Start a new write operation. The handler object will be invoked when the
+  // given descriptor is ready to be written, or an error has occurred.
+  template <typename Handler>
+  void start_write_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (!write_op_queue_.has_operation(descriptor))
+      if (handler(0))
+        return;
+
+    if (write_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      epoll_event ev = { 0, { 0 } };
+      ev.events = EPOLLOUT | EPOLLERR | EPOLLHUP;
+      if (read_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLIN;
+      if (except_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLPRI;
+      ev.data.fd = descriptor;
+
+      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+      if (result != 0)
+      {
+        int error = errno;
+        write_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Start a new exception operation. The handler object will be invoked when
+  // the given descriptor has exception information, or an error has occurred.
+  template <typename Handler>
+  void start_except_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (except_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      epoll_event ev = { 0, { 0 } };
+      ev.events = EPOLLPRI | EPOLLERR | EPOLLHUP;
+      if (read_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLIN;
+      if (write_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLOUT;
+      ev.data.fd = descriptor;
+
+      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+      if (result != 0)
+      {
+        int error = errno;
+        except_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Start new write and exception operations. The handler object will be
+  // invoked when the given descriptor is ready for writing or has exception
+  // information available, or an error has occurred.
+  template <typename Handler>
+  void start_write_and_except_ops(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    bool need_mod = write_op_queue_.enqueue_operation(descriptor, handler);
+    need_mod = except_op_queue_.enqueue_operation(descriptor, handler)
+      && need_mod;
+    if (need_mod)
+    {
+      epoll_event ev = { 0, { 0 } };
+      ev.events = EPOLLOUT | EPOLLPRI | EPOLLERR | EPOLLHUP;
+      if (read_op_queue_.has_operation(descriptor))
+        ev.events |= EPOLLIN;
+      ev.data.fd = descriptor;
+
+      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+      if (result != 0)
+      {
+        int error = errno;
+        write_op_queue_.dispatch_all_operations(descriptor, error);
+        except_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Cancel all operations associated with the given descriptor. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  void cancel_ops(socket_type descriptor)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    cancel_ops_unlocked(descriptor);
+  }
+
+  // Enqueue cancellation of all operations associated with the given
+  // descriptor. The handlers associated with the descriptor will be invoked
+  // with the operation_aborted error. This function does not acquire the
+  // epoll_reactor's mutex, and so should only be used from within a reactor
+  // handler.
+  void enqueue_cancel_ops_unlocked(socket_type descriptor)
+  {
+    pending_cancellations_.push_back(descriptor);
+  }
+
+  // Cancel any operations that are running against the descriptor and remove
+  // its registration from the reactor.
+  void close_descriptor(socket_type descriptor)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // Remove the descriptor from epoll.
+    epoll_event ev = { 0, { 0 } };
+    epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
+
+    // Cancel any outstanding operations associated with the descriptor.
+    cancel_ops_unlocked(descriptor);
+  }
+
+  // Schedule a timer to expire at the specified absolute time. The handler
+  // object will be invoked when the timer expires.
+  template <typename Handler>
+  void schedule_timer(const boost::posix_time::ptime& time,
+      Handler handler, void* token)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+      if (timer_queue_.enqueue_timer(time, handler, token))
+        interrupter_.interrupt();
+  }
+
+  // Cancel the timer associated with the given token. Returns the number of
+  // handlers that have been posted or dispatched.
+  std::size_t cancel_timer(void* token)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    return timer_queue_.cancel_timer(token);
+  }
+
+private:
+  friend class task_io_service<epoll_reactor<Own_Thread> >;
+
+  // Run epoll once until interrupted or events are ready to be dispatched.
+  void run(bool block)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // Dispatch any operation cancellations that were made while the select
+    // loop was not running.
+    read_op_queue_.dispatch_cancellations();
+    write_op_queue_.dispatch_cancellations();
+    except_op_queue_.dispatch_cancellations();
+
+    // Check if the thread is supposed to stop.
+    if (stop_thread_)
+    {
+      // Clean up operations. We must not hold the lock since the operations may
+      // make calls back into this reactor.
+      lock.unlock();
+      read_op_queue_.cleanup_operations();
+      write_op_queue_.cleanup_operations();
+      except_op_queue_.cleanup_operations();
+      return;
+    }
+
+    // We can return immediately if there's no work to do and the reactor is
+    // not supposed to block.
+    if (!block && read_op_queue_.empty() && write_op_queue_.empty()
+        && except_op_queue_.empty() && timer_queue_.empty())
+    {
+      // Clean up operations. We must not hold the lock since the operations may
+      // make calls back into this reactor.
+      lock.unlock();
+      read_op_queue_.cleanup_operations();
+      write_op_queue_.cleanup_operations();
+      except_op_queue_.cleanup_operations();
+      return;
+    }
+
+    int timeout = block ? get_timeout() : 0;
+    wait_in_progress_ = true;
+    lock.unlock();
+
+    // Block on the epoll descriptor.
+    epoll_event events[128];
+    int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
+
+    lock.lock();
+    wait_in_progress_ = false;
+
+    // Block signals while dispatching operations.
+    boost::asio::detail::signal_blocker sb;
+
+    // Dispatch the waiting events.
+    for (int i = 0; i < num_events; ++i)
+    {
+      int descriptor = events[i].data.fd;
+      if (descriptor == interrupter_.read_descriptor())
+      {
+        interrupter_.reset();
+      }
+      else
+      {
+        if (events[i].events & (EPOLLERR | EPOLLHUP))
+        {
+          except_op_queue_.dispatch_all_operations(descriptor, 0);
+          read_op_queue_.dispatch_all_operations(descriptor, 0);
+          write_op_queue_.dispatch_all_operations(descriptor, 0);
+
+          epoll_event ev = { 0, { 0 } };
+          ev.events = 0;
+          ev.data.fd = descriptor;
+          epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+        }
+        else
+        {
+          bool more_reads = false;
+          bool more_writes = false;
+          bool more_except = false;
+
+          // Exception operations must be processed first to ensure that any
+          // out-of-band data is read before normal data.
+          if (events[i].events & EPOLLPRI)
+            more_except = except_op_queue_.dispatch_operation(descriptor, 0);
+          else
+            more_except = except_op_queue_.has_operation(descriptor);
+
+          if (events[i].events & EPOLLIN)
+            more_reads = read_op_queue_.dispatch_operation(descriptor, 0);
+          else
+            more_reads = read_op_queue_.has_operation(descriptor);
+
+          if (events[i].events & EPOLLOUT)
+            more_writes = write_op_queue_.dispatch_operation(descriptor, 0);
+          else
+            more_writes = write_op_queue_.has_operation(descriptor);
+
+          epoll_event ev = { 0, { 0 } };
+          ev.events = EPOLLERR | EPOLLHUP;
+          if (more_reads)
+            ev.events |= EPOLLIN;
+          if (more_writes)
+            ev.events |= EPOLLOUT;
+          if (more_except)
+            ev.events |= EPOLLPRI;
+          ev.data.fd = descriptor;
+          int result = epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+          if (result != 0)
+          {
+            int error = errno;
+            read_op_queue_.dispatch_all_operations(descriptor, error);
+            write_op_queue_.dispatch_all_operations(descriptor, error);
+            except_op_queue_.dispatch_all_operations(descriptor, error);
+          }
+        }
+      }
+    }
+    read_op_queue_.dispatch_cancellations();
+    write_op_queue_.dispatch_cancellations();
+    except_op_queue_.dispatch_cancellations();
+    timer_queue_.dispatch_timers(
+        boost::posix_time::microsec_clock::universal_time());
+
+    // Issue any pending cancellations.
+    for (size_t i = 0; i < pending_cancellations_.size(); ++i)
+      cancel_ops_unlocked(pending_cancellations_[i]);
+    pending_cancellations_.clear();
+
+    // Clean up operations. We must not hold the lock since the operations may
+    // make calls back into this reactor.
+    lock.unlock();
+    read_op_queue_.cleanup_operations();
+    write_op_queue_.cleanup_operations();
+    except_op_queue_.cleanup_operations();
+  }
+
+  // Run the select loop in the thread.
+  void run_thread()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    while (!stop_thread_)
+    {
+      lock.unlock();
+      run(true);
+      lock.lock();
+    }
+  }
+
+  // Entry point for the select loop thread.
+  static void call_run_thread(epoll_reactor* reactor)
+  {
+    reactor->run_thread();
+  }
+
+  // Interrupt the select loop.
+  void interrupt()
+  {
+    interrupter_.interrupt();
+  }
+
+  // The hint to pass to epoll_create to size its data structures.
+  enum { epoll_size = 20000 };
+
+  // Create the epoll file descriptor. Throws an exception if the descriptor
+  // cannot be created.
+  static int do_epoll_create()
+  {
+    int fd = epoll_create(epoll_size);
+    if (fd == -1)
+    {
+      system_exception e("epoll", errno);
+      boost::throw_exception(e);
+    }
+    return fd;
+  }
+
+  // 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.
+  int get_timeout()
+  {
+    if (timer_queue_.empty())
+      return -1;
+
+    boost::posix_time::ptime now
+      = boost::posix_time::microsec_clock::universal_time();
+    boost::posix_time::ptime earliest_timer;
+    timer_queue_.get_earliest_time(earliest_timer);
+    if (now < earliest_timer)
+    {
+      boost::posix_time::time_duration timeout = earliest_timer - now;
+      const int max_timeout_in_seconds = INT_MAX / 1000;
+      if (max_timeout_in_seconds < timeout.total_seconds())
+        return max_timeout_in_seconds * 1000;
+      else
+        return timeout.total_milliseconds();
+    }
+    else
+    {
+      return 0;
+    }
+  }
+
+  // Cancel all operations associated with the given descriptor. The do_cancel
+  // function of the handler objects will be invoked. This function does not
+  // acquire the epoll_reactor's mutex.
+  void cancel_ops_unlocked(socket_type descriptor)
+  {
+    bool interrupt = read_op_queue_.cancel_operations(descriptor);
+    interrupt = write_op_queue_.cancel_operations(descriptor) || interrupt;
+    interrupt = except_op_queue_.cancel_operations(descriptor) || interrupt;
+    if (interrupt)
+      interrupter_.interrupt();
+  }
+
+  // Mutex to protect access to internal data.
+  boost::asio::detail::mutex mutex_;
+
+  // The epoll file descriptor.
+  int epoll_fd_;
+
+  // Whether the epoll_wait call is currently in progress
+  bool wait_in_progress_;
+
+  // The interrupter is used to break a blocking epoll_wait call.
+  select_interrupter interrupter_;
+
+  // The queue of read operations.
+  reactor_op_queue<socket_type> read_op_queue_;
+
+  // The queue of write operations.
+  reactor_op_queue<socket_type> write_op_queue_;
+
+  // The queue of except operations.
+  reactor_op_queue<socket_type> except_op_queue_;
+
+  // The queue of timers.
+  reactor_timer_queue<boost::posix_time::ptime> timer_queue_;
+
+  // The descriptors that are pending cancellation.
+  std::vector<socket_type> pending_cancellations_;
+
+  // Does the reactor loop thread need to stop.
+  bool stop_thread_;
+
+  // The thread that is running the reactor loop.
+  boost::asio::detail::thread* thread_;
+
+  // Whether the service has been shut down.
+  bool shutdown_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_EPOLL)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
diff --git a/include/boost/asio/detail/epoll_reactor_fwd.hpp b/include/boost/asio/detail/epoll_reactor_fwd.hpp
new file mode 100644
index 0000000000..754741f2fd
--- /dev/null
+++ b/include/boost/asio/detail/epoll_reactor_fwd.hpp
@@ -0,0 +1,49 @@
+//
+// epoll_reactor_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
+#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#if !defined(BOOST_ASIO_DISABLE_EPOLL)
+#if defined(__linux__) // This service is only supported on Linux.
+
+#include <boost/asio/detail/push_options.hpp>
+#include <linux/version.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION (2,5,45) // Only kernels >= 2.5.45.
+
+// Define this to indicate that epoll is supported on the target platform.
+#define BOOST_ASIO_HAS_EPOLL 1
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <bool Own_Thread>
+class epoll_reactor;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // LINUX_VERSION_CODE >= KERNEL_VERSION (2,5,45)
+#endif // defined(__linux__)
+#endif // !defined(BOOST_ASIO_DISABLE_EPOLL)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
diff --git a/include/boost/asio/detail/event.hpp b/include/boost/asio/detail/event.hpp
new file mode 100644
index 0000000000..79a1105fac
--- /dev/null
+++ b/include/boost/asio/detail/event.hpp
@@ -0,0 +1,52 @@
+//
+// event.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_EVENT_HPP
+#define BOOST_ASIO_DETAIL_EVENT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+# include <boost/asio/detail/null_event.hpp>
+#elif defined(BOOST_WINDOWS)
+# include <boost/asio/detail/win_event.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/asio/detail/posix_event.hpp>
+#else
+# error Only Windows and POSIX are supported!
+#endif
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if !defined(BOOST_HAS_THREADS)
+typedef null_event event;
+#elif defined(BOOST_WINDOWS)
+typedef win_event event;
+#elif defined(BOOST_HAS_PTHREADS)
+typedef posix_event event;
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_EVENT_HPP
diff --git a/include/boost/asio/detail/fd_set_adapter.hpp b/include/boost/asio/detail/fd_set_adapter.hpp
new file mode 100644
index 0000000000..19f3544418
--- /dev/null
+++ b/include/boost/asio/detail/fd_set_adapter.hpp
@@ -0,0 +1,69 @@
+//
+// fd_set_adapter.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP
+#define BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Adapts the FD_SET type to meet the Descriptor_Set concept's requirements.
+class fd_set_adapter
+{
+public:
+  fd_set_adapter()
+    : max_descriptor_(invalid_socket)
+  {
+    FD_ZERO(&fd_set_);
+  }
+
+  void set(socket_type descriptor)
+  {
+    if (max_descriptor_ == invalid_socket || descriptor > max_descriptor_)
+      max_descriptor_ = descriptor;
+    FD_SET(descriptor, &fd_set_);
+  }
+
+  bool is_set(socket_type descriptor) const
+  {
+    return FD_ISSET(descriptor, &fd_set_) != 0;
+  }
+
+  operator fd_set*()
+  {
+    return &fd_set_;
+  }
+
+  socket_type max_descriptor() const
+  {
+    return max_descriptor_;
+  }
+
+private:
+  fd_set fd_set_;
+  socket_type max_descriptor_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP
diff --git a/include/boost/asio/detail/handler_alloc_helpers.hpp b/include/boost/asio/detail/handler_alloc_helpers.hpp
new file mode 100644
index 0000000000..687e9c3a30
--- /dev/null
+++ b/include/boost/asio/detail/handler_alloc_helpers.hpp
@@ -0,0 +1,258 @@
+//
+// handler_alloc_helpers.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
+#define BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/handler_alloc_hook.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+// Calls to asio_handler_allocate and asio_handler_deallocate must be made from
+// a namespace that does not contain any overloads of these functions. The
+// boost_asio_handler_alloc_helpers namespace is defined here for that purpose.
+namespace boost_asio_handler_alloc_helpers {
+
+template <typename Handler>
+inline void* allocate(std::size_t s, Handler* h)
+{
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+  return ::operator new(s);
+#else
+  using namespace boost::asio;
+  return asio_handler_allocate(s, h);
+#endif
+}
+
+template <typename Handler>
+inline void deallocate(void* p, std::size_t s, Handler* h)
+{
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+  ::operator delete(p);
+#else
+  using namespace boost::asio;
+  asio_handler_deallocate(p, s, h);
+#endif
+}
+
+} // namespace boost_asio_handler_alloc_helpers
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Traits for handler allocation.
+template <typename Handler, typename Object>
+struct handler_alloc_traits
+{
+  typedef Handler handler_type;
+  typedef Object value_type;
+  typedef Object* pointer_type;
+  BOOST_STATIC_CONSTANT(std::size_t, value_size = sizeof(Object));
+};
+
+template <typename Alloc_Traits>
+class handler_ptr;
+
+// Helper class to provide RAII on uninitialised handler memory.
+template <typename Alloc_Traits>
+class raw_handler_ptr
+  : private noncopyable
+{
+public:
+  typedef typename Alloc_Traits::handler_type handler_type;
+  typedef typename Alloc_Traits::value_type value_type;
+  typedef typename Alloc_Traits::pointer_type pointer_type;
+  BOOST_STATIC_CONSTANT(std::size_t, value_size = Alloc_Traits::value_size);
+
+  // Constructor allocates the memory.
+  raw_handler_ptr(handler_type& handler)
+    : handler_(handler),
+      pointer_(static_cast<pointer_type>(
+            boost_asio_handler_alloc_helpers::allocate(value_size, &handler_)))
+  {
+  }
+
+  // Destructor automatically deallocates memory, unless it has been stolen by
+  // a handler_ptr object.
+  ~raw_handler_ptr()
+  {
+    if (pointer_)
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer_, value_size, &handler_);
+  }
+
+private:
+  friend class handler_ptr<Alloc_Traits>;
+  handler_type& handler_;
+  pointer_type pointer_;
+};
+
+// Helper class to provide RAII on uninitialised handler memory.
+template <typename Alloc_Traits>
+class handler_ptr
+  : private noncopyable
+{
+public:
+  typedef typename Alloc_Traits::handler_type handler_type;
+  typedef typename Alloc_Traits::value_type value_type;
+  typedef typename Alloc_Traits::pointer_type pointer_type;
+  BOOST_STATIC_CONSTANT(std::size_t, value_size = Alloc_Traits::value_size);
+  typedef raw_handler_ptr<Alloc_Traits> raw_ptr_type;
+
+  // Take ownership of existing memory.
+  handler_ptr(handler_type& handler, pointer_type pointer)
+    : handler_(handler),
+      pointer_(pointer)
+  {
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  handler_ptr(raw_ptr_type& raw_ptr)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type)
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1, a2))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2, typename Arg3>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2, Arg3& a3)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1, a2, a3))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2, Arg3& a3, Arg4& a4)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1, a2, a3, a4))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2, Arg3& a3, Arg4& a4,
+      Arg5& a5)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1, a2, a3, a4, a5))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5, typename Arg6>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2, Arg3& a3, Arg4& a4,
+      Arg5& a5, Arg6& a6)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1, a2, a3, a4, a5, a6))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5, typename Arg6, typename Arg7>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2, Arg3& a3, Arg4& a4,
+      Arg5& a5, Arg6& a6, Arg7& a7)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(a1, a2, a3, a4, a5, a6, a7))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Construct object in raw memory and take ownership if construction succeeds.
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5, typename Arg6, typename Arg7, typename Arg8>
+  handler_ptr(raw_ptr_type& raw_ptr, Arg1& a1, Arg2& a2, Arg3& a3, Arg4& a4,
+      Arg5& a5, Arg6& a6, Arg7& a7, Arg8& a8)
+    : handler_(raw_ptr.handler_),
+      pointer_(new (raw_ptr.pointer_) value_type(
+            a1, a2, a3, a4, a5, a6, a7, a8))
+  {
+    raw_ptr.pointer_ = 0;
+  }
+
+  // Destructor automatically deallocates memory, unless it has been released.
+  ~handler_ptr()
+  {
+    reset();
+  }
+
+  // Get the memory.
+  pointer_type get() const
+  {
+    return pointer_;
+  }
+
+  // Release ownership of the memory.
+  pointer_type release()
+  {
+    pointer_type tmp = pointer_;
+    pointer_ = 0;
+    return tmp;
+  }
+
+  // Explicitly destroy and deallocate the memory.
+  void reset()
+  {
+    if (pointer_)
+    {
+      pointer_->value_type::~value_type();
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer_, value_size, &handler_);
+      pointer_ = 0;
+    }
+  }
+
+private:
+  handler_type& handler_;
+  pointer_type pointer_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
diff --git a/include/boost/asio/detail/hash_map.hpp b/include/boost/asio/detail/hash_map.hpp
new file mode 100644
index 0000000000..5e86701e39
--- /dev/null
+++ b/include/boost/asio/detail/hash_map.hpp
@@ -0,0 +1,197 @@
+//
+// hash_map.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_HASH_MAP_HPP
+#define BOOST_ASIO_DETAIL_HASH_MAP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cassert>
+#include <list>
+#include <utility>
+#include <boost/functional/hash.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename K, typename V>
+class hash_map
+  : private noncopyable
+{
+public:
+  // The type of a value in the map.
+  typedef std::pair<const K, V> value_type;
+
+  // The type of a non-const iterator over the hash map.
+  typedef typename std::list<value_type>::iterator iterator;
+
+  // The type of a const iterator over the hash map.
+  typedef typename std::list<value_type>::const_iterator const_iterator;
+
+  // Constructor.
+  hash_map()
+  {
+    // Initialise all buckets to empty.
+    for (size_t i = 0; i < num_buckets; ++i)
+      buckets_[i].first = buckets_[i].last = values_.end();
+  }
+
+  // Get an iterator for the beginning of the map.
+  iterator begin()
+  {
+    return values_.begin();
+  }
+
+  // Get an iterator for the beginning of the map.
+  const_iterator begin() const
+  {
+    return values_.begin();
+  }
+
+  // Get an iterator for the end of the map.
+  iterator end()
+  {
+    return values_.end();
+  }
+
+  // Get an iterator for the end of the map.
+  const_iterator end() const
+  {
+    return values_.end();
+  }
+
+  // Check whether the map is empty.
+  bool empty() const
+  {
+    return values_.empty();
+  }
+
+  // Find an entry in the map.
+  iterator find(const K& k)
+  {
+    size_t bucket = boost::hash_value(k) % num_buckets;
+    iterator it = buckets_[bucket].first;
+    if (it == values_.end())
+      return values_.end();
+    iterator end = buckets_[bucket].last;
+    ++end;
+    while (it != end)
+    {
+      if (it->first == k)
+        return it;
+      ++it;
+    }
+    return values_.end();
+  }
+
+  // Find an entry in the map.
+  const_iterator find(const K& k) const
+  {
+    size_t bucket = boost::hash_value(k) % num_buckets;
+    const_iterator it = buckets_[bucket].first;
+    if (it == values_.end())
+      return it;
+    const_iterator end = buckets_[bucket].last;
+    ++end;
+    while (it != end)
+    {
+      if (it->first == k)
+        return it;
+      ++it;
+    }
+    return values_.end();
+  }
+
+  // Insert a new entry into the map.
+  std::pair<iterator, bool> insert(const value_type& v)
+  {
+    size_t bucket = boost::hash_value(v.first) % num_buckets;
+    iterator it = buckets_[bucket].first;
+    if (it == values_.end())
+    {
+      buckets_[bucket].first = buckets_[bucket].last =
+        values_.insert(values_.end(), v);
+      return std::pair<iterator, bool>(buckets_[bucket].last, true);
+    }
+    iterator end = buckets_[bucket].last;
+    ++end;
+    while (it != end)
+    {
+      if (it->first == v.first)
+        return std::pair<iterator, bool>(it, false);
+      ++it;
+    }
+    buckets_[bucket].last = values_.insert(end, v);
+    return std::pair<iterator, bool>(buckets_[bucket].last, true);
+  }
+
+  // Erase an entry from the map.
+  void erase(iterator it)
+  {
+    assert(it != values_.end());
+
+    size_t bucket = boost::hash_value(it->first) % num_buckets;
+    bool is_first = (it == buckets_[bucket].first);
+    bool is_last = (it == buckets_[bucket].last);
+    if (is_first && is_last)
+      buckets_[bucket].first = buckets_[bucket].last = values_.end();
+    else if (is_first)
+      ++buckets_[bucket].first;
+    else if (is_last)
+      --buckets_[bucket].last;
+
+    values_.erase(it);
+  }
+
+  // Remove all entries from the map.
+  void clear()
+  {
+    // Clear the values.
+    values_.clear();
+
+    // Initialise all buckets to empty.
+    for (size_t i = 0; i < num_buckets; ++i)
+      buckets_[i].first = buckets_[i].last = values_.end();
+  }
+
+private:
+  // The list of all values in the hash map.
+  std::list<value_type> values_;
+
+  // The type for a bucket in the hash table.
+  struct bucket_type
+  {
+    iterator first;
+    iterator last;
+  };
+
+  // The number of buckets in the hash.
+  enum { num_buckets = 1021 };
+
+  // The buckets in the hash.
+  bucket_type buckets_[num_buckets];
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_HASH_MAP_HPP
diff --git a/include/boost/asio/detail/io_control.hpp b/include/boost/asio/detail/io_control.hpp
new file mode 100644
index 0000000000..e8e9453a95
--- /dev/null
+++ b/include/boost/asio/detail/io_control.hpp
@@ -0,0 +1,141 @@
+//
+// io_control.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IO_CONTROL_HPP
+#define BOOST_ASIO_DETAIL_IO_CONTROL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+namespace io_control {
+
+// Helper template for implementing boolean-based IO control commands.
+template <int Name>
+class boolean
+{
+public:
+  // Default constructor.
+  boolean()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific command value.
+  boolean(bool value)
+    : value_(value ? 1 : 0)
+  {
+  }
+
+  // Get the name of the IO control command.
+  int name() const
+  {
+    return Name;
+  }
+
+  // Set the value of the boolean.
+  void set(bool value)
+  {
+    value_ = value ? 1 : 0;
+  }
+
+  // Get the current value of the boolean.
+  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_;
+};
+
+// Helper template for implementing size-based IO control commands.
+template <int Name>
+class size
+{
+public:
+  // Default constructor.
+  size()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific command value.
+  size(std::size_t value)
+    : value_(value)
+  {
+  }
+
+  // Get the name of the IO control command.
+  int name() const
+  {
+    return Name;
+  }
+
+  // Set the value of the size.
+  void set(std::size_t value)
+  {
+    value_ = static_cast<detail::ioctl_arg_type>(value);
+  }
+
+  // Get the current value of the size.
+  std::size_t get() const
+  {
+    return static_cast<std::size_t>(value_);
+  }
+
+  // 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_;
+};
+
+} // namespace io_control
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_IO_CONTROL_HPP
diff --git a/include/boost/asio/detail/kqueue_reactor.hpp b/include/boost/asio/detail/kqueue_reactor.hpp
new file mode 100644
index 0000000000..2aea08acd8
--- /dev/null
+++ b/include/boost/asio/detail/kqueue_reactor.hpp
@@ -0,0 +1,566 @@
+//
+// kqueue_reactor.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 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
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP
+#define BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/kqueue_reactor_fwd.hpp>
+
+#if defined(BOOST_ASIO_HAS_KQUEUE)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <vector>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <boost/config.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/task_io_service.hpp>
+#include <boost/asio/detail/thread.hpp>
+#include <boost/asio/detail/reactor_op_queue.hpp>
+#include <boost/asio/detail/reactor_timer_queue.hpp>
+#include <boost/asio/detail/select_interrupter.hpp>
+#include <boost/asio/detail/signal_blocker.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <bool Own_Thread>
+class kqueue_reactor
+  : public boost::asio::io_service::service
+{
+public:
+  // Constructor.
+  kqueue_reactor(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      mutex_(),
+      kqueue_fd_(do_kqueue_create()),
+      wait_in_progress_(false),
+      interrupter_(),
+      read_op_queue_(),
+      write_op_queue_(),
+      except_op_queue_(),
+      pending_cancellations_(),
+      stop_thread_(false),
+      thread_(0),
+      shutdown_(false)
+  {
+    // Start the reactor's internal thread only if needed.
+    if (Own_Thread)
+    {
+      boost::asio::detail::signal_blocker sb;
+      thread_ = new boost::asio::detail::thread(
+          bind_handler(&kqueue_reactor::call_run_thread, this));
+    }
+
+    // Add the interrupter's descriptor to the kqueue.
+    struct kevent event;
+    EV_SET(&event, interrupter_.read_descriptor(),
+        EVFILT_READ, EV_ADD, 0, 0, 0);
+    ::kevent(kqueue_fd_, &event, 1, 0, 0, 0);
+  }
+
+  // Destructor.
+  ~kqueue_reactor()
+  {
+    shutdown_service();
+    close(kqueue_fd_);
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    shutdown_ = true;
+    stop_thread_ = true;
+    lock.unlock();
+
+    if (thread_)
+    {
+      interrupter_.interrupt();
+      thread_->join();
+      delete thread_;
+      thread_ = 0;
+    }
+
+    read_op_queue_.destroy_operations();
+    write_op_queue_.destroy_operations();
+    except_op_queue_.destroy_operations();
+    timer_queue_.destroy_timers();
+  }
+
+  // Register a socket with the reactor. Returns 0 on success, system error
+  // code on failure.
+  int register_descriptor(socket_type)
+  {
+    return 0;
+  }
+
+  // Start a new read operation. The handler object will be invoked when the
+  // given descriptor is ready to be read, or an error has occurred.
+  template <typename Handler>
+  void start_read_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (!read_op_queue_.has_operation(descriptor))
+      if (handler(0))
+        return;
+
+    if (read_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      struct kevent event;
+      EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, 0, 0, 0);
+      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+      {
+        int error = errno;
+        read_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Start a new write operation. The handler object will be invoked when the
+  // given descriptor is ready to be written, or an error has occurred.
+  template <typename Handler>
+  void start_write_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (!write_op_queue_.has_operation(descriptor))
+      if (handler(0))
+        return;
+
+    if (write_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      struct kevent event;
+      EV_SET(&event, descriptor, EVFILT_WRITE, EV_ADD, 0, 0, 0);
+      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+      {
+        int error = errno;
+        write_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Start a new exception operation. The handler object will be invoked when
+  // the given descriptor has exception information, or an error has occurred.
+  template <typename Handler>
+  void start_except_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (except_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      struct kevent event;
+      if (read_op_queue_.has_operation(descriptor))
+        EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, 0, 0, 0);
+      else
+        EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, EV_OOBAND, 0, 0);
+      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+      {
+        int error = errno;
+        except_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Start new write and exception operations. The handler object will be
+  // invoked when the given descriptor is ready for writing or has exception
+  // information available, or an error has occurred.
+  template <typename Handler>
+  void start_write_and_except_ops(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    if (shutdown_)
+      return;
+
+    if (write_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      struct kevent event;
+      EV_SET(&event, descriptor, EVFILT_WRITE, EV_ADD, 0, 0, 0);
+      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+      {
+        int error = errno;
+        write_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+
+    if (except_op_queue_.enqueue_operation(descriptor, handler))
+    {
+      struct kevent event;
+      if (read_op_queue_.has_operation(descriptor))
+        EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, 0, 0, 0);
+      else
+        EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, EV_OOBAND, 0, 0);
+      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+      {
+        int error = errno;
+        except_op_queue_.dispatch_all_operations(descriptor, error);
+        write_op_queue_.dispatch_all_operations(descriptor, error);
+      }
+    }
+  }
+
+  // Cancel all operations associated with the given descriptor. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  void cancel_ops(socket_type descriptor)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    cancel_ops_unlocked(descriptor);
+  }
+
+  // Enqueue cancellation of all operations associated with the given
+  // descriptor. The handlers associated with the descriptor will be invoked
+  // with the operation_aborted error. This function does not acquire the
+  // kqueue_reactor's mutex, and so should only be used from within a reactor
+  // handler.
+  void enqueue_cancel_ops_unlocked(socket_type descriptor)
+  {
+    pending_cancellations_.push_back(descriptor);
+  }
+
+  // Cancel any operations that are running against the descriptor and remove
+  // its registration from the reactor.
+  void close_descriptor(socket_type descriptor)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // Remove the descriptor from kqueue.
+    struct kevent event[2];
+    EV_SET(&event[0], descriptor, EVFILT_READ, EV_DELETE, 0, 0, 0);
+    EV_SET(&event[1], descriptor, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
+    ::kevent(kqueue_fd_, event, 2, 0, 0, 0);
+    
+    // Cancel any outstanding operations associated with the descriptor.
+    cancel_ops_unlocked(descriptor);
+  }
+
+  // Schedule a timer to expire at the specified absolute time. The
+  // do_operation function of the handler object will be invoked when the timer
+  // expires. Returns a token that may be used for cancelling the timer, but it
+  // is not valid after the timer expires.
+  template <typename Handler>
+  void schedule_timer(const boost::posix_time::ptime& time,
+      Handler handler, void* token)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+      if (timer_queue_.enqueue_timer(time, handler, token))
+        interrupter_.interrupt();
+  }
+
+  // Cancel the timer associated with the given token. Returns the number of
+  // handlers that have been posted or dispatched.
+  std::size_t cancel_timer(void* token)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    return timer_queue_.cancel_timer(token);
+  }
+
+private:
+  friend class task_io_service<kqueue_reactor<Own_Thread> >;
+
+  // Run the kqueue loop.
+  void run(bool block)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // Dispatch any operation cancellations that were made while the select
+    // loop was not running.
+    read_op_queue_.dispatch_cancellations();
+    write_op_queue_.dispatch_cancellations();
+    except_op_queue_.dispatch_cancellations();
+
+    // Check if the thread is supposed to stop.
+    if (stop_thread_)
+    {
+      // Clean up operations. We must not hold the lock since the operations may
+      // make calls back into this reactor.
+      lock.unlock();
+      read_op_queue_.cleanup_operations();
+      write_op_queue_.cleanup_operations();
+      except_op_queue_.cleanup_operations();
+      return;
+    }
+
+    // We can return immediately if there's no work to do and the reactor is
+    // not supposed to block.
+    if (!block && read_op_queue_.empty() && write_op_queue_.empty()
+        && except_op_queue_.empty() && timer_queue_.empty())
+    {
+      // Clean up operations. We must not hold the lock since the operations may
+      // make calls back into this reactor.
+      lock.unlock();
+      read_op_queue_.cleanup_operations();
+      write_op_queue_.cleanup_operations();
+      except_op_queue_.cleanup_operations();
+      return;
+    }
+
+    // Determine how long to block while waiting for events.
+    timespec timeout_buf = { 0, 0 };
+    timespec* timeout = block ? get_timeout(timeout_buf) : &timeout_buf;
+
+    wait_in_progress_ = true;
+    lock.unlock();
+
+    // Block on the kqueue descriptor.
+    struct kevent events[128];
+    int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout);
+
+    lock.lock();
+    wait_in_progress_ = false;
+
+    // Block signals while dispatching operations.
+    boost::asio::detail::signal_blocker sb;
+
+    // Dispatch the waiting events.
+    for (int i = 0; i < num_events; ++i)
+    {
+      int descriptor = events[i].ident;
+      if (descriptor == interrupter_.read_descriptor())
+      {
+        interrupter_.reset();
+      }
+      else if (events[i].filter == EVFILT_READ)
+      {
+        // Dispatch operations associated with the descriptor.
+        bool more_reads = false;
+        bool more_except = false;
+        if (events[i].flags & EV_ERROR)
+        {
+          int error = events[i].data;
+          except_op_queue_.dispatch_all_operations(descriptor, error);
+          read_op_queue_.dispatch_all_operations(descriptor, error);
+        }
+        else if (events[i].flags & EV_OOBAND)
+        {
+          more_except = except_op_queue_.dispatch_operation(descriptor, 0);
+          if (events[i].data > 0)
+            more_reads = read_op_queue_.dispatch_operation(descriptor, 0);
+          else
+            more_reads = read_op_queue_.has_operation(descriptor);
+        }
+        else
+        {
+          more_reads = read_op_queue_.dispatch_operation(descriptor, 0);
+          more_except = except_op_queue_.has_operation(descriptor);
+        }
+
+        // Update the descriptor in the kqueue.
+        struct kevent event;
+        if (more_reads)
+          EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, 0, 0, 0);
+        else if (more_except)
+          EV_SET(&event, descriptor, EVFILT_READ, EV_ADD, EV_OOBAND, 0, 0);
+        else
+          EV_SET(&event, descriptor, EVFILT_READ, EV_DELETE, 0, 0, 0);
+        if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+        {
+          int error = errno;
+          except_op_queue_.dispatch_all_operations(descriptor, error);
+          read_op_queue_.dispatch_all_operations(descriptor, error);
+        }
+      }
+      else if (events[i].filter == EVFILT_WRITE)
+      {
+        // Dispatch operations associated with the descriptor.
+        bool more_writes = false;
+        if (events[i].flags & EV_ERROR)
+        {
+          int error = events[i].data;
+          write_op_queue_.dispatch_all_operations(descriptor, error);
+        }
+        else
+        {
+          more_writes = write_op_queue_.dispatch_operation(descriptor, 0);
+        }
+
+        // Update the descriptor in the kqueue.
+        struct kevent event;
+        if (more_writes)
+          EV_SET(&event, descriptor, EVFILT_WRITE, EV_ADD, 0, 0, 0);
+        else
+          EV_SET(&event, descriptor, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
+        if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+        {
+          int error = errno;
+          write_op_queue_.dispatch_all_operations(descriptor, error);
+        }
+      }
+    }
+
+    read_op_queue_.dispatch_cancellations();
+    write_op_queue_.dispatch_cancellations();
+    except_op_queue_.dispatch_cancellations();
+    timer_queue_.dispatch_timers(
+        boost::posix_time::microsec_clock::universal_time());
+
+    // Issue any pending cancellations.
+    for (size_t i = 0; i < pending_cancellations_.size(); ++i)
+      cancel_ops_unlocked(pending_cancellations_[i]);
+    pending_cancellations_.clear();
+
+    // Clean up operations. We must not hold the lock since the operations may
+    // make calls back into this reactor.
+    lock.unlock();
+    read_op_queue_.cleanup_operations();
+    write_op_queue_.cleanup_operations();
+    except_op_queue_.cleanup_operations();
+  }
+
+  // Run the select loop in the thread.
+  void run_thread()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    while (!stop_thread_)
+    {
+      lock.unlock();
+      run(true);
+      lock.lock();
+    }
+  }
+
+  // Entry point for the select loop thread.
+  static void call_run_thread(kqueue_reactor* reactor)
+  {
+    reactor->run_thread();
+  }
+
+  // Interrupt the select loop.
+  void interrupt()
+  {
+    interrupter_.interrupt();
+  }
+
+  // Create the kqueue file descriptor. Throws an exception if the descriptor
+  // cannot be created.
+  static int do_kqueue_create()
+  {
+    int fd = kqueue();
+    if (fd == -1)
+    {
+      system_exception e("kqueue", errno);
+      boost::throw_exception(e);
+    }
+    return fd;
+  }
+
+  // Get the timeout value for the kevent call.
+  timespec* get_timeout(timespec& ts)
+  {
+    if (timer_queue_.empty())
+      return 0;
+
+    boost::posix_time::ptime now
+      = boost::posix_time::microsec_clock::universal_time();
+    boost::posix_time::ptime earliest_timer;
+    timer_queue_.get_earliest_time(earliest_timer);
+    if (now < earliest_timer)
+    {
+      boost::posix_time::time_duration timeout = earliest_timer - now;
+      ts.tv_sec = timeout.total_seconds();
+      ts.tv_nsec = timeout.total_nanoseconds() % 1000000000;
+    }
+    else
+    {
+      ts.tv_sec = 0;
+      ts.tv_nsec = 0;
+    }
+
+    return &ts;
+  }
+
+  // Cancel all operations associated with the given descriptor. The do_cancel
+  // function of the handler objects will be invoked. This function does not
+  // acquire the epoll_reactor's mutex.
+  void cancel_ops_unlocked(socket_type descriptor)
+  {
+    bool interrupt = read_op_queue_.cancel_operations(descriptor);
+    interrupt = write_op_queue_.cancel_operations(descriptor) || interrupt;
+    interrupt = except_op_queue_.cancel_operations(descriptor) || interrupt;
+    if (interrupt)
+      interrupter_.interrupt();
+  }
+
+  // Mutex to protect access to internal data.
+  boost::asio::detail::mutex mutex_;
+
+  // The epoll file descriptor.
+  int kqueue_fd_;
+
+  // Whether the kqueue wait call is currently in progress
+  bool wait_in_progress_;
+
+  // The interrupter is used to break a blocking epoll_wait call.
+  select_interrupter interrupter_;
+
+  // The queue of read operations.
+  reactor_op_queue<socket_type> read_op_queue_;
+
+  // The queue of write operations.
+  reactor_op_queue<socket_type> write_op_queue_;
+
+  // The queue of except operations.
+  reactor_op_queue<socket_type> except_op_queue_;
+
+  // The queue of timers.
+  reactor_timer_queue<boost::posix_time::ptime> timer_queue_;
+
+  // The descriptors that are pending cancellation.
+  std::vector<socket_type> pending_cancellations_;
+
+  // Does the reactor loop thread need to stop.
+  bool stop_thread_;
+
+  // The thread that is running the reactor loop.
+  boost::asio::detail::thread* thread_;
+
+  // Whether the service has been shut down.
+  bool shutdown_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_KQUEUE)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP
diff --git a/include/boost/asio/detail/kqueue_reactor_fwd.hpp b/include/boost/asio/detail/kqueue_reactor_fwd.hpp
new file mode 100644
index 0000000000..11fe60b964
--- /dev/null
+++ b/include/boost/asio/detail/kqueue_reactor_fwd.hpp
@@ -0,0 +1,43 @@
+//
+// kqueue_reactor_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 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
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP
+#define BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#if !defined(BOOST_ASIO_DISABLE_KQUEUE)
+#if defined(__MACH__) && defined(__APPLE__)
+
+// Define this to indicate that epoll is supported on the target platform.
+#define BOOST_ASIO_HAS_KQUEUE 1
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <bool Own_Thread>
+class kqueue_reactor;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(__MACH__) && defined(__APPLE__)
+#endif // !defined(BOOST_ASIO_DISABLE_KQUEUE)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP
diff --git a/include/boost/asio/detail/mutex.hpp b/include/boost/asio/detail/mutex.hpp
new file mode 100644
index 0000000000..9f3182f903
--- /dev/null
+++ b/include/boost/asio/detail/mutex.hpp
@@ -0,0 +1,52 @@
+//
+// mutex.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+# include <boost/asio/detail/null_mutex.hpp>
+#elif defined(BOOST_WINDOWS)
+# include <boost/asio/detail/win_mutex.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/asio/detail/posix_mutex.hpp>
+#else
+# error Only Windows and POSIX are supported!
+#endif
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if !defined(BOOST_HAS_THREADS)
+typedef null_mutex mutex;
+#elif defined(BOOST_WINDOWS)
+typedef win_mutex mutex;
+#elif defined(BOOST_HAS_PTHREADS)
+typedef posix_mutex mutex;
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_MUTEX_HPP
diff --git a/include/boost/asio/detail/noncopyable.hpp b/include/boost/asio/detail/noncopyable.hpp
new file mode 100644
index 0000000000..ad12f932d3
--- /dev/null
+++ b/include/boost/asio/detail/noncopyable.hpp
@@ -0,0 +1,57 @@
+//
+// noncopyable.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
+#define BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+// Redefine the noncopyable class for Borland C++ since that compiler does not
+// apply the empty base optimisation unless the base class contains a dummy
+// char data member.
+class noncopyable
+{
+protected:
+  noncopyable() {}
+  ~noncopyable() {}
+private:
+  noncopyable(const noncopyable&);
+  const noncopyable& operator=(const noncopyable&);
+  char dummy_;
+};
+#else
+using boost::noncopyable;
+#endif
+
+} // namespace detail
+
+using boost::asio::detail::noncopyable;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
diff --git a/include/boost/asio/detail/null_event.hpp b/include/boost/asio/detail/null_event.hpp
new file mode 100644
index 0000000000..bf88e8751b
--- /dev/null
+++ b/include/boost/asio/detail/null_event.hpp
@@ -0,0 +1,70 @@
+//
+// null_event.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_NULL_EVENT_HPP
+#define BOOST_ASIO_DETAIL_NULL_EVENT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class null_event
+  : private noncopyable
+{
+public:
+  // Constructor.
+  null_event()
+  {
+  }
+
+  // Destructor.
+  ~null_event()
+  {
+  }
+
+  // Signal the event.
+  void signal()
+  {
+  }
+
+  // Reset the event.
+  void clear()
+  {
+  }
+
+  // Wait for the event to become signalled.
+  void wait()
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_NULL_EVENT_HPP
diff --git a/include/boost/asio/detail/null_mutex.hpp b/include/boost/asio/detail/null_mutex.hpp
new file mode 100644
index 0000000000..5f5724fb44
--- /dev/null
+++ b/include/boost/asio/detail/null_mutex.hpp
@@ -0,0 +1,68 @@
+//
+// null_mutex.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_NULL_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_NULL_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/scoped_lock.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class null_mutex
+  : private noncopyable
+{
+public:
+  typedef boost::asio::detail::scoped_lock<null_mutex> scoped_lock;
+
+  // Constructor.
+  null_mutex()
+  {
+  }
+
+  // Destructor.
+  ~null_mutex()
+  {
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_NULL_MUTEX_HPP
diff --git a/include/boost/asio/detail/null_signal_blocker.hpp b/include/boost/asio/detail/null_signal_blocker.hpp
new file mode 100644
index 0000000000..d5d112c5b6
--- /dev/null
+++ b/include/boost/asio/detail/null_signal_blocker.hpp
@@ -0,0 +1,65 @@
+//
+// null_signal_blocker.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
+#define BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class null_signal_blocker
+  : private noncopyable
+{
+public:
+  // Constructor blocks all signals for the calling thread.
+  null_signal_blocker()
+  {
+  }
+
+  // Destructor restores the previous signal mask.
+  ~null_signal_blocker()
+  {
+  }
+
+  // Block all signals for the calling thread.
+  void block()
+  {
+  }
+
+  // Restore the previous signal mask.
+  void unblock()
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
diff --git a/include/boost/asio/detail/null_thread.hpp b/include/boost/asio/detail/null_thread.hpp
new file mode 100644
index 0000000000..4f5eef81f2
--- /dev/null
+++ b/include/boost/asio/detail/null_thread.hpp
@@ -0,0 +1,69 @@
+//
+// null_thread.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_NULL_THREAD_HPP
+#define BOOST_ASIO_DETAIL_NULL_THREAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class null_thread
+  : private noncopyable
+{
+public:
+  // Constructor.
+  template <typename Function>
+  null_thread(Function f)
+  {
+    system_exception e("thread", boost::asio::error::not_supported);
+    boost::throw_exception(e);
+  }
+
+  // Destructor.
+  ~null_thread()
+  {
+  }
+
+  // Wait for the thread to exit.
+  void join()
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_NULL_THREAD_HPP
diff --git a/include/boost/asio/detail/null_tss_ptr.hpp b/include/boost/asio/detail/null_tss_ptr.hpp
new file mode 100644
index 0000000000..9970cc2dcd
--- /dev/null
+++ b/include/boost/asio/detail/null_tss_ptr.hpp
@@ -0,0 +1,72 @@
+//
+// null_tss_ptr.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP
+#define BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename T>
+class null_tss_ptr
+  : private noncopyable
+{
+public:
+  // Constructor.
+  null_tss_ptr()
+    : value_(0)
+  {
+  }
+
+  // Destructor.
+  ~null_tss_ptr()
+  {
+  }
+
+  // Get the value.
+  operator T*() const
+  {
+    return value_;
+  }
+
+  // Set the value.
+  void operator=(T* value)
+  {
+    value_ = value;
+  }
+
+private:
+  T* value_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_HAS_THREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP
diff --git a/include/boost/asio/detail/old_win_sdk_compat.hpp b/include/boost/asio/detail/old_win_sdk_compat.hpp
new file mode 100644
index 0000000000..09c6eaac1b
--- /dev/null
+++ b/include/boost/asio/detail/old_win_sdk_compat.hpp
@@ -0,0 +1,314 @@
+//
+// old_win_sdk_compat.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
+#define BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+// Guess whether we are building against on old Platform SDK.
+#if !defined(IPPROTO_IPV6)
+#define BOOST_ASIO_HAS_OLD_WIN_SDK 1
+#endif // !defined(IPPROTO_IPV6)
+
+#if defined(BOOST_ASIO_HAS_OLD_WIN_SDK)
+
+// Emulation of types that are missing from old Platform SDKs.
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+enum
+{
+  sockaddr_storage_maxsize = 128, // Maximum size.
+  sockaddr_storage_alignsize = (sizeof(__int64)), // Desired alignment.
+  sockaddr_storage_pad1size = (sockaddr_storage_alignsize - sizeof(short)),
+  sockaddr_storage_pad2size = (sockaddr_storage_maxsize -
+      (sizeof(short) + sockaddr_storage_pad1size + sockaddr_storage_alignsize))
+};
+
+struct sockaddr_storage_emulation
+{
+  short ss_family;
+  char __ss_pad1[sockaddr_storage_pad1size];
+  __int64 __ss_align;
+  char __ss_pad2[sockaddr_storage_pad2size];
+};
+
+struct in6_addr_emulation
+{
+  u_char s6_addr[16];
+};
+
+struct sockaddr_in6_emulation
+{
+  short sin6_family;
+  u_short sin6_port;
+  u_long sin6_flowinfo;
+  in6_addr_emulation sin6_addr;
+  u_long sin6_scope_id;
+};
+
+struct ipv6_mreq_emulation
+{
+  in6_addr_emulation ipv6mr_multiaddr;
+  unsigned int ipv6mr_interface;
+};
+
+#if !defined(IN6ADDR_ANY_INIT)
+# define IN6ADDR_ANY_INIT { 0 }
+#endif
+
+#if !defined(IN6ADDR_LOOPBACK_INIT)
+# define IN6ADDR_LOOPBACK_INIT { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }
+#endif
+
+struct addrinfo_emulation
+{
+  int ai_flags;
+  int ai_family;
+  int ai_socktype;
+  int ai_protocol;
+  size_t ai_addrlen;
+  char* ai_canonname;
+  sockaddr* ai_addr;
+  addrinfo_emulation* ai_next;
+};
+
+#if !defined(AI_PASSIVE)
+# define AI_PASSIVE 0x1
+#endif
+
+#if !defined(AI_CANONNAME)
+# define AI_CANONNAME 0x2
+#endif
+
+#if !defined(AI_NUMERICHOST)
+# define AI_NUMERICHOST 0x4
+#endif
+
+#if !defined(EAI_AGAIN)
+# define EAI_AGAIN WSATRY_AGAIN
+#endif
+
+#if !defined(EAI_BADFLAGS)
+# define EAI_BADFLAGS WSAEINVAL
+#endif
+
+#if !defined(EAI_FAIL)
+# define EAI_FAIL WSANO_RECOVERY
+#endif
+
+#if !defined(EAI_FAMILY)
+# define EAI_FAMILY WSAEAFNOSUPPORT
+#endif
+
+#if !defined(EAI_MEMORY)
+# define EAI_MEMORY WSA_NOT_ENOUGH_MEMORY
+#endif
+
+#if !defined(EAI_NODATA)
+# define EAI_NODATA WSANO_DATA
+#endif
+
+#if !defined(EAI_NONAME)
+# define EAI_NONAME WSAHOST_NOT_FOUND
+#endif
+
+#if !defined(EAI_SERVICE)
+# define EAI_SERVICE WSATYPE_NOT_FOUND
+#endif
+
+#if !defined(EAI_SOCKTYPE)
+# define EAI_SOCKTYPE WSAESOCKTNOSUPPORT
+#endif
+
+#if !defined(NI_NOFQDN)
+# define NI_NOFQDN 0x01
+#endif
+
+#if !defined(NI_NUMERICHOST)
+# define NI_NUMERICHOST 0x02
+#endif
+
+#if !defined(NI_NAMEREQD)
+# define NI_NAMEREQD 0x04
+#endif
+
+#if !defined(NI_NUMERICSERV)
+# define NI_NUMERICSERV 0x08
+#endif
+
+#if !defined(NI_DGRAM)
+# define NI_DGRAM 0x10
+#endif
+
+#if !defined(IPPROTO_IPV6)
+# define IPPROTO_IPV6 41
+#endif
+
+#if !defined(IPV6_MULTICAST_IF)
+# define IPV6_MULTICAST_IF 9
+#endif
+
+#if !defined(IPV6_MULTICAST_HOPS)
+# define IPV6_MULTICAST_HOPS 10
+#endif
+
+#if !defined(IPV6_MULTICAST_LOOP)
+# define IPV6_MULTICAST_LOOP 11
+#endif
+
+#if !defined(IPV6_JOIN_GROUP)
+# define IPV6_JOIN_GROUP 12
+#endif
+
+#if !defined(IPV6_LEAVE_GROUP)
+# define IPV6_LEAVE_GROUP 13
+#endif
+
+inline int IN6_IS_ADDR_UNSPECIFIED(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0)
+      && (a->s6_addr[11] == 0)
+      && (a->s6_addr[12] == 0)
+      && (a->s6_addr[13] == 0)
+      && (a->s6_addr[14] == 0)
+      && (a->s6_addr[15] == 0));
+}
+
+inline int IN6_IS_ADDR_LOOPBACK(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0)
+      && (a->s6_addr[11] == 0)
+      && (a->s6_addr[12] == 0)
+      && (a->s6_addr[13] == 0)
+      && (a->s6_addr[14] == 0)
+      && (a->s6_addr[15] == 1));
+}
+
+inline int IN6_IS_ADDR_MULTICAST(const in6_addr_emulation* a)
+{
+  return (a->s6_addr[0] == 0xff);
+}
+
+inline int IN6_IS_ADDR_LINKLOCAL(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0xfe) && ((a->s6_addr[1] & 0xc0) == 0x80));
+}
+
+inline int IN6_IS_ADDR_SITELOCAL(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0xfe) && ((a->s6_addr[1] & 0xc0) == 0xc0));
+}
+
+inline int IN6_IS_ADDR_V4MAPPED(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0xff)
+      && (a->s6_addr[11] == 0xff));
+}
+
+inline int IN6_IS_ADDR_V4COMPAT(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0xff)
+      && (a->s6_addr[11] == 0xff)
+      && !((a->s6_addr[12] == 0)
+        && (a->s6_addr[13] == 0)
+        && (a->s6_addr[14] == 0)
+        && ((a->s6_addr[15] == 0) || (a->s6_addr[15] == 1))));
+}
+
+inline int IN6_IS_ADDR_MC_NODELOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 1);
+}
+
+inline int IN6_IS_ADDR_MC_LINKLOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 2);
+}
+
+inline int IN6_IS_ADDR_MC_SITELOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 5);
+}
+
+inline int IN6_IS_ADDR_MC_ORGLOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 8);
+}
+
+inline int IN6_IS_ADDR_MC_GLOBAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 0xe);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_OLD_WIN_SDK)
+
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
diff --git a/include/boost/asio/detail/pipe_select_interrupter.hpp b/include/boost/asio/detail/pipe_select_interrupter.hpp
new file mode 100644
index 0000000000..e4c6eda1a1
--- /dev/null
+++ b/include/boost/asio/detail/pipe_select_interrupter.hpp
@@ -0,0 +1,106 @@
+//
+// pipe_select_interrupter.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
+#define BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <fcntl.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class pipe_select_interrupter
+{
+public:
+  // Constructor.
+  pipe_select_interrupter()
+  {
+    int pipe_fds[2];
+    if (pipe(pipe_fds) == 0)
+    {
+      read_descriptor_ = pipe_fds[0];
+      ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
+      write_descriptor_ = pipe_fds[1];
+      ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
+    }
+  }
+
+  // Destructor.
+  ~pipe_select_interrupter()
+  {
+    if (read_descriptor_ != -1)
+      ::close(read_descriptor_);
+    if (write_descriptor_ != -1)
+      ::close(write_descriptor_);
+  }
+
+  // Interrupt the select call.
+  void interrupt()
+  {
+    char byte = 0;
+    ::write(write_descriptor_, &byte, 1);
+  }
+
+  // Reset the select interrupt. Returns true if the call was interrupted.
+  bool reset()
+  {
+    char data[1024];
+    int bytes_read = ::read(read_descriptor_, data, sizeof(data));
+    bool was_interrupted = (bytes_read > 0);
+    while (bytes_read == sizeof(data))
+      bytes_read = ::read(read_descriptor_, data, sizeof(data));
+    return was_interrupted;
+  }
+
+  // Get the read descriptor to be passed to select.
+  int read_descriptor() const
+  {
+    return read_descriptor_;
+  }
+
+private:
+  // The read end of a connection used to interrupt the select call. This file
+  // descriptor is passed to select such that when it is time to stop, a single
+  // byte will be written on the other end of the connection and this
+  // descriptor will become readable.
+  int read_descriptor_;
+
+  // The write end of a connection used to interrupt the select call. A single
+  // byte may be written to this to wake up the select which is waiting for the
+  // other end to become readable.
+  int write_descriptor_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
diff --git a/include/boost/asio/detail/pop_options.hpp b/include/boost/asio/detail/pop_options.hpp
new file mode 100644
index 0000000000..4c942e8d3b
--- /dev/null
+++ b/include/boost/asio/detail/pop_options.hpp
@@ -0,0 +1,88 @@
+//
+// pop_options.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// No header guard
+
+#if defined(__COMO__)
+
+// Comeau C++
+
+#elif defined(__DMC__)
+
+// Digital Mars C++
+
+#elif defined(__INTEL_COMPILER) || defined(__ICL) \
+  || defined(__ICC) || defined(__ECC)
+
+// Intel C++
+
+#elif defined(__GNUC__)
+
+// GNU C++
+
+# if defined(__MINGW32__) || defined(__CYGWIN__)
+#  pragma pack (pop)
+# endif
+
+#elif defined(__KCC)
+
+// Kai C++
+
+#elif defined(__sgi)
+
+// SGI MIPSpro C++
+
+#elif defined(__DECCXX)
+
+// Compaq Tru64 Unix cxx
+
+#elif defined(__ghs)
+
+// Greenhills C++
+
+#elif defined(__BORLANDC__)
+
+// Borland C++
+
+# pragma option pop
+# pragma nopushoptwarn
+# pragma nopackwarning
+
+#elif defined(__MWERKS__)
+
+// Metrowerks CodeWarrior
+
+#elif defined(__SUNPRO_CC)
+
+// Sun Workshop Compiler C++
+
+#elif defined(__HP_aCC)
+
+// HP aCC
+
+#elif defined(__MRC__) || defined(__SC__)
+
+// MPW MrCpp or SCpp
+
+#elif defined(__IBMCPP__)
+
+// IBM Visual Age
+
+#elif defined(_MSC_VER)
+
+// Microsoft Visual C++
+//
+// Must remain the last #elif since some other vendors (Metrowerks, for example)
+// also #define _MSC_VER
+
+# pragma warning (pop)
+# pragma pack (pop)
+
+#endif
diff --git a/include/boost/asio/detail/posix_event.hpp b/include/boost/asio/detail/posix_event.hpp
new file mode 100644
index 0000000000..9e11a3dc12
--- /dev/null
+++ b/include/boost/asio/detail/posix_event.hpp
@@ -0,0 +1,109 @@
+//
+// posix_event.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
+#define BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <pthread.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class posix_event
+  : private noncopyable
+{
+public:
+  // Constructor.
+  posix_event()
+    : signalled_(false)
+  {
+    int error = ::pthread_mutex_init(&mutex_, 0);
+    if (error != 0)
+    {
+      system_exception e("event", error);
+      boost::throw_exception(e);
+    }
+
+    error = ::pthread_cond_init(&cond_, 0);
+    if (error != 0)
+    {
+      ::pthread_mutex_destroy(&mutex_);
+      system_exception e("event", error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~posix_event()
+  {
+    ::pthread_cond_destroy(&cond_);
+    ::pthread_mutex_destroy(&mutex_);
+  }
+
+  // Signal the event.
+  void signal()
+  {
+    ::pthread_mutex_lock(&mutex_); // Ignore EINVAL and EDEADLK.
+    signalled_ = true;
+    ::pthread_cond_signal(&cond_); // Ignore EINVAL.
+    ::pthread_mutex_unlock(&mutex_); // Ignore EINVAL and EPERM.
+  }
+
+  // Reset the event.
+  void clear()
+  {
+    ::pthread_mutex_lock(&mutex_); // Ignore EINVAL and EDEADLK.
+    signalled_ = false;
+    ::pthread_mutex_unlock(&mutex_); // Ignore EINVAL and EPERM.
+  }
+
+  // Wait for the event to become signalled.
+  void wait()
+  {
+    ::pthread_mutex_lock(&mutex_); // Ignore EINVAL and EDEADLK.
+    while (!signalled_)
+      ::pthread_cond_wait(&cond_, &mutex_); // Ignore EINVAL.
+    ::pthread_mutex_unlock(&mutex_); // Ignore EINVAL and EPERM.
+  }
+
+private:
+  ::pthread_mutex_t mutex_;
+  ::pthread_cond_t cond_;
+  bool signalled_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
diff --git a/include/boost/asio/detail/posix_mutex.hpp b/include/boost/asio/detail/posix_mutex.hpp
new file mode 100644
index 0000000000..bec51e97fd
--- /dev/null
+++ b/include/boost/asio/detail/posix_mutex.hpp
@@ -0,0 +1,96 @@
+//
+// posix_mutex.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <pthread.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/scoped_lock.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class posix_mutex
+  : private noncopyable
+{
+public:
+  typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
+
+  // Constructor.
+  posix_mutex()
+  {
+    int error = ::pthread_mutex_init(&mutex_, 0);
+    if (error != 0)
+    {
+      system_exception e("mutex", error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~posix_mutex()
+  {
+    ::pthread_mutex_destroy(&mutex_);
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+    int error = ::pthread_mutex_lock(&mutex_);
+    if (error != 0)
+    {
+      system_exception e("mutex", error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    int error = ::pthread_mutex_unlock(&mutex_);
+    if (error != 0)
+    {
+      system_exception e("mutex", error);
+      boost::throw_exception(e);
+    }
+  }
+
+private:
+  ::pthread_mutex_t mutex_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
diff --git a/include/boost/asio/detail/posix_signal_blocker.hpp b/include/boost/asio/detail/posix_signal_blocker.hpp
new file mode 100644
index 0000000000..6b8b9af364
--- /dev/null
+++ b/include/boost/asio/detail/posix_signal_blocker.hpp
@@ -0,0 +1,91 @@
+//
+// posix_signal_blocker.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
+#define BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <csignal>
+#include <pthread.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class posix_signal_blocker
+  : private noncopyable
+{
+public:
+  // Constructor blocks all signals for the calling thread.
+  posix_signal_blocker()
+    : blocked_(false)
+  {
+    sigset_t new_mask;
+    sigfillset(&new_mask);
+    blocked_ = (pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask_) == 0);
+  }
+
+  // Destructor restores the previous signal mask.
+  ~posix_signal_blocker()
+  {
+    if (blocked_)
+      pthread_sigmask(SIG_SETMASK, &old_mask_, 0);
+  }
+
+  // Block all signals for the calling thread.
+  void block()
+  {
+    if (!blocked_)
+    {
+      sigset_t new_mask;
+      sigfillset(&new_mask);
+      blocked_ = (pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask_) == 0);
+    }
+  }
+
+  // Restore the previous signal mask.
+  void unblock()
+  {
+    if (blocked_)
+      blocked_ = (pthread_sigmask(SIG_SETMASK, &old_mask_, 0) != 0);
+  }
+
+private:
+  // Have signals been blocked.
+  bool blocked_;
+
+  // The previous signal mask.
+  sigset_t old_mask_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
diff --git a/include/boost/asio/detail/posix_thread.hpp b/include/boost/asio/detail/posix_thread.hpp
new file mode 100644
index 0000000000..f50c2a488d
--- /dev/null
+++ b/include/boost/asio/detail/posix_thread.hpp
@@ -0,0 +1,127 @@
+//
+// posix_thread.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
+#define BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <memory>
+#include <boost/throw_exception.hpp>
+#include <pthread.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+extern "C" void* asio_detail_posix_thread_function(void* arg);
+
+class posix_thread
+  : private noncopyable
+{
+public:
+  // Constructor.
+  template <typename Function>
+  posix_thread(Function f)
+    : joined_(false)
+  {
+    std::auto_ptr<func_base> arg(new func<Function>(f));
+    int error = ::pthread_create(&thread_, 0,
+          asio_detail_posix_thread_function, arg.get());
+    if (error != 0)
+    {
+      system_exception e("thread", error);
+      boost::throw_exception(e);
+    }
+    arg.release();
+  }
+
+  // Destructor.
+  ~posix_thread()
+  {
+    if (!joined_)
+      ::pthread_detach(thread_);
+  }
+
+  // Wait for the thread to exit.
+  void join()
+  {
+    if (!joined_)
+    {
+      ::pthread_join(thread_, 0);
+      joined_ = true;
+    }
+  }
+
+private:
+  friend void* asio_detail_posix_thread_function(void* 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_;
+  };
+
+  ::pthread_t thread_;
+  bool joined_;
+};
+
+inline void* asio_detail_posix_thread_function(void* arg)
+{
+  std::auto_ptr<posix_thread::func_base> f(
+      static_cast<posix_thread::func_base*>(arg));
+  f->run();
+  return 0;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
diff --git a/include/boost/asio/detail/posix_tss_ptr.hpp b/include/boost/asio/detail/posix_tss_ptr.hpp
new file mode 100644
index 0000000000..2d8540a601
--- /dev/null
+++ b/include/boost/asio/detail/posix_tss_ptr.hpp
@@ -0,0 +1,86 @@
+//
+// posix_tss_ptr.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP
+#define BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <pthread.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename T>
+class posix_tss_ptr
+  : private noncopyable
+{
+public:
+  // Constructor.
+  posix_tss_ptr()
+  {
+    int error = ::pthread_key_create(&tss_key_, 0);
+    if (error != 0)
+    {
+      system_exception e("tss", error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~posix_tss_ptr()
+  {
+    ::pthread_key_delete(tss_key_);
+  }
+
+  // Get the value.
+  operator T*() const
+  {
+    return static_cast<T*>(::pthread_getspecific(tss_key_));
+  }
+
+  // Set the value.
+  void operator=(T* value)
+  {
+    ::pthread_setspecific(tss_key_, value);
+  }
+
+private:
+  // Thread-specific storage to allow unlocked access to determine whether a
+  // thread is a member of the pool.
+  pthread_key_t tss_key_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_HAS_PTHREADS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP
diff --git a/include/boost/asio/detail/push_options.hpp b/include/boost/asio/detail/push_options.hpp
new file mode 100644
index 0000000000..45493ed295
--- /dev/null
+++ b/include/boost/asio/detail/push_options.hpp
@@ -0,0 +1,106 @@
+//
+// push_options.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// No header guard
+
+#if defined(__COMO__)
+
+// Comeau C++
+
+#elif defined(__DMC__)
+
+// Digital Mars C++
+
+#elif defined(__INTEL_COMPILER) || defined(__ICL) \
+  || defined(__ICC) || defined(__ECC)
+
+// Intel C++
+
+#elif defined(__GNUC__)
+
+// GNU C++
+
+# if defined(__MINGW32__) || defined(__CYGWIN__)
+#  pragma pack (push, 8)
+# endif
+
+#elif defined(__KCC)
+
+// Kai C++
+
+#elif defined(__sgi)
+
+// SGI MIPSpro C++
+
+#elif defined(__DECCXX)
+
+// Compaq Tru64 Unix cxx
+
+#elif defined(__ghs)
+
+// Greenhills C++
+
+#elif defined(__BORLANDC__)
+
+// Borland C++
+
+# pragma option push -a8 -b -Ve- -Vx- -w-inl -vi-
+# pragma nopushoptwarn
+# pragma nopackwarning
+# if !defined(__MT__)
+#  error Multithreaded RTL must be selected.
+# endif // !defined(__MT__)
+
+#elif defined(__MWERKS__)
+
+// Metrowerks CodeWarrior
+
+#elif defined(__SUNPRO_CC)
+
+// Sun Workshop Compiler C++
+
+#elif defined(__HP_aCC)
+
+// HP aCC
+
+#elif defined(__MRC__) || defined(__SC__)
+
+// MPW MrCpp or SCpp
+
+#elif defined(__IBMCPP__)
+
+// IBM Visual Age
+
+#elif defined(_MSC_VER)
+
+// Microsoft Visual C++
+//
+// Must remain the last #elif since some other vendors (Metrowerks, for example)
+// also #define _MSC_VER
+
+# pragma warning (disable:4103)
+# pragma warning (push)
+# pragma warning (disable:4244)
+# pragma warning (disable:4355)
+# pragma warning (disable:4675)
+# pragma pack (push, 8)
+// Note that if the /Og optimisation flag is enabled with MSVC6, the compiler
+// has a tendency to incorrectly optimise away some calls to member template
+// functions, even though those functions contain code that should not be
+// optimised away! Therefore we will always disable this optimisation option
+// for the MSVC6 compiler.
+# if (_MSC_VER < 1300)
+#  pragma optimize ("g", off)
+# endif
+# if !defined(_MT)
+#  error Multithreaded RTL must be selected.
+# endif // !defined(_MT)
+
+#endif
diff --git a/include/boost/asio/detail/reactive_deadline_timer_service.hpp b/include/boost/asio/detail/reactive_deadline_timer_service.hpp
new file mode 100644
index 0000000000..94580f344e
--- /dev/null
+++ b/include/boost/asio/detail/reactive_deadline_timer_service.hpp
@@ -0,0 +1,179 @@
+//
+// reactive_deadline_timer_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_REACTIVE_DEADLINE_TIMER_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_REACTIVE_DEADLINE_TIMER_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Time_Traits, typename Reactor>
+class reactive_deadline_timer_service
+  : public boost::asio::io_service::service
+{
+public:
+  // The implementation type of the timer. This type is dependent on the
+  // underlying implementation of the timer service.
+  struct implementation_type
+    : private boost::asio::detail::noncopyable
+  {
+    boost::posix_time::ptime expiry;
+    bool might_have_pending_waits;
+  };
+
+  // The time type.
+  typedef typename Time_Traits::time_type time_type;
+
+  // The duration type.
+  typedef typename Time_Traits::duration_type duration_type;
+
+  // Constructor.
+  reactive_deadline_timer_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      reactor_(boost::asio::use_service<Reactor>(io_service))
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  // Construct a new timer implementation.
+  void construct(implementation_type& impl)
+  {
+    impl.expiry = boost::posix_time::ptime();
+    impl.might_have_pending_waits = false;
+  }
+
+  // Destroy a timer implementation.
+  void destroy(implementation_type& impl)
+  {
+    cancel(impl);
+  }
+
+  // Cancel any asynchronous wait operations associated with the timer.
+  std::size_t cancel(implementation_type& impl)
+  {
+    if (!impl.might_have_pending_waits)
+      return 0;
+    std::size_t count = reactor_.cancel_timer(&impl);
+    impl.might_have_pending_waits = false;
+    return count;
+  }
+
+  // Get the expiry time for the timer as an absolute time.
+  time_type expires_at(const implementation_type& impl) const
+  {
+    return Time_Traits::from_utc(impl.expiry);
+  }
+
+  // Set the expiry time for the timer as an absolute time.
+  std::size_t expires_at(implementation_type& impl,
+      const time_type& expiry_time)
+  {
+    std::size_t count = cancel(impl);
+    impl.expiry = Time_Traits::to_utc(expiry_time);
+    return count;
+  }
+
+  // Get the expiry time for the timer relative to now.
+  duration_type expires_from_now(const implementation_type& impl) const
+  {
+    return Time_Traits::subtract(expires_at(impl), Time_Traits::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)
+  {
+    return expires_at(impl, Time_Traits::add(Time_Traits::now(), expiry_time));
+  }
+
+  // Perform a blocking wait on the timer.
+  void wait(implementation_type& impl)
+  {
+    boost::posix_time::ptime now
+      = boost::posix_time::microsec_clock::universal_time();
+    while (now < impl.expiry)
+    {
+      boost::posix_time::time_duration timeout = impl.expiry - now;
+      ::timeval tv;
+      tv.tv_sec = timeout.total_seconds();
+      tv.tv_usec = timeout.total_microseconds() % 1000000;
+      socket_ops::select(0, 0, 0, 0, &tv);
+      now = boost::posix_time::microsec_clock::universal_time();
+    }
+  }
+
+  template <typename Handler>
+  class wait_handler
+  {
+  public:
+    wait_handler(boost::asio::io_service& io_service, Handler handler)
+      : io_service_(io_service),
+        work_(io_service),
+        handler_(handler)
+    {
+    }
+
+    void operator()(int result)
+    {
+      boost::asio::error e(result);
+      io_service_.post(detail::bind_handler(handler_, e));
+    }
+
+  private:
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous wait on the timer.
+  template <typename Handler>
+  void async_wait(implementation_type& impl, Handler handler)
+  {
+    impl.might_have_pending_waits = true;
+    reactor_.schedule_timer(impl.expiry,
+        wait_handler<Handler>(owner(), handler), &impl);
+  }
+
+private:
+  // The selector that performs event demultiplexing for the provider.
+  Reactor& reactor_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_REACTIVE_DEADLINE_TIMER_SERVICE_HPP
diff --git a/include/boost/asio/detail/reactive_socket_service.hpp b/include/boost/asio/detail/reactive_socket_service.hpp
new file mode 100644
index 0000000000..e07b069095
--- /dev/null
+++ b/include/boost/asio/detail/reactive_socket_service.hpp
@@ -0,0 +1,1544 @@
+//
+// reactive_socket_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_holder.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol, typename Reactor>
+class reactive_socket_service
+  : public boost::asio::io_service::service
+{
+public:
+  // The protocol type.
+  typedef Protocol protocol_type;
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // The native type of a socket.
+  typedef socket_type native_type;
+
+  // The implementation type of the socket.
+  class implementation_type
+    : private boost::asio::detail::noncopyable
+  {
+  public:
+    // Default constructor.
+    implementation_type()
+      : socket_(invalid_socket),
+        flags_(0),
+        protocol_(endpoint_type().protocol())
+    {
+    }
+
+  private:
+    // Only this service will have access to the internal values.
+    friend class reactive_socket_service<Protocol, Reactor>;
+
+    // The native socket representation.
+    socket_type socket_;
+
+    enum
+    {
+      user_set_non_blocking = 1, // The user wants a non-blocking socket.
+      internal_non_blocking = 2, // The socket has been set non-blocking.
+      enable_connection_aborted = 4, // User wants connection_aborted errors.
+    };
+
+    // Flags indicating the current state of the socket.
+    unsigned char flags_;
+
+    // The protocol associated with the socket.
+    protocol_type protocol_;
+  };
+
+  // The maximum number of buffers to support in a single operation.
+  enum { max_buffers = 16 };
+
+  // Constructor.
+  reactive_socket_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      reactor_(boost::asio::use_service<Reactor>(io_service))
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  // Construct a new socket implementation.
+  void construct(implementation_type& impl)
+  {
+    impl.socket_ = invalid_socket;
+    impl.flags_ = 0;
+  }
+
+  // Destroy a socket implementation.
+  void destroy(implementation_type& impl)
+  {
+    close(impl, boost::asio::ignore_error());
+  }
+
+  // Open a new socket implementation.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const protocol_type& protocol,
+      Error_Handler error_handler)
+  {
+    close(impl, boost::asio::ignore_error());
+
+    socket_holder sock(socket_ops::socket(protocol.family(),
+          protocol.type(), protocol.protocol()));
+    if (sock.get() == invalid_socket)
+    {
+      error_handler(boost::asio::error(socket_ops::get_error()));
+      return;
+    }
+
+    if (int err = reactor_.register_descriptor(sock.get()))
+    {
+      error_handler(boost::asio::error(err));
+      return;
+    }
+
+    impl.socket_ = sock.release();
+    impl.flags_ = 0;
+    impl.protocol_ = protocol;
+
+    error_handler(boost::asio::error(0));
+  }
+
+  // Assign a native socket to a socket implementation.
+  template <typename Error_Handler>
+  void assign(implementation_type& impl, const protocol_type& protocol,
+      const native_type& native_socket, Error_Handler error_handler)
+  {
+    close(impl, boost::asio::ignore_error());
+
+    if (int err = reactor_.register_descriptor(native_socket))
+    {
+      error_handler(boost::asio::error(err));
+      return;
+    }
+
+    impl.socket_ = native_socket;
+    impl.flags_ = 0;
+    impl.protocol_ = protocol;
+
+    error_handler(boost::asio::error(0));
+  }
+
+  // Destroy a socket implementation.
+  template <typename Error_Handler>
+  void close(implementation_type& impl, Error_Handler error_handler)
+  {
+    if (impl.socket_ != invalid_socket)
+    {
+      reactor_.close_descriptor(impl.socket_);
+
+      if (impl.flags_ & implementation_type::internal_non_blocking)
+      {
+        ioctl_arg_type non_blocking = 0;
+        socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking);
+        impl.flags_ &= ~implementation_type::internal_non_blocking;
+      }
+
+      if (socket_ops::close(impl.socket_) == socket_error_retval)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+
+      impl.socket_ = invalid_socket;
+    }
+
+    error_handler(boost::asio::error(0));
+  }
+
+  // Get the native socket representation.
+  native_type native(implementation_type& impl)
+  {
+    return impl.socket_;
+  }
+
+  // Bind the socket to the specified local endpoint.
+  template <typename Error_Handler>
+  void bind(implementation_type& impl, const endpoint_type& endpoint,
+      Error_Handler error_handler)
+  {
+    if (socket_ops::bind(impl.socket_, endpoint.data(),
+          endpoint.size()) == socket_error_retval)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Place the socket into the state where it will listen for new connections.
+  template <typename Error_Handler>
+  void listen(implementation_type& impl, int backlog,
+      Error_Handler error_handler)
+  {
+    if (backlog == 0)
+      backlog = SOMAXCONN;
+
+    if (socket_ops::listen(impl.socket_, backlog) == socket_error_retval)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void set_option(implementation_type& impl, const Option& option,
+      Error_Handler error_handler)
+  {
+    if (option.level(impl.protocol_) == custom_socket_option_level
+        && option.name(impl.protocol_) == enable_connection_aborted_option)
+    {
+      if (option.size(impl.protocol_) != sizeof(int))
+      {
+        error_handler(boost::asio::error(boost::asio::error::invalid_argument));
+      }
+      else
+      {
+        if (*static_cast<const int*>(option.data(impl.protocol_)))
+          impl.flags_ |= implementation_type::enable_connection_aborted;
+        else
+          impl.flags_ &= ~implementation_type::enable_connection_aborted;
+        error_handler(boost::asio::error(0));
+      }
+    }
+    else
+    {
+      if (socket_ops::setsockopt(impl.socket_,
+            option.level(impl.protocol_), option.name(impl.protocol_),
+            option.data(impl.protocol_), option.size(impl.protocol_)))
+        error_handler(boost::asio::error(socket_ops::get_error()));
+      else
+        error_handler(boost::asio::error(0));
+    }
+  }
+
+  // Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void get_option(const implementation_type& impl, Option& option,
+      Error_Handler error_handler) const
+  {
+    if (option.level(impl.protocol_) == custom_socket_option_level
+        && option.name(impl.protocol_) == enable_connection_aborted_option)
+    {
+      if (option.size(impl.protocol_) != sizeof(int))
+      {
+        error_handler(boost::asio::error(boost::asio::error::invalid_argument));
+      }
+      else
+      {
+        int* target = static_cast<int*>(option.data(impl.protocol_));
+        if (impl.flags_ & implementation_type::enable_connection_aborted)
+          *target = 1;
+        else
+          *target = 0;
+        error_handler(boost::asio::error(0));
+      }
+    }
+    else
+    {
+      size_t size = option.size(impl.protocol_);
+      if (socket_ops::getsockopt(impl.socket_,
+            option.level(impl.protocol_), option.name(impl.protocol_),
+            option.data(impl.protocol_), &size))
+        error_handler(boost::asio::error(socket_ops::get_error()));
+      else
+        error_handler(boost::asio::error(0));
+    }
+  }
+
+  // Perform an IO control command on the socket.
+  template <typename IO_Control_Command, typename Error_Handler>
+  void io_control(implementation_type& impl, IO_Control_Command& command,
+      Error_Handler error_handler)
+  {
+    if (command.name() == static_cast<int>(FIONBIO))
+    {
+      if (command.get())
+        impl.flags_ |= implementation_type::user_set_non_blocking;
+      else
+        impl.flags_ &= ~implementation_type::user_set_non_blocking;
+      error_handler(boost::asio::error(0));
+    }
+    else
+    {
+      if (socket_ops::ioctl(impl.socket_, command.name(),
+            static_cast<ioctl_arg_type*>(command.data())))
+        error_handler(boost::asio::error(socket_ops::get_error()));
+      else
+        error_handler(boost::asio::error(0));
+    }
+  }
+
+  // Get the local endpoint.
+  template <typename Error_Handler>
+  void get_local_endpoint(const implementation_type& impl,
+      endpoint_type& endpoint, Error_Handler error_handler) const
+  {
+    socket_addr_len_type addr_len = endpoint.capacity();
+    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len))
+    {
+      error_handler(boost::asio::error(socket_ops::get_error()));
+      return;
+    }
+
+    endpoint.resize(addr_len);
+    error_handler(boost::asio::error(0));
+  }
+
+  // Get the remote endpoint.
+  template <typename Error_Handler>
+  void get_remote_endpoint(const implementation_type& impl,
+      endpoint_type& endpoint, Error_Handler error_handler) const
+  {
+    socket_addr_len_type addr_len = endpoint.capacity();
+    if (socket_ops::getpeername(impl.socket_, endpoint.data(), &addr_len))
+    {
+      error_handler(boost::asio::error(socket_ops::get_error()));
+      return;
+    }
+
+    endpoint.resize(addr_len);
+    error_handler(boost::asio::error(0));
+  }
+
+  /// Disable sends or receives on the socket.
+  template <typename Error_Handler>
+  void shutdown(implementation_type& impl, socket_base::shutdown_type what,
+      Error_Handler error_handler)
+  {
+    if (socket_ops::shutdown(impl.socket_, what) != 0)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Send the given data to the peer.
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    // Copy buffers into array.
+    socket_ops::buf bufs[max_buffers];
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    size_t i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      socket_ops::init_buf(bufs[i],
+          boost::asio::buffer_cast<const void*>(buffer),
+          boost::asio::buffer_size(buffer));
+    }
+
+    // Send the data.
+    for (;;)
+    {
+      // Try to complete the operation without blocking.
+      int bytes_sent = socket_ops::send(impl.socket_, bufs, i, flags);
+      int error = socket_ops::get_error();
+
+      // Check if operation succeeded.
+      if (bytes_sent >= 0)
+      {
+        error_handler(boost::asio::error(0));
+        return bytes_sent;
+      }
+
+      // Operation failed.
+      if ((impl.flags_ & implementation_type::user_set_non_blocking)
+          || (error != boost::asio::error::would_block
+            && error != boost::asio::error::try_again))
+      {
+        error_handler(boost::asio::error(error));
+        return 0;
+      }
+
+      // Wait for socket to become ready.
+      if (socket_ops::poll_write(impl.socket_) < 0)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return 0;
+      }
+    }
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  class send_handler
+  {
+  public:
+    send_handler(socket_type socket, boost::asio::io_service& io_service,
+        const Const_Buffers& buffers, socket_base::message_flags flags,
+        Handler handler)
+      : socket_(socket),
+        io_service_(io_service),
+        work_(io_service),
+        buffers_(buffers),
+        flags_(flags),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error, 0));
+        return true;
+      }
+
+      // Copy buffers into array.
+      socket_ops::buf bufs[max_buffers];
+      typename Const_Buffers::const_iterator iter = buffers_.begin();
+      typename Const_Buffers::const_iterator end = buffers_.end();
+      size_t i = 0;
+      for (; iter != end && i < max_buffers; ++iter, ++i)
+      {
+        boost::asio::const_buffer buffer(*iter);
+        socket_ops::init_buf(bufs[i],
+            boost::asio::buffer_cast<const void*>(buffer),
+            boost::asio::buffer_size(buffer));
+      }
+
+      // Send the data.
+      int bytes = socket_ops::send(socket_, bufs, i, flags_);
+      boost::asio::error error(bytes < 0
+          ? socket_ops::get_error() : boost::asio::error::success);
+
+      // Check if we need to run the operation again.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+        return false;
+
+      io_service_.post(bind_handler(handler_, error, bytes < 0 ? 0 : bytes));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Const_Buffers buffers_;
+    socket_base::message_flags flags_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error, 0));
+    }
+    else
+    {
+      // Make socket non-blocking.
+      if (!(impl.flags_ & implementation_type::internal_non_blocking))
+      {
+        ioctl_arg_type non_blocking = 1;
+        if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+        {
+          boost::asio::error error(socket_ops::get_error());
+          owner().post(bind_handler(handler, error, 0));
+          return;
+        }
+        impl.flags_ |= implementation_type::internal_non_blocking;
+      }
+
+      reactor_.start_write_op(impl.socket_,
+          send_handler<Const_Buffers, Handler>(
+            impl.socket_, owner(), buffers, flags, handler));
+    }
+  }
+
+  // Send a datagram to the specified endpoint. Returns the number of bytes
+  // sent.
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t send_to(implementation_type& impl, const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    // Copy buffers into array.
+    socket_ops::buf bufs[max_buffers];
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    size_t i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      socket_ops::init_buf(bufs[i],
+          boost::asio::buffer_cast<const void*>(buffer),
+          boost::asio::buffer_size(buffer));
+    }
+
+    // Send the data.
+    for (;;)
+    {
+      // Try to complete the operation without blocking.
+      int bytes_sent = socket_ops::sendto(impl.socket_, bufs, i, flags,
+          destination.data(), destination.size());
+      int error = socket_ops::get_error();
+
+      // Check if operation succeeded.
+      if (bytes_sent >= 0)
+      {
+        error_handler(boost::asio::error(0));
+        return bytes_sent;
+      }
+
+      // Operation failed.
+      if ((impl.flags_ & implementation_type::user_set_non_blocking)
+          || (error != boost::asio::error::would_block
+            && error != boost::asio::error::try_again))
+      {
+        error_handler(boost::asio::error(error));
+        return 0;
+      }
+
+      // Wait for socket to become ready.
+      if (socket_ops::poll_write(impl.socket_) < 0)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return 0;
+      }
+    }
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  class send_to_handler
+  {
+  public:
+    send_to_handler(socket_type socket, boost::asio::io_service& io_service,
+        const Const_Buffers& buffers, const endpoint_type& endpoint,
+        socket_base::message_flags flags, Handler handler)
+      : socket_(socket),
+        io_service_(io_service),
+        work_(io_service),
+        buffers_(buffers),
+        destination_(endpoint),
+        flags_(flags),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error, 0));
+        return true;
+      }
+
+      // Copy buffers into array.
+      socket_ops::buf bufs[max_buffers];
+      typename Const_Buffers::const_iterator iter = buffers_.begin();
+      typename Const_Buffers::const_iterator end = buffers_.end();
+      size_t i = 0;
+      for (; iter != end && i < max_buffers; ++iter, ++i)
+      {
+        boost::asio::const_buffer buffer(*iter);
+        socket_ops::init_buf(bufs[i],
+            boost::asio::buffer_cast<const void*>(buffer),
+            boost::asio::buffer_size(buffer));
+      }
+
+      // Send the data.
+      int bytes = socket_ops::sendto(socket_, bufs, i, flags_,
+          destination_.data(), destination_.size());
+      boost::asio::error error(bytes < 0
+          ? socket_ops::get_error() : boost::asio::error::success);
+
+      // Check if we need to run the operation again.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+        return false;
+
+      io_service_.post(bind_handler(handler_, error, bytes < 0 ? 0 : bytes));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Const_Buffers buffers_;
+    endpoint_type destination_;
+    socket_base::message_flags flags_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_send_to(implementation_type& impl, const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Handler handler)
+  {
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error, 0));
+    }
+    else
+    {
+      // Make socket non-blocking.
+      if (!(impl.flags_ & implementation_type::internal_non_blocking))
+      {
+        ioctl_arg_type non_blocking = 1;
+        if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+        {
+          boost::asio::error error(socket_ops::get_error());
+          owner().post(bind_handler(handler, error, 0));
+          return;
+        }
+        impl.flags_ |= implementation_type::internal_non_blocking;
+      }
+
+      reactor_.start_write_op(impl.socket_,
+          send_to_handler<Const_Buffers, Handler>(
+            impl.socket_, owner(), buffers, destination, flags, handler));
+    }
+  }
+
+  // Receive some data from the peer. Returns the number of bytes received.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    // Copy buffers into array.
+    socket_ops::buf bufs[max_buffers];
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    size_t i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      socket_ops::init_buf(bufs[i],
+          boost::asio::buffer_cast<void*>(buffer),
+          boost::asio::buffer_size(buffer));
+    }
+
+    // Receive some data.
+    for (;;)
+    {
+      // Try to complete the operation without blocking.
+      int bytes_recvd = socket_ops::recv(impl.socket_, bufs, i, flags);
+      int error = socket_ops::get_error();
+
+      // Check if operation succeeded.
+      if (bytes_recvd > 0)
+      {
+        error_handler(boost::asio::error(0));
+        return bytes_recvd;
+      }
+
+      // Check for EOF.
+      if (bytes_recvd == 0)
+      {
+        error_handler(boost::asio::error(boost::asio::error::eof));
+        return 0;
+      }
+
+      // Operation failed.
+      if ((impl.flags_ & implementation_type::user_set_non_blocking)
+          || (error != boost::asio::error::would_block
+            && error != boost::asio::error::try_again))
+      {
+        error_handler(boost::asio::error(error));
+        return 0;
+      }
+
+      // Wait for socket to become ready.
+      if (socket_ops::poll_read(impl.socket_) < 0)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return 0;
+      }
+    }
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  class receive_handler
+  {
+  public:
+    receive_handler(socket_type socket, boost::asio::io_service& io_service,
+        const Mutable_Buffers& buffers, socket_base::message_flags flags,
+        Handler handler)
+      : socket_(socket),
+        io_service_(io_service),
+        work_(io_service),
+        buffers_(buffers),
+        flags_(flags),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error, 0));
+        return true;
+      }
+
+      // Copy buffers into array.
+      socket_ops::buf bufs[max_buffers];
+      typename Mutable_Buffers::const_iterator iter = buffers_.begin();
+      typename Mutable_Buffers::const_iterator end = buffers_.end();
+      size_t i = 0;
+      for (; iter != end && i < max_buffers; ++iter, ++i)
+      {
+        boost::asio::mutable_buffer buffer(*iter);
+        socket_ops::init_buf(bufs[i],
+            boost::asio::buffer_cast<void*>(buffer),
+            boost::asio::buffer_size(buffer));
+      }
+
+      // Receive some data.
+      int bytes = socket_ops::recv(socket_, bufs, i, flags_);
+      int error_code = boost::asio::error::success;
+      if (bytes < 0)
+        error_code = socket_ops::get_error();
+      else if (bytes == 0)
+        error_code = boost::asio::error::eof;
+      boost::asio::error error(error_code);
+
+      // Check if we need to run the operation again.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+        return false;
+
+      io_service_.post(bind_handler(handler_, error, bytes < 0 ? 0 : bytes));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Mutable_Buffers buffers_;
+    socket_base::message_flags flags_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error, 0));
+    }
+    else
+    {
+      // Make socket non-blocking.
+      if (!(impl.flags_ & implementation_type::internal_non_blocking))
+      {
+        ioctl_arg_type non_blocking = 1;
+        if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+        {
+          boost::asio::error error(socket_ops::get_error());
+          owner().post(bind_handler(handler, error, 0));
+          return;
+        }
+        impl.flags_ |= implementation_type::internal_non_blocking;
+      }
+
+      if (flags & socket_base::message_out_of_band)
+      {
+        reactor_.start_except_op(impl.socket_,
+            receive_handler<Mutable_Buffers, Handler>(
+              impl.socket_, owner(), buffers, flags, handler));
+      }
+      else
+      {
+        reactor_.start_read_op(impl.socket_,
+            receive_handler<Mutable_Buffers, Handler>(
+              impl.socket_, owner(), buffers, flags, handler));
+      }
+    }
+  }
+
+  // Receive a datagram with the endpoint of the sender. Returns the number of
+  // bytes received.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t receive_from(implementation_type& impl, const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    // Copy buffers into array.
+    socket_ops::buf bufs[max_buffers];
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    size_t i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      socket_ops::init_buf(bufs[i],
+          boost::asio::buffer_cast<void*>(buffer),
+          boost::asio::buffer_size(buffer));
+    }
+
+    // Receive some data.
+    for (;;)
+    {
+      // Try to complete the operation without blocking.
+      socket_addr_len_type addr_len = sender_endpoint.capacity();
+      int bytes_recvd = socket_ops::recvfrom(impl.socket_, bufs, i, flags,
+          sender_endpoint.data(), &addr_len);
+      int error = socket_ops::get_error();
+
+      // Check if operation succeeded.
+      if (bytes_recvd > 0)
+      {
+        sender_endpoint.resize(addr_len);
+        error_handler(boost::asio::error(0));
+        return bytes_recvd;
+      }
+
+      // Check for EOF.
+      if (bytes_recvd == 0)
+      {
+        error_handler(boost::asio::error(boost::asio::error::eof));
+        return 0;
+      }
+
+      // Operation failed.
+      if ((impl.flags_ & implementation_type::user_set_non_blocking)
+          || (error != boost::asio::error::would_block
+            && error != boost::asio::error::try_again))
+      {
+        error_handler(boost::asio::error(error));
+        return 0;
+      }
+
+      // Wait for socket to become ready.
+      if (socket_ops::poll_read(impl.socket_) < 0)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return 0;
+      }
+    }
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  class receive_from_handler
+  {
+  public:
+    receive_from_handler(socket_type socket,
+        boost::asio::io_service& io_service, const Mutable_Buffers& buffers,
+        endpoint_type& endpoint, socket_base::message_flags flags,
+        Handler handler)
+      : socket_(socket),
+        io_service_(io_service),
+        work_(io_service),
+        buffers_(buffers),
+        sender_endpoint_(endpoint),
+        flags_(flags),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error, 0));
+        return true;
+      }
+
+      // Copy buffers into array.
+      socket_ops::buf bufs[max_buffers];
+      typename Mutable_Buffers::const_iterator iter = buffers_.begin();
+      typename Mutable_Buffers::const_iterator end = buffers_.end();
+      size_t i = 0;
+      for (; iter != end && i < max_buffers; ++iter, ++i)
+      {
+        boost::asio::mutable_buffer buffer(*iter);
+        socket_ops::init_buf(bufs[i],
+            boost::asio::buffer_cast<void*>(buffer),
+            boost::asio::buffer_size(buffer));
+      }
+
+      // Receive some data.
+      socket_addr_len_type addr_len = sender_endpoint_.capacity();
+      int bytes = socket_ops::recvfrom(socket_, bufs, i, flags_,
+          sender_endpoint_.data(), &addr_len);
+      int error_code = boost::asio::error::success;
+      if (bytes < 0)
+        error_code = socket_ops::get_error();
+      else if (bytes == 0)
+        error_code = boost::asio::error::eof;
+      boost::asio::error error(error_code);
+
+      // Check if we need to run the operation again.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+        return false;
+
+      sender_endpoint_.resize(addr_len);
+      io_service_.post(bind_handler(handler_, error, bytes < 0 ? 0 : bytes));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Mutable_Buffers buffers_;
+    endpoint_type& sender_endpoint_;
+    socket_base::message_flags flags_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous receive. The buffer for the data being received and
+  // the sender_endpoint object must both be valid for the lifetime of the
+  // asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive_from(implementation_type& impl,
+      const Mutable_Buffers& buffers, endpoint_type& sender_endpoint,
+      socket_base::message_flags flags, Handler handler)
+  {
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error, 0));
+    }
+    else
+    {
+      // Make socket non-blocking.
+      if (!(impl.flags_ & implementation_type::internal_non_blocking))
+      {
+        ioctl_arg_type non_blocking = 1;
+        if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+        {
+          boost::asio::error error(socket_ops::get_error());
+          owner().post(bind_handler(handler, error, 0));
+          return;
+        }
+        impl.flags_ |= implementation_type::internal_non_blocking;
+      }
+
+      reactor_.start_read_op(impl.socket_,
+          receive_from_handler<Mutable_Buffers, Handler>(
+            impl.socket_, owner(), buffers,
+            sender_endpoint, flags, handler));
+    }
+  }
+
+  // Accept a new connection.
+  template <typename Socket, typename Error_Handler>
+  void accept(implementation_type& impl, Socket& peer,
+      Error_Handler error_handler)
+  {
+    // We cannot accept a socket that is already open.
+    if (peer.native() != invalid_socket)
+    {
+      error_handler(boost::asio::error(boost::asio::error::already_connected));
+      return;
+    }
+
+    // Accept a socket.
+    for (;;)
+    {
+      // Try to complete the operation without blocking.
+      socket_holder new_socket(socket_ops::accept(impl.socket_, 0, 0));
+      int error = socket_ops::get_error();
+
+      // Check if operation succeeded.
+      if (new_socket.get() >= 0)
+      {
+        boost::asio::error temp_error;
+        peer.assign(impl.protocol_, new_socket.get(),
+            boost::asio::assign_error(temp_error));
+        if (temp_error)
+        {
+          error_handler(temp_error);
+        }
+        else
+        {
+          new_socket.release();
+          error_handler(boost::asio::error(0));
+        }
+        return;
+      }
+
+      // Operation failed.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+      {
+        if (impl.flags_ & implementation_type::user_set_non_blocking)
+        {
+          error_handler(boost::asio::error(error));
+          return;
+        }
+        // Fall through to retry operation.
+      }
+      else if (error == boost::asio::error::connection_aborted)
+      {
+        if (impl.flags_ & implementation_type::enable_connection_aborted)
+        {
+          error_handler(boost::asio::error(error));
+          return;
+        }
+        // Fall through to retry operation.
+      }
+      else
+      {
+        error_handler(boost::asio::error(error));
+        return;
+      }
+
+      // Wait for socket to become ready.
+      if (socket_ops::poll_read(impl.socket_) < 0)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+    }
+  }
+
+  // Accept a new connection.
+  template <typename Socket, typename Error_Handler>
+  void accept_endpoint(implementation_type& impl, Socket& peer,
+      endpoint_type& peer_endpoint, Error_Handler error_handler)
+  {
+    // We cannot accept a socket that is already open.
+    if (peer.native() != invalid_socket)
+    {
+      error_handler(boost::asio::error(boost::asio::error::already_connected));
+      return;
+    }
+
+    if (int err = socket_ops::get_error())
+    {
+      error_handler(boost::asio::error(err));
+      return;
+    }
+
+    // Accept a socket.
+    for (;;)
+    {
+      // Try to complete the operation without blocking.
+      socket_addr_len_type addr_len = peer_endpoint.capacity();
+      socket_holder new_socket(socket_ops::accept(
+            impl.socket_, peer_endpoint.data(), &addr_len));
+      int error = socket_ops::get_error();
+
+      // Check if operation succeeded.
+      if (new_socket.get() >= 0)
+      {
+        peer_endpoint.resize(addr_len);
+        boost::asio::error temp_error;
+        peer.assign(impl.protocol_, new_socket.get(),
+            boost::asio::assign_error(temp_error));
+        if (temp_error)
+        {
+          error_handler(temp_error);
+        }
+        else
+        {
+          new_socket.release();
+          error_handler(boost::asio::error(0));
+        }
+        return;
+      }
+
+      // Operation failed.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+      {
+        if (impl.flags_ & implementation_type::user_set_non_blocking)
+        {
+          error_handler(boost::asio::error(error));
+          return;
+        }
+        // Fall through to retry operation.
+      }
+      else if (error == boost::asio::error::connection_aborted)
+      {
+        if (impl.flags_ & implementation_type::enable_connection_aborted)
+        {
+          error_handler(boost::asio::error(error));
+          return;
+        }
+        // Fall through to retry operation.
+      }
+      else
+      {
+        error_handler(boost::asio::error(error));
+        return;
+      }
+
+      // Wait for socket to become ready.
+      if (socket_ops::poll_read(impl.socket_) < 0)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+    }
+  }
+
+  template <typename Socket, typename Handler>
+  class accept_handler
+  {
+  public:
+    accept_handler(socket_type socket, boost::asio::io_service& io_service,
+        Socket& peer, const protocol_type& protocol,
+        bool enable_connection_aborted, Handler handler)
+      : socket_(socket),
+        io_service_(io_service),
+        work_(io_service),
+        peer_(peer),
+        protocol_(protocol),
+        enable_connection_aborted_(enable_connection_aborted),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Accept the waiting connection.
+      socket_holder new_socket(socket_ops::accept(socket_, 0, 0));
+      boost::asio::error error(new_socket.get() == invalid_socket
+          ? socket_ops::get_error() : boost::asio::error::success);
+
+      // Check if we need to run the operation again.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+        return false;
+      if (error == boost::asio::error::connection_aborted
+          && !enable_connection_aborted_)
+        return false;
+
+      // Transfer ownership of the new socket to the peer object.
+      if (!error)
+      {
+        peer_.assign(protocol_, new_socket.get(),
+            boost::asio::assign_error(error));
+        if (!error)
+          new_socket.release();
+      }
+
+      io_service_.post(bind_handler(handler_, error));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Socket& peer_;
+    protocol_type protocol_;
+    bool enable_connection_aborted_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous accept. The peer object must be valid until the
+  // accept's handler is invoked.
+  template <typename Socket, typename Handler>
+  void async_accept(implementation_type& impl, Socket& peer, Handler handler)
+  {
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error));
+    }
+    else if (peer.native() != invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::already_connected);
+      owner().post(bind_handler(handler, error));
+    }
+    else
+    {
+      // Make socket non-blocking.
+      if (!(impl.flags_ & implementation_type::internal_non_blocking))
+      {
+        ioctl_arg_type non_blocking = 1;
+        if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+        {
+          boost::asio::error error(socket_ops::get_error());
+          owner().post(bind_handler(handler, error));
+          return;
+        }
+        impl.flags_ |= implementation_type::internal_non_blocking;
+      }
+
+      reactor_.start_read_op(impl.socket_,
+          accept_handler<Socket, Handler>(
+            impl.socket_, owner(), peer, impl.protocol_,
+            (impl.flags_ & implementation_type::enable_connection_aborted) != 0,
+            handler));
+    }
+  }
+
+  template <typename Socket, typename Handler>
+  class accept_endp_handler
+  {
+  public:
+    accept_endp_handler(socket_type socket, boost::asio::io_service& io_service,
+        Socket& peer, endpoint_type& peer_endpoint,
+        bool enable_connection_aborted, Handler handler)
+      : socket_(socket),
+        io_service_(io_service),
+        work_(io_service),
+        peer_(peer),
+        peer_endpoint_(peer_endpoint),
+        enable_connection_aborted_(enable_connection_aborted),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Accept the waiting connection.
+      socket_addr_len_type addr_len = peer_endpoint_.capacity();
+      socket_holder new_socket(socket_ops::accept(
+            socket_, peer_endpoint_.data(), &addr_len));
+      boost::asio::error error(new_socket.get() == invalid_socket
+          ? socket_ops::get_error() : boost::asio::error::success);
+
+      // Check if we need to run the operation again.
+      if (error == boost::asio::error::would_block
+          || error == boost::asio::error::try_again)
+        return false;
+      if (error == boost::asio::error::connection_aborted
+          && !enable_connection_aborted_)
+        return false;
+
+      // Transfer ownership of the new socket to the peer object.
+      if (!error)
+      {
+        peer_endpoint_.resize(addr_len);
+        peer_.assign(peer_endpoint_.protocol(), new_socket.get(),
+            boost::asio::assign_error(error));
+        if (!error)
+          new_socket.release();
+      }
+
+      io_service_.post(bind_handler(handler_, error));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Socket& peer_;
+    endpoint_type& peer_endpoint_;
+    bool enable_connection_aborted_;
+    Handler handler_;
+  };
+
+  // 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_endpoint(implementation_type& impl, Socket& peer,
+      endpoint_type& peer_endpoint, Handler handler)
+  {
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error));
+    }
+    else if (peer.native() != invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::already_connected);
+      owner().post(bind_handler(handler, error));
+    }
+    else
+    {
+      // Make socket non-blocking.
+      if (!(impl.flags_ & implementation_type::internal_non_blocking))
+      {
+        ioctl_arg_type non_blocking = 1;
+        if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+        {
+          boost::asio::error error(socket_ops::get_error());
+          owner().post(bind_handler(handler, error));
+          return;
+        }
+        impl.flags_ |= implementation_type::internal_non_blocking;
+      }
+
+      reactor_.start_read_op(impl.socket_,
+          accept_endp_handler<Socket, Handler>(
+            impl.socket_, owner(), peer, peer_endpoint,
+            (impl.flags_ & implementation_type::enable_connection_aborted) != 0,
+            handler));
+    }
+  }
+
+  // Connect the socket to the specified endpoint.
+  template <typename Error_Handler>
+  void connect(implementation_type& impl, const endpoint_type& peer_endpoint,
+      Error_Handler error_handler)
+  {
+    // Open the socket if it is not already open.
+    if (impl.socket_ == invalid_socket)
+    {
+      // Get the flags used to create the new socket.
+      int family = peer_endpoint.protocol().family();
+      int type = peer_endpoint.protocol().type();
+      int proto = peer_endpoint.protocol().protocol();
+
+      // Create a new socket.
+      impl.socket_ = socket_ops::socket(family, type, proto);
+      if (impl.socket_ == invalid_socket)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+
+      // Register the socket with the reactor.
+      if (int err = reactor_.register_descriptor(impl.socket_))
+      {
+        socket_ops::close(impl.socket_);
+        error_handler(boost::asio::error(err));
+        return;
+      }
+    }
+    else if (impl.flags_ & implementation_type::internal_non_blocking)
+    {
+      // Mark the socket as blocking while we perform the connect.
+      ioctl_arg_type non_blocking = 0;
+      if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+      impl.flags_ &= ~implementation_type::internal_non_blocking;
+    }
+
+    // Perform the connect operation.
+    int result = socket_ops::connect(impl.socket_,
+        peer_endpoint.data(), peer_endpoint.size());
+    if (result == socket_error_retval)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  template <typename Handler>
+  class connect_handler
+  {
+  public:
+    connect_handler(socket_type socket, boost::shared_ptr<bool> completed,
+        boost::asio::io_service& io_service, Reactor& reactor, Handler handler)
+      : socket_(socket),
+        completed_(completed),
+        io_service_(io_service),
+        work_(io_service),
+        reactor_(reactor),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether a handler has already been called for the connection.
+      // If it has, then we don't want to do anything in this handler.
+      if (*completed_)
+        return true;
+
+      // Cancel the other reactor operation for the connection.
+      *completed_ = true;
+      reactor_.enqueue_cancel_ops_unlocked(socket_);
+
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Get the error code from the connect operation.
+      int connect_error = 0;
+      size_t connect_error_len = sizeof(connect_error);
+      if (socket_ops::getsockopt(socket_, SOL_SOCKET, SO_ERROR,
+            &connect_error, &connect_error_len) == socket_error_retval)
+      {
+        boost::asio::error error(socket_ops::get_error());
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // If connection failed then post the handler with the error code.
+      if (connect_error)
+      {
+        boost::asio::error error(connect_error);
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Post the result of the successful connection operation.
+      boost::asio::error error(boost::asio::error::success);
+      io_service_.post(bind_handler(handler_, error));
+
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::shared_ptr<bool> completed_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Reactor& reactor_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, Handler handler)
+  {
+    // Open the socket if it is not already open.
+    if (impl.socket_ == invalid_socket)
+    {
+      // Get the flags used to create the new socket.
+      int family = peer_endpoint.protocol().family();
+      int type = peer_endpoint.protocol().type();
+      int proto = peer_endpoint.protocol().protocol();
+
+      // Create a new socket.
+      impl.socket_ = socket_ops::socket(family, type, proto);
+      if (impl.socket_ == invalid_socket)
+      {
+        boost::asio::error error(socket_ops::get_error());
+        owner().post(bind_handler(handler, error));
+        return;
+      }
+
+      // Register the socket with the reactor.
+      if (int err = reactor_.register_descriptor(impl.socket_))
+      {
+        socket_ops::close(impl.socket_);
+        boost::asio::error error(err);
+        owner().post(bind_handler(handler, error));
+        return;
+      }
+    }
+
+    // Make socket non-blocking.
+    if (!(impl.flags_ & implementation_type::internal_non_blocking))
+    {
+      ioctl_arg_type non_blocking = 1;
+      if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+      {
+        boost::asio::error error(socket_ops::get_error());
+        owner().post(bind_handler(handler, error));
+        return;
+      }
+      impl.flags_ |= implementation_type::internal_non_blocking;
+    }
+
+    // Start the connect operation. The socket is already marked as non-blocking
+    // so the connection will take place asynchronously.
+    if (socket_ops::connect(impl.socket_, peer_endpoint.data(),
+          peer_endpoint.size()) == 0)
+    {
+      // The connect operation has finished successfully so we need to post the
+      // handler immediately.
+      boost::asio::error error(boost::asio::error::success);
+      owner().post(bind_handler(handler, error));
+    }
+    else if (socket_ops::get_error() == boost::asio::error::in_progress
+        || socket_ops::get_error() == boost::asio::error::would_block)
+    {
+      // The connection is happening in the background, and we need to wait
+      // until the socket becomes writeable.
+      boost::shared_ptr<bool> completed(new bool(false));
+      reactor_.start_write_and_except_ops(impl.socket_,
+          connect_handler<Handler>(
+            impl.socket_, completed, owner(), reactor_, handler));
+    }
+    else
+    {
+      // The connect operation has failed, so post the handler immediately.
+      boost::asio::error error(socket_ops::get_error());
+      owner().post(bind_handler(handler, error));
+    }
+  }
+
+private:
+  // The selector that performs event demultiplexing for the provider.
+  Reactor& reactor_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
diff --git a/include/boost/asio/detail/reactor_op_queue.hpp b/include/boost/asio/detail/reactor_op_queue.hpp
new file mode 100644
index 0000000000..bd22af3fe0
--- /dev/null
+++ b/include/boost/asio/detail/reactor_op_queue.hpp
@@ -0,0 +1,381 @@
+//
+// reactor_op_queue.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
+#define BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <memory>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/detail/hash_map.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Descriptor>
+class reactor_op_queue
+  : private noncopyable
+{
+public:
+  // Constructor.
+  reactor_op_queue()
+    : operations_(),
+      cancelled_operations_(0),
+      cleanup_operations_(0)
+  {
+  }
+
+  // Add a new operation to the queue. Returns true if this is the only
+  // operation for the given descriptor, in which case the reactor's event
+  // demultiplexing function call may need to be interrupted and restarted.
+  template <typename Handler>
+  bool enqueue_operation(Descriptor descriptor, Handler handler)
+  {
+    op_base* new_op = new op<Handler>(descriptor, handler);
+
+    typedef typename operation_map::iterator iterator;
+    typedef typename operation_map::value_type value_type;
+    std::pair<iterator, bool> entry =
+      operations_.insert(value_type(descriptor, new_op));
+    if (entry.second)
+      return true;
+
+    op_base* current_op = entry.first->second;
+    while (current_op->next_)
+      current_op = current_op->next_;
+    current_op->next_ = new_op;
+
+    return false;
+  }
+
+  // Cancel all operations associated with the descriptor. Any operations
+  // pending for the descriptor will be notified that they have been cancelled
+  // next time dispatch_cancellations is called. Returns true if any operations
+  // were cancelled, in which case the reactor's event demultiplexing function
+  // may need to be interrupted and restarted.
+  bool cancel_operations(Descriptor descriptor)
+  {
+    typename operation_map::iterator i = operations_.find(descriptor);
+    if (i != operations_.end())
+    {
+      op_base* last_op = i->second;
+      while (last_op->next_)
+        last_op = last_op->next_;
+      last_op->next_ = cancelled_operations_;
+      cancelled_operations_ = i->second;
+      operations_.erase(i);
+      return true;
+    }
+
+    return false;
+  }
+
+  // Whether there are no operations in the queue.
+  bool empty() const
+  {
+    return operations_.empty();
+  }
+
+  // Determine whether there are any operations associated with the descriptor.
+  bool has_operation(Descriptor descriptor) const
+  {
+    return operations_.find(descriptor) != operations_.end();
+  }
+
+  // Dispatch the first operation corresponding to the descriptor. Returns true
+  // if there are more operations queued for the descriptor.
+  bool dispatch_operation(Descriptor descriptor, int result)
+  {
+    typename operation_map::iterator i = operations_.find(descriptor);
+    if (i != operations_.end())
+    {
+      op_base* this_op = i->second;
+      i->second = this_op->next_;
+      this_op->next_ = cleanup_operations_;
+      cleanup_operations_ = this_op;
+      bool done = this_op->invoke(result);
+      if (done)
+      {
+        // Operation has finished.
+        if (i->second)
+        {
+          return true;
+        }
+        else
+        {
+          operations_.erase(i);
+          return false;
+        }
+      }
+      else
+      {
+        // Operation wants to be called again. Leave it at the front of the
+        // queue for this descriptor, and remove from the cleanup list.
+        cleanup_operations_ = this_op->next_;
+        this_op->next_ = i->second;
+        i->second = this_op;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Dispatch all operations corresponding to the descriptor.
+  void dispatch_all_operations(Descriptor descriptor, int result)
+  {
+    typename operation_map::iterator i = operations_.find(descriptor);
+    if (i != operations_.end())
+    {
+      while (i->second)
+      {
+        op_base* this_op = i->second;
+        i->second = this_op->next_;
+        this_op->next_ = cleanup_operations_;
+        cleanup_operations_ = this_op;
+        bool done = i->second->invoke(result);
+        if (!done)
+        {
+          // Operation has not finished yet, so leave at front of queue, and
+          // remove from the cleanup list.
+          cleanup_operations_ = this_op->next_;
+          this_op->next_ = i->second;
+          i->second = this_op;
+          return;
+        }
+        operations_.erase(i);
+      }
+    }
+  }
+
+  // Fill a descriptor set with the descriptors corresponding to each active
+  // operation.
+  template <typename Descriptor_Set>
+  void get_descriptors(Descriptor_Set& descriptors)
+  {
+    typename operation_map::iterator i = operations_.begin();
+    while (i != operations_.end())
+    {
+      descriptors.set(i->first);
+      ++i;
+    }
+  }
+
+  // Dispatch the operations corresponding to the ready file descriptors
+  // contained in the given descriptor set.
+  template <typename Descriptor_Set>
+  void dispatch_descriptors(const Descriptor_Set& descriptors, int result)
+  {
+    typename operation_map::iterator i = operations_.begin();
+    while (i != operations_.end())
+    {
+      typename operation_map::iterator op_iter = i++;
+      if (descriptors.is_set(op_iter->first))
+      {
+        op_base* this_op = op_iter->second;
+        op_iter->second = this_op->next_;
+        this_op->next_ = cleanup_operations_;
+        cleanup_operations_ = this_op;
+        bool done = this_op->invoke(result);
+        if (done)
+        {
+          if (!op_iter->second)
+            operations_.erase(op_iter);
+        }
+        else
+        {
+          // Operation has not finished yet, so leave at front of queue, and
+          // remove from the cleanup list.
+          cleanup_operations_ = this_op->next_;
+          this_op->next_ = op_iter->second;
+          op_iter->second = this_op;
+        }
+      }
+    }
+  }
+
+  // Dispatch any pending cancels for operations.
+  void dispatch_cancellations()
+  {
+    while (cancelled_operations_)
+    {
+      op_base* this_op = cancelled_operations_;
+      cancelled_operations_ = this_op->next_;
+      this_op->next_ = cleanup_operations_;
+      cleanup_operations_ = this_op;
+      this_op->invoke(boost::asio::error::operation_aborted);
+    }
+  }
+
+  // Destroy operations that are waiting to be cleaned up.
+  void cleanup_operations()
+  {
+    while (cleanup_operations_)
+    {
+      op_base* next_op = cleanup_operations_->next_;
+      cleanup_operations_->next_ = 0;
+      cleanup_operations_->destroy();
+      cleanup_operations_ = next_op;
+    }
+  }
+
+  // Destroy all operations owned by the queue.
+  void destroy_operations()
+  {
+    while (cancelled_operations_)
+    {
+      op_base* next_op = cancelled_operations_->next_;
+      cancelled_operations_->next_ = 0;
+      cancelled_operations_->destroy();
+      cancelled_operations_ = next_op;
+    }
+
+    while (cleanup_operations_)
+    {
+      op_base* next_op = cleanup_operations_->next_;
+      cleanup_operations_->next_ = 0;
+      cleanup_operations_->destroy();
+      cleanup_operations_ = next_op;
+    }
+
+    typename operation_map::iterator i = operations_.begin();
+    while (i != operations_.end())
+    {
+      typename operation_map::iterator op_iter = i++;
+      op_base* curr_op = op_iter->second;
+      operations_.erase(op_iter);
+      while (curr_op)
+      {
+        op_base* next_op = curr_op->next_;
+        curr_op->next_ = 0;
+        curr_op->destroy();
+        curr_op = next_op;
+      }
+    }
+  }
+
+private:
+  // Base class for reactor operations. A function pointer is used instead of
+  // virtual functions to avoid the associated overhead.
+  class op_base
+  {
+  public:
+    // Get the descriptor associated with the operation.
+    Descriptor descriptor() const
+    {
+      return descriptor_;
+    }
+
+    // Perform the operation.
+    bool invoke(int result)
+    {
+      return invoke_func_(this, result);
+    }
+
+    // Destroy the operation.
+    void destroy()
+    {
+      return destroy_func_(this);
+    }
+
+  protected:
+    typedef bool (*invoke_func_type)(op_base*, int);
+    typedef void (*destroy_func_type)(op_base*);
+
+    // Construct an operation for the given descriptor.
+    op_base(invoke_func_type invoke_func,
+        destroy_func_type destroy_func, Descriptor descriptor)
+      : invoke_func_(invoke_func),
+        destroy_func_(destroy_func),
+        descriptor_(descriptor),
+        next_(0)
+    {
+    }
+
+    // Prevent deletion through this type.
+    ~op_base()
+    {
+    }
+
+  private:
+    friend class reactor_op_queue<Descriptor>;
+
+    // The function to be called to dispatch the handler.
+    invoke_func_type invoke_func_;
+
+    // The function to be called to delete the handler.
+    destroy_func_type destroy_func_;
+
+    // The descriptor associated with the operation.
+    Descriptor descriptor_;
+
+    // The next operation for the same file descriptor.
+    op_base* next_;
+  };
+
+  // Adaptor class template for using handlers in operations.
+  template <typename Handler>
+  class op
+    : public op_base
+  {
+  public:
+    // Constructor.
+    op(Descriptor descriptor, Handler handler)
+      : op_base(&op<Handler>::invoke_handler,
+          &op<Handler>::destroy_handler, descriptor),
+        handler_(handler)
+    {
+    }
+
+    // Invoke the handler.
+    static bool invoke_handler(op_base* base, int result)
+    {
+      return static_cast<op<Handler>*>(base)->handler_(result);
+    }
+
+    // Delete the handler.
+    static void destroy_handler(op_base* base)
+    {
+      delete static_cast<op<Handler>*>(base);
+    }
+
+  private:
+    Handler handler_;
+  };
+
+  // The type for a map of operations.
+  typedef hash_map<Descriptor, op_base*> operation_map;
+
+  // The operations that are currently executing asynchronously.
+  operation_map operations_;
+
+  // The list of operations that have been cancelled.
+  op_base* cancelled_operations_;
+
+  // The list of operations to be destroyed.
+  op_base* cleanup_operations_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
diff --git a/include/boost/asio/detail/reactor_timer_queue.hpp b/include/boost/asio/detail/reactor_timer_queue.hpp
new file mode 100644
index 0000000000..38c5eac819
--- /dev/null
+++ b/include/boost/asio/detail/reactor_timer_queue.hpp
@@ -0,0 +1,340 @@
+//
+// reactor_timer_queue.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_REACTOR_TIMER_QUEUE_HPP
+#define BOOST_ASIO_DETAIL_REACTOR_TIMER_QUEUE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <vector>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/detail/hash_map.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Time, typename Comparator = std::less<Time> >
+class reactor_timer_queue
+  : private noncopyable
+{
+public:
+  // Constructor.
+  reactor_timer_queue()
+    : timers_(),
+      heap_()
+  {
+  }
+
+  // Add a new timer to the queue. Returns true if this is the timer that is
+  // earliest in the queue, in which case the reactor's event demultiplexing
+  // function call may need to be interrupted and restarted.
+  template <typename Handler>
+  bool enqueue_timer(const Time& time, Handler handler, void* token)
+  {
+    // Ensure that there is space for the timer in the heap. We reserve here so
+    // that the push_back below will not throw due to a reallocation failure.
+    heap_.reserve(heap_.size() + 1);
+
+    // Create a new timer object.
+    std::auto_ptr<timer<Handler> > new_timer(
+        new timer<Handler>(time, handler, token));
+
+    // Insert the new timer into the hash.
+    typedef typename hash_map<void*, timer_base*>::iterator iterator;
+    typedef typename hash_map<void*, timer_base*>::value_type value_type;
+    std::pair<iterator, bool> result =
+      timers_.insert(value_type(token, new_timer.get()));
+    if (!result.second)
+    {
+      result.first->second->prev_ = new_timer.get();
+      new_timer->next_ = result.first->second;
+      result.first->second = new_timer.get();
+    }
+
+    // Put the timer at the correct position in the heap.
+    new_timer->heap_index_ = heap_.size();
+    heap_.push_back(new_timer.get());
+    up_heap(heap_.size() - 1);
+    bool is_first = (heap_[0] == new_timer.get());
+
+    // Ownership of the timer is transferred to the timer queue.
+    new_timer.release();
+
+    return is_first;
+  }
+
+  // Whether there are no timers in the queue.
+  bool empty() const
+  {
+    return heap_.empty();
+  }
+
+  // Get the time for the timer that is earliest in the queue.
+  void get_earliest_time(Time& time)
+  {
+    time = heap_[0]->time_;
+  }
+
+  // Dispatch the timers that are earlier than the specified time.
+  void dispatch_timers(const Time& time)
+  {
+    Comparator comp;
+    while (!heap_.empty() && !comp(time, heap_[0]->time_))
+    {
+      timer_base* t = heap_[0];
+      remove_timer(t);
+      t->invoke(0);
+    }
+  }
+
+  // Cancel the timer with the given token. The handler will be invoked
+  // immediately with the result operation_aborted.
+  std::size_t cancel_timer(void* timer_token)
+  {
+    std::size_t num_cancelled = 0;
+    typedef typename hash_map<void*, timer_base*>::iterator iterator;
+    iterator it = timers_.find(timer_token);
+    if (it != timers_.end())
+    {
+      timer_base* t = it->second;
+      while (t)
+      {
+        timer_base* next = t->next_;
+        remove_timer(t);
+        t->invoke(boost::asio::error::operation_aborted);
+        t = next;
+        ++num_cancelled;
+      }
+    }
+    return num_cancelled;
+  }
+
+  // Destroy all timers.
+  void destroy_timers()
+  {
+    typename hash_map<void*, timer_base*>::iterator i = timers_.begin();
+    typename hash_map<void*, timer_base*>::iterator end = timers_.end();
+    while (i != end)
+    {
+      timer_base* t = i->second;
+      typename hash_map<void*, timer_base*>::iterator old_i = i++;
+      timers_.erase(old_i);
+      t->destroy();
+    }
+    heap_.clear();
+    timers_.clear();
+  }
+
+private:
+  // Base class for timer operations. Function pointers are used instead of
+  // virtual functions to avoid the associated overhead.
+  class timer_base
+  {
+  public:
+    // Perform the timer operation and then destroy.
+    void invoke(int result)
+    {
+      invoke_func_(this, result);
+    }
+
+    // Destroy the timer operation.
+    void destroy()
+    {
+      destroy_func_(this);
+    }
+
+  protected:
+    typedef void (*invoke_func_type)(timer_base*, int);
+    typedef void (*destroy_func_type)(timer_base*);
+
+    // Constructor.
+    timer_base(invoke_func_type invoke_func, destroy_func_type destroy_func,
+        const Time& time, void* token)
+      : invoke_func_(invoke_func),
+        destroy_func_(destroy_func),
+        time_(time),
+        token_(token),
+        next_(0),
+        prev_(0),
+        heap_index_(
+            std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION())
+    {
+    }
+
+    // Prevent deletion through this type.
+    ~timer_base()
+    {
+    }
+
+  private:
+    friend class reactor_timer_queue<Time, Comparator>;
+
+    // The function to be called to dispatch the handler.
+    invoke_func_type invoke_func_;
+
+    // The function to be called to destroy the handler.
+    destroy_func_type destroy_func_;
+
+    // The time when the operation should fire.
+    Time time_;
+
+    // The token associated with the timer.
+    void* token_;
+
+    // The next timer known to the queue.
+    timer_base* next_;
+
+    // The previous timer known to the queue.
+    timer_base* prev_;
+
+    // The index of the timer in the heap.
+    size_t heap_index_;
+  };
+
+  // Adaptor class template for using handlers in timers.
+  template <typename Handler>
+  class timer
+    : public timer_base
+  {
+  public:
+    // Constructor.
+    timer(const Time& time, Handler handler, void* token)
+      : timer_base(&timer<Handler>::invoke_handler,
+          &timer<Handler>::destroy_handler, time, token),
+        handler_(handler)
+    {
+    }
+
+    // Invoke the handler and then destroy it.
+    static void invoke_handler(timer_base* base, int result)
+    {
+      std::auto_ptr<timer<Handler> > t(static_cast<timer<Handler>*>(base));
+      t->handler_(result);
+    }
+
+    // Destroy the handler.
+    static void destroy_handler(timer_base* base)
+    {
+      delete static_cast<timer<Handler>*>(base);
+    }
+
+  private:
+    Handler handler_;
+  };
+
+  // Move the item at the given index up the heap to its correct position.
+  void up_heap(size_t index)
+  {
+    Comparator comp;
+    size_t parent = (index - 1) / 2;
+    while (index > 0 && comp(heap_[index]->time_, heap_[parent]->time_))
+    {
+      swap_heap(index, parent);
+      index = parent;
+      parent = (index - 1) / 2;
+    }
+  }
+
+  // Move the item at the given index down the heap to its correct position.
+  void down_heap(size_t index)
+  {
+    Comparator comp;
+    size_t child = index * 2 + 1;
+    while (child < heap_.size())
+    {
+      size_t min_child = (child + 1 == heap_.size()
+          || comp(heap_[child]->time_, heap_[child + 1]->time_))
+        ? child : child + 1;
+      if (comp(heap_[index]->time_, heap_[min_child]->time_))
+        break;
+      swap_heap(index, min_child);
+      index = min_child;
+      child = index * 2 + 1;
+    }
+  }
+
+  // Swap two entries in the heap.
+  void swap_heap(size_t index1, size_t index2)
+  {
+    timer_base* tmp = heap_[index1];
+    heap_[index1] = heap_[index2];
+    heap_[index2] = tmp;
+    heap_[index1]->heap_index_ = index1;
+    heap_[index2]->heap_index_ = index2;
+  }
+
+  // Remove a timer from the heap and list of timers.
+  void remove_timer(timer_base* t)
+  {
+    // Remove the timer from the heap.
+    size_t index = t->heap_index_;
+    if (!heap_.empty() && index < heap_.size())
+    {
+      if (index == heap_.size() - 1)
+      {
+        heap_.pop_back();
+      }
+      else
+      {
+        swap_heap(index, heap_.size() - 1);
+        heap_.pop_back();
+        Comparator comp;
+        size_t parent = (index - 1) / 2;
+        if (index > 0 && comp(t->time_, heap_[parent]->time_))
+          up_heap(index);
+        else
+          down_heap(index);
+      }
+    }
+
+    // Remove the timer from the hash.
+    typedef typename hash_map<void*, timer_base*>::iterator iterator;
+    iterator it = timers_.find(t->token_);
+    if (it != timers_.end())
+    {
+      if (it->second == t)
+        it->second = t->next_;
+      if (t->prev_)
+        t->prev_->next_ = t->next_;
+      if (t->next_)
+        t->next_->prev_ = t->prev_;
+      if (it->second == 0)
+        timers_.erase(it);
+    }
+  }
+
+  // A hash of timer token to linked lists of timers.
+  hash_map<void*, timer_base*> timers_;
+
+  // The heap of timers, with the earliest timer at the front.
+  std::vector<timer_base*> heap_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_REACTOR_TIMER_QUEUE_HPP
diff --git a/include/boost/asio/detail/resolver_service.hpp b/include/boost/asio/detail/resolver_service.hpp
new file mode 100644
index 0000000000..5935e1dce3
--- /dev/null
+++ b/include/boost/asio/detail/resolver_service.hpp
@@ -0,0 +1,363 @@
+//
+// resolver_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstring>
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/thread.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class resolver_service
+  : public boost::asio::io_service::service
+{
+private:
+  // Helper class to perform exception-safe cleanup of addrinfo objects.
+  class auto_addrinfo
+    : private boost::asio::detail::noncopyable
+  {
+  public:
+    explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
+      : ai_(ai)
+    {
+    }
+
+    ~auto_addrinfo()
+    {
+      if (ai_)
+        socket_ops::freeaddrinfo(ai_);
+    }
+
+    operator boost::asio::detail::addrinfo_type*()
+    {
+      return ai_;
+    }
+
+  private:
+    boost::asio::detail::addrinfo_type* ai_;
+  };
+
+public:
+  // The implementation type of the resolver. The shared pointer is used as a
+  // cancellation token to indicate to the background thread that the operation
+  // has been cancelled.
+  typedef boost::shared_ptr<void> implementation_type;
+  struct noop_deleter { void operator()(void*) {} };
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // The query type.
+  typedef typename Protocol::resolver_query query_type;
+
+  // The iterator type.
+  typedef typename Protocol::resolver_iterator iterator_type;
+
+  // Constructor.
+  resolver_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      mutex_(),
+      work_io_service_(new boost::asio::io_service),
+      work_(new boost::asio::io_service::work(*work_io_service_)),
+      work_thread_(0)
+  {
+  }
+
+  // Destructor.
+  ~resolver_service()
+  {
+    shutdown_service();
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    work_.reset();
+    if (work_io_service_)
+    {
+      work_io_service_->interrupt();
+      if (work_thread_)
+      {
+        work_thread_->join();
+        work_thread_.reset();
+      }
+      work_io_service_.reset();
+    }
+  }
+
+  // Construct a new resolver implementation.
+  void construct(implementation_type& impl)
+  {
+    impl.reset(static_cast<void*>(0), noop_deleter());
+  }
+
+  // Destroy a resolver implementation.
+  void destroy(implementation_type&)
+  {
+  }
+
+  // Cancel pending asynchronous operations.
+  void cancel(implementation_type& impl)
+  {
+    impl.reset(static_cast<void*>(0), noop_deleter());
+  }
+
+  // Resolve a query to a list of entries.
+  template <typename Error_Handler>
+  iterator_type resolve(implementation_type&, const query_type& query,
+      Error_Handler error_handler)
+  {
+    boost::asio::detail::addrinfo_type* address_info = 0;
+    std::string host_name = query.host_name();
+    std::string service_name = query.service_name();
+    boost::asio::detail::addrinfo_type hints = query.hints();
+
+    int result = socket_ops::getaddrinfo(
+        host_name.length() ? host_name.c_str() : 0,
+        service_name.c_str(), &hints, &address_info);
+    auto_addrinfo auto_address_info(address_info);
+
+    error_handler(boost::asio::error(result));
+    if (result != 0)
+      return iterator_type();
+    return iterator_type::create(address_info, host_name, service_name);
+  }
+
+  template <typename Handler>
+  class resolve_query_handler
+  {
+  public:
+    resolve_query_handler(implementation_type impl, const query_type& query,
+        boost::asio::io_service& io_service, Handler handler)
+      : impl_(impl),
+        query_(query),
+        io_service_(io_service),
+        work_(io_service),
+        handler_(handler)
+    {
+    }
+
+    void operator()()
+    {
+      // Check if the operation has been cancelled.
+      if (impl_.expired())
+      {
+        iterator_type iterator;
+        io_service_.post(boost::asio::detail::bind_handler(handler_,
+              boost::asio::error(boost::asio::error::operation_aborted),
+              iterator));
+        return;
+      }
+
+      // Perform the blocking host resolution operation.
+      boost::asio::detail::addrinfo_type* address_info = 0;
+      std::string host_name = query_.host_name();
+      std::string service_name = query_.service_name();
+      boost::asio::detail::addrinfo_type hints = query_.hints();
+      int result = socket_ops::getaddrinfo(
+          host_name.length() ? host_name.c_str() : 0,
+          service_name.c_str(), &hints, &address_info);
+      auto_addrinfo auto_address_info(address_info);
+
+      // Invoke the handler and pass the result.
+      boost::asio::error e(result);
+      iterator_type iterator;
+      if (result == 0)
+        iterator = iterator_type::create(address_info, host_name, service_name);
+      io_service_.post(boost::asio::detail::bind_handler(
+            handler_, e, iterator));
+    }
+
+  private:
+    boost::weak_ptr<void> impl_;
+    query_type query_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Handler handler_;
+  };
+
+  // Asynchronously resolve a query to a list of entries.
+  template <typename Handler>
+  void async_resolve(implementation_type& impl, const query_type& query,
+      Handler handler)
+  {
+    if (work_io_service_)
+    {
+      start_work_thread();
+      work_io_service_->post(
+          resolve_query_handler<Handler>(
+            impl, query, owner(), handler));
+    }
+  }
+
+  // Resolve an endpoint to a list of entries.
+  template <typename Error_Handler>
+  iterator_type resolve(implementation_type&,
+      const endpoint_type& endpoint, Error_Handler error_handler)
+  {
+    // First try resolving with the service name. If that fails try resolving
+    // but allow the service to be returned as a number.
+    char host_name[NI_MAXHOST];
+    char service_name[NI_MAXSERV];
+    int flags = endpoint.protocol().type() == SOCK_DGRAM ? NI_DGRAM : 0;
+    int result = socket_ops::getnameinfo(endpoint.data(), endpoint.size(),
+        host_name, NI_MAXHOST, service_name, NI_MAXSERV, flags);
+    if (result)
+    {
+      flags |= NI_NUMERICSERV;
+      result = socket_ops::getnameinfo(endpoint.data(), endpoint.size(),
+          host_name, NI_MAXHOST, service_name, NI_MAXSERV, flags);
+    }
+
+    error_handler(boost::asio::error(result));
+    if (result != 0)
+      return iterator_type();
+    return iterator_type::create(endpoint, host_name, service_name);
+  }
+
+  template <typename Handler>
+  class resolve_endpoint_handler
+  {
+  public:
+    resolve_endpoint_handler(implementation_type impl,
+        const endpoint_type& endpoint, boost::asio::io_service& io_service,
+        Handler handler)
+      : impl_(impl),
+        endpoint_(endpoint),
+        io_service_(io_service),
+        work_(io_service),
+        handler_(handler)
+    {
+    }
+
+    void operator()()
+    {
+      // Check if the operation has been cancelled.
+      if (impl_.expired())
+      {
+        iterator_type iterator;
+        io_service_.post(boost::asio::detail::bind_handler(handler_,
+              boost::asio::error(boost::asio::error::operation_aborted),
+              iterator));
+        return;
+      }
+
+
+      // First try resolving with the service name. If that fails try resolving
+      // but allow the service to be returned as a number.
+      char host_name[NI_MAXHOST];
+      char service_name[NI_MAXSERV];
+      int flags = endpoint_.protocol().type() == SOCK_DGRAM ? NI_DGRAM : 0;
+      int result = socket_ops::getnameinfo(endpoint_.data(), endpoint_.size(),
+          host_name, NI_MAXHOST, service_name, NI_MAXSERV, flags);
+      if (result)
+      {
+        flags |= NI_NUMERICSERV;
+        result = socket_ops::getnameinfo(endpoint_.data(), endpoint_.size(),
+            host_name, NI_MAXHOST, service_name, NI_MAXSERV, flags);
+      }
+
+      // Invoke the handler and pass the result.
+      boost::asio::error e(result);
+      iterator_type iterator;
+      if (result == 0)
+        iterator = iterator_type::create(endpoint_, host_name, service_name);
+      io_service_.post(boost::asio::detail::bind_handler(
+            handler_, e, iterator));
+    }
+
+  private:
+    boost::weak_ptr<void> impl_;
+    endpoint_type endpoint_;
+    boost::asio::io_service& io_service_;
+    boost::asio::io_service::work work_;
+    Handler handler_;
+  };
+
+  // Asynchronously resolve an endpoint to a list of entries.
+  template <typename Handler>
+  void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
+      Handler handler)
+  {
+    if (work_io_service_)
+    {
+      start_work_thread();
+      work_io_service_->post(
+          resolve_endpoint_handler<Handler>(
+            impl, endpoint, owner(), handler));
+    }
+  }
+
+private:
+  // Helper class to run the work io_service in a thread.
+  class work_io_service_runner
+  {
+  public:
+    work_io_service_runner(boost::asio::io_service& io_service)
+      : io_service_(io_service) {}
+    void operator()() { io_service_.run(); }
+  private:
+    boost::asio::io_service& io_service_;
+  };
+
+  // Start the work thread if it's not already running.
+  void start_work_thread()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (work_thread_ == 0)
+    {
+      work_thread_.reset(new boost::asio::detail::thread(
+            work_io_service_runner(*work_io_service_)));
+    }
+  }
+
+  // Mutex to protect access to internal data.
+  boost::asio::detail::mutex mutex_;
+
+  // Private io_service used for performing asynchronous host resolution.
+  boost::scoped_ptr<boost::asio::io_service> work_io_service_;
+
+  // Work for the private io_service to perform.
+  boost::scoped_ptr<boost::asio::io_service::work> work_;
+
+  // Thread used for running the work io_service's run loop.
+  boost::scoped_ptr<boost::asio::detail::thread> work_thread_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
diff --git a/include/boost/asio/detail/scoped_lock.hpp b/include/boost/asio/detail/scoped_lock.hpp
new file mode 100644
index 0000000000..452cad170f
--- /dev/null
+++ b/include/boost/asio/detail/scoped_lock.hpp
@@ -0,0 +1,81 @@
+//
+// scoped_lock.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
+#define BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Helper class to lock and unlock a mutex automatically.
+template <typename Mutex>
+class scoped_lock
+  : private noncopyable
+{
+public:
+  // Constructor acquires the lock.
+  scoped_lock(Mutex& m)
+    : mutex_(m)
+  {
+    mutex_.lock();
+    locked_ = true;
+  }
+
+  // Destructor releases the lock.
+  ~scoped_lock()
+  {
+    if (locked_)
+      mutex_.unlock();
+  }
+
+  // Explicitly acquire the lock.
+  void lock()
+  {
+    if (!locked_)
+    {
+      mutex_.lock();
+      locked_ = true;
+    }
+  }
+
+  // Explicitly release the lock.
+  void unlock()
+  {
+    if (locked_)
+    {
+      mutex_.unlock();
+      locked_ = false;
+    }
+  }
+
+private:
+  // The underlying mutex.
+  Mutex& mutex_;
+
+  // Whether the mutex is currently locked or unlocked.
+  bool locked_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
diff --git a/include/boost/asio/detail/select_interrupter.hpp b/include/boost/asio/detail/select_interrupter.hpp
new file mode 100644
index 0000000000..d36a295d7a
--- /dev/null
+++ b/include/boost/asio/detail/select_interrupter.hpp
@@ -0,0 +1,43 @@
+//
+// select_interrupter.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
+#define BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/pipe_select_interrupter.hpp>
+#include <boost/asio/detail/socket_select_interrupter.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+typedef socket_select_interrupter select_interrupter;
+#else
+typedef pipe_select_interrupter select_interrupter;
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
diff --git a/include/boost/asio/detail/select_reactor.hpp b/include/boost/asio/detail/select_reactor.hpp
new file mode 100644
index 0000000000..7d6e398d82
--- /dev/null
+++ b/include/boost/asio/detail/select_reactor.hpp
@@ -0,0 +1,408 @@
+//
+// select_reactor.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP
+#define BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp> // Must come before posix_time.
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <vector>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fd_set_adapter.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/task_io_service.hpp>
+#include <boost/asio/detail/thread.hpp>
+#include <boost/asio/detail/reactor_op_queue.hpp>
+#include <boost/asio/detail/reactor_timer_queue.hpp>
+#include <boost/asio/detail/select_interrupter.hpp>
+#include <boost/asio/detail/select_reactor_fwd.hpp>
+#include <boost/asio/detail/signal_blocker.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <bool Own_Thread>
+class select_reactor
+  : public boost::asio::io_service::service
+{
+public:
+  // Constructor.
+  select_reactor(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      mutex_(),
+      select_in_progress_(false),
+      interrupter_(),
+      read_op_queue_(),
+      write_op_queue_(),
+      except_op_queue_(),
+      pending_cancellations_(),
+      stop_thread_(false),
+      thread_(0),
+      shutdown_(false)
+  {
+    if (Own_Thread)
+    {
+      boost::asio::detail::signal_blocker sb;
+      thread_ = new boost::asio::detail::thread(
+          bind_handler(&select_reactor::call_run_thread, this));
+    }
+  }
+
+  // Destructor.
+  ~select_reactor()
+  {
+    shutdown_service();
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    shutdown_ = true;
+    stop_thread_ = true;
+    lock.unlock();
+
+    if (thread_)
+    {
+      interrupter_.interrupt();
+      thread_->join();
+      delete thread_;
+      thread_ = 0;
+    }
+
+    read_op_queue_.destroy_operations();
+    write_op_queue_.destroy_operations();
+    except_op_queue_.destroy_operations();
+    timer_queue_.destroy_timers();
+  }
+
+  // Register a socket with the reactor. Returns 0 on success, system error
+  // code on failure.
+  int register_descriptor(socket_type descriptor)
+  {
+    return 0;
+  }
+
+  // Start a new read operation. The handler object will be invoked when the
+  // given descriptor is ready to be read, or an error has occurred.
+  template <typename Handler>
+  void start_read_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+      if (read_op_queue_.enqueue_operation(descriptor, handler))
+        interrupter_.interrupt();
+  }
+
+  // Start a new write operation. The handler object will be invoked when the
+  // given descriptor is ready to be written, or an error has occurred.
+  template <typename Handler>
+  void start_write_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+      if (write_op_queue_.enqueue_operation(descriptor, handler))
+        interrupter_.interrupt();
+  }
+
+  // Start a new exception operation. The handler object will be invoked when
+  // the given descriptor has exception information, or an error has occurred.
+  template <typename Handler>
+  void start_except_op(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+      if (except_op_queue_.enqueue_operation(descriptor, handler))
+        interrupter_.interrupt();
+  }
+
+  // Start new write and exception operations. The handler object will be
+  // invoked when the given descriptor is ready for writing or has exception
+  // information available, or an error has occurred.
+  template <typename Handler>
+  void start_write_and_except_ops(socket_type descriptor, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+    {
+      bool interrupt = write_op_queue_.enqueue_operation(descriptor, handler);
+      interrupt = except_op_queue_.enqueue_operation(descriptor, handler)
+        || interrupt;
+      if (interrupt)
+        interrupter_.interrupt();
+    }
+  }
+
+  // Cancel all operations associated with the given descriptor. The
+  // handlers associated with the descriptor will be invoked with the
+  // operation_aborted error.
+  void cancel_ops(socket_type descriptor)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    cancel_ops_unlocked(descriptor);
+  }
+
+  // Enqueue cancellation of all operations associated with the given
+  // descriptor. The handlers associated with the descriptor will be invoked
+  // with the operation_aborted error. This function does not acquire the
+  // select_reactor's mutex, and so should only be used from within a reactor
+  // handler.
+  void enqueue_cancel_ops_unlocked(socket_type descriptor)
+  {
+    pending_cancellations_.push_back(descriptor);
+  }
+
+  // Cancel any operations that are running against the descriptor and remove
+  // its registration from the reactor.
+  void close_descriptor(socket_type descriptor)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    cancel_ops_unlocked(descriptor);
+  }
+
+  // Schedule a timer to expire at the specified absolute time. The handler
+  // object will be invoked when the timer expires.
+  template <typename Handler>
+  void schedule_timer(const boost::posix_time::ptime& time,
+      Handler handler, void* token)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (!shutdown_)
+      if (timer_queue_.enqueue_timer(time, handler, token))
+        interrupter_.interrupt();
+  }
+
+  // Cancel the timer associated with the given token. Returns the number of
+  // handlers that have been posted or dispatched.
+  std::size_t cancel_timer(void* token)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    return timer_queue_.cancel_timer(token);
+  }
+
+private:
+  friend class task_io_service<select_reactor<Own_Thread> >;
+
+  // Run select once until interrupted or events are ready to be dispatched.
+  void run(bool block)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // Dispatch any operation cancellations that were made while the select
+    // loop was not running.
+    read_op_queue_.dispatch_cancellations();
+    write_op_queue_.dispatch_cancellations();
+    except_op_queue_.dispatch_cancellations();
+
+    // Check if the thread is supposed to stop.
+    if (stop_thread_)
+    {
+      // Clean up operations. We must not hold the lock since the operations may
+      // make calls back into this reactor.
+      lock.unlock();
+      read_op_queue_.cleanup_operations();
+      write_op_queue_.cleanup_operations();
+      except_op_queue_.cleanup_operations();
+      return;
+    }
+
+    // We can return immediately if there's no work to do and the reactor is
+    // not supposed to block.
+    if (!block && read_op_queue_.empty() && write_op_queue_.empty()
+        && except_op_queue_.empty() && timer_queue_.empty())
+    {
+      // Clean up operations. We must not hold the lock since the operations may
+      // make calls back into this reactor.
+      lock.unlock();
+      read_op_queue_.cleanup_operations();
+      write_op_queue_.cleanup_operations();
+      except_op_queue_.cleanup_operations();
+      return;
+    }
+
+    // Set up the descriptor sets.
+    fd_set_adapter read_fds;
+    read_fds.set(interrupter_.read_descriptor());
+    read_op_queue_.get_descriptors(read_fds);
+    fd_set_adapter write_fds;
+    write_op_queue_.get_descriptors(write_fds);
+    fd_set_adapter except_fds;
+    except_op_queue_.get_descriptors(except_fds);
+    socket_type max_fd = read_fds.max_descriptor();
+    if (write_fds.max_descriptor() > max_fd)
+      max_fd = write_fds.max_descriptor();
+    if (except_fds.max_descriptor() > max_fd)
+      max_fd = except_fds.max_descriptor();
+
+    // Block on the select call without holding the lock so that new
+    // operations can be started while the call is executing.
+    timeval tv_buf = { 0, 0 };
+    timeval* tv = block ? get_timeout(tv_buf) : &tv_buf;
+    select_in_progress_ = true;
+    lock.unlock();
+    int retval = socket_ops::select(static_cast<int>(max_fd + 1),
+        read_fds, write_fds, except_fds, tv);
+    lock.lock();
+    select_in_progress_ = false;
+
+    // Block signals while dispatching operations.
+    boost::asio::detail::signal_blocker sb;
+
+    // Reset the interrupter.
+    if (retval > 0 && read_fds.is_set(interrupter_.read_descriptor()))
+      interrupter_.reset();
+
+    // Dispatch all ready operations.
+    if (retval > 0)
+    {
+      // Exception operations must be processed first to ensure that any
+      // out-of-band data is read before normal data.
+      except_op_queue_.dispatch_descriptors(except_fds, 0);
+      read_op_queue_.dispatch_descriptors(read_fds, 0);
+      write_op_queue_.dispatch_descriptors(write_fds, 0);
+      except_op_queue_.dispatch_cancellations();
+      read_op_queue_.dispatch_cancellations();
+      write_op_queue_.dispatch_cancellations();
+    }
+    timer_queue_.dispatch_timers(
+        boost::posix_time::microsec_clock::universal_time());
+
+    // Issue any pending cancellations.
+    for (size_t i = 0; i < pending_cancellations_.size(); ++i)
+      cancel_ops_unlocked(pending_cancellations_[i]);
+    pending_cancellations_.clear();
+
+    // Clean up operations. We must not hold the lock since the operations may
+    // make calls back into this reactor.
+    lock.unlock();
+    read_op_queue_.cleanup_operations();
+    write_op_queue_.cleanup_operations();
+    except_op_queue_.cleanup_operations();
+  }
+
+  // Run the select loop in the thread.
+  void run_thread()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    while (!stop_thread_)
+    {
+      lock.unlock();
+      run(true);
+      lock.lock();
+    }
+  }
+
+  // Entry point for the select loop thread.
+  static void call_run_thread(select_reactor* reactor)
+  {
+    reactor->run_thread();
+  }
+
+  // Interrupt the select loop.
+  void interrupt()
+  {
+    interrupter_.interrupt();
+  }
+
+  // Get the timeout value for the select call.
+  timeval* get_timeout(timeval& tv)
+  {
+    if (timer_queue_.empty())
+      return 0;
+
+    boost::posix_time::ptime now
+      = boost::posix_time::microsec_clock::universal_time();
+    boost::posix_time::ptime earliest_timer;
+    timer_queue_.get_earliest_time(earliest_timer);
+    if (now < earliest_timer)
+    {
+      boost::posix_time::time_duration timeout = earliest_timer - now;
+      tv.tv_sec = timeout.total_seconds();
+      tv.tv_usec = timeout.total_microseconds() % 1000000;
+    }
+    else
+    {
+      tv.tv_sec = 0;
+      tv.tv_usec = 0;
+    }
+
+    return &tv;
+  }
+
+  // Cancel all operations associated with the given descriptor. The do_cancel
+  // function of the handler objects will be invoked. This function does not
+  // acquire the select_reactor's mutex.
+  void cancel_ops_unlocked(socket_type descriptor)
+  {
+    bool interrupt = read_op_queue_.cancel_operations(descriptor);
+    interrupt = write_op_queue_.cancel_operations(descriptor) || interrupt;
+    interrupt = except_op_queue_.cancel_operations(descriptor) || interrupt;
+    if (interrupt)
+      interrupter_.interrupt();
+  }
+
+  // Mutex to protect access to internal data.
+  boost::asio::detail::mutex mutex_;
+
+  // Whether the select loop is currently running or not.
+  bool select_in_progress_;
+
+  // The interrupter is used to break a blocking select call.
+  select_interrupter interrupter_;
+
+  // The queue of read operations.
+  reactor_op_queue<socket_type> read_op_queue_;
+
+  // The queue of write operations.
+  reactor_op_queue<socket_type> write_op_queue_;
+
+  // The queue of exception operations.
+  reactor_op_queue<socket_type> except_op_queue_;
+
+  // The queue of timers.
+  reactor_timer_queue<boost::posix_time::ptime> timer_queue_;
+
+  // The descriptors that are pending cancellation.
+  std::vector<socket_type> pending_cancellations_;
+
+  // Does the reactor loop thread need to stop.
+  bool stop_thread_;
+
+  // The thread that is running the reactor loop.
+  boost::asio::detail::thread* thread_;
+
+  // Whether the service has been shut down.
+  bool shutdown_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP
diff --git a/include/boost/asio/detail/select_reactor_fwd.hpp b/include/boost/asio/detail/select_reactor_fwd.hpp
new file mode 100644
index 0000000000..fe076ab2ca
--- /dev/null
+++ b/include/boost/asio/detail/select_reactor_fwd.hpp
@@ -0,0 +1,33 @@
+//
+// select_reactor_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP
+#define BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <bool Own_Thread>
+class select_reactor;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP
diff --git a/include/boost/asio/detail/service_registry.hpp b/include/boost/asio/detail/service_registry.hpp
new file mode 100644
index 0000000000..8203968057
--- /dev/null
+++ b/include/boost/asio/detail/service_registry.hpp
@@ -0,0 +1,165 @@
+//
+// service_registry.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
+#define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <memory>
+#include <typeinfo>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Owner>
+class service_registry
+  : private noncopyable
+{
+public:
+  // Constructor.
+  service_registry(Owner& o)
+    : owner_(o),
+      first_service_(0)
+  {
+  }
+
+  // Destructor.
+  ~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.
+    typename Owner::service* service = first_service_;
+    while (service)
+    {
+      service->shutdown_service();
+      service = service->next_;
+    }
+
+    // Destroy all services.
+    while (first_service_)
+    {
+      typename Owner::service* next_service = first_service_->next_;
+      delete first_service_;
+      first_service_ = next_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.
+  template <typename Service>
+  Service& use_service()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // First see if there is an existing service object for the given type.
+    typename Owner::service* service = first_service_;
+    while (service)
+    {
+      if (*service->type_info_ == typeid(Service))
+        return *static_cast<Service*>(service);
+      service = service->next_;
+    }
+
+    // Create a new service object. The service registry's mutex is not locked
+    // at this time to allow for nested calls into this function from the new
+    // service's constructor.
+    lock.unlock();
+    std::auto_ptr<Service> new_service(new Service(owner_));
+    new_service->type_info_ = &typeid(Service);
+    Service& new_service_ref = *new_service;
+    lock.lock();
+
+    // Check that nobody else created another service object of the same type
+    // while the lock was released.
+    service = first_service_;
+    while (service)
+    {
+      if (*service->type_info_ == typeid(Service))
+        return *static_cast<Service*>(service);
+      service = service->next_;
+    }
+
+    // Service was successfully initialised, pass ownership to registry.
+    new_service->next_ = first_service_;
+    first_service_ = new_service.release();
+
+    return new_service_ref;
+  }
+
+  // Add a service object. Returns false on error, in which case ownership of
+  // the object is retained by the caller.
+  template <typename Service>
+  bool add_service(Service* new_service)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // Check if there is an existing service object for the given type.
+    typename Owner::service* service = first_service_;
+    while (service)
+    {
+      if (*service->type_info_ == typeid(Service))
+        return false;
+      service = service->next_;
+    }
+
+    // Take ownership of the service object.
+    new_service->type_info_ = &typeid(Service);
+    new_service->next_ = first_service_;
+    first_service_ = new_service;
+  }
+
+  // Check whether a service object of the specified type already exists.
+  template <typename Service>
+  bool has_service() const
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    typename Owner::service* service = first_service_;
+    while (service)
+    {
+      if (*service->type_info_ == typeid(Service))
+        return true;
+      service = service->next_;
+    }
+
+    return false;
+  }
+
+private:
+  // Mutex to protect access to internal data.
+  mutable boost::asio::detail::mutex mutex_;
+
+  // The owner of this service registry and the services it contains.
+  Owner& owner_;
+
+  // The first service in the list of contained services.
+  typename Owner::service* first_service_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
diff --git a/include/boost/asio/detail/signal_blocker.hpp b/include/boost/asio/detail/signal_blocker.hpp
new file mode 100644
index 0000000000..11655a77fd
--- /dev/null
+++ b/include/boost/asio/detail/signal_blocker.hpp
@@ -0,0 +1,52 @@
+//
+// signal_blocker.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
+#define BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+# include <boost/asio/detail/null_signal_blocker.hpp>
+#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# include <boost/asio/detail/win_signal_blocker.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/asio/detail/posix_signal_blocker.hpp>
+#else
+# error Only Windows and POSIX are supported!
+#endif
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if !defined(BOOST_HAS_THREADS)
+typedef null_signal_blocker signal_blocker;
+#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+typedef win_signal_blocker signal_blocker;
+#elif defined(BOOST_HAS_PTHREADS)
+typedef posix_signal_blocker signal_blocker;
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
diff --git a/include/boost/asio/detail/signal_init.hpp b/include/boost/asio/detail/signal_init.hpp
new file mode 100644
index 0000000000..2c41a3773c
--- /dev/null
+++ b/include/boost/asio/detail/signal_init.hpp
@@ -0,0 +1,53 @@
+//
+// signal_init.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP
+#define BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <csignal>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <int Signal = SIGPIPE>
+class signal_init
+{
+public:
+  // Constructor.
+  signal_init()
+  {
+    std::signal(Signal, SIG_IGN);
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP
diff --git a/include/boost/asio/detail/socket_holder.hpp b/include/boost/asio/detail/socket_holder.hpp
new file mode 100644
index 0000000000..f06867cf5a
--- /dev/null
+++ b/include/boost/asio/detail/socket_holder.hpp
@@ -0,0 +1,93 @@
+//
+// socket_holder.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
+#define BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Implement the resource acquisition is initialisation idiom for sockets.
+class socket_holder
+  : private noncopyable
+{
+public:
+  // Construct as an uninitialised socket.
+  socket_holder()
+    : socket_(invalid_socket)
+  {
+  }
+
+  // Construct to take ownership of the specified socket.
+  explicit socket_holder(socket_type s)
+    : socket_(s)
+  {
+  }
+
+  // Destructor.
+  ~socket_holder()
+  {
+    if (socket_ != invalid_socket)
+      socket_ops::close(socket_);
+  }
+
+  // Get the underlying socket.
+  socket_type get() const
+  {
+    return socket_;
+  }
+
+  // Reset to an uninitialised socket.
+  void reset()
+  {
+    if (socket_ != invalid_socket)
+    {
+      socket_ops::close(socket_);
+      socket_ = invalid_socket;
+    }
+  }
+
+  // Reset to take ownership of the specified socket.
+  void reset(socket_type s)
+  {
+    reset();
+    socket_ = s;
+  }
+
+  // Release ownership of the socket.
+  socket_type release()
+  {
+    socket_type tmp = socket_;
+    socket_ = invalid_socket;
+    return tmp;
+  }
+
+private:
+  // The underlying socket.
+  socket_type socket_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
diff --git a/include/boost/asio/detail/socket_ops.hpp b/include/boost/asio/detail/socket_ops.hpp
new file mode 100644
index 0000000000..48f0cf4f93
--- /dev/null
+++ b/include/boost/asio/detail/socket_ops.hpp
@@ -0,0 +1,1514 @@
+//
+// socket_ops.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
+#define BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <boost/detail/workaround.hpp>
+#include <new>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+namespace socket_ops {
+
+inline int get_error()
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return WSAGetLastError();
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return errno;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline void set_error(int error)
+{
+  errno = error;
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  WSASetLastError(error);
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+template <typename ReturnType>
+inline ReturnType error_wrapper(ReturnType return_value)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  errno = WSAGetLastError();
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return return_value;
+}
+
+inline socket_type accept(socket_type s, socket_addr_type* addr,
+    socket_addr_len_type* addrlen)
+{
+  set_error(0);
+#if defined(__MACH__) && defined(__APPLE__)
+  socket_type new_s = error_wrapper(::accept(s, addr, addrlen));
+  if (new_s == invalid_socket)
+    return new_s;
+
+  int optval = 1;
+  int result = error_wrapper(::setsockopt(new_s,
+        SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)));
+  if (result != 0)
+  {
+    ::close(new_s);
+    return invalid_socket;
+  }
+
+  return new_s;
+#else
+  return error_wrapper(::accept(s, addr, addrlen));
+#endif
+}
+
+inline int bind(socket_type s, const socket_addr_type* addr,
+    socket_addr_len_type addrlen)
+{
+  set_error(0);
+  return error_wrapper(::bind(s, addr, addrlen));
+}
+
+inline int close(socket_type s)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::closesocket(s));
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::close(s));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int shutdown(socket_type s, int what)
+{
+  set_error(0);
+  return error_wrapper(::shutdown(s, what));
+}
+
+inline int connect(socket_type s, const socket_addr_type* addr,
+    socket_addr_len_type addrlen)
+{
+  set_error(0);
+  return error_wrapper(::connect(s, addr, addrlen));
+}
+
+inline int listen(socket_type s, int backlog)
+{
+  set_error(0);
+  return error_wrapper(::listen(s, backlog));
+}
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+typedef WSABUF buf;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+typedef iovec buf;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+inline void init_buf(buf& b, void* data, size_t size)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  b.buf = static_cast<char*>(data);
+  b.len = static_cast<u_long>(size);
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  b.iov_base = data;
+  b.iov_len = size;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline void init_buf(buf& b, const void* data, size_t size)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  b.buf = static_cast<char*>(const_cast<void*>(data));
+  b.len = static_cast<u_long>(size);
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  b.iov_base = const_cast<void*>(data);
+  b.iov_len = size;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int recv(socket_type s, buf* bufs, size_t count, int flags)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  // Receive some data.
+  DWORD recv_buf_count = static_cast<DWORD>(count);
+  DWORD bytes_transferred = 0;
+  DWORD recv_flags = flags;
+  int result = error_wrapper(::WSARecv(s, bufs,
+        recv_buf_count, &bytes_transferred, &recv_flags, 0, 0));
+  if (result != 0)
+    return -1;
+  return bytes_transferred;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg;
+  msg.msg_name = 0;
+  msg.msg_namelen = 0;
+  msg.msg_iov = bufs;
+  msg.msg_iovlen = count;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+  return error_wrapper(::recvmsg(s, &msg, flags));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int recvfrom(socket_type s, buf* bufs, size_t count, int flags,
+    socket_addr_type* addr, socket_addr_len_type* addrlen)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  // Receive some data.
+  DWORD recv_buf_count = static_cast<DWORD>(count);
+  DWORD bytes_transferred = 0;
+  DWORD recv_flags = flags;
+  int result = error_wrapper(::WSARecvFrom(s, bufs, recv_buf_count,
+        &bytes_transferred, &recv_flags, addr, addrlen, 0, 0));
+  if (result != 0)
+    return -1;
+  return bytes_transferred;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg;
+  msg.msg_name = addr;
+  msg.msg_namelen = *addrlen;
+  msg.msg_iov = bufs;
+  msg.msg_iovlen = count;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+  int result = error_wrapper(::recvmsg(s, &msg, flags));
+  *addrlen = msg.msg_namelen;
+  return result;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int send(socket_type s, const buf* bufs, size_t count, int flags)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  // Send the data.
+  DWORD send_buf_count = static_cast<DWORD>(count);
+  DWORD bytes_transferred = 0;
+  DWORD send_flags = flags;
+  int result = error_wrapper(::WSASend(s, const_cast<buf*>(bufs),
+        send_buf_count, &bytes_transferred, send_flags, 0, 0));
+  if (result != 0)
+    return -1;
+  return bytes_transferred;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg;
+  msg.msg_name = 0;
+  msg.msg_namelen = 0;
+  msg.msg_iov = const_cast<buf*>(bufs);
+  msg.msg_iovlen = count;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+#if defined(__linux__)
+  flags |= MSG_NOSIGNAL;
+#endif // defined(__linux__)
+  return error_wrapper(::sendmsg(s, &msg, flags));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int sendto(socket_type s, const buf* bufs, size_t count, int flags,
+    const socket_addr_type* addr, socket_addr_len_type addrlen)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  // Send the data.
+  DWORD send_buf_count = static_cast<DWORD>(count);
+  DWORD bytes_transferred = 0;
+  int result = ::WSASendTo(s, const_cast<buf*>(bufs), send_buf_count,
+      &bytes_transferred, flags, addr, addrlen, 0, 0);
+  if (result != 0)
+    return -1;
+  return bytes_transferred;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  msghdr msg;
+  msg.msg_name = const_cast<socket_addr_type*>(addr);
+  msg.msg_namelen = addrlen;
+  msg.msg_iov = const_cast<buf*>(bufs);
+  msg.msg_iovlen = count;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+#if defined(__linux__)
+  flags |= MSG_NOSIGNAL;
+#endif // defined(__linux__)
+  return error_wrapper(::sendmsg(s, &msg, flags));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline socket_type socket(int af, int type, int protocol)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::WSASocket(af, type, protocol, 0, 0,
+        WSA_FLAG_OVERLAPPED));
+#elif defined(__MACH__) && defined(__APPLE__)
+  socket_type s = error_wrapper(::socket(af, type, protocol));
+  if (s == invalid_socket)
+    return s;
+
+  int optval = 1;
+  int result = error_wrapper(::setsockopt(s,
+        SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)));
+  if (result != 0)
+  {
+    ::close(s);
+    return invalid_socket;
+  }
+
+  return s;
+#else
+  return error_wrapper(::socket(af, type, protocol));
+#endif
+}
+
+inline int setsockopt(socket_type s, int level, int optname,
+    const void* optval, size_t optlen)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::setsockopt(s, level, optname,
+        reinterpret_cast<const char*>(optval), static_cast<int>(optlen)));
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::setsockopt(s, level, optname, optval,
+        static_cast<socklen_t>(optlen)));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int getsockopt(socket_type s, int level, int optname, void* optval,
+    size_t* optlen)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  int tmp_optlen = static_cast<int>(*optlen);
+  int result = error_wrapper(::getsockopt(s, level, optname,
+        reinterpret_cast<char*>(optval), &tmp_optlen));
+  *optlen = static_cast<size_t>(tmp_optlen);
+  return result;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  socklen_t tmp_optlen = static_cast<socklen_t>(*optlen);
+  int result = error_wrapper(::getsockopt(s, level, optname,
+        optval, &tmp_optlen));
+  *optlen = static_cast<size_t>(tmp_optlen);
+  return result;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int getpeername(socket_type s, socket_addr_type* addr,
+    socket_addr_len_type* addrlen)
+{
+  set_error(0);
+  return error_wrapper(::getpeername(s, addr, addrlen));
+}
+
+inline int getsockname(socket_type s, socket_addr_type* addr,
+    socket_addr_len_type* addrlen)
+{
+  set_error(0);
+  return error_wrapper(::getsockname(s, addr, addrlen));
+}
+
+inline int ioctl(socket_type s, long cmd, ioctl_arg_type* arg)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::ioctlsocket(s, cmd, arg));
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::ioctl(s, cmd, arg));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int select(int nfds, fd_set* readfds, fd_set* writefds,
+    fd_set* exceptfds, timeval* timeout)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  if (!readfds && !writefds && !exceptfds && timeout)
+  {
+    DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
+    if (milliseconds == 0)
+      milliseconds = 1; // Force context switch.
+    ::Sleep(milliseconds);
+    return 0;
+  }
+
+  // The select() call allows timeout values measured in microseconds, but the
+  // system clock (as wrapped by boost::posix_time::microsec_clock) typically
+  // has a resolution of 10 milliseconds. This can lead to a spinning select
+  // reactor, meaning increased CPU usage, when waiting for the earliest
+  // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight
+  // spin we'll use a minimum timeout of 1 millisecond.
+  if (timeout && timeout->tv_sec == 0
+      && timeout->tv_usec > 0 && timeout->tv_usec < 1000)
+    timeout->tv_usec = 1000;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  return error_wrapper(::select(nfds, readfds, writefds, exceptfds, timeout));
+}
+
+inline int poll_read(socket_type s)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  FD_SET fds;
+  FD_ZERO(&fds);
+  FD_SET(s, &fds);
+  set_error(0);
+  return error_wrapper(::select(s, &fds, 0, 0, 0));
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  pollfd fds;
+  fds.fd = s;
+  fds.events = POLLIN;
+  fds.revents = 0;
+  set_error(0);
+  return error_wrapper(::poll(&fds, 1, -1));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int poll_write(socket_type s)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  FD_SET fds;
+  FD_ZERO(&fds);
+  FD_SET(s, &fds);
+  set_error(0);
+  return error_wrapper(::select(s, 0, &fds, 0, 0));
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  pollfd fds;
+  fds.fd = s;
+  fds.events = POLLOUT;
+  fds.revents = 0;
+  set_error(0);
+  return error_wrapper(::poll(&fds, 1, -1));
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline const char* inet_ntop(int af, const void* src, char* dest, size_t length,
+    unsigned long scope_id = 0)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  using namespace std; // For memcpy.
+
+  if (af != AF_INET && af != AF_INET6)
+  {
+    set_error(boost::asio::error::address_family_not_supported);
+    return 0;
+  }
+
+  sockaddr_storage_type address;
+  DWORD address_length;
+  if (af == AF_INET)
+  {
+    address_length = sizeof(sockaddr_in4_type);
+    sockaddr_in4_type* ipv4_address =
+      reinterpret_cast<sockaddr_in4_type*>(&address);
+    ipv4_address->sin_family = AF_INET;
+    ipv4_address->sin_port = 0;
+    memcpy(&ipv4_address->sin_addr, src, sizeof(in4_addr_type));
+  }
+  else // AF_INET6
+  {
+    address_length = sizeof(sockaddr_in6_type);
+    sockaddr_in6_type* ipv6_address =
+      reinterpret_cast<sockaddr_in6_type*>(&address);
+    ipv6_address->sin6_family = AF_INET6;
+    ipv6_address->sin6_port = 0;
+    ipv6_address->sin6_flowinfo = 0;
+    ipv6_address->sin6_scope_id = scope_id;
+    memcpy(&ipv6_address->sin6_addr, src, sizeof(in6_addr_type));
+  }
+
+  DWORD string_length = length;
+  int result = error_wrapper(::WSAAddressToStringA(
+        reinterpret_cast<sockaddr*>(&address),
+        address_length, 0, dest, &string_length));
+
+  // Windows may not set an error code on failure.
+  if (result == socket_error_retval && get_error() == 0)
+    set_error(boost::asio::error::invalid_argument);
+
+  return result == socket_error_retval ? 0 : dest;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  const char* result = error_wrapper(::inet_ntop(af, src, dest, length));
+  if (result == 0 && get_error() == 0)
+    set_error(boost::asio::error::invalid_argument);
+  if (result != 0 && af == AF_INET6 && scope_id != 0)
+  {
+    using namespace std; // For strcat and sprintf.
+    char if_name[IF_NAMESIZE + 1] = "%";
+    const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
+    bool is_link_local = IN6_IS_ADDR_LINKLOCAL(ipv6_address);
+    if (!is_link_local || if_indextoname(scope_id, if_name + 1) == 0)
+      sprintf(if_name + 1, "%lu", scope_id);
+    strcat(dest, if_name);
+  }
+  return result;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int inet_pton(int af, const char* src, void* dest,
+    unsigned long* scope_id = 0)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  using namespace std; // For memcpy and strcmp.
+
+  if (af != AF_INET && af != AF_INET6)
+  {
+    set_error(boost::asio::error::address_family_not_supported);
+    return -1;
+  }
+
+  sockaddr_storage_type address;
+  int address_length = sizeof(sockaddr_storage_type);
+  int result = error_wrapper(::WSAStringToAddressA(
+        const_cast<char*>(src), af, 0,
+        reinterpret_cast<sockaddr*>(&address),
+        &address_length));
+
+  if (af == AF_INET)
+  {
+    if (result != socket_error_retval)
+    {
+      sockaddr_in4_type* ipv4_address =
+        reinterpret_cast<sockaddr_in4_type*>(&address);
+      memcpy(dest, &ipv4_address->sin_addr, sizeof(in4_addr_type));
+    }
+    else if (strcmp(src, "255.255.255.255") == 0)
+    {
+      static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
+    }
+  }
+  else // AF_INET6
+  {
+    if (result != socket_error_retval)
+    {
+      sockaddr_in6_type* ipv6_address =
+        reinterpret_cast<sockaddr_in6_type*>(&address);
+      memcpy(dest, &ipv6_address->sin6_addr, sizeof(in6_addr_type));
+      if (scope_id)
+        *scope_id = ipv6_address->sin6_scope_id;
+    }
+  }
+
+  // Windows may not set an error code on failure.
+  if (result == socket_error_retval && get_error() == 0)
+    set_error(boost::asio::error::invalid_argument);
+
+  return result == socket_error_retval ? -1 : 1;
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  int result = error_wrapper(::inet_pton(af, src, dest));
+  if (result <= 0 && get_error() == 0)
+    set_error(boost::asio::error::invalid_argument);
+  if (result > 0 && af == AF_INET6 && scope_id)
+  {
+    using namespace std; // For strchr and atoi.
+    *scope_id = 0;
+    if (const char* if_name = strchr(src, '%'))
+    {
+      in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
+      bool is_link_local = IN6_IS_ADDR_LINKLOCAL(ipv6_address);
+      if (is_link_local)
+        *scope_id = if_nametoindex(if_name + 1);
+      if (*scope_id == 0)
+        *scope_id = atoi(if_name + 1);
+    }
+  }
+  return result;
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+}
+
+inline int gethostname(char* name, int namelen)
+{
+  set_error(0);
+  return error_wrapper(::gethostname(name, namelen));
+}
+
+inline int translate_netdb_error(int error)
+{
+  switch (error)
+  {
+  case 0:
+    return boost::asio::error::success;
+  case HOST_NOT_FOUND:
+    return boost::asio::error::host_not_found;
+  case TRY_AGAIN:
+    return boost::asio::error::host_not_found_try_again;
+  case NO_RECOVERY:
+    return boost::asio::error::no_recovery;
+  case NO_DATA:
+    return boost::asio::error::no_data;
+  default:
+    BOOST_ASSERT(false);
+    return get_error();
+  }
+}
+
+inline hostent* gethostbyaddr(const char* addr, int length, int af,
+    hostent* result, char* buffer, int buflength, int* error)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  (void)(buffer);
+  (void)(buflength);
+  hostent* retval = error_wrapper(::gethostbyaddr(addr, length, af));
+  *error = get_error();
+  if (!retval)
+    return 0;
+  *result = *retval;
+  return retval;
+#elif defined(__sun) || defined(__QNX__)
+  hostent* retval = error_wrapper(::gethostbyaddr_r(addr, length, af, result,
+        buffer, buflength, error));
+  *error = translate_netdb_error(*error);
+  return retval;
+#elif defined(__MACH__) && defined(__APPLE__)
+  (void)(buffer);
+  (void)(buflength);
+  hostent* retval = error_wrapper(::getipnodebyaddr(addr, length, af, error));
+  *error = translate_netdb_error(*error);
+  if (!retval)
+    return 0;
+  *result = *retval;
+  return retval;
+#else
+  hostent* retval = 0;
+  error_wrapper(::gethostbyaddr_r(addr, length, af, result, buffer,
+        buflength, &retval, error));
+  *error = translate_netdb_error(*error);
+  return retval;
+#endif
+}
+
+inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
+    char* buffer, int buflength, int* error, int ai_flags = 0)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+  (void)(buffer);
+  (void)(buflength);
+  (void)(ai_flags);
+  if (af != AF_INET)
+  {
+    *error = boost::asio::error::address_family_not_supported;
+    return 0;
+  }
+  hostent* retval = error_wrapper(::gethostbyname(name));
+  *error = get_error();
+  if (!retval)
+    return 0;
+  *result = *retval;
+  return result;
+#elif defined(__sun) || defined(__QNX__)
+  (void)(ai_flags);
+  if (af != AF_INET)
+  {
+    *error = boost::asio::error::address_family_not_supported;
+    return 0;
+  }
+  hostent* retval = error_wrapper(::gethostbyname_r(name, result, buffer,
+        buflength, error));
+  *error = translate_netdb_error(*error);
+  return retval;
+#elif defined(__MACH__) && defined(__APPLE__)
+  (void)(buffer);
+  (void)(buflength);
+  hostent* retval = error_wrapper(::getipnodebyname(
+        name, af, ai_flags, error));
+  *error = translate_netdb_error(*error);
+  if (!retval)
+    return 0;
+  *result = *retval;
+  return retval;
+#else
+  (void)(ai_flags);
+  if (af != AF_INET)
+  {
+    *error = boost::asio::error::address_family_not_supported;
+    return 0;
+  }
+  hostent* retval = 0;
+  error_wrapper(::gethostbyname_r(name, result, buffer, buflength, &retval,
+        error));
+  *error = translate_netdb_error(*error);
+  return retval;
+#endif
+}
+
+inline void freehostent(hostent* h)
+{
+#if defined(__MACH__) && defined(__APPLE__)
+  if (h)
+    ::freehostent(h);
+#else
+  (void)(h);
+#endif
+}
+
+// Emulation of getaddrinfo based on implementation in:
+// Stevens, W. R., UNIX Network Programming Vol. 1, 2nd Ed., Prentice-Hall 1998.
+
+struct gai_search
+{
+  const char* host;
+  int family;
+};
+
+inline int gai_nsearch(const char* host,
+    const addrinfo_type* hints, gai_search (&search)[2])
+{
+  int search_count = 0;
+  if (host == 0 || host[0] == '\0')
+  {
+    if (hints->ai_flags & AI_PASSIVE)
+    {
+      // No host and AI_PASSIVE implies wildcard bind.
+      switch (hints->ai_family)
+      {
+      case AF_INET:
+        search[search_count].host = "0.0.0.0";
+        search[search_count].family = AF_INET;
+        ++search_count;
+        break;
+      case AF_INET6:
+        search[search_count].host = "0::0";
+        search[search_count].family = AF_INET6;
+        ++search_count;
+        break;
+      case AF_UNSPEC:
+        search[search_count].host = "0::0";
+        search[search_count].family = AF_INET6;
+        ++search_count;
+        search[search_count].host = "0.0.0.0";
+        search[search_count].family = AF_INET;
+        ++search_count;
+        break;
+      default:
+        break;
+      }
+    }
+    else
+    {
+      // No host and not AI_PASSIVE means connect to local host.
+      switch (hints->ai_family)
+      {
+      case AF_INET:
+        search[search_count].host = "localhost";
+        search[search_count].family = AF_INET;
+        ++search_count;
+        break;
+      case AF_INET6:
+        search[search_count].host = "localhost";
+        search[search_count].family = AF_INET6;
+        ++search_count;
+        break;
+      case AF_UNSPEC:
+        search[search_count].host = "localhost";
+        search[search_count].family = AF_INET6;
+        ++search_count;
+        search[search_count].host = "localhost";
+        search[search_count].family = AF_INET;
+        ++search_count;
+        break;
+      default:
+        break;
+      }
+    }
+  }
+  else
+  {
+    // Host is specified.
+    switch (hints->ai_family)
+    {
+    case AF_INET:
+      search[search_count].host = host;
+      search[search_count].family = AF_INET;
+      ++search_count;
+      break;
+    case AF_INET6:
+      search[search_count].host = host;
+      search[search_count].family = AF_INET6;
+      ++search_count;
+      break;
+    case AF_UNSPEC:
+      search[search_count].host = host;
+      search[search_count].family = AF_INET6;
+      ++search_count;
+      search[search_count].host = host;
+      search[search_count].family = AF_INET;
+      ++search_count;
+      break;
+    default:
+      break;
+    }
+  }
+  return search_count;
+}
+
+template <typename T>
+inline T* gai_alloc(std::size_t size = sizeof(T))
+{
+  using namespace std;
+  T* p = static_cast<T*>(::operator new(size, std::nothrow));
+  if (p)
+    memset(p, 0, size);
+  return p;
+}
+
+inline void gai_free(void* p)
+{
+  ::operator delete(p);
+}
+
+enum { gai_clone_flag = 1 << 30 };
+
+inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints,
+    const void* addr, int family)
+{
+  using namespace std;
+
+  addrinfo_type* ai = gai_alloc<addrinfo_type>();
+  if (ai == 0)
+    return EAI_MEMORY;
+
+  ai->ai_next = 0;
+  **next = ai;
+  *next = &ai->ai_next;
+
+  ai->ai_canonname = 0;
+  ai->ai_socktype = hints->ai_socktype;
+  if (ai->ai_socktype == 0)
+    ai->ai_flags |= gai_clone_flag;
+  ai->ai_protocol = hints->ai_protocol;
+  ai->ai_family = family;
+
+  switch (ai->ai_family)
+  {
+  case AF_INET:
+    {
+      sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>();
+      if (sinptr == 0)
+        return EAI_MEMORY;
+      sinptr->sin_family = AF_INET;
+      memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type));
+      ai->ai_addr = reinterpret_cast<sockaddr*>(sinptr);
+      ai->ai_addrlen = sizeof(sockaddr_in4_type);
+      break;
+    }
+  case AF_INET6:
+    {
+      sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>();
+      if (sin6ptr == 0)
+        return EAI_MEMORY;
+      sin6ptr->sin6_family = AF_INET6;
+      memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type));
+      ai->ai_addr = reinterpret_cast<sockaddr*>(sin6ptr);
+      ai->ai_addrlen = sizeof(sockaddr_in6_type);
+      break;
+    }
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+inline addrinfo_type* gai_clone(addrinfo_type* ai)
+{
+  using namespace std;
+
+  addrinfo_type* new_ai = gai_alloc<addrinfo_type>();
+  if (new_ai == 0)
+    return new_ai;
+
+  new_ai->ai_next = ai->ai_next;
+  ai->ai_next = new_ai;
+
+  new_ai->ai_flags = 0;
+  new_ai->ai_family = ai->ai_family;
+  new_ai->ai_socktype = ai->ai_socktype;
+  new_ai->ai_protocol = ai->ai_protocol;
+  new_ai->ai_canonname = 0;
+  new_ai->ai_addrlen = ai->ai_addrlen;
+  new_ai->ai_addr = gai_alloc<sockaddr>(ai->ai_addrlen);
+  memcpy(new_ai->ai_addr, ai->ai_addr, ai->ai_addrlen);
+
+  return new_ai;
+}
+
+inline int gai_port(addrinfo_type* aihead, int port, int socktype)
+{
+  int num_found = 0;
+
+  for (addrinfo_type* ai = aihead; ai; ai = ai->ai_next)
+  {
+    if (ai->ai_flags & gai_clone_flag)
+    {
+      if (ai->ai_socktype != 0)
+      {
+        ai = gai_clone(ai);
+        if (ai == 0)
+          return -1;
+        // ai now points to newly cloned entry.
+      }
+    }
+    else if (ai->ai_socktype != socktype)
+    {
+      // Ignore if mismatch on socket type.
+      continue;
+    }
+
+    ai->ai_socktype = socktype;
+
+    switch (ai->ai_family)
+    {
+    case AF_INET:
+      {
+        sockaddr_in4_type* sinptr =
+          reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
+        sinptr->sin_port = port;
+        ++num_found;
+        break;
+      }
+    case AF_INET6:
+      {
+        sockaddr_in6_type* sin6ptr =
+          reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
+        sin6ptr->sin6_port = port;
+        ++num_found;
+        break;
+      }
+    default:
+      break;
+    }
+  }
+
+  return num_found;
+}
+
+inline int gai_serv(addrinfo_type* aihead,
+    const addrinfo_type* hints, const char* serv)
+{
+  using namespace std;
+
+  int num_found = 0;
+
+  if (
+#if defined(AI_NUMERICSERV)
+      (hints->ai_flags & AI_NUMERICSERV) ||
+#endif
+      isdigit(serv[0]))
+  {
+    int port = htons(atoi(serv));
+    if (hints->ai_socktype)
+    {
+      // Caller specifies socket type.
+      int rc = gai_port(aihead, port, hints->ai_socktype);
+      if (rc < 0)
+        return EAI_MEMORY;
+      num_found += rc;
+    }
+    else
+    {
+      // Caller does not specify socket type.
+      int rc = gai_port(aihead, port, SOCK_STREAM);
+      if (rc < 0)
+        return EAI_MEMORY;
+      num_found += rc;
+      rc = gai_port(aihead, port, SOCK_DGRAM);
+      if (rc < 0)
+        return EAI_MEMORY;
+      num_found += rc;
+    }
+  }
+  else
+  {
+    // Try service name with TCP first, then UDP.
+    if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_STREAM)
+    {
+      servent* sptr = getservbyname(serv, "tcp");
+      if (sptr != 0)
+      {
+        int rc = gai_port(aihead, sptr->s_port, SOCK_STREAM);
+        if (rc < 0)
+          return EAI_MEMORY;
+        num_found += rc;
+      }
+    }
+    if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_DGRAM)
+    {
+      servent* sptr = getservbyname(serv, "udp");
+      if (sptr != 0)
+      {
+        int rc = gai_port(aihead, sptr->s_port, SOCK_DGRAM);
+        if (rc < 0)
+          return EAI_MEMORY;
+        num_found += rc;
+      }
+    }
+  }
+
+  if (num_found == 0)
+  {
+    if (hints->ai_socktype == 0)
+    {
+      // All calls to getservbyname() failed.
+      return EAI_NONAME;
+    }
+    else
+    {
+      // Service not supported for socket type.
+      return EAI_SERVICE;
+    }
+  }
+
+  return 0;
+}
+
+inline int gai_echeck(const char* host, const char* service,
+    int flags, int family, int socktype, int protocol)
+{
+  (void)(flags);
+  (void)(protocol);
+
+  // Host or service must be specified.
+  if (host == 0 || host[0] == '\0')
+    if (service == 0 || service[0] == '\0')
+      return EAI_NONAME;
+
+  // Check combination of family and socket type.
+  switch (family)
+  {
+  case AF_UNSPEC:
+    break;
+  case AF_INET:
+  case AF_INET6:
+    if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM)
+      return EAI_SOCKTYPE;
+    break;
+  default:
+    return EAI_FAMILY;
+  }
+
+  return 0;
+}
+
+inline void freeaddrinfo_emulation(addrinfo_type* aihead)
+{
+  addrinfo_type* ai = aihead;
+  while (ai)
+  {
+    gai_free(ai->ai_addr);
+    gai_free(ai->ai_canonname);
+    addrinfo_type* ainext = ai->ai_next;
+    gai_free(ai);
+    ai = ainext;
+  }
+}
+
+inline int getaddrinfo_emulation(const char* host, const char* service,
+    const addrinfo_type* hintsp, addrinfo_type** result)
+{
+  // Set up linked list of addrinfo structures.
+  addrinfo_type* aihead = 0;
+  addrinfo_type** ainext = &aihead;
+  char* canon = 0;
+
+  // Supply default hints if not specified by caller.
+  addrinfo_type hints = addrinfo_type();
+  hints.ai_family = AF_UNSPEC;
+  if (hintsp)
+    hints = *hintsp;
+
+  // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED
+  // and AI_ALL flags.
+#if defined(AI_V4MAPPED)
+  if (hints.ai_family != AF_INET6)
+    hints.ai_flags &= ~AI_V4MAPPED;
+#endif
+#if defined(AI_ALL)
+  if (hints.ai_family != AF_INET6)
+    hints.ai_flags &= ~AI_ALL;
+#endif
+
+  // Basic error checking.
+  int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family,
+      hints.ai_socktype, hints.ai_protocol);
+  if (rc != 0)
+  {
+    freeaddrinfo_emulation(aihead);
+    return rc;
+  }
+
+  gai_search search[2];
+  int search_count = gai_nsearch(host, &hints, search);
+  for (gai_search* sptr = search; sptr < search + search_count; ++sptr)
+  {
+    // Check for IPv4 dotted decimal string.
+    in4_addr_type inaddr;
+    if (socket_ops::inet_pton(AF_INET, sptr->host, &inaddr) == 1)
+    {
+      if (hints.ai_family != AF_UNSPEC && hints.ai_family != AF_INET)
+      {
+        freeaddrinfo_emulation(aihead);
+        gai_free(canon);
+        return EAI_FAMILY;
+      }
+      if (sptr->family == AF_INET)
+      {
+        rc = gai_aistruct(&ainext, &hints, &inaddr, AF_INET);
+        if (rc != 0)
+        {
+          freeaddrinfo_emulation(aihead);
+          gai_free(canon);
+          return rc;
+        }
+      }
+      continue;
+    }
+
+    // Check for IPv6 hex string.
+    in6_addr_type in6addr;
+    if (socket_ops::inet_pton(AF_INET6, sptr->host, &in6addr) == 1)
+    {
+      if (hints.ai_family != AF_UNSPEC && hints.ai_family != AF_INET6)
+      {
+        freeaddrinfo_emulation(aihead);
+        gai_free(canon);
+        return EAI_FAMILY;
+      }
+      if (sptr->family == AF_INET6)
+      {
+        rc = gai_aistruct(&ainext, &hints, &in6addr, AF_INET6);
+        if (rc != 0)
+        {
+          freeaddrinfo_emulation(aihead);
+          gai_free(canon);
+          return rc;
+        }
+      }
+      continue;
+    }
+
+    // Look up hostname.
+    hostent hent;
+    char hbuf[8192] = "";
+    int herr = 0;
+    hostent* hptr = socket_ops::gethostbyname(sptr->host,
+        sptr->family, &hent, hbuf, sizeof(hbuf), &herr, hints.ai_flags);
+    if (hptr == 0)
+    {
+      if (search_count == 2)
+      {
+        // Failure is OK if there are multiple searches.
+        continue;
+      }
+      freeaddrinfo_emulation(aihead);
+      gai_free(canon);
+      switch (herr)
+      {
+      case HOST_NOT_FOUND:
+        return EAI_NONAME;
+      case TRY_AGAIN:
+        return EAI_AGAIN;
+      case NO_RECOVERY:
+        return EAI_FAIL;
+      case NO_DATA:
+        return EAI_NODATA;
+      default:
+        return EAI_NONAME;
+      }
+    }
+
+    // Check for address family mismatch if one was specified.
+    if (hints.ai_family != AF_UNSPEC && hints.ai_family != hptr->h_addrtype)
+    {
+      freeaddrinfo_emulation(aihead);
+      gai_free(canon);
+      socket_ops::freehostent(hptr);
+      return EAI_FAMILY;
+    }
+
+    // Save canonical name first time.
+    if (host != 0 && host[0] != '\0' && hptr->h_name && hptr->h_name[0]
+        && (hints.ai_flags & AI_CANONNAME) && canon == 0)
+    {
+      canon = gai_alloc<char>(strlen(hptr->h_name) + 1);
+      if (canon == 0)
+      {
+        freeaddrinfo_emulation(aihead);
+        socket_ops::freehostent(hptr);
+        return EAI_MEMORY;
+      }
+      strcpy(canon, hptr->h_name);
+    }
+
+    // Create an addrinfo structure for each returned address.
+    for (char** ap = hptr->h_addr_list; *ap; ++ap)
+    {
+      rc = gai_aistruct(&ainext, &hints, *ap, hptr->h_addrtype);
+      if (rc != 0)
+      {
+        freeaddrinfo_emulation(aihead);
+        gai_free(canon);
+        socket_ops::freehostent(hptr);
+        return EAI_FAMILY;
+      }
+    }
+
+    socket_ops::freehostent(hptr);
+  }
+
+  // Check if we found anything.
+  if (aihead == 0)
+  {
+    gai_free(canon);
+    return EAI_NONAME;
+  }
+
+  // Return canonical name in first entry.
+  if (host != 0 && host[0] != '\0' && (hints.ai_flags & AI_CANONNAME))
+  {
+    if (canon)
+    {
+      aihead->ai_canonname = canon;
+      canon = 0;
+    }
+    else
+    {
+      aihead->ai_canonname = gai_alloc<char>(strlen(search[0].host) + 1);
+      if (aihead->ai_canonname == 0)
+      {
+        freeaddrinfo_emulation(aihead);
+        return EAI_MEMORY;
+      }
+      strcpy(aihead->ai_canonname, search[0].host);
+    }
+  }
+  gai_free(canon);
+
+  // Process the service name.
+  if (service != 0 && service[0] != '\0')
+  {
+    rc = gai_serv(aihead, &hints, service);
+    if (rc != 0)
+    {
+      freeaddrinfo_emulation(aihead);
+      return rc;
+    }
+  }
+
+  // Return result to caller.
+  *result = aihead;
+  return 0;
+}
+
+inline int translate_addrinfo_error(int error)
+{
+  switch (error)
+  {
+  case 0:
+    return boost::asio::error::success;
+  case EAI_AGAIN:
+    return boost::asio::error::host_not_found_try_again;
+  case EAI_BADFLAGS:
+    return boost::asio::error::invalid_argument;
+  case EAI_FAIL:
+    return boost::asio::error::no_recovery;
+  case EAI_FAMILY:
+    return boost::asio::error::address_family_not_supported;
+  case EAI_MEMORY:
+    return boost::asio::error::no_memory;
+  case EAI_NONAME:
+    return boost::asio::error::host_not_found;
+  case EAI_SERVICE:
+    return boost::asio::error::service_not_found;
+  case EAI_SOCKTYPE:
+    return boost::asio::error::socket_type_not_supported;
+  default: // Possibly the non-portable EAI_SYSTEM.
+    return get_error();
+  }
+}
+
+inline int getaddrinfo(const char* host, const char* service,
+    const addrinfo_type* hints, addrinfo_type** result)
+{
+  set_error(0);
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
+  // Building for Windows XP, Windows Server 2003, or later.
+  int error = ::getaddrinfo(host, service, hints, result);
+  return translate_addrinfo_error(error);
+# else
+  // Building for Windows 2000 or earlier.
+  typedef int (WSAAPI *gai_t)(const char*,
+      const char*, const addrinfo_type*, addrinfo_type**);
+  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
+  {
+    if (gai_t gai = (gai_t)::GetProcAddress(winsock_module, "getaddrinfo"))
+    {
+      int error = gai(host, service, hints, result);
+      return translate_addrinfo_error(error);
+    }
+  }
+  int error = getaddrinfo_emulation(host, service, hints, result);
+  return translate_addrinfo_error(error);
+# endif
+#elif defined(__MACH__) && defined(__APPLE__)
+  int error = getaddrinfo_emulation(host, service, hints, result);
+  return translate_addrinfo_error(error);
+#else
+  int error = ::getaddrinfo(host, service, hints, result);
+  return translate_addrinfo_error(error);
+#endif
+}
+
+inline void freeaddrinfo(addrinfo_type* ai)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
+  // Building for Windows XP, Windows Server 2003, or later.
+  ::freeaddrinfo(ai);
+# else
+  // Building for Windows 2000 or earlier.
+  typedef int (WSAAPI *fai_t)(addrinfo_type*);
+  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
+  {
+    if (fai_t fai = (fai_t)::GetProcAddress(winsock_module, "freeaddrinfo"))
+    {
+      fai(ai);
+      return;
+    }
+  }
+  freeaddrinfo_emulation(ai);
+# endif
+#elif defined(__MACH__) && defined(__APPLE__)
+  freeaddrinfo_emulation(ai);
+#else
+  ::freeaddrinfo(ai);
+#endif
+}
+
+inline int getnameinfo_emulation(const socket_addr_type* sa,
+    socket_addr_len_type salen, char* host, std::size_t hostlen,
+    char* serv, std::size_t servlen, int flags)
+{
+  using namespace std;
+
+  const char* addr;
+  size_t addr_len;
+  unsigned short port;
+  switch (sa->sa_family)
+  {
+  case AF_INET:
+    if (salen != sizeof(sockaddr_in4_type))
+    {
+      set_error(boost::asio::error::invalid_argument);
+      return 1;
+    }
+    addr = reinterpret_cast<const char*>(
+        &reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_addr);
+    addr_len = sizeof(in4_addr_type);
+    port = reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_port;
+    break;
+  case AF_INET6:
+    if (salen != sizeof(sockaddr_in6_type))
+    {
+      set_error(boost::asio::error::invalid_argument);
+      return 1;
+    }
+    addr = reinterpret_cast<const char*>(
+        &reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_addr);
+    addr_len = sizeof(in6_addr_type);
+    port = reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_port;
+    break;
+  default:
+    set_error(boost::asio::error::address_family_not_supported);
+    return 1;
+  }
+
+  if (host && hostlen > 0)
+  {
+    if (flags & NI_NUMERICHOST)
+    {
+      if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen) == 0)
+      {
+        return 1;
+      }
+    }
+    else
+    {
+      hostent hent;
+      char hbuf[8192] = "";
+      int herr = 0;
+      hostent* hptr = socket_ops::gethostbyaddr(addr, addr_len,
+          sa->sa_family, &hent, hbuf, sizeof(hbuf), &herr);
+      if (hptr && hptr->h_name && hptr->h_name[0] != '\0')
+      {
+        if (flags & NI_NOFQDN)
+        {
+          char* dot = strchr(hptr->h_name, '.');
+          if (dot)
+          {
+            *dot = 0;
+          }
+        }
+        *host = '\0';
+        strncat(host, hptr->h_name, hostlen);
+        socket_ops::freehostent(hptr);
+      }
+      else
+      {
+        socket_ops::freehostent(hptr);
+        if (flags & NI_NAMEREQD)
+        {
+          set_error(boost::asio::error::host_not_found);
+          return 1;
+        }
+        if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen) == 0)
+        {
+          return 1;
+        }
+      }
+    }
+  }
+
+  if (serv && servlen > 0)
+  {
+    if (flags & NI_NUMERICSERV)
+    {
+      if (servlen < 6)
+      {
+        set_error(boost::asio::error::no_buffer_space);
+        return 1;
+      }
+      sprintf(serv, "%u", ntohs(port));
+    }
+    else
+    {
+#if defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS)
+      static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+      ::pthread_mutex_lock(&mutex);
+#endif // defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS)
+      servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0);
+      if (sptr && sptr->s_name && sptr->s_name[0] != '\0')
+      {
+        *serv = '\0';
+        strncat(serv, sptr->s_name, servlen);
+      }
+      else
+      {
+        if (servlen < 6)
+        {
+          set_error(boost::asio::error::no_buffer_space);
+          return 1;
+        }
+        sprintf(serv, "%u", ntohs(port));
+      }
+#if defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS)
+      ::pthread_mutex_unlock(&mutex);
+#endif // defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS)
+    }
+  }
+
+  set_error(0);
+  return 0;
+}
+
+inline int getnameinfo(const socket_addr_type* addr,
+    socket_addr_len_type addrlen, char* host, std::size_t hostlen,
+    char* serv, std::size_t servlen, int flags)
+{
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
+  // Building for Windows XP, Windows Server 2003, or later.
+  set_error(0);
+  int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
+  return translate_addrinfo_error(error);
+# else
+  // Building for Windows 2000 or earlier.
+  typedef int (WSAAPI *gni_t)(const socket_addr_type*,
+      socket_addr_len_type, char*, std::size_t, char*, std::size_t, int);
+  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
+  {
+    if (gni_t gni = (gni_t)::GetProcAddress(winsock_module, "getnameinfo"))
+    {
+      set_error(0);
+      int error = gni(addr, addrlen, host, hostlen, serv, servlen, flags);
+      return translate_addrinfo_error(error);
+    }
+  }
+  set_error(0);
+  int error = getnameinfo_emulation(addr, addrlen,
+      host, hostlen, serv, servlen, flags);
+  return translate_addrinfo_error(error);
+# endif
+#elif defined(__MACH__) && defined(__APPLE__)
+  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);
+  set_error(0);
+  int error = getnameinfo_emulation(addr, addrlen,
+      host, hostlen, serv, servlen, flags);
+  return translate_addrinfo_error(error);
+#else
+  set_error(0);
+  int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
+  return translate_addrinfo_error(error);
+#endif
+}
+
+inline u_long_type network_to_host_long(u_long_type value)
+{
+  return ntohl(value);
+}
+
+inline u_long_type host_to_network_long(u_long_type value)
+{
+  return htonl(value);
+}
+
+inline u_short_type network_to_host_short(u_short_type value)
+{
+  return ntohs(value);
+}
+
+inline u_short_type host_to_network_short(u_short_type value)
+{
+  return htons(value);
+}
+
+} // namespace socket_ops
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
diff --git a/include/boost/asio/detail/socket_option.hpp b/include/boost/asio/detail/socket_option.hpp
new file mode 100644
index 0000000000..b5bac48721
--- /dev/null
+++ b/include/boost/asio/detail/socket_option.hpp
@@ -0,0 +1,325 @@
+//
+// socket_option.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
+#define BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+namespace socket_option {
+
+// Helper template for implementing boolean-based options.
+template <int Level, int Name>
+class boolean
+{
+public:
+  // Default constructor.
+  boolean()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  boolean(bool value)
+    : value_(value ? 1 : 0)
+  {
+  }
+
+  // Set the value of the boolean.
+  void set(bool value)
+  {
+    value_ = value ? 1 : 0;
+  }
+
+  // Get the current value of the boolean.
+  bool get() const
+  {
+    return value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol&) const
+  {
+    return Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol&) const
+  {
+    return Name;
+  }
+
+  // Get the address of the boolean data.
+  template <typename Protocol>
+  int* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the boolean data.
+  template <typename Protocol>
+  const int* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the boolean data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+private:
+  int value_;
+};
+
+// Helper template for implementing integer options.
+template <int Level, int Name>
+class integer
+{
+public:
+  // Default constructor.
+  integer()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  integer(int value)
+    : value_(value)
+  {
+  }
+
+  // Set the value of the int option.
+  void set(int value)
+  {
+    value_ = value;
+  }
+
+  // Get the current value of the int option.
+  int get() const
+  {
+    return value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol&) const
+  {
+    return Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol&) const
+  {
+    return Name;
+  }
+
+  // Get the address of the int data.
+  template <typename Protocol>
+  int* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the int data.
+  template <typename Protocol>
+  const int* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the int data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+private:
+  int value_;
+};
+
+// Helper template for implementing unsigned integer options.
+template <int Level, int Name>
+class unsigned_integer
+{
+public:
+  // Default constructor.
+  unsigned_integer()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  unsigned_integer(unsigned int value)
+    : value_(value)
+  {
+  }
+
+  // Set the value of the int option.
+  void set(unsigned int value)
+  {
+    value_ = value;
+  }
+
+  // Get the current value of the int option.
+  unsigned int get() const
+  {
+    return value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol&) const
+  {
+    return Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol&) const
+  {
+    return Name;
+  }
+
+  // Get the address of the int data.
+  template <typename Protocol>
+  unsigned int* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the int data.
+  template <typename Protocol>
+  const unsigned int* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the int data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+private:
+  unsigned int value_;
+};
+
+// Helper template for implementing linger options.
+template <int Level, int Name>
+class linger
+{
+public:
+  // Default constructor.
+  linger()
+  {
+    value_.l_onoff = 0;
+    value_.l_linger = 0;
+  }
+
+  // Construct with specific option values.
+  linger(bool value, unsigned short timeout)
+  {
+    value_.l_onoff = value ? 1 : 0;
+    value_.l_linger = timeout;
+  }
+
+  // Set the value for whether linger is enabled.
+  void enabled(bool value)
+  {
+    value_.l_onoff = value ? 1 : 0;
+  }
+
+  // Get the value for whether linger is enabled.
+  bool enabled() const
+  {
+    return value_.l_onoff != 0;
+  }
+
+  // Set the value for the linger timeout.
+  void timeout(unsigned short value)
+  {
+    value_.l_linger = value;
+  }
+
+  // Get the value for the linger timeout.
+  unsigned short timeout() const
+  {
+    return value_.l_linger;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol&) const
+  {
+    return Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol&) const
+  {
+    return Name;
+  }
+
+  // Get the address of the linger data.
+  template <typename Protocol>
+  ::linger* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the linger data.
+  template <typename Protocol>
+  const ::linger* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the linger data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+private:
+  ::linger value_;
+};
+
+} // namespace socket_option
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
diff --git a/include/boost/asio/detail/socket_select_interrupter.hpp b/include/boost/asio/detail/socket_select_interrupter.hpp
new file mode 100644
index 0000000000..2cba77c4e3
--- /dev/null
+++ b/include/boost/asio/detail/socket_select_interrupter.hpp
@@ -0,0 +1,179 @@
+//
+// socket_select_interrupter.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
+#define BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/detail/socket_holder.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class socket_select_interrupter
+{
+public:
+  // Constructor.
+  socket_select_interrupter()
+  {
+    socket_holder acceptor(socket_ops::socket(AF_INET, SOCK_STREAM,
+          IPPROTO_TCP));
+    if (acceptor.get() == invalid_socket)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    int opt = 1;
+    socket_ops::setsockopt(acceptor.get(),
+        SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+    sockaddr_in4_type addr;
+    socket_addr_len_type addr_len = sizeof(addr);
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+    addr.sin_port = 0;
+    if (socket_ops::bind(acceptor.get(), (const socket_addr_type*)&addr,
+          addr_len) == socket_error_retval)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    if (getsockname(acceptor.get(), (socket_addr_type*)&addr, &addr_len)
+        == socket_error_retval)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    if (socket_ops::listen(acceptor.get(), SOMAXCONN) == socket_error_retval)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    socket_holder client(socket_ops::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+    if (client.get() == invalid_socket)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    if (socket_ops::connect(client.get(), (const socket_addr_type*)&addr,
+          addr_len) == socket_error_retval)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    socket_holder server(socket_ops::accept(acceptor.get(), 0, 0));
+    if (server.get() == invalid_socket)
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+    
+    ioctl_arg_type non_blocking = 1;
+    if (socket_ops::ioctl(client.get(), FIONBIO, &non_blocking))
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    opt = 1;
+    socket_ops::setsockopt(client.get(),
+        IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
+
+    non_blocking = 1;
+    if (socket_ops::ioctl(server.get(), FIONBIO, &non_blocking))
+    {
+      boost::asio::error e(socket_ops::get_error());
+      boost::throw_exception(e);
+    }
+
+    opt = 1;
+    socket_ops::setsockopt(server.get(),
+        IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
+
+    read_descriptor_ = server.release();
+    write_descriptor_ = client.release();
+  }
+
+  // Destructor.
+  ~socket_select_interrupter()
+  {
+    if (read_descriptor_ != invalid_socket)
+      socket_ops::close(read_descriptor_);
+    if (write_descriptor_ != invalid_socket)
+      socket_ops::close(write_descriptor_);
+  }
+
+  // Interrupt the select call.
+  void interrupt()
+  {
+    char byte = 0;
+    socket_ops::buf b;
+    socket_ops::init_buf(b, &byte, 1);
+    socket_ops::send(write_descriptor_, &b, 1, 0);
+  }
+
+  // Reset the select interrupt. Returns true if the call was interrupted.
+  bool reset()
+  {
+    char data[1024];
+    socket_ops::buf b;
+    socket_ops::init_buf(b, data, sizeof(data));
+    int bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0);
+    bool was_interrupted = (bytes_read > 0);
+    while (bytes_read == sizeof(data))
+      bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0);
+    return was_interrupted;
+  }
+
+  // Get the read descriptor to be passed to select.
+  socket_type read_descriptor() const
+  {
+    return read_descriptor_;
+  }
+
+private:
+  // The read end of a connection used to interrupt the select call. This file
+  // descriptor is passed to select such that when it is time to stop, a single
+  // byte will be written on the other end of the connection and this
+  // descriptor will become readable.
+  socket_type read_descriptor_;
+
+  // The write end of a connection used to interrupt the select call. A single
+  // byte may be written to this to wake up the select which is waiting for the
+  // other end to become readable.
+  socket_type write_descriptor_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
diff --git a/include/boost/asio/detail/socket_types.hpp b/include/boost/asio/detail/socket_types.hpp
new file mode 100644
index 0000000000..3338eeaccb
--- /dev/null
+++ b/include/boost/asio/detail/socket_types.hpp
@@ -0,0 +1,162 @@
+//
+// socket_types.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
+#define BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
+#  if defined(_MSC_VER) || defined(__BORLANDC__)
+#   pragma message("Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately")
+#   pragma message("Assuming _WIN32_WINNT=0x0500 (i.e. Windows 2000 target)")
+#  else // defined(_MSC_VER) || defined(__BORLANDC__)
+#   warning Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately
+#   warning Assuming _WIN32_WINNT=0x0500 (i.e. Windows 2000 target)
+#  endif // defined(_MSC_VER) || defined(__BORLANDC__)
+#  define _WIN32_WINNT 0x0500
+# endif // !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
+# if defined(__BORLANDC__) && !defined(_WSPIAPI_H_)
+#  include <stdlib.h> // Needed for __errno
+#  if defined(__WIN32__) && !defined(WIN32)
+#   define WIN32 // Needed for correct types in winsock2.h
+#  endif // defined(__WIN32__) && !defined(WIN32)
+#  define _WSPIAPI_H_
+#  define BOOST_ASIO_WSPIAPI_H_DEFINED
+# endif // defined(__BORLANDC__) && !defined(_WSPIAPI_H_)
+# define FD_SETSIZE 1024
+# if !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN)
+#  if !defined(WIN32_LEAN_AND_MEAN)
+#   define WIN32_LEAN_AND_MEAN
+#  endif // !defined(WIN32_LEAN_AND_MEAN)
+# endif // !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN)
+# if defined(__CYGWIN__)
+#  if !defined(__USE_W32_SOCKETS)
+#   error You must add -D__USE_W32_SOCKETS to your compiler options.
+#  endif // !defined(__USE_W32_SOCKETS)
+#  if !defined(NOMINMAX)
+#   define NOMINMAX 1
+#  endif // !defined(NOMINMAX)
+# endif // defined(__CYGWIN__)
+# include <winsock2.h>
+# include <ws2tcpip.h>
+# include <mswsock.h>
+# if defined(BOOST_ASIO_WSPIAPI_H_DEFINED)
+#  undef _WSPIAPI_H_
+#  undef BOOST_ASIO_WSPIAPI_H_DEFINED
+# endif // defined(BOOST_ASIO_WSPIAPI_H_DEFINED)
+# if !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
+#  if defined(_MSC_VER) || defined(__BORLANDC__)
+#   pragma comment(lib, "ws2_32.lib")
+#   pragma comment(lib, "mswsock.lib")
+#  endif // defined(_MSC_VER) || defined(__BORLANDC__)
+# endif // !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
+# include <boost/asio/detail/old_win_sdk_compat.hpp>
+#else
+# include <sys/ioctl.h>
+# include <sys/poll.h>
+# include <sys/types.h>
+# include <sys/select.h>
+# include <sys/socket.h>
+# include <sys/uio.h>
+# include <netinet/in.h>
+# include <netinet/tcp.h>
+# include <arpa/inet.h>
+# include <netdb.h>
+# include <net/if.h>
+# if defined(__sun)
+#  include <sys/filio.h>
+# endif
+#endif
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+typedef SOCKET socket_type;
+const SOCKET invalid_socket = INVALID_SOCKET;
+const int socket_error_retval = SOCKET_ERROR;
+const int max_addr_v4_str_len = 256;
+const int max_addr_v6_str_len = 256;
+typedef sockaddr socket_addr_type;
+typedef int socket_addr_len_type;
+typedef in_addr in4_addr_type;
+typedef ip_mreq in4_mreq_type;
+typedef sockaddr_in sockaddr_in4_type;
+# if defined(BOOST_ASIO_HAS_OLD_WIN_SDK)
+typedef in6_addr_emulation in6_addr_type;
+typedef ipv6_mreq_emulation in6_mreq_type;
+typedef sockaddr_in6_emulation sockaddr_in6_type;
+typedef sockaddr_storage_emulation sockaddr_storage_type;
+typedef addrinfo_emulation addrinfo_type;
+# else
+typedef in6_addr in6_addr_type;
+typedef ipv6_mreq in6_mreq_type;
+typedef sockaddr_in6 sockaddr_in6_type;
+typedef sockaddr_storage sockaddr_storage_type;
+typedef addrinfo addrinfo_type;
+# endif
+typedef unsigned long ioctl_arg_type;
+typedef u_long u_long_type;
+typedef u_short u_short_type;
+const int shutdown_receive = SD_RECEIVE;
+const int shutdown_send = SD_SEND;
+const int shutdown_both = SD_BOTH;
+const int message_peek = MSG_PEEK;
+const int message_out_of_band = MSG_OOB;
+const int message_do_not_route = MSG_DONTROUTE;
+#else
+typedef int socket_type;
+const int invalid_socket = -1;
+const int socket_error_retval = -1;
+const int max_addr_v4_str_len = INET_ADDRSTRLEN;
+const int max_addr_v6_str_len = INET6_ADDRSTRLEN + 1 + IF_NAMESIZE;
+typedef sockaddr socket_addr_type;
+typedef socklen_t socket_addr_len_type;
+typedef in_addr in4_addr_type;
+typedef ip_mreq in4_mreq_type;
+typedef sockaddr_in sockaddr_in4_type;
+typedef in6_addr in6_addr_type;
+typedef ipv6_mreq in6_mreq_type;
+typedef sockaddr_in6 sockaddr_in6_type;
+typedef sockaddr_storage sockaddr_storage_type;
+typedef addrinfo addrinfo_type;
+typedef int ioctl_arg_type;
+typedef uint32_t u_long_type;
+typedef uint16_t u_short_type;
+const int shutdown_receive = SHUT_RD;
+const int shutdown_send = SHUT_WR;
+const int shutdown_both = SHUT_RDWR;
+const int message_peek = MSG_PEEK;
+const int message_out_of_band = MSG_OOB;
+const int message_do_not_route = MSG_DONTROUTE;
+#endif
+const int custom_socket_option_level = 0xA5100000;
+const int enable_connection_aborted_option = 1;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
diff --git a/include/boost/asio/detail/strand_service.hpp b/include/boost/asio/detail/strand_service.hpp
new file mode 100644
index 0000000000..fb1eb6bf9c
--- /dev/null
+++ b/include/boost/asio/detail/strand_service.hpp
@@ -0,0 +1,427 @@
+//
+// strand_service.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/assert.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/strand_service.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Default service implementation for a strand.
+class strand_service
+  : public boost::asio::io_service::service
+{
+public:
+  class handler_base;
+  class invoke_current_handler;
+  class post_next_waiter_on_exit;
+
+  // The native type of the deadline timer.
+  class implementation_type
+  {
+  private:
+    // Only this service will have access to the internal values.
+    friend class strand_service;
+    friend class post_next_waiter_on_exit;
+    friend class invoke_current_handler;
+
+    // Mutex to protect access to internal data.
+    boost::asio::detail::mutex mutex_;
+
+    // The handler that is ready to execute. If this pointer is non-null then it
+    // indicates that a handler holds the lock.
+    handler_base* current_handler_;
+
+    // The start of the list of waiting handlers for the strand.
+    handler_base* first_waiter_;
+    
+    // The end of the list of waiting handlers for the strand.
+    handler_base* last_waiter_;
+
+    // Storage for posted handlers.
+    boost::aligned_storage<64> handler_storage_;
+
+    // Pointers to adjacent socket implementations in linked list.
+    implementation_type* next_;
+    implementation_type* prev_;
+  };
+
+  // Base class for all handler types.
+  class handler_base
+  {
+  public:
+    typedef void (*invoke_func_type)(handler_base*,
+        strand_service&, implementation_type&);
+    typedef void (*destroy_func_type)(handler_base*);
+
+    handler_base(invoke_func_type invoke_func, destroy_func_type destroy_func)
+      : next_(0),
+        invoke_func_(invoke_func),
+        destroy_func_(destroy_func)
+    {
+    }
+
+    void invoke(strand_service& service_impl, implementation_type& impl)
+    {
+      invoke_func_(this, service_impl, impl);
+    }
+
+    void destroy()
+    {
+      destroy_func_(this);
+    }
+
+  protected:
+    ~handler_base()
+    {
+    }
+
+  private:
+    friend class strand_service;
+    friend class post_next_waiter_on_exit;
+    handler_base* next_;
+    invoke_func_type invoke_func_;
+    destroy_func_type destroy_func_;
+  };
+
+  // Helper class to allow handlers to be dispatched.
+  class invoke_current_handler
+  {
+  public:
+    invoke_current_handler(strand_service& service_impl,
+        implementation_type& impl)
+      : service_impl_(service_impl),
+        impl_(impl)
+    {
+    }
+
+    void operator()()
+    {
+      impl_.current_handler_->invoke(service_impl_, impl_);
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        invoke_current_handler* this_handler)
+    {
+      return this_handler->do_handler_allocate(size);
+    }
+
+    friend void asio_handler_deallocate(void*, std::size_t,
+        invoke_current_handler*)
+    {
+    }
+
+    void* do_handler_allocate(std::size_t size)
+    {
+      BOOST_ASSERT(size <= impl_.handler_storage_.size);
+      return impl_.handler_storage_.address();
+    }
+
+  private:
+    strand_service& service_impl_;
+    implementation_type& impl_;
+  };
+
+  // Helper class to automatically enqueue next waiter on block exit.
+  class post_next_waiter_on_exit
+  {
+  public:
+    post_next_waiter_on_exit(strand_service& service_impl,
+        implementation_type& impl)
+      : service_impl_(service_impl),
+        impl_(impl),
+        cancelled_(false)
+    {
+    }
+
+    ~post_next_waiter_on_exit()
+    {
+      if (!cancelled_)
+      {
+        boost::asio::detail::mutex::scoped_lock lock(impl_.mutex_);
+        impl_.current_handler_ = impl_.first_waiter_;
+        if (impl_.current_handler_)
+        {
+          impl_.first_waiter_ = impl_.first_waiter_->next_;
+          if (impl_.first_waiter_ == 0)
+            impl_.last_waiter_ = 0;
+          lock.unlock();
+          service_impl_.owner().post(
+              invoke_current_handler(service_impl_, impl_));
+        }
+      }
+    }
+
+    void cancel()
+    {
+      cancelled_ = true;
+    }
+
+  private:
+    strand_service& service_impl_;
+    implementation_type& impl_;
+    bool cancelled_;
+  };
+
+  // Class template for a waiter.
+  template <typename Handler>
+  class handler_wrapper
+    : public handler_base
+  {
+  public:
+    handler_wrapper(Handler handler)
+      : handler_base(&handler_wrapper<Handler>::do_invoke,
+          &handler_wrapper<Handler>::do_destroy),
+        handler_(handler)
+    {
+    }
+
+    static void do_invoke(handler_base* base,
+        strand_service& service_impl, implementation_type& impl)
+    {
+      // Take ownership of the handler object.
+      typedef handler_wrapper<Handler> this_type;
+      this_type* h(static_cast<this_type*>(base));
+      typedef handler_alloc_traits<Handler, this_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(h->handler_, h);
+
+      post_next_waiter_on_exit p1(service_impl, impl);
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(h->handler_);
+
+      // A handler object must still be valid when the next waiter is posted
+      // since destroying the last handler might cause the strand object to be
+      // destroyed. Therefore we create a second post_next_waiter_on_exit object
+      // that will be destroyed before the handler object.
+      p1.cancel();
+      post_next_waiter_on_exit p2(service_impl, impl);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Make the upcall.
+      handler();
+    }
+
+    static void do_destroy(handler_base* base)
+    {
+      // Take ownership of the handler object.
+      typedef handler_wrapper<Handler> this_type;
+      this_type* h(static_cast<this_type*>(base));
+      typedef handler_alloc_traits<Handler, this_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(h->handler_, h);
+    }
+
+  private:
+    Handler handler_;
+  };
+
+  // Construct a new timer service for the specified io_service.
+  explicit strand_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      mutex_(),
+      impl_list_(0)
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    // Construct a list of all handlers to be destroyed.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    implementation_type* impl = impl_list_;
+    handler_base* first_handler = 0;
+    while (impl)
+    {
+      if (impl->current_handler_)
+      {
+        impl->current_handler_->next_ = first_handler;
+        first_handler = impl->current_handler_;
+        impl->current_handler_ = 0;
+      }
+      if (impl->first_waiter_)
+      {
+        impl->last_waiter_->next_ = first_handler;
+        first_handler = impl->first_waiter_;
+        impl->first_waiter_ = 0;
+        impl->last_waiter_ = 0;
+      }
+      impl = impl->next_;
+    }
+
+    // Destroy all handlers without holding the lock.
+    lock.unlock();
+    while (first_handler)
+    {
+      handler_base* next = first_handler->next_;
+      first_handler->destroy();
+      first_handler = next;
+    }
+  }
+
+  // Construct a new timer implementation.
+  void construct(implementation_type& impl)
+  {
+    impl.current_handler_ = 0;
+    impl.first_waiter_ = 0;
+    impl.last_waiter_ = 0;
+
+    // Insert implementation into linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    impl.next_ = impl_list_;
+    impl.prev_ = 0;
+    if (impl_list_)
+      impl_list_->prev_ = &impl;
+    impl_list_ = &impl;
+  }
+
+  // Destroy a timer implementation.
+  void destroy(implementation_type& impl)
+  {
+    if (impl.current_handler_)
+    {
+      impl.current_handler_->destroy();
+      impl.current_handler_ = 0;
+    }
+
+    while (impl.first_waiter_)
+    {
+      handler_base* next = impl.first_waiter_->next_;
+      impl.first_waiter_->destroy();
+      impl.first_waiter_ = next;
+    }
+    impl.last_waiter_ = 0;
+
+    // Remove implementation from linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  // Request the io_service to invoke the given handler.
+  template <typename Handler>
+  void dispatch(implementation_type& impl, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(impl.mutex_);
+
+    // Allocate and construct an object to wrap the handler.
+    typedef handler_wrapper<Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr, handler);
+
+    if (impl.current_handler_ == 0)
+    {
+      // This handler now has the lock, so can be dispatched immediately.
+      impl.current_handler_ = ptr.get();
+      lock.unlock();
+      owner().dispatch(invoke_current_handler(*this, impl));
+      ptr.release();
+    }
+    else
+    {
+      // Another handler already holds the lock, so this handler must join the
+      // list of waiters. The handler will be posted automatically when its turn
+      // comes.
+      if (impl.last_waiter_)
+      {
+        impl.last_waiter_->next_ = ptr.get();
+        impl.last_waiter_ = impl.last_waiter_->next_;
+      }
+      else
+      {
+        impl.first_waiter_ = ptr.get();
+        impl.last_waiter_ = ptr.get();
+      }
+      ptr.release();
+    }
+  }
+
+  // Request the io_service to invoke the given handler and return immediately.
+  template <typename Handler>
+  void post(implementation_type& impl, Handler handler)
+  {
+    boost::asio::detail::mutex::scoped_lock lock(impl.mutex_);
+
+    // Allocate and construct an object to wrap the handler.
+    typedef handler_wrapper<Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr, handler);
+
+    if (impl.current_handler_ == 0)
+    {
+      // This handler now has the lock, so can be dispatched immediately.
+      impl.current_handler_ = ptr.get();
+      lock.unlock();
+      owner().post(invoke_current_handler(*this, impl));
+      ptr.release();
+    }
+    else
+    {
+      // Another handler already holds the lock, so this handler must join the
+      // list of waiters. The handler will be posted automatically when its turn
+      // comes.
+      if (impl.last_waiter_)
+      {
+        impl.last_waiter_->next_ = ptr.get();
+        impl.last_waiter_ = impl.last_waiter_->next_;
+      }
+      else
+      {
+        impl.first_waiter_ = ptr.get();
+        impl.last_waiter_ = ptr.get();
+      }
+      ptr.release();
+    }
+  }
+
+private:
+  // Mutex to protect access to the linked list of implementations. 
+  boost::asio::detail::mutex mutex_;
+
+  // The head of a linked list of all implementations.
+  implementation_type* impl_list_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
diff --git a/include/boost/asio/detail/task_io_service.hpp b/include/boost/asio/detail/task_io_service.hpp
new file mode 100644
index 0000000000..ada43a4222
--- /dev/null
+++ b/include/boost/asio/detail/task_io_service.hpp
@@ -0,0 +1,459 @@
+//
+// task_io_service.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/call_stack.hpp>
+#include <boost/asio/detail/event.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/task_io_service_fwd.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Task>
+class task_io_service
+  : public boost::asio::io_service::service
+{
+public:
+  // Constructor.
+  task_io_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      mutex_(),
+      task_(use_service<Task>(io_service)),
+      outstanding_work_(0),
+      handler_queue_(&task_handler_),
+      handler_queue_end_(&task_handler_),
+      interrupted_(false),
+      shutdown_(false),
+      first_idle_thread_(0)
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    shutdown_ = true;
+    lock.unlock();
+
+    // Destroy handler objects.
+    while (handler_queue_)
+    {
+      handler_base* h = handler_queue_;
+      handler_queue_ = h->next_;
+      if (h != &task_handler_)
+        h->destroy();
+    }
+
+    // Reset handler queue to initial state.
+    handler_queue_ = &task_handler_;
+    handler_queue_end_ = &task_handler_;
+  }
+
+  // Run the event processing loop.
+  void run()
+  {
+    typename call_stack<task_io_service>::context ctx(this);
+
+    idle_thread_info this_idle_thread;
+    this_idle_thread.prev = &this_idle_thread;
+    this_idle_thread.next = &this_idle_thread;
+
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    while (!interrupted_ && outstanding_work_ > 0)
+    {
+      if (handler_queue_)
+      {
+        // Prepare to execute first handler from queue.
+        handler_base* h = handler_queue_;
+        handler_queue_ = h->next_;
+        if (handler_queue_ == 0)
+          handler_queue_end_ = 0;
+        bool more_handlers = (handler_queue_ != 0);
+        lock.unlock();
+
+        if (h == &task_handler_)
+        {
+          task_cleanup c(lock, handler_queue_,
+              handler_queue_end_, task_handler_);
+
+          // Run the task. May throw an exception. Only block if the handler
+          // queue is empty, otherwise we want to return as soon as possible to
+          // execute the handlers.
+          task_.run(!more_handlers);
+        }
+        else
+        {
+          handler_cleanup c(lock, outstanding_work_);
+
+          // Invoke the handler. May throw an exception.
+          h->call(); // call() deletes the handler object
+        }
+      }
+      else 
+      {
+        // Nothing to run right now, so just wait for work to do.
+        if (first_idle_thread_)
+        {
+          this_idle_thread.next = first_idle_thread_;
+          this_idle_thread.prev = first_idle_thread_->prev;
+          first_idle_thread_->prev->next = &this_idle_thread;
+          first_idle_thread_->prev = &this_idle_thread;
+        }
+        first_idle_thread_ = &this_idle_thread;
+        this_idle_thread.wakeup_event.clear();
+        lock.unlock();
+        this_idle_thread.wakeup_event.wait();
+        lock.lock();
+        if (this_idle_thread.next == &this_idle_thread)
+        {
+          first_idle_thread_ = 0;
+        }
+        else
+        {
+          if (first_idle_thread_ == &this_idle_thread)
+            first_idle_thread_ = this_idle_thread.next;
+          this_idle_thread.next->prev = this_idle_thread.prev;
+          this_idle_thread.prev->next = this_idle_thread.next;
+          this_idle_thread.next = &this_idle_thread;
+          this_idle_thread.prev = &this_idle_thread;
+        }
+      }
+    }
+
+    if (!interrupted_)
+    {
+      // No more work to do!
+      interrupt_all_threads();
+    }
+  }
+
+  // Interrupt the event processing loop.
+  void interrupt()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    interrupt_all_threads();
+  }
+
+  // Reset in preparation for a subsequent run invocation.
+  void reset()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    interrupted_ = false;
+  }
+
+  // Notify that some work has started.
+  void work_started()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    ++outstanding_work_;
+  }
+
+  // Notify that some work has finished.
+  void work_finished()
+  {
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (--outstanding_work_ == 0)
+      interrupt_all_threads();
+  }
+
+  // Request invocation of the given handler.
+  template <typename Handler>
+  void dispatch(Handler handler)
+  {
+    if (call_stack<task_io_service>::contains(this))
+      handler();
+    else
+      post(handler);
+  }
+
+  // Request invocation of the given handler and return immediately.
+  template <typename Handler>
+  void post(Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef handler_wrapper<Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr, handler);
+
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+    // If the service has been shut down we silently discard the handler.
+    if (shutdown_)
+      return;
+
+    // Add the handler to the end of the queue.
+    if (handler_queue_end_)
+    {
+      handler_queue_end_->next_ = ptr.get();
+      handler_queue_end_ = ptr.get();
+    }
+    else
+    {
+      handler_queue_ = handler_queue_end_ = ptr.get();
+    }
+    ptr.release();
+
+    // An undelivered handler is treated as unfinished work.
+    ++outstanding_work_;
+
+    // Wake up a thread to execute the handler.
+    if (!interrupt_one_idle_thread())
+      if (task_handler_.next_ == 0 && handler_queue_end_ != &task_handler_)
+        task_.interrupt();
+  }
+
+private:
+  // Interrupt the task and all idle threads.
+  void interrupt_all_threads()
+  {
+    interrupted_ = true;
+    interrupt_all_idle_threads();
+    if (task_handler_.next_ == 0 && handler_queue_end_ != &task_handler_)
+      task_.interrupt();
+  }
+
+  // Interrupt a single idle thread. Returns true if a thread was interrupted,
+  // false if no running thread could be found to interrupt.
+  bool interrupt_one_idle_thread()
+  {
+    if (first_idle_thread_)
+    {
+      first_idle_thread_->wakeup_event.signal();
+      first_idle_thread_ = first_idle_thread_->next;
+      return true;
+    }
+    return false;
+  }
+
+  // Interrupt all idle threads.
+  void interrupt_all_idle_threads()
+  {
+    if (first_idle_thread_)
+    {
+      first_idle_thread_->wakeup_event.signal();
+      idle_thread_info* current_idle_thread = first_idle_thread_->next;
+      while (current_idle_thread != first_idle_thread_)
+      {
+        current_idle_thread->wakeup_event.signal();
+        current_idle_thread = current_idle_thread->next;
+      }
+    }
+  }
+
+  class task_cleanup;
+
+  // The base class for all handler wrappers. A function pointer is used
+  // instead of virtual functions to avoid the associated overhead.
+  class handler_base
+  {
+  public:
+    typedef void (*call_func_type)(handler_base*);
+    typedef void (*destroy_func_type)(handler_base*);
+
+    handler_base(call_func_type call_func, destroy_func_type destroy_func)
+      : next_(0),
+        call_func_(call_func),
+        destroy_func_(destroy_func)
+    {
+    }
+
+    void call()
+    {
+      call_func_(this);
+    }
+
+    void destroy()
+    {
+      destroy_func_(this);
+    }
+
+  protected:
+    // Prevent deletion through this type.
+    ~handler_base()
+    {
+    }
+
+  private:
+    friend class task_io_service<Task>;
+    friend class task_cleanup;
+    handler_base* next_;
+    call_func_type call_func_;
+    destroy_func_type destroy_func_;
+  };
+
+  // Template wrapper for handlers.
+  template <typename Handler>
+  class handler_wrapper
+    : public handler_base
+  {
+  public:
+    handler_wrapper(Handler handler)
+      : handler_base(&handler_wrapper<Handler>::do_call,
+          &handler_wrapper<Handler>::do_destroy),
+        handler_(handler)
+    {
+    }
+
+    static void do_call(handler_base* base)
+    {
+      // Take ownership of the handler object.
+      typedef handler_wrapper<Handler> this_type;
+      this_type* h(static_cast<this_type*>(base));
+      typedef handler_alloc_traits<Handler, this_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(h->handler_, h);
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(h->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Make the upcall.
+      handler();
+    }
+
+    static void do_destroy(handler_base* base)
+    {
+      // Take ownership of the handler object.
+      typedef handler_wrapper<Handler> this_type;
+      this_type* h(static_cast<this_type*>(base));
+      typedef handler_alloc_traits<Handler, this_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(h->handler_, h);
+    }
+
+  private:
+    Handler handler_;
+  };
+
+  // Helper class to perform task-related operations on block exit.
+  class task_cleanup
+  {
+  public:
+    task_cleanup(boost::asio::detail::mutex::scoped_lock& lock,
+        handler_base*& handler_queue, handler_base*& handler_queue_end,
+        handler_base& task_handler)
+      : lock_(lock),
+        handler_queue_(handler_queue),
+        handler_queue_end_(handler_queue_end),
+        task_handler_(task_handler)
+    {
+    }
+
+    ~task_cleanup()
+    {
+      // Reinsert the task at the end of the handler queue.
+      lock_.lock();
+      task_handler_.next_ = 0;
+      if (handler_queue_end_)
+      {
+        handler_queue_end_->next_ = &task_handler_;
+        handler_queue_end_ = &task_handler_;
+      }
+      else
+      {
+        handler_queue_ = handler_queue_end_ = &task_handler_;
+      }
+    }
+
+  private:
+    boost::asio::detail::mutex::scoped_lock& lock_;
+    handler_base*& handler_queue_;
+    handler_base*& handler_queue_end_;
+    handler_base& task_handler_;
+  };
+
+  // Helper class to perform handler-related operations on block exit.
+  class handler_cleanup
+  {
+  public:
+    handler_cleanup(boost::asio::detail::mutex::scoped_lock& lock,
+        int& outstanding_work)
+      : lock_(lock),
+        outstanding_work_(outstanding_work)
+    {
+    }
+
+    ~handler_cleanup()
+    {
+      lock_.lock();
+      --outstanding_work_;
+    }
+
+  private:
+    boost::asio::detail::mutex::scoped_lock& lock_;
+    int& outstanding_work_;
+  };
+
+  // Mutex to protect access to internal data.
+  boost::asio::detail::mutex mutex_;
+
+  // The task to be run by this service.
+  Task& task_;
+
+  // Handler object to represent the position of the task in the queue.
+  class task_handler
+    : public handler_base
+  {
+  public:
+    task_handler()
+      : handler_base(0, 0)
+    {
+    }
+  } task_handler_;
+
+  // The count of unfinished work.
+  int outstanding_work_;
+
+  // The start of a linked list of handlers that are ready to be delivered.
+  handler_base* handler_queue_;
+
+  // The end of a linked list of handlers that are ready to be delivered.
+  handler_base* handler_queue_end_;
+
+  // Flag to indicate that the dispatcher has been interrupted.
+  bool interrupted_;
+
+  // Flag to indicate that the dispatcher has been shut down.
+  bool shutdown_;
+
+  // Structure containing information about an idle thread.
+  struct idle_thread_info
+  {
+    event wakeup_event;
+    idle_thread_info* prev;
+    idle_thread_info* next;
+  };
+
+  // The number of threads that are currently idle.
+  idle_thread_info* first_idle_thread_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
diff --git a/include/boost/asio/detail/task_io_service_fwd.hpp b/include/boost/asio/detail/task_io_service_fwd.hpp
new file mode 100644
index 0000000000..795e1e0708
--- /dev/null
+++ b/include/boost/asio/detail/task_io_service_fwd.hpp
@@ -0,0 +1,33 @@
+//
+// task_io_service_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP
+#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Task>
+class task_io_service;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP
diff --git a/include/boost/asio/detail/thread.hpp b/include/boost/asio/detail/thread.hpp
new file mode 100644
index 0000000000..742e1ce87b
--- /dev/null
+++ b/include/boost/asio/detail/thread.hpp
@@ -0,0 +1,52 @@
+//
+// thread.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_THREAD_HPP
+#define BOOST_ASIO_DETAIL_THREAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+# include <boost/asio/detail/null_thread.hpp>
+#elif defined(BOOST_WINDOWS)
+# include <boost/asio/detail/win_thread.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/asio/detail/posix_thread.hpp>
+#else
+# error Only Windows and POSIX are supported!
+#endif
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if !defined(BOOST_HAS_THREADS)
+typedef null_thread thread;
+#elif defined(BOOST_WINDOWS)
+typedef win_thread thread;
+#elif defined(BOOST_HAS_PTHREADS)
+typedef posix_thread thread;
+#endif
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_THREAD_HPP
diff --git a/include/boost/asio/detail/tss_ptr.hpp b/include/boost/asio/detail/tss_ptr.hpp
new file mode 100644
index 0000000000..bc4264afdb
--- /dev/null
+++ b/include/boost/asio/detail/tss_ptr.hpp
@@ -0,0 +1,67 @@
+//
+// tss_ptr.hpp
+// ~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_TSS_PTR_HPP
+#define BOOST_ASIO_DETAIL_TSS_PTR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if !defined(BOOST_HAS_THREADS)
+# include <boost/asio/detail/null_tss_ptr.hpp>
+#elif defined(BOOST_WINDOWS)
+# include <boost/asio/detail/win_tss_ptr.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+# include <boost/asio/detail/posix_tss_ptr.hpp>
+#else
+# error Only Windows and POSIX are supported!
+#endif
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename T>
+class tss_ptr
+#if !defined(BOOST_HAS_THREADS)
+  : public null_tss_ptr<T>
+#elif defined(BOOST_WINDOWS)
+  : public win_tss_ptr<T>
+#elif defined(BOOST_HAS_PTHREADS)
+  : public posix_tss_ptr<T>
+#endif
+{
+public:
+  void operator=(T* value)
+  {
+#if !defined(BOOST_HAS_THREADS)
+    null_tss_ptr<T>::operator=(value);
+#elif defined(BOOST_WINDOWS)
+    win_tss_ptr<T>::operator=(value);
+#elif defined(BOOST_HAS_PTHREADS)
+    posix_tss_ptr<T>::operator=(value);
+#endif
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_TSS_PTR_HPP
diff --git a/include/boost/asio/detail/win_event.hpp b/include/boost/asio/detail/win_event.hpp
new file mode 100644
index 0000000000..89860021ca
--- /dev/null
+++ b/include/boost/asio/detail/win_event.hpp
@@ -0,0 +1,90 @@
+//
+// win_event.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_EVENT_HPP
+#define BOOST_ASIO_DETAIL_WIN_EVENT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS)
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_event
+  : private noncopyable
+{
+public:
+  // Constructor.
+  win_event()
+    : event_(::CreateEvent(0, true, false, 0))
+  {
+    if (!event_)
+    {
+      DWORD last_error = ::GetLastError();
+      system_exception e("event", last_error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~win_event()
+  {
+    ::CloseHandle(event_);
+  }
+
+  // Signal the event.
+  void signal()
+  {
+    ::SetEvent(event_);
+  }
+
+  // Reset the event.
+  void clear()
+  {
+    ::ResetEvent(event_);
+  }
+
+  // Wait for the event to become signalled.
+  void wait()
+  {
+    ::WaitForSingleObject(event_, INFINITE);
+  }
+
+private:
+  HANDLE event_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_EVENT_HPP
diff --git a/include/boost/asio/detail/win_iocp_io_service.hpp b/include/boost/asio/detail/win_iocp_io_service.hpp
new file mode 100644
index 0000000000..34c4eeaee1
--- /dev/null
+++ b/include/boost/asio/detail/win_iocp_io_service.hpp
@@ -0,0 +1,334 @@
+//
+// win_iocp_io_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/call_stack.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/win_iocp_operation.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_iocp_io_service
+  : public boost::asio::io_service::service
+{
+public:
+  // Base class for all operations.
+  typedef win_iocp_operation operation;
+
+  // Constructor.
+  win_iocp_io_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      iocp_(::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0)),
+      outstanding_work_(0),
+      interrupted_(0),
+      shutdown_(0)
+  {
+    if (!iocp_.handle)
+    {
+      DWORD last_error = ::GetLastError();
+      system_exception e("iocp", last_error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    ::InterlockedExchange(&shutdown_, 1);
+
+    for (;;)
+    {
+      DWORD bytes_transferred = 0;
+#if (WINVER < 0x0500)
+      DWORD completion_key = 0;
+#else
+      DWORD_PTR completion_key = 0;
+#endif
+      LPOVERLAPPED overlapped = 0;
+      ::GetQueuedCompletionStatus(iocp_.handle,
+          &bytes_transferred, &completion_key, &overlapped, 0);
+      DWORD last_error = ::GetLastError();
+      if (last_error == WAIT_TIMEOUT)
+        break;
+      if (overlapped)
+        static_cast<operation*>(overlapped)->destroy();
+    }
+  }
+
+  // Register a socket with the IO completion port.
+  void register_socket(socket_type sock)
+  {
+    HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock);
+    ::CreateIoCompletionPort(sock_as_handle, iocp_.handle, 0, 0);
+  }
+
+  struct auto_work
+  {
+    auto_work(win_iocp_io_service& io_service)
+      : io_service_(io_service)
+    {
+      io_service_.work_started();
+    }
+
+    ~auto_work()
+    {
+      io_service_.work_finished();
+    }
+
+  private:
+    win_iocp_io_service& io_service_;
+  };
+
+  // Run the event processing loop.
+  void run()
+  {
+    if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
+      return;
+
+    call_stack<win_iocp_io_service>::context ctx(this);
+
+    for (;;)
+    {
+      // Get the next operation from the queue.
+      DWORD bytes_transferred = 0;
+#if (WINVER < 0x0500)
+      DWORD completion_key = 0;
+#else
+      DWORD_PTR completion_key = 0;
+#endif
+      LPOVERLAPPED overlapped = 0;
+      ::SetLastError(0);
+      ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
+          &completion_key, &overlapped, INFINITE);
+      DWORD last_error = ::GetLastError();
+
+      if (overlapped)
+      {
+        // We may have been passed a last_error value in the completion_key.
+        if (last_error == 0)
+        {
+          last_error = completion_key;
+        }
+
+        // Ensure that the io_service does not exit due to running out of work
+        // while we make the upcall.
+        auto_work work(*this);
+
+        // Dispatch the operation.
+        operation* op = static_cast<operation*>(overlapped);
+        op->do_completion(last_error, bytes_transferred);
+      }
+      else
+      {
+        // The interrupted_ flag is always checked to ensure that any leftover
+        // interrupts from a previous run invocation are ignored.
+        if (::InterlockedExchangeAdd(&interrupted_, 0) != 0)
+        {
+          // Wake up next thread that is blocked on GetQueuedCompletionStatus.
+          if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
+          {
+            DWORD last_error = ::GetLastError();
+            system_exception e("pqcs", last_error);
+            boost::throw_exception(e);
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  // Interrupt the event processing loop.
+  void interrupt()
+  {
+    if (::InterlockedExchange(&interrupted_, 1) == 0)
+    {
+      if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
+      {
+        DWORD last_error = ::GetLastError();
+        system_exception e("pqcs", last_error);
+        boost::throw_exception(e);
+      }
+    }
+  }
+
+  // Reset in preparation for a subsequent run invocation.
+  void reset()
+  {
+    ::InterlockedExchange(&interrupted_, 0);
+  }
+
+  // Notify that some work has started.
+  void work_started()
+  {
+    ::InterlockedIncrement(&outstanding_work_);
+  }
+
+  // Notify that some work has finished.
+  void work_finished()
+  {
+    if (::InterlockedDecrement(&outstanding_work_) == 0)
+      interrupt();
+  }
+
+  template <typename Handler>
+  struct handler_operation
+    : public operation
+  {
+    handler_operation(win_iocp_io_service& io_service,
+        Handler handler)
+      : operation(&handler_operation<Handler>::do_completion_impl,
+          &handler_operation<Handler>::destroy_impl),
+        io_service_(io_service),
+        handler_(handler)
+    {
+      io_service_.work_started();
+    }
+
+    ~handler_operation()
+    {
+      io_service_.work_finished();
+    }
+
+  private:
+    // Prevent copying and assignment.
+    handler_operation(const handler_operation&);
+    void operator=(const handler_operation&);
+    
+    static void do_completion_impl(operation* op, DWORD, size_t)
+    {
+      // Take ownership of the operation object.
+      typedef handler_operation<Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Make the upcall.
+      handler();
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef handler_operation<Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    win_iocp_io_service& io_service_;
+    Handler handler_;
+  };
+
+  // Request invocation of the given handler.
+  template <typename Handler>
+  void dispatch(Handler handler)
+  {
+    if (call_stack<win_iocp_io_service>::contains(this))
+      handler();
+    else
+      post(handler);
+  }
+
+  // Request invocation of the given handler and return immediately.
+  template <typename Handler>
+  void post(Handler handler)
+  {
+    // If the service has been shut down we silently discard the handler.
+    if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
+      return;
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef handler_operation<Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr, *this, handler);
+
+    // Enqueue the operation on the I/O completion port.
+    if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, ptr.get()))
+    {
+      DWORD last_error = ::GetLastError();
+      system_exception e("pqcs", last_error);
+      boost::throw_exception(e);
+    }
+
+    // Operation has been successfully posted.
+    ptr.release();
+  }
+
+  // Request invocation of the given OVERLAPPED-derived operation.
+  void post_completion(win_iocp_operation* op, DWORD op_last_error,
+      DWORD bytes_transferred)
+  {
+    // Enqueue the operation on the I/O completion port.
+    if (!::PostQueuedCompletionStatus(iocp_.handle,
+          bytes_transferred, op_last_error, op))
+    {
+      DWORD last_error = ::GetLastError();
+      system_exception e("pqcs", last_error);
+      boost::throw_exception(e);
+    }
+  }
+
+private:
+  // The IO completion port used for queueing operations.
+  struct iocp_holder
+  {
+    HANDLE handle;
+    iocp_holder(HANDLE h) : handle(h) {}
+    ~iocp_holder() { ::CloseHandle(handle); }
+  } iocp_;
+
+  // The count of unfinished work.
+  long outstanding_work_;
+
+  // Flag to indicate whether the event loop has been interrupted.
+  long interrupted_;
+
+  // Flag to indicate whether the service has been shut down.
+  long shutdown_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
diff --git a/include/boost/asio/detail/win_iocp_io_service_fwd.hpp b/include/boost/asio/detail/win_iocp_io_service_fwd.hpp
new file mode 100644
index 0000000000..657bbbba72
--- /dev/null
+++ b/include/boost/asio/detail/win_iocp_io_service_fwd.hpp
@@ -0,0 +1,48 @@
+//
+// win_iocp_io_service_fwd.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+// This service is only supported on Win32 (NT4 and later).
+#if !defined(BOOST_ASIO_DISABLE_IOCP)
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
+
+// Define this to indicate that IOCP is supported on the target platform.
+#define BOOST_ASIO_HAS_IOCP 1
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_iocp_io_service;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_DISABLE_IOCP)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP
diff --git a/include/boost/asio/detail/win_iocp_operation.hpp b/include/boost/asio/detail/win_iocp_operation.hpp
new file mode 100644
index 0000000000..92b9d47a58
--- /dev/null
+++ b/include/boost/asio/detail/win_iocp_operation.hpp
@@ -0,0 +1,83 @@
+//
+// win_iocp_operation.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+// Base class for all IOCP operations. A function pointer is used instead of
+// virtual functions to avoid the associated overhead.
+//
+// This class inherits from OVERLAPPED so that we can downcast to get back to
+// the win_iocp_operation pointer from the LPOVERLAPPED out parameter of
+// GetQueuedCompletionStatus.
+struct win_iocp_operation
+  : public OVERLAPPED
+{
+  typedef void (*invoke_func_type)(win_iocp_operation*, DWORD, size_t);
+  typedef void (*destroy_func_type)(win_iocp_operation*);
+
+  win_iocp_operation(invoke_func_type invoke_func,
+      destroy_func_type destroy_func)
+    : invoke_func_(invoke_func),
+      destroy_func_(destroy_func)
+  {
+    Internal = 0;
+    InternalHigh = 0;
+    Offset = 0;
+    OffsetHigh = 0;
+    hEvent = 0;
+  }
+
+  void do_completion(DWORD last_error, size_t bytes_transferred)
+  {
+    invoke_func_(this, last_error, bytes_transferred);
+  }
+
+  void destroy()
+  {
+    destroy_func_(this);
+  }
+
+protected:
+  // Prevent deletion through this type.
+  ~win_iocp_operation()
+  {
+  }
+
+private:
+  invoke_func_type invoke_func_;
+  destroy_func_type destroy_func_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
diff --git a/include/boost/asio/detail/win_iocp_socket_service.hpp b/include/boost/asio/detail/win_iocp_socket_service.hpp
new file mode 100644
index 0000000000..b3a146c746
--- /dev/null
+++ b/include/boost/asio/detail/win_iocp_socket_service.hpp
@@ -0,0 +1,1825 @@
+//
+// win_iocp_socket_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstring>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/select_reactor.hpp>
+#include <boost/asio/detail/socket_holder.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/win_iocp_io_service.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class win_iocp_socket_service
+  : public boost::asio::io_service::service
+{
+public:
+  // The protocol type.
+  typedef Protocol protocol_type;
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // Base class for all operations.
+  typedef win_iocp_operation operation;
+
+  struct noop_deleter { void operator()(void*) {} };
+  typedef boost::shared_ptr<void> shared_cancel_token_type;
+  typedef boost::weak_ptr<void> weak_cancel_token_type;
+
+  // The native type of a socket.
+  typedef socket_type native_type;
+
+  // The implementation type of the socket.
+  class implementation_type
+  {
+  public:
+    // Default constructor.
+    implementation_type()
+      : socket_(invalid_socket),
+        flags_(0),
+        cancel_token_(),
+        protocol_(endpoint_type().protocol()),
+        next_(0),
+        prev_(0)
+    {
+    }
+
+  private:
+    // Only this service will have access to the internal values.
+    friend class win_iocp_socket_service;
+
+    // The native socket representation.
+    socket_type socket_;
+
+    enum
+    {
+      enable_connection_aborted = 1 // User wants connection_aborted errors.
+    };
+
+    // Flags indicating the current state of the socket.
+    unsigned char flags_;
+
+    // We use a shared pointer as a cancellation token here to work around the
+    // broken Windows support for cancellation. MSDN says that when you call
+    // closesocket any outstanding WSARecv or WSASend operations will complete
+    // with the error ERROR_OPERATION_ABORTED. In practice they complete with
+    // ERROR_NETNAME_DELETED, which means you can't tell the difference between
+    // a local cancellation and the socket being hard-closed by the peer.
+    shared_cancel_token_type cancel_token_;
+
+    // The protocol associated with the socket.
+    protocol_type protocol_;
+
+    // Pointers to adjacent socket implementations in linked list.
+    implementation_type* next_;
+    implementation_type* prev_;
+  };
+
+  // The type of the reactor used for connect operations.
+  typedef detail::select_reactor<true> reactor_type;
+
+  // The maximum number of buffers to support in a single operation.
+  enum { max_buffers = 16 };
+
+  // Constructor.
+  win_iocp_socket_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      iocp_service_(boost::asio::use_service<win_iocp_io_service>(io_service)),
+      reactor_(0),
+      mutex_(),
+      impl_list_(0)
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    // Close all implementations, causing all operations to complete.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    implementation_type* impl = impl_list_;
+    while (impl)
+    {
+      close(*impl, boost::asio::ignore_error());
+      impl = impl->next_;
+    }
+  }
+
+  // Construct a new socket implementation.
+  void construct(implementation_type& impl)
+  {
+    impl.socket_ = invalid_socket;
+    impl.cancel_token_.reset();
+
+    // Insert implementation into linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    impl.next_ = impl_list_;
+    impl.prev_ = 0;
+    if (impl_list_)
+      impl_list_->prev_ = &impl;
+    impl_list_ = &impl;
+  }
+
+  // Destroy a socket implementation.
+  void destroy(implementation_type& impl)
+  {
+    close(impl, boost::asio::ignore_error());
+
+    // Remove implementation from linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  // Open a new socket implementation.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const protocol_type& protocol,
+      Error_Handler error_handler)
+  {
+    close(impl, boost::asio::ignore_error());
+
+    socket_holder sock(socket_ops::socket(protocol.family(), protocol.type(),
+          protocol.protocol()));
+    if (sock.get() == invalid_socket)
+    {
+      error_handler(boost::asio::error(socket_ops::get_error()));
+      return;
+    }
+
+    iocp_service_.register_socket(sock.get());
+
+    impl.socket_ = sock.release();
+    impl.cancel_token_.reset(static_cast<void*>(0), noop_deleter());
+    impl.protocol_ = protocol;
+
+    error_handler(boost::asio::error(0));
+  }
+
+  // Assign a native socket to a socket implementation.
+  template <typename Error_Handler>
+  void assign(implementation_type& impl, const protocol_type& protocol,
+      const native_type& native_socket, Error_Handler error_handler)
+  {
+    close(impl, boost::asio::ignore_error());
+
+    iocp_service_.register_socket(native_socket);
+
+    impl.socket_ = native_socket;
+    impl.cancel_token_.reset(static_cast<void*>(0), noop_deleter());
+    impl.protocol_ = protocol;
+
+    error_handler(boost::asio::error(0));
+  }
+
+  // Destroy a socket implementation.
+  template <typename Error_Handler>
+  void close(implementation_type& impl, Error_Handler error_handler)
+  {
+    if (impl.socket_ != invalid_socket)
+    {
+      // 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_type* reactor = static_cast<reactor_type*>(
+            interlocked_compare_exchange_pointer(
+              reinterpret_cast<void**>(&reactor_), 0, 0));
+      if (reactor)
+        reactor->close_descriptor(impl.socket_);
+
+      if (socket_ops::close(impl.socket_) == socket_error_retval)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+      else
+      {
+        impl.socket_ = invalid_socket;
+        impl.cancel_token_.reset();
+      }
+    }
+
+    error_handler(boost::asio::error(0));
+  }
+
+  // Get the native socket representation.
+  native_type native(implementation_type& impl)
+  {
+    return impl.socket_;
+  }
+
+  // Bind the socket to the specified local endpoint.
+  template <typename Error_Handler>
+  void bind(implementation_type& impl, const endpoint_type& endpoint,
+      Error_Handler error_handler)
+  {
+    if (socket_ops::bind(impl.socket_, endpoint.data(),
+          endpoint.size()) == socket_error_retval)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Place the socket into the state where it will listen for new connections.
+  template <typename Error_Handler>
+  void listen(implementation_type& impl, int backlog,
+      Error_Handler error_handler)
+  {
+    if (backlog == 0)
+      backlog = SOMAXCONN;
+
+    if (socket_ops::listen(impl.socket_, backlog) == socket_error_retval)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void set_option(implementation_type& impl, const Option& option,
+      Error_Handler error_handler)
+  {
+    if (option.level(impl.protocol_) == custom_socket_option_level
+        && option.name(impl.protocol_) == enable_connection_aborted_option)
+    {
+      if (option.size(impl.protocol_) != sizeof(int))
+      {
+        error_handler(boost::asio::error(boost::asio::error::invalid_argument));
+      }
+      else
+      {
+        if (*static_cast<const int*>(option.data(impl.protocol_)))
+          impl.flags_ |= implementation_type::enable_connection_aborted;
+        else
+          impl.flags_ &= ~implementation_type::enable_connection_aborted;
+        error_handler(boost::asio::error(0));
+      }
+    }
+    else
+    {
+      if (socket_ops::setsockopt(impl.socket_,
+            option.level(impl.protocol_), option.name(impl.protocol_),
+            option.data(impl.protocol_), option.size(impl.protocol_)))
+        error_handler(boost::asio::error(socket_ops::get_error()));
+      else
+        error_handler(boost::asio::error(0));
+    }
+  }
+
+  // Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void get_option(const implementation_type& impl, Option& option,
+      Error_Handler error_handler) const
+  {
+    if (option.level(impl.protocol_) == custom_socket_option_level
+        && option.name(impl.protocol_) == enable_connection_aborted_option)
+    {
+      if (option.size(impl.protocol_) != sizeof(int))
+      {
+        error_handler(boost::asio::error(boost::asio::error::invalid_argument));
+      }
+      else
+      {
+        int* target = static_cast<int*>(option.data(impl.protocol_));
+        if (impl.flags_ & implementation_type::enable_connection_aborted)
+          *target = 1;
+        else
+          *target = 0;
+        error_handler(boost::asio::error(0));
+      }
+    }
+    else
+    {
+      size_t size = option.size(impl.protocol_);
+      if (socket_ops::getsockopt(impl.socket_,
+            option.level(impl.protocol_), option.name(impl.protocol_),
+            option.data(impl.protocol_), &size))
+        error_handler(boost::asio::error(socket_ops::get_error()));
+      else
+        error_handler(boost::asio::error(0));
+    }
+  }
+
+  // Perform an IO control command on the socket.
+  template <typename IO_Control_Command, typename Error_Handler>
+  void io_control(implementation_type& impl, IO_Control_Command& command,
+      Error_Handler error_handler)
+  {
+    if (socket_ops::ioctl(impl.socket_, command.name(),
+          static_cast<ioctl_arg_type*>(command.data())))
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Get the local endpoint.
+  template <typename Error_Handler>
+  void get_local_endpoint(const implementation_type& impl,
+      endpoint_type& endpoint, Error_Handler error_handler) const
+  {
+    socket_addr_len_type addr_len = endpoint.capacity();
+    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len))
+    {
+      error_handler(boost::asio::error(socket_ops::get_error()));
+      return;
+    }
+
+    endpoint.resize(addr_len);
+    error_handler(boost::asio::error(0));
+  }
+
+  // Get the remote endpoint.
+  template <typename Error_Handler>
+  void get_remote_endpoint(const implementation_type& impl,
+      endpoint_type& endpoint, Error_Handler error_handler) const
+  {
+    socket_addr_len_type addr_len = endpoint.capacity();
+    if (socket_ops::getpeername(impl.socket_, endpoint.data(), &addr_len))
+    {
+      error_handler(boost::asio::error(socket_ops::get_error()));
+      return;
+    }
+
+    endpoint.resize(addr_len);
+    error_handler(boost::asio::error(0));
+  }
+
+  /// Disable sends or receives on the socket.
+  template <typename Error_Handler>
+  void shutdown(implementation_type& impl, socket_base::shutdown_type what,
+      Error_Handler error_handler)
+  {
+    if (socket_ops::shutdown(impl.socket_, what) != 0)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  // Send the given data to the peer. Returns the number of bytes sent.
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = const_cast<char*>(
+          boost::asio::buffer_cast<const char*>(buffer));
+    }
+
+    // Send the data.
+    DWORD bytes_transferred = 0;
+    int result = ::WSASend(impl.socket_, bufs,
+        i, &bytes_transferred, flags, 0, 0);
+    if (result != 0)
+    {
+      DWORD last_error = ::WSAGetLastError();
+      if (last_error == ERROR_NETNAME_DELETED)
+        last_error = WSAECONNRESET;
+      error_handler(boost::asio::error(last_error));
+      return 0;
+    }
+
+    error_handler(boost::asio::error(0));
+    return bytes_transferred;
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  class send_operation
+    : public operation
+  {
+  public:
+    send_operation(boost::asio::io_service& io_service,
+        weak_cancel_token_type cancel_token,
+        const Const_Buffers& buffers, Handler handler)
+      : operation(
+          &send_operation<Const_Buffers, Handler>::do_completion_impl,
+          &send_operation<Const_Buffers, Handler>::destroy_impl),
+        work_(io_service),
+        cancel_token_(cancel_token),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+  private:
+    static void do_completion_impl(operation* op,
+        DWORD last_error, size_t bytes_transferred)
+    {
+      // Take ownership of the operation object.
+      typedef send_operation<Const_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Map ERROR_NETNAME_DELETED to more useful error.
+      if (last_error == ERROR_NETNAME_DELETED)
+      {
+        if (handler_op->cancel_token_.expired())
+          last_error = ERROR_OPERATION_ABORTED;
+        else
+          last_error = WSAECONNRESET;
+      }
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Call the handler.
+      boost::asio::error error(last_error);
+      handler(error, bytes_transferred);
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef send_operation<Const_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    boost::asio::io_service::work work_;
+    weak_cancel_token_type cancel_token_;
+    Const_Buffers buffers_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef send_operation<Const_Buffers, Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr,
+        owner(), impl.cancel_token_, buffers, handler);
+
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = const_cast<char*>(
+          boost::asio::buffer_cast<const char*>(buffer));
+    }
+
+    // Send the data.
+    DWORD bytes_transferred = 0;
+    int result = ::WSASend(impl.socket_, bufs, i,
+        &bytes_transferred, flags, ptr.get(), 0);
+    DWORD last_error = ::WSAGetLastError();
+
+    // Check if the operation completed immediately.
+    if (result != 0 && last_error != WSA_IO_PENDING)
+    {
+      ptr.reset();
+      boost::asio::error error(last_error);
+      iocp_service_.post(bind_handler(handler, error, bytes_transferred));
+    }
+    else
+    {
+      ptr.release();
+    }
+  }
+
+  // Send a datagram to the specified endpoint. Returns the number of bytes
+  // sent.
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t send_to(implementation_type& impl, const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = const_cast<char*>(
+          boost::asio::buffer_cast<const char*>(buffer));
+    }
+
+    // Send the data.
+    DWORD bytes_transferred = 0;
+    int result = ::WSASendTo(impl.socket_, bufs, i, &bytes_transferred,
+        flags, destination.data(), destination.size(), 0, 0);
+    if (result != 0)
+    {
+      DWORD last_error = ::WSAGetLastError();
+      error_handler(boost::asio::error(last_error));
+      return 0;
+    }
+
+    error_handler(boost::asio::error(0));
+    return bytes_transferred;
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  class send_to_operation
+    : public operation
+  {
+  public:
+    send_to_operation(boost::asio::io_service& io_service,
+        const Const_Buffers& buffers, Handler handler)
+      : operation(
+          &send_to_operation<Const_Buffers, Handler>::do_completion_impl,
+          &send_to_operation<Const_Buffers, Handler>::destroy_impl),
+        work_(io_service),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+  private:
+    static void do_completion_impl(operation* op,
+        DWORD last_error, size_t bytes_transferred)
+    {
+      // Take ownership of the operation object.
+      typedef send_to_operation<Const_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Call the handler.
+      boost::asio::error error(last_error);
+      handler(error, bytes_transferred);
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef send_to_operation<Const_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    boost::asio::io_service::work work_;
+    Const_Buffers buffers_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename Const_Buffers, typename Handler>
+  void async_send_to(implementation_type& impl, const Const_Buffers& buffers,
+      const endpoint_type& destination, socket_base::message_flags flags,
+      Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef send_to_operation<Const_Buffers, Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr, owner(), buffers, handler);
+
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = const_cast<char*>(
+          boost::asio::buffer_cast<const char*>(buffer));
+    }
+
+    // Send the data.
+    DWORD bytes_transferred = 0;
+    int result = ::WSASendTo(impl.socket_, bufs, i, &bytes_transferred,
+        flags, destination.data(), destination.size(), ptr.get(), 0);
+    DWORD last_error = ::WSAGetLastError();
+
+    // Check if the operation completed immediately.
+    if (result != 0 && last_error != WSA_IO_PENDING)
+    {
+      ptr.reset();
+      boost::asio::error error(last_error);
+      iocp_service_.post(bind_handler(handler, error, bytes_transferred));
+    }
+    else
+    {
+      ptr.release();
+    }
+  }
+
+  // Receive some data from the peer. Returns the number of bytes received.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = boost::asio::buffer_cast<char*>(buffer);
+    }
+
+    // Receive some data.
+    DWORD bytes_transferred = 0;
+    DWORD recv_flags = flags;
+    int result = ::WSARecv(impl.socket_, bufs, i,
+        &bytes_transferred, &recv_flags, 0, 0);
+    if (result != 0)
+    {
+      DWORD last_error = ::WSAGetLastError();
+      if (last_error == ERROR_NETNAME_DELETED)
+        last_error = WSAECONNRESET;
+      error_handler(boost::asio::error(last_error));
+      return 0;
+    }
+    if (bytes_transferred == 0)
+    {
+      error_handler(boost::asio::error(boost::asio::error::eof));
+      return 0;
+    }
+
+    error_handler(boost::asio::error(0));
+    return bytes_transferred;
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  class receive_operation
+    : public operation
+  {
+  public:
+    receive_operation(boost::asio::io_service& io_service,
+        weak_cancel_token_type cancel_token,
+        const Mutable_Buffers& buffers, Handler handler)
+      : operation(
+          &receive_operation<Mutable_Buffers, Handler>::do_completion_impl,
+          &receive_operation<Mutable_Buffers, Handler>::destroy_impl),
+        work_(io_service),
+        cancel_token_(cancel_token),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+  private:
+    static void do_completion_impl(operation* op,
+        DWORD last_error, size_t bytes_transferred)
+    {
+      // Take ownership of the operation object.
+      typedef receive_operation<Mutable_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Map ERROR_NETNAME_DELETED to more useful error.
+      if (last_error == ERROR_NETNAME_DELETED)
+      {
+        if (handler_op->cancel_token_.expired())
+          last_error = ERROR_OPERATION_ABORTED;
+        else
+          last_error = WSAECONNRESET;
+      }
+
+      // Check for connection closed.
+      else if (last_error == 0 && bytes_transferred == 0)
+      {
+        last_error = boost::asio::error::eof;
+      }
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Call the handler.
+      boost::asio::error error(last_error);
+      handler(error, bytes_transferred);
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef receive_operation<Mutable_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    boost::asio::io_service::work work_;
+    weak_cancel_token_type cancel_token_;
+    Mutable_Buffers buffers_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef receive_operation<Mutable_Buffers, Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr,
+        owner(), impl.cancel_token_, buffers, handler);
+
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = boost::asio::buffer_cast<char*>(buffer);
+    }
+
+    // Receive some data.
+    DWORD bytes_transferred = 0;
+    DWORD recv_flags = flags;
+    int result = ::WSARecv(impl.socket_, bufs, i,
+        &bytes_transferred, &recv_flags, ptr.get(), 0);
+    DWORD last_error = ::WSAGetLastError();
+    if (result != 0 && last_error != WSA_IO_PENDING)
+    {
+      ptr.reset();
+      boost::asio::error error(last_error);
+      iocp_service_.post(bind_handler(handler, error, bytes_transferred));
+    }
+    else
+    {
+      ptr.release();
+    }
+  }
+
+  // Receive a datagram with the endpoint of the sender. Returns the number of
+  // bytes received.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t receive_from(implementation_type& impl, const Mutable_Buffers& buffers,
+      endpoint_type& sender_endpoint, socket_base::message_flags flags,
+      Error_Handler error_handler)
+  {
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = boost::asio::buffer_cast<char*>(buffer);
+    }
+
+    // Receive some data.
+    DWORD bytes_transferred = 0;
+    DWORD recv_flags = flags;
+    int endpoint_size = sender_endpoint.capacity();
+    int result = ::WSARecvFrom(impl.socket_, bufs, i, &bytes_transferred,
+        &recv_flags, sender_endpoint.data(), &endpoint_size, 0, 0);
+    if (result != 0)
+    {
+      DWORD last_error = ::WSAGetLastError();
+      error_handler(boost::asio::error(last_error));
+      return 0;
+    }
+    if (bytes_transferred == 0)
+    {
+      error_handler(boost::asio::error(boost::asio::error::eof));
+      return 0;
+    }
+
+    sender_endpoint.resize(endpoint_size);
+
+    error_handler(boost::asio::error(0));
+    return bytes_transferred;
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  class receive_from_operation
+    : public operation
+  {
+  public:
+    receive_from_operation(boost::asio::io_service& io_service,
+        endpoint_type& endpoint, const Mutable_Buffers& buffers,
+        Handler handler)
+      : operation(
+          &receive_from_operation<Mutable_Buffers, Handler>::do_completion_impl,
+          &receive_from_operation<Mutable_Buffers, Handler>::destroy_impl),
+        endpoint_(endpoint),
+        endpoint_size_(endpoint.capacity()),
+        work_(io_service),
+        buffers_(buffers),
+        handler_(handler)
+    {
+    }
+
+    int& endpoint_size()
+    {
+      return endpoint_size_;
+    }
+
+  private:
+    static void do_completion_impl(operation* op,
+        DWORD last_error, size_t bytes_transferred)
+    {
+      // Take ownership of the operation object.
+      typedef receive_from_operation<Mutable_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Check for connection closed.
+      if (last_error == 0 && bytes_transferred == 0)
+      {
+        last_error = boost::asio::error::eof;
+      }
+
+      // Record the size of the endpoint returned by the operation.
+      handler_op->endpoint_.resize(handler_op->endpoint_size_);
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Call the handler.
+      boost::asio::error error(last_error);
+      handler(error, bytes_transferred);
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef receive_from_operation<Mutable_Buffers, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    endpoint_type& endpoint_;
+    int endpoint_size_;
+    boost::asio::io_service::work work_;
+    Mutable_Buffers buffers_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous receive. The buffer for the data being received and
+  // the sender_endpoint object must both be valid for the lifetime of the
+  // asynchronous operation.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive_from(implementation_type& impl,
+      const Mutable_Buffers& buffers, endpoint_type& sender_endp,
+      socket_base::message_flags flags, Handler handler)
+  {
+    // Allocate and construct an operation to wrap the handler.
+    typedef receive_from_operation<Mutable_Buffers, Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    handler_ptr<alloc_traits> ptr(raw_ptr,
+        owner(), sender_endp, buffers, handler);
+
+    // Copy buffers into WSABUF array.
+    ::WSABUF bufs[max_buffers];
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    DWORD i = 0;
+    for (; iter != end && i < max_buffers; ++iter, ++i)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      bufs[i].len = static_cast<u_long>(boost::asio::buffer_size(buffer));
+      bufs[i].buf = boost::asio::buffer_cast<char*>(buffer);
+    }
+
+    // Receive some data.
+    DWORD bytes_transferred = 0;
+    DWORD recv_flags = flags;
+    int result = ::WSARecvFrom(impl.socket_, bufs, i, &bytes_transferred,
+        &recv_flags, sender_endp.data(), &ptr.get()->endpoint_size(),
+        ptr.get(), 0);
+    DWORD last_error = ::WSAGetLastError();
+    if (result != 0 && last_error != WSA_IO_PENDING)
+    {
+      ptr.reset();
+      boost::asio::error error(last_error);
+      iocp_service_.post(bind_handler(handler, error, bytes_transferred));
+    }
+    else
+    {
+      ptr.release();
+    }
+  }
+
+  // Accept a new connection.
+  template <typename Socket, typename Error_Handler>
+  void accept(implementation_type& impl, Socket& peer,
+      Error_Handler error_handler)
+  {
+    // We cannot accept a socket that is already open.
+    if (peer.native() != invalid_socket)
+    {
+      error_handler(boost::asio::error(boost::asio::error::already_connected));
+      return;
+    }
+
+    for (;;)
+    {
+      socket_holder new_socket(socket_ops::accept(impl.socket_, 0, 0));
+      if (int err = socket_ops::get_error())
+      {
+        if (err == boost::asio::error::connection_aborted
+            && !(impl.flags_ & implementation_type::enable_connection_aborted))
+        {
+          // Retry accept operation.
+          continue;
+        }
+        else
+        {
+          error_handler(boost::asio::error(err));
+          return;
+        }
+      }
+
+      boost::asio::error temp_error;
+      peer.assign(impl.protocol_, new_socket.get(),
+          boost::asio::assign_error(temp_error));
+      if (temp_error)
+      {
+        error_handler(temp_error);
+        return;
+      }
+      else
+      {
+        new_socket.release();
+        error_handler(boost::asio::error(0));
+        return;
+      }
+    }
+  }
+
+  // Accept a new connection.
+  template <typename Socket, typename Error_Handler>
+  void accept_endpoint(implementation_type& impl, Socket& peer,
+      endpoint_type& peer_endpoint, Error_Handler error_handler)
+  {
+    // We cannot accept a socket that is already open.
+    if (peer.native() != invalid_socket)
+    {
+      error_handler(boost::asio::error(boost::asio::error::already_connected));
+      return;
+    }
+
+    for (;;)
+    {
+      socket_addr_len_type addr_len = peer_endpoint.capacity();
+      socket_holder new_socket(socket_ops::accept(
+            impl.socket_, peer_endpoint.data(), &addr_len));
+      if (int err = socket_ops::get_error())
+      {
+        if (err == boost::asio::error::connection_aborted
+            && !(impl.flags_ & implementation_type::enable_connection_aborted))
+        {
+          // Retry accept operation.
+          continue;
+        }
+        else
+        {
+          error_handler(boost::asio::error(err));
+          return;
+        }
+      }
+
+      peer_endpoint.resize(addr_len);
+
+      boost::asio::error temp_error;
+      peer.assign(impl.protocol_, new_socket.get(),
+          boost::asio::assign_error(temp_error));
+      if (temp_error)
+      {
+        error_handler(temp_error);
+        return;
+      }
+      else
+      {
+        new_socket.release();
+        error_handler(boost::asio::error(0));
+        return;
+      }
+    }
+  }
+
+  template <typename Socket, typename Handler>
+  class accept_operation
+    : public operation
+  {
+  public:
+    accept_operation(win_iocp_io_service& io_service, socket_type socket,
+        socket_type new_socket, Socket& peer, const protocol_type& protocol,
+        bool enable_connection_aborted, Handler handler)
+      : operation(
+          &accept_operation<Socket, Handler>::do_completion_impl,
+          &accept_operation<Socket, Handler>::destroy_impl),
+        io_service_(io_service),
+        socket_(socket),
+        new_socket_(new_socket),
+        peer_(peer),
+        protocol_(protocol),
+        work_(io_service.owner()),
+        enable_connection_aborted_(enable_connection_aborted),
+        handler_(handler)
+    {
+    }
+
+    socket_type new_socket()
+    {
+      return new_socket_.get();
+    }
+
+    void* output_buffer()
+    {
+      return output_buffer_;
+    }
+
+    DWORD address_length()
+    {
+      return sizeof(sockaddr_storage_type) + 16;
+    }
+
+  private:
+    static void do_completion_impl(operation* op,
+        DWORD last_error, size_t bytes_transferred)
+    {
+      // Take ownership of the operation object.
+      typedef accept_operation<Socket, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Map Windows error ERROR_NETNAME_DELETED to connection_aborted.
+      if (last_error == ERROR_NETNAME_DELETED)
+      {
+        last_error = boost::asio::error::connection_aborted;
+      }
+
+      // Restart the accept operation if we got the connection_aborted error
+      // and the enable_connection_aborted socket option is not set.
+      if (last_error == boost::asio::error::connection_aborted
+          && !ptr.get()->enable_connection_aborted_)
+      {
+        // Reset OVERLAPPED structure.
+        ptr.get()->Internal = 0;
+        ptr.get()->InternalHigh = 0;
+        ptr.get()->Offset = 0;
+        ptr.get()->OffsetHigh = 0;
+        ptr.get()->hEvent = 0;
+
+        // Create a new socket for the next connection, since the AcceptEx call
+        // fails with WSAEINVAL if we try to reuse the same socket.
+        ptr.get()->new_socket_.reset();
+        ptr.get()->new_socket_.reset(
+            socket_ops::socket(ptr.get()->protocol_.family(),
+              ptr.get()->protocol_.type(), ptr.get()->protocol_.protocol()));
+        last_error = socket_ops::get_error();
+        if (ptr.get()->new_socket() != invalid_socket)
+        {
+          // Accept a connection.
+          DWORD bytes_read = 0;
+          BOOL result = ::AcceptEx(ptr.get()->socket_, ptr.get()->new_socket(),
+              ptr.get()->output_buffer(), 0, ptr.get()->address_length(),
+              ptr.get()->address_length(), &bytes_read, ptr.get());
+          last_error = ::WSAGetLastError();
+
+          // Check if the operation completed immediately.
+          if (!result && last_error != WSA_IO_PENDING)
+          {
+            if (last_error == ERROR_NETNAME_DELETED
+                || last_error == boost::asio::error::connection_aborted)
+            {
+              // Post this handler so that operation will be restarted again.
+              ptr.get()->io_service_.post_completion(ptr.get(), last_error, 0);
+              ptr.release();
+              return;
+            }
+            else
+            {
+              // Operation already complete. Continue with rest of this handler.
+            }
+          }
+          else
+          {
+            // Asynchronous operation has been successfully restarted.
+            ptr.release();
+            return;
+          }
+        }
+      }
+
+      // Need to set the SO_UPDATE_ACCEPT_CONTEXT option so that getsockname
+      // and getpeername will work on the accepted socket.
+      if (last_error == 0)
+      {
+        DWORD update_ctx_param = handler_op->socket_;
+        if (socket_ops::setsockopt(handler_op->new_socket_.get(), SOL_SOCKET,
+              SO_UPDATE_ACCEPT_CONTEXT, &update_ctx_param, sizeof(DWORD)) != 0)
+        {
+          last_error = socket_ops::get_error();
+        }
+      }
+
+      // If the socket was successfully accepted, transfer ownership of the
+      // socket to the peer object.
+      if (last_error == 0)
+      {
+        boost::asio::error temp_error;
+        handler_op->peer_.assign(handler_op->protocol_,
+            handler_op->new_socket_.get(),
+            boost::asio::assign_error(temp_error));
+        if (temp_error)
+          last_error = temp_error.code();
+        else
+          handler_op->new_socket_.release();
+      }
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Call the handler.
+      boost::asio::error error(last_error);
+      handler(error);
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef accept_operation<Socket, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    win_iocp_io_service& io_service_;
+    socket_type socket_;
+    socket_holder new_socket_;
+    Socket& peer_;
+    protocol_type protocol_;
+    boost::asio::io_service::work work_;
+    unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
+    bool enable_connection_aborted_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous accept. The peer object must be valid until the
+  // accept's handler is invoked.
+  template <typename Socket, typename Handler>
+  void async_accept(implementation_type& impl, Socket& peer, Handler handler)
+  {
+    // Check whether acceptor has been initialised.
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Check that peer socket has not already been connected.
+    if (peer.native() != invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::already_connected);
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Create a new socket for the connection.
+    socket_holder sock(socket_ops::socket(impl.protocol_.family(),
+          impl.protocol_.type(), impl.protocol_.protocol()));
+    if (sock.get() == invalid_socket)
+    {
+      boost::asio::error error(socket_ops::get_error());
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef accept_operation<Socket, Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    socket_type new_socket = sock.get();
+    bool enable_connection_aborted =
+      (impl.flags_ & implementation_type::enable_connection_aborted);
+    handler_ptr<alloc_traits> ptr(raw_ptr,
+        iocp_service_, impl.socket_, new_socket, peer, impl.protocol_,
+        enable_connection_aborted, handler);
+    sock.release();
+
+    // Accept a connection.
+    DWORD bytes_read = 0;
+    BOOL result = ::AcceptEx(impl.socket_, ptr.get()->new_socket(),
+        ptr.get()->output_buffer(), 0, ptr.get()->address_length(),
+        ptr.get()->address_length(), &bytes_read, ptr.get());
+    DWORD last_error = ::WSAGetLastError();
+
+    // Check if the operation completed immediately.
+    if (!result && last_error != WSA_IO_PENDING)
+    {
+      if (!enable_connection_aborted
+          && (last_error == ERROR_NETNAME_DELETED
+            || last_error == boost::asio::error::connection_aborted))
+      {
+        // Post handler so that operation will be restarted again. We do not
+        // perform the AcceptEx again here to avoid the possibility of starving
+        // other handlers.
+        iocp_service_.post_completion(ptr.get(), last_error, 0);
+        ptr.release();
+      }
+      else
+      {
+        ptr.reset();
+        boost::asio::error error(last_error);
+        iocp_service_.post(bind_handler(handler, error));
+      }
+    }
+    else
+    {
+      ptr.release();
+    }
+  }
+
+  template <typename Socket, typename Handler>
+  class accept_endp_operation
+    : public operation
+  {
+  public:
+    accept_endp_operation(win_iocp_io_service& io_service,
+        socket_type socket, socket_type new_socket, Socket& peer,
+        const protocol_type& protocol, endpoint_type& peer_endpoint,
+        bool enable_connection_aborted, Handler handler)
+      : operation(
+          &accept_endp_operation<Socket, Handler>::do_completion_impl,
+          &accept_endp_operation<Socket, Handler>::destroy_impl),
+        io_service_(io_service),
+        socket_(socket),
+        new_socket_(new_socket),
+        peer_(peer),
+        protocol_(protocol),
+        peer_endpoint_(peer_endpoint),
+        work_(io_service.owner()),
+        enable_connection_aborted_(enable_connection_aborted),
+        handler_(handler)
+    {
+    }
+
+    socket_type new_socket()
+    {
+      return new_socket_.get();
+    }
+
+    void* output_buffer()
+    {
+      return output_buffer_;
+    }
+
+    DWORD address_length()
+    {
+      return sizeof(sockaddr_storage_type) + 16;
+    }
+
+  private:
+    static void do_completion_impl(operation* op,
+        DWORD last_error, size_t bytes_transferred)
+    {
+      // Take ownership of the operation object.
+      typedef accept_endp_operation<Socket, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+
+      // Map Windows error ERROR_NETNAME_DELETED to connection_aborted.
+      if (last_error == ERROR_NETNAME_DELETED)
+      {
+        last_error = boost::asio::error::connection_aborted;
+      }
+
+      // Restart the accept operation if we got the connection_aborted error
+      // and the enable_connection_aborted socket option is not set.
+      if (last_error == boost::asio::error::connection_aborted
+          && !ptr.get()->enable_connection_aborted_)
+      {
+        // Reset OVERLAPPED structure.
+        ptr.get()->Internal = 0;
+        ptr.get()->InternalHigh = 0;
+        ptr.get()->Offset = 0;
+        ptr.get()->OffsetHigh = 0;
+        ptr.get()->hEvent = 0;
+
+        // Create a new socket for the next connection, since the AcceptEx call
+        // fails with WSAEINVAL if we try to reuse the same socket.
+        ptr.get()->new_socket_.reset();
+        ptr.get()->new_socket_.reset(
+            socket_ops::socket(ptr.get()->protocol_.family(),
+              ptr.get()->protocol_.type(), ptr.get()->protocol_.protocol()));
+        last_error = socket_ops::get_error();
+        if (ptr.get()->new_socket() != invalid_socket)
+        {
+          // Accept a connection.
+          DWORD bytes_read = 0;
+          BOOL result = ::AcceptEx(ptr.get()->socket_, ptr.get()->new_socket(),
+              ptr.get()->output_buffer(), 0, ptr.get()->address_length(),
+              ptr.get()->address_length(), &bytes_read, ptr.get());
+          last_error = ::WSAGetLastError();
+
+          // Check if the operation completed immediately.
+          if (!result && last_error != WSA_IO_PENDING)
+          {
+            if (last_error == ERROR_NETNAME_DELETED
+                || last_error == boost::asio::error::connection_aborted)
+            {
+              // Post this handler so that operation will be restarted again.
+              ptr.get()->io_service_.post_completion(ptr.get(), last_error, 0);
+              ptr.release();
+              return;
+            }
+            else
+            {
+              // Operation already complete. Continue with rest of this handler.
+            }
+          }
+          else
+          {
+            // Asynchronous operation has been successfully restarted.
+            ptr.release();
+            return;
+          }
+        }
+      }
+
+      // Get the address of the peer.
+      if (last_error == 0)
+      {
+        LPSOCKADDR local_addr = 0;
+        int local_addr_length = 0;
+        LPSOCKADDR remote_addr = 0;
+        int remote_addr_length = 0;
+        GetAcceptExSockaddrs(handler_op->output_buffer(), 0,
+            handler_op->address_length(), handler_op->address_length(),
+            &local_addr, &local_addr_length, &remote_addr, &remote_addr_length);
+        if (remote_addr_length > handler_op->peer_endpoint_.capacity())
+        {
+          last_error = boost::asio::error::invalid_argument;
+        }
+        else
+        {
+          handler_op->peer_endpoint_.resize(remote_addr_length);
+          using namespace std; // For memcpy.
+          memcpy(handler_op->peer_endpoint_.data(),
+              remote_addr, remote_addr_length);
+        }
+      }
+
+      // Need to set the SO_UPDATE_ACCEPT_CONTEXT option so that getsockname
+      // and getpeername will work on the accepted socket.
+      if (last_error == 0)
+      {
+        DWORD update_ctx_param = handler_op->socket_;
+        if (socket_ops::setsockopt(handler_op->new_socket_.get(), SOL_SOCKET,
+              SO_UPDATE_ACCEPT_CONTEXT, &update_ctx_param, sizeof(DWORD)) != 0)
+        {
+          last_error = socket_ops::get_error();
+        }
+      }
+
+      // If the socket was successfully accepted, transfer ownership of the
+      // socket to the peer object.
+      if (last_error == 0)
+      {
+        boost::asio::error temp_error;
+        handler_op->peer_.assign(handler_op->peer_endpoint_.protocol(),
+            handler_op->new_socket_.get(),
+            boost::asio::assign_error(temp_error));
+        if (temp_error)
+          last_error = temp_error.code();
+        else
+          handler_op->new_socket_.release();
+      }
+
+      // Make a copy of the handler so that the memory can be deallocated before
+      // the upcall is made.
+      Handler handler(handler_op->handler_);
+
+      // Free the memory associated with the handler.
+      ptr.reset();
+
+      // Call the handler.
+      boost::asio::error error(last_error);
+      handler(error);
+    }
+
+    static void destroy_impl(operation* op)
+    {
+      // Take ownership of the operation object.
+      typedef accept_endp_operation<Socket, Handler> op_type;
+      op_type* handler_op(static_cast<op_type*>(op));
+      typedef handler_alloc_traits<Handler, op_type> alloc_traits;
+      handler_ptr<alloc_traits> ptr(handler_op->handler_, handler_op);
+    }
+
+    win_iocp_io_service& io_service_;
+    socket_type socket_;
+    socket_holder new_socket_;
+    Socket& peer_;
+    protocol_type protocol_;
+    endpoint_type& peer_endpoint_;
+    boost::asio::io_service::work work_;
+    unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
+    bool enable_connection_aborted_;
+    Handler handler_;
+  };
+
+  // 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_endpoint(implementation_type& impl, Socket& peer,
+      endpoint_type& peer_endpoint, Handler handler)
+  {
+    // Check whether acceptor has been initialised.
+    if (impl.socket_ == invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::bad_descriptor);
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Check that peer socket has not already been connected.
+    if (peer.native() != invalid_socket)
+    {
+      boost::asio::error error(boost::asio::error::already_connected);
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Create a new socket for the connection.
+    socket_holder sock(socket_ops::socket(impl.protocol_.family(),
+          impl.protocol_.type(), impl.protocol_.protocol()));
+    if (sock.get() == invalid_socket)
+    {
+      boost::asio::error error(socket_ops::get_error());
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef accept_endp_operation<Socket, Handler> value_type;
+    typedef handler_alloc_traits<Handler, value_type> alloc_traits;
+    raw_handler_ptr<alloc_traits> raw_ptr(handler);
+    socket_type new_socket = sock.get();
+    bool enable_connection_aborted =
+      (impl.flags_ & implementation_type::enable_connection_aborted);
+    handler_ptr<alloc_traits> ptr(raw_ptr,
+        iocp_service_, impl.socket_, new_socket, peer, impl.protocol_,
+        peer_endpoint, enable_connection_aborted, handler);
+    sock.release();
+
+    // Accept a connection.
+    DWORD bytes_read = 0;
+    BOOL result = ::AcceptEx(impl.socket_, ptr.get()->new_socket(),
+        ptr.get()->output_buffer(), 0, ptr.get()->address_length(),
+        ptr.get()->address_length(), &bytes_read, ptr.get());
+    DWORD last_error = ::WSAGetLastError();
+
+    // Check if the operation completed immediately.
+    if (!result && last_error != WSA_IO_PENDING)
+    {
+      if (!enable_connection_aborted
+          && (last_error == ERROR_NETNAME_DELETED
+            || last_error == boost::asio::error::connection_aborted))
+      {
+        // Post handler so that operation will be restarted again. We do not
+        // perform the AcceptEx again here to avoid the possibility of starving
+        // other handlers.
+        iocp_service_.post_completion(ptr.get(), last_error, 0);
+        ptr.release();
+      }
+      else
+      {
+        ptr.reset();
+        boost::asio::error error(last_error);
+        iocp_service_.post(bind_handler(handler, error));
+      }
+    }
+    else
+    {
+      ptr.release();
+    }
+  }
+
+  // Connect the socket to the specified endpoint.
+  template <typename Error_Handler>
+  void connect(implementation_type& impl, const endpoint_type& peer_endpoint,
+      Error_Handler error_handler)
+  {
+    // Open the socket if it is not already open.
+    if (impl.socket_ == invalid_socket)
+    {
+      // Get the flags used to create the new socket.
+      int family = peer_endpoint.protocol().family();
+      int type = peer_endpoint.protocol().type();
+      int proto = peer_endpoint.protocol().protocol();
+
+      // Create a new socket.
+      impl.socket_ = socket_ops::socket(family, type, proto);
+      if (impl.socket_ == invalid_socket)
+      {
+        error_handler(boost::asio::error(socket_ops::get_error()));
+        return;
+      }
+      iocp_service_.register_socket(impl.socket_);
+    }
+
+    // Perform the connect operation.
+    int result = socket_ops::connect(impl.socket_,
+        peer_endpoint.data(), peer_endpoint.size());
+    if (result == socket_error_retval)
+      error_handler(boost::asio::error(socket_ops::get_error()));
+    else
+      error_handler(boost::asio::error(0));
+  }
+
+  template <typename Handler>
+  class connect_handler
+  {
+  public:
+    connect_handler(socket_type socket,
+        boost::shared_ptr<bool> completed,
+        boost::asio::io_service& io_service,
+        reactor_type& reactor, Handler handler)
+      : socket_(socket),
+        completed_(completed),
+        io_service_(io_service),
+        reactor_(reactor),
+        work_(io_service),
+        handler_(handler)
+    {
+    }
+
+    bool operator()(int result)
+    {
+      // Check whether a handler has already been called for the connection.
+      // If it has, then we don't want to do anything in this handler.
+      if (*completed_)
+        return true;
+
+      // Cancel the other reactor operation for the connection.
+      *completed_ = true;
+      reactor_.enqueue_cancel_ops_unlocked(socket_);
+
+      // Check whether the operation was successful.
+      if (result != 0)
+      {
+        boost::asio::error error(result);
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Get the error code from the connect operation.
+      int connect_error = 0;
+      size_t connect_error_len = sizeof(connect_error);
+      if (socket_ops::getsockopt(socket_, SOL_SOCKET, SO_ERROR,
+            &connect_error, &connect_error_len) == socket_error_retval)
+      {
+        boost::asio::error error(socket_ops::get_error());
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // If connection failed then post the handler with the error code.
+      if (connect_error)
+      {
+        boost::asio::error error(connect_error);
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Make the socket blocking again (the default).
+      ioctl_arg_type non_blocking = 0;
+      if (socket_ops::ioctl(socket_, FIONBIO, &non_blocking))
+      {
+        boost::asio::error error(socket_ops::get_error());
+        io_service_.post(bind_handler(handler_, error));
+        return true;
+      }
+
+      // Post the result of the successful connection operation.
+      boost::asio::error error(boost::asio::error::success);
+      io_service_.post(bind_handler(handler_, error));
+      return true;
+    }
+
+  private:
+    socket_type socket_;
+    boost::shared_ptr<bool> completed_;
+    boost::asio::io_service& io_service_;
+    reactor_type& reactor_;
+    boost::asio::io_service::work work_;
+    Handler handler_;
+  };
+
+  // Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, Handler handler)
+  {
+    // Check if the reactor was already obtained from the io_service.
+    reactor_type* reactor = static_cast<reactor_type*>(
+          interlocked_compare_exchange_pointer(
+            reinterpret_cast<void**>(&reactor_), 0, 0));
+    if (!reactor)
+    {
+      reactor = &(boost::asio::use_service<reactor_type>(owner()));
+      interlocked_exchange_pointer(
+          reinterpret_cast<void**>(&reactor_), reactor);
+    }
+
+    // Open the socket if it is not already open.
+    if (impl.socket_ == invalid_socket)
+    {
+      // Get the flags used to create the new socket.
+      int family = peer_endpoint.protocol().family();
+      int type = peer_endpoint.protocol().type();
+      int proto = peer_endpoint.protocol().protocol();
+
+      // Create a new socket.
+      impl.socket_ = socket_ops::socket(family, type, proto);
+      if (impl.socket_ == invalid_socket)
+      {
+        boost::asio::error error(socket_ops::get_error());
+        owner().post(bind_handler(handler, error));
+        return;
+      }
+      iocp_service_.register_socket(impl.socket_);
+    }
+
+    // Mark the socket as non-blocking so that the connection will take place
+    // asynchronously.
+    ioctl_arg_type non_blocking = 1;
+    if (socket_ops::ioctl(impl.socket_, FIONBIO, &non_blocking))
+    {
+      boost::asio::error error(socket_ops::get_error());
+      owner().post(bind_handler(handler, error));
+      return;
+    }
+
+    // Start the connect operation.
+    if (socket_ops::connect(impl.socket_, peer_endpoint.data(),
+          peer_endpoint.size()) == 0)
+    {
+      // The connect operation has finished successfully so we need to post the
+      // handler immediately.
+      boost::asio::error error(boost::asio::error::success);
+      owner().post(bind_handler(handler, error));
+    }
+    else if (socket_ops::get_error() == boost::asio::error::in_progress
+        || socket_ops::get_error() == boost::asio::error::would_block)
+    {
+      // The connection is happening in the background, and we need to wait
+      // until the socket becomes writeable.
+      boost::shared_ptr<bool> completed(new bool(false));
+      reactor->start_write_and_except_ops(impl.socket_,
+          connect_handler<Handler>(
+            impl.socket_, completed, owner(), *reactor, handler));
+    }
+    else
+    {
+      // The connect operation has failed, so post the handler immediately.
+      boost::asio::error error(socket_ops::get_error());
+      owner().post(bind_handler(handler, error));
+    }
+  }
+
+private:
+  // Helper function to provide InterlockedCompareExchangePointer functionality
+  // on very old Platform SDKs.
+  void* interlocked_compare_exchange_pointer(void** dest, void* exch, void* cmp)
+  {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT <= 0x400) && (_M_IX86)
+    return reinterpret_cast<void*>(InterlockedCompareExchange(
+          reinterpret_cast<LONG*>(dest), reinterpret_cast<LONG>(exch),
+          reinterpret_cast<LONG>(cmp)));
+#else
+    return InterlockedCompareExchangePointer(dest, exch, cmp);
+#endif
+  }
+
+  // Helper function to provide InterlockedExchangePointer functionality on very
+  // old Platform SDKs.
+  void* interlocked_exchange_pointer(void** dest, void* val)
+  {
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT <= 0x400) && (_M_IX86)
+    return reinterpret_cast<void*>(InterlockedExchange(
+          reinterpret_cast<LONG*>(dest), reinterpret_cast<LONG>(val)));
+#else
+    return InterlockedExchangePointer(dest, val);
+#endif
+  }
+
+  // The IOCP service used for running asynchronous operations and dispatching
+  // handlers.
+  win_iocp_io_service& iocp_service_;
+
+  // The reactor used for performing connect operations. This object is created
+  // only if needed.
+  reactor_type* reactor_;
+
+  // Mutex to protect access to the linked list of implementations. 
+  boost::asio::detail::mutex mutex_;
+
+  // The head of a linked list of all implementations.
+  implementation_type* impl_list_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
diff --git a/include/boost/asio/detail/win_local_free_on_block_exit.hpp b/include/boost/asio/detail/win_local_free_on_block_exit.hpp
new file mode 100644
index 0000000000..1cce956008
--- /dev/null
+++ b/include/boost/asio/detail/win_local_free_on_block_exit.hpp
@@ -0,0 +1,61 @@
+//
+// win_local_free_on_block_exit.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_LOCAL_FREE_ON_BLOCK_EXIT_HPP
+#define BOOST_ASIO_DETAIL_WIN_LOCAL_FREE_ON_BLOCK_EXIT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_local_free_on_block_exit
+  : private noncopyable
+{
+public:
+  // Constructor blocks all signals for the calling thread.
+  explicit win_local_free_on_block_exit(void* p)
+    : p_(p)
+  {
+  }
+
+  // Destructor restores the previous signal mask.
+  ~win_local_free_on_block_exit()
+  {
+    ::LocalFree(p_);
+  }
+
+private:
+  void* p_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_LOCAL_FREE_ON_BLOCK_EXIT_HPP
diff --git a/include/boost/asio/detail/win_mutex.hpp b/include/boost/asio/detail/win_mutex.hpp
new file mode 100644
index 0000000000..dc07833686
--- /dev/null
+++ b/include/boost/asio/detail/win_mutex.hpp
@@ -0,0 +1,144 @@
+//
+// win_mutex.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_WIN_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS)
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/scoped_lock.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_mutex
+  : private noncopyable
+{
+public:
+  typedef boost::asio::detail::scoped_lock<win_mutex> scoped_lock;
+
+  // Constructor.
+  win_mutex()
+  {
+    int error = do_init();
+    if (error != 0)
+    {
+      system_exception e("mutex", error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~win_mutex()
+  {
+    ::DeleteCriticalSection(&crit_section_);
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+    int error = do_lock();
+    if (error != 0)
+    {
+      system_exception e("mutex", error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    ::LeaveCriticalSection(&crit_section_);
+  }
+
+private:
+  // Initialisation must be performed in a separate function to the constructor
+  // since the compiler does not support the use of structured exceptions and
+  // C++ exceptions in the same function.
+  int do_init()
+  {
+#if defined(__MINGW32__)
+    // Not sure if MinGW supports structured exception handling, so for now
+    // we'll just call the Windows API and hope.
+    ::InitializeCriticalSection(&crit_section_);
+    return 0;
+#else
+    __try
+    {
+      ::InitializeCriticalSection(&crit_section_);
+    }
+    __except(GetExceptionCode() == STATUS_NO_MEMORY
+        ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+      return ERROR_OUTOFMEMORY;
+    }
+
+    return 0;
+#endif
+  }
+
+  // Locking must be performed in a separate function to lock() since the
+  // compiler does not support the use of structured exceptions and C++
+  // exceptions in the same function.
+  int do_lock()
+  {
+#if defined(__MINGW32__)
+    // Not sure if MinGW supports structured exception handling, so for now
+    // we'll just call the Windows API and hope.
+    ::EnterCriticalSection(&crit_section_);
+    return 0;
+#else
+    __try
+    {
+      ::EnterCriticalSection(&crit_section_);
+    }
+    __except(GetExceptionCode() == STATUS_INVALID_HANDLE
+        || GetExceptionCode() == STATUS_NO_MEMORY
+        ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
+    {
+      if (GetExceptionCode() == STATUS_NO_MEMORY)
+        return ERROR_OUTOFMEMORY;
+      return ERROR_INVALID_HANDLE;
+    }
+
+    return 0;
+#endif
+  }
+
+  ::CRITICAL_SECTION crit_section_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_MUTEX_HPP
diff --git a/include/boost/asio/detail/win_signal_blocker.hpp b/include/boost/asio/detail/win_signal_blocker.hpp
new file mode 100644
index 0000000000..5436d23771
--- /dev/null
+++ b/include/boost/asio/detail/win_signal_blocker.hpp
@@ -0,0 +1,69 @@
+//
+// win_signal_blocker.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_SIGNAL_BLOCKER_HPP
+#define BOOST_ASIO_DETAIL_WIN_SIGNAL_BLOCKER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/noncopyable.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_signal_blocker
+  : private noncopyable
+{
+public:
+  // Constructor blocks all signals for the calling thread.
+  win_signal_blocker()
+  {
+    // No-op.
+  }
+
+  // Destructor restores the previous signal mask.
+  ~win_signal_blocker()
+  {
+    // No-op.
+  }
+
+  // Block all signals for the calling thread.
+  void block()
+  {
+    // No-op.
+  }
+
+  // Restore the previous signal mask.
+  void unblock()
+  {
+    // No-op.
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_SIGNAL_BLOCKER_HPP
diff --git a/include/boost/asio/detail/win_thread.hpp b/include/boost/asio/detail/win_thread.hpp
new file mode 100644
index 0000000000..d4db01110e
--- /dev/null
+++ b/include/boost/asio/detail/win_thread.hpp
@@ -0,0 +1,123 @@
+//
+// win_thread.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_THREAD_HPP
+#define BOOST_ASIO_DETAIL_WIN_THREAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS)
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <memory>
+#include <process.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+unsigned int __stdcall win_thread_function(void* arg);
+
+class win_thread
+  : private noncopyable
+{
+public:
+  // Constructor.
+  template <typename Function>
+  win_thread(Function f)
+  {
+    std::auto_ptr<func_base> arg(new func<Function>(f));
+    unsigned int thread_id = 0;
+    thread_ = reinterpret_cast<HANDLE>(::_beginthreadex(0, 0,
+          win_thread_function, arg.get(), 0, &thread_id));
+    if (!thread_)
+    {
+      DWORD last_error = ::GetLastError();
+      system_exception e("thread", last_error);
+      boost::throw_exception(e);
+    }
+    arg.release();
+  }
+
+  // Destructor.
+  ~win_thread()
+  {
+    ::CloseHandle(thread_);
+  }
+
+  // Wait for the thread to exit.
+  void join()
+  {
+    ::WaitForSingleObject(thread_, INFINITE);
+  }
+
+private:
+  friend unsigned int __stdcall win_thread_function(void* 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 unsigned int __stdcall win_thread_function(void* arg)
+{
+  std::auto_ptr<win_thread::func_base> func(
+      static_cast<win_thread::func_base*>(arg));
+  func->run();
+  return 0;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_THREAD_HPP
diff --git a/include/boost/asio/detail/win_tss_ptr.hpp b/include/boost/asio/detail/win_tss_ptr.hpp
new file mode 100644
index 0000000000..fda922d38b
--- /dev/null
+++ b/include/boost/asio/detail/win_tss_ptr.hpp
@@ -0,0 +1,87 @@
+//
+// win_tss_ptr.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP
+#define BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS)
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename T>
+class win_tss_ptr
+  : private noncopyable
+{
+public:
+  // Constructor.
+  win_tss_ptr()
+  {
+    tss_key_ = ::TlsAlloc();
+    if (tss_key_ == TLS_OUT_OF_INDEXES)
+    {
+      DWORD last_error = ::GetLastError();
+      system_exception e("tss", last_error);
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~win_tss_ptr()
+  {
+    ::TlsFree(tss_key_);
+  }
+
+  // Get the value.
+  operator T*() const
+  {
+    return static_cast<T*>(::TlsGetValue(tss_key_));
+  }
+
+  // Set the value.
+  void operator=(T* value)
+  {
+    ::TlsSetValue(tss_key_, value);
+  }
+
+private:
+  // Thread-specific storage to allow unlocked access to determine whether a
+  // thread is a member of the pool.
+  DWORD tss_key_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP
diff --git a/include/boost/asio/detail/winsock_init.hpp b/include/boost/asio/detail/winsock_init.hpp
new file mode 100644
index 0000000000..2eb57c1efd
--- /dev/null
+++ b/include/boost/asio/detail/winsock_init.hpp
@@ -0,0 +1,118 @@
+//
+// winsock_init.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
+#define BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/system_exception.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <int Major = 2, int Minor = 0>
+class winsock_init
+  : private noncopyable
+{
+private:
+  // Structure to perform the actual initialisation.
+  struct do_init
+  {
+    do_init()
+    {
+      WSADATA wsa_data;
+      result_ = ::WSAStartup(MAKEWORD(Major, Minor), &wsa_data);
+    }
+
+    ~do_init()
+    {
+      ::WSACleanup();
+    }
+
+    int result() const
+    {
+      return result_;
+    }
+
+    // Helper function to manage a do_init singleton. The static instance of the
+    // winsock_init object ensures that this function is always called before
+    // main, and therefore before any other threads can get started. The do_init
+    // instance must be static in this function to ensure that it gets
+    // initialised before any other global objects try to use it.
+    static boost::shared_ptr<do_init> instance()
+    {
+      static boost::shared_ptr<do_init> init(new do_init);
+      return init;
+    }
+
+  private:
+    int result_;
+  };
+
+public:
+  // Constructor.
+  winsock_init()
+    : ref_(do_init::instance())
+  {
+    // Check whether winsock was successfully initialised. This check is not
+    // performed for the global instance since there will be nobody around to
+    // catch the exception.
+    if (this != &instance_ && ref_->result() != 0)
+    {
+      system_exception e("winsock", ref_->result());
+      boost::throw_exception(e);
+    }
+  }
+
+  // Destructor.
+  ~winsock_init()
+  {
+  }
+
+private:
+  // Instance to force initialisation of winsock at global scope.
+  static winsock_init instance_;
+
+  // Reference to singleton do_init object to ensure that winsock does not get
+  // cleaned up until the last user has finished with it.
+  boost::shared_ptr<do_init> ref_;
+};
+
+template <int Major, int Minor>
+winsock_init<Major, Minor> winsock_init<Major, Minor>::instance_;
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
diff --git a/include/boost/asio/detail/wrapped_handler.hpp b/include/boost/asio/detail/wrapped_handler.hpp
new file mode 100644
index 0000000000..44d2e7006f
--- /dev/null
+++ b/include/boost/asio/detail/wrapped_handler.hpp
@@ -0,0 +1,140 @@
+//
+// wrapped_handler.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
+#define BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Dispatcher, typename Handler>
+class wrapped_handler
+{
+public:
+  typedef void result_type;
+
+  wrapped_handler(Dispatcher& dispatcher, Handler handler)
+    : dispatcher_(dispatcher),
+      handler_(handler)
+  {
+  }
+
+  void operator()()
+  {
+    dispatcher_.dispatch(handler_);
+  }
+
+  void operator()() const
+  {
+    dispatcher_.dispatch(handler_);
+  }
+
+  template <typename Arg1>
+  void operator()(Arg1 arg1)
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
+  }
+
+  template <typename Arg1>
+  void operator()(Arg1 arg1) const
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
+  }
+
+  template <typename Arg1, typename Arg2>
+  void operator()(Arg1 arg1, Arg2 arg2)
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
+  }
+
+  template <typename Arg1, typename Arg2>
+  void operator()(Arg1 arg1, Arg2 arg2) const
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3>
+  void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3)
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3>
+  void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3) const
+  {
+    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+  void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+  void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4) const
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5>
+  void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
+  }
+
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+      typename Arg5>
+  void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5) const
+  {
+    dispatcher_.dispatch(
+        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
+  }
+
+  friend void* asio_handler_allocate(std::size_t size,
+      wrapped_handler<Dispatcher, Handler>* this_handler)
+  {
+    return boost_asio_handler_alloc_helpers::allocate(
+        size, &this_handler->handler_);
+  }
+
+  friend void asio_handler_deallocate(void* pointer, std::size_t size,
+      wrapped_handler<Dispatcher, Handler>* this_handler)
+  {
+    boost_asio_handler_alloc_helpers::deallocate(
+        pointer, size, &this_handler->handler_);
+  }
+
+private:
+  Dispatcher& dispatcher_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
diff --git a/include/boost/asio/error.hpp b/include/boost/asio/error.hpp
new file mode 100644
index 0000000000..261f6fb52d
--- /dev/null
+++ b/include/boost/asio/error.hpp
@@ -0,0 +1,388 @@
+//
+// error.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ERROR_HPP
+#define BOOST_ASIO_ERROR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <cerrno>
+#include <cstring>
+#include <exception>
+#include <string>
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# include <iostream>
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/win_local_free_on_block_exit.hpp>
+
+namespace boost {
+namespace asio {
+
+#if defined(GENERATING_DOCUMENTATION)
+/// INTERNAL ONLY.
+# define BOOST_ASIO_SOCKET_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define BOOST_ASIO_NETDB_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define BOOST_ASIO_GETADDRINFO_ERROR(e) implementation_defined
+/// INTERNAL ONLY.
+# define BOOST_ASIO_OS_ERROR(e_win, e_posix) implementation_defined
+#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# define BOOST_ASIO_SOCKET_ERROR(e) WSA ## e
+# define BOOST_ASIO_NETDB_ERROR(e) WSA ## e
+# define BOOST_ASIO_GETADDRINFO_ERROR(e) e
+# define BOOST_ASIO_OS_ERROR(e_win, e_posix) e_win
+#else
+# define BOOST_ASIO_SOCKET_ERROR(e) e
+# define BOOST_ASIO_NETDB_ERROR(e) 16384 + e
+# define BOOST_ASIO_GETADDRINFO_ERROR(e) 32768 + e
+# define BOOST_ASIO_OS_ERROR(e_win, e_posix) e_posix
+#endif
+
+/// The error class is used to encapsulate system error codes.
+class error
+  : public std::exception
+{
+public:
+  /// Error codes.
+  enum code_type
+  {
+    /// Permission denied.
+    access_denied = BOOST_ASIO_SOCKET_ERROR(EACCES),
+
+    /// Address family not supported by protocol.
+    address_family_not_supported = BOOST_ASIO_SOCKET_ERROR(EAFNOSUPPORT),
+
+    /// Address already in use.
+    address_in_use = BOOST_ASIO_SOCKET_ERROR(EADDRINUSE),
+
+    /// Transport endpoint is already connected.
+    already_connected = BOOST_ASIO_SOCKET_ERROR(EISCONN),
+
+    /// Operation already in progress.
+    already_started = BOOST_ASIO_SOCKET_ERROR(EALREADY),
+
+    /// A connection has been aborted.
+    connection_aborted = BOOST_ASIO_SOCKET_ERROR(ECONNABORTED),
+
+    /// Connection refused.
+    connection_refused = BOOST_ASIO_SOCKET_ERROR(ECONNREFUSED),
+
+    /// Connection reset by peer.
+    connection_reset = BOOST_ASIO_SOCKET_ERROR(ECONNRESET),
+
+    /// Bad file descriptor.
+    bad_descriptor = BOOST_ASIO_SOCKET_ERROR(EBADF),
+
+    /// End of file or stream.
+    eof = BOOST_ASIO_OS_ERROR(ERROR_HANDLE_EOF, -1),
+
+    /// Bad address.
+    fault = BOOST_ASIO_SOCKET_ERROR(EFAULT),
+
+    /// Host not found (authoritative).
+    host_not_found = BOOST_ASIO_NETDB_ERROR(HOST_NOT_FOUND),
+
+    /// Host not found (non-authoritative).
+    host_not_found_try_again = BOOST_ASIO_NETDB_ERROR(TRY_AGAIN),
+
+    /// No route to host.
+    host_unreachable = BOOST_ASIO_SOCKET_ERROR(EHOSTUNREACH),
+
+    /// Operation now in progress.
+    in_progress = BOOST_ASIO_SOCKET_ERROR(EINPROGRESS),
+
+    /// Interrupted system call.
+    interrupted = BOOST_ASIO_SOCKET_ERROR(EINTR),
+
+    /// Invalid argument.
+    invalid_argument = BOOST_ASIO_SOCKET_ERROR(EINVAL),
+
+    /// Message too long.
+    message_size = BOOST_ASIO_SOCKET_ERROR(EMSGSIZE),
+
+    /// Network is down.
+    network_down = BOOST_ASIO_SOCKET_ERROR(ENETDOWN),
+
+    /// Network dropped connection on reset.
+    network_reset = BOOST_ASIO_SOCKET_ERROR(ENETRESET),
+
+    /// Network is unreachable.
+    network_unreachable = BOOST_ASIO_SOCKET_ERROR(ENETUNREACH),
+
+    /// Too many open files.
+    no_descriptors = BOOST_ASIO_SOCKET_ERROR(EMFILE),
+
+    /// No buffer space available.
+    no_buffer_space = BOOST_ASIO_SOCKET_ERROR(ENOBUFS),
+
+    /// The query is valid but does not have associated address data.
+    no_data = BOOST_ASIO_NETDB_ERROR(NO_DATA),
+
+    /// Cannot allocate memory.
+    no_memory = BOOST_ASIO_OS_ERROR(ERROR_OUTOFMEMORY, ENOMEM),
+
+    /// Operation not permitted.
+    no_permission = BOOST_ASIO_OS_ERROR(ERROR_ACCESS_DENIED, EPERM),
+
+    /// Protocol not available.
+    no_protocol_option = BOOST_ASIO_SOCKET_ERROR(ENOPROTOOPT),
+
+    /// A non-recoverable error occurred.
+    no_recovery = BOOST_ASIO_NETDB_ERROR(NO_RECOVERY),
+
+    /// Transport endpoint is not connected.
+    not_connected = BOOST_ASIO_SOCKET_ERROR(ENOTCONN),
+
+    /// Socket operation on non-socket.
+    not_socket = BOOST_ASIO_SOCKET_ERROR(ENOTSOCK),
+
+    /// Operation not supported.
+    not_supported = BOOST_ASIO_SOCKET_ERROR(EOPNOTSUPP),
+
+    /// Operation cancelled.
+    operation_aborted = BOOST_ASIO_OS_ERROR(ERROR_OPERATION_ABORTED, ECANCELED),
+
+    /// The service is not supported for the given socket type.
+    service_not_found = BOOST_ASIO_OS_ERROR(
+        WSATYPE_NOT_FOUND,
+        BOOST_ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),
+
+    /// The socket type is not supported.
+    socket_type_not_supported = BOOST_ASIO_OS_ERROR(
+        WSAESOCKTNOSUPPORT,
+        BOOST_ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE)),
+
+    /// Cannot send after transport endpoint shutdown.
+    shut_down = BOOST_ASIO_SOCKET_ERROR(ESHUTDOWN),
+
+    /// Success.
+    success = 0,
+
+    /// Connection timed out.
+    timed_out = BOOST_ASIO_SOCKET_ERROR(ETIMEDOUT),
+
+    /// Resource temporarily unavailable.
+    try_again = BOOST_ASIO_OS_ERROR(ERROR_RETRY, EAGAIN),
+
+    /// The socket is marked non-blocking and the requested operation would
+    /// block.
+    would_block = BOOST_ASIO_SOCKET_ERROR(EWOULDBLOCK)
+  };
+
+  /// Default constructor.
+  error()
+    : code_(success)
+  {
+  }
+
+  /// Construct with a specific error code.
+  error(int code)
+    : code_(code)
+  {
+  }
+
+  /// Copy constructor.
+  error(const error& e)
+    : std::exception(e),
+      code_(e.code_)
+  {
+  }
+
+  /// Destructor.
+  virtual ~error() throw ()
+  {
+  }
+
+  /// Assignment operator.
+  error& operator=(const error& e)
+  {
+    code_ = e.code_;
+    what_.reset();
+    return *this;
+  }
+
+  /// Get a string representation of the exception.
+  virtual const char* what() const throw ()
+  {
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+    try
+    {
+      if (!what_)
+      {
+        char* msg = 0;
+        DWORD length = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
+            | FORMAT_MESSAGE_FROM_SYSTEM
+            | FORMAT_MESSAGE_IGNORE_INSERTS, 0, code_,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, 0);
+        detail::win_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)
+          what_.reset(new std::string(msg));
+        else
+          return "asio error";
+      }
+      return what_->c_str();
+    }
+    catch (std::exception&)
+    {
+      return "asio error";
+    }
+#else // defined(BOOST_WINDOWS)
+    switch (code_)
+    {
+    case error::eof:
+      return "End of file.";
+    case error::host_not_found:
+      return "Host not found (authoritative).";
+    case error::host_not_found_try_again:
+      return "Host not found (non-authoritative), try again later.";
+    case error::no_recovery:
+      return "A non-recoverable error occurred during database lookup.";
+    case error::no_data:
+      return "The query is valid, but it does not have associated data.";
+#if !defined(__sun)
+    case error::operation_aborted:
+      return "Operation aborted.";
+#endif // !defined(__sun)
+    case error::service_not_found:
+      return "Service not found.";
+    case error::socket_type_not_supported:
+      return "Socket type not supported.";
+    default:
+#if defined(__sun) || defined(__QNX__)
+      return strerror(code_);
+#elif defined(__MACH__) && defined(__APPLE__)
+      try
+      {
+        char buf[256] = "";
+        strerror_r(code_, buf, sizeof(buf));
+        what_.reset(new std::string(buf));
+        return what_->c_str();
+      }
+      catch (std::exception&)
+      {
+        return "asio error";
+      }
+#else
+      try
+      {
+        char buf[256] = "";
+        what_.reset(new std::string(strerror_r(code_, buf, sizeof(buf))));
+        return what_->c_str();
+      }
+      catch (std::exception&)
+      {
+        return "asio error";
+      }
+#endif
+    }
+#endif // defined(BOOST_WINDOWS)
+  }
+
+  /// Get the code associated with the error.
+  int code() const
+  {
+    return code_;
+  }
+
+  struct unspecified_bool_type_t
+  {
+  };
+
+  typedef unspecified_bool_type_t* unspecified_bool_type;
+
+  /// Operator returns non-null if there is a non-success error code.
+  operator unspecified_bool_type() const
+  {
+    if (code_ == success)
+      return 0;
+    else
+      return reinterpret_cast<unspecified_bool_type>(1);
+  }
+
+  /// Operator to test if the error represents success.
+  bool operator!() const
+  {
+    return code_ == success;
+  }
+
+  /// Equality operator to compare two error objects.
+  friend bool operator==(const error& e1, const error& e2)
+  {
+    return e1.code_ == e2.code_;
+  }
+
+  /// Inequality operator to compare two error objects.
+  friend bool operator!=(const error& e1, const error& e2)
+  {
+    return e1.code_ != e2.code_;
+  }
+
+private:
+  // The code associated with the error.
+  int code_;
+
+  // The string representation of the error.
+  mutable boost::scoped_ptr<std::string> what_;
+};
+
+/// Output the string associated with an error.
+/**
+ * Used to output a human-readable string that is associated with an error.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param e The error to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::error
+ */
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+std::ostream& operator<<(std::ostream& os, const error& e)
+{
+  os << e.what();
+  return os;
+}
+#else // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <typename Ostream>
+Ostream& operator<<(Ostream& os, const error& e)
+{
+  os << e.what();
+  return os;
+}
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+} // namespace asio
+} // namespace boost
+
+#undef BOOST_ASIO_SOCKET_ERROR
+#undef BOOST_ASIO_NETDB_ERROR
+#undef BOOST_ASIO_GETADDRINFO_ERROR
+#undef BOOST_ASIO_OS_ERROR
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ERROR_HPP
diff --git a/include/boost/asio/error_handler.hpp b/include/boost/asio/error_handler.hpp
new file mode 100644
index 0000000000..5372def366
--- /dev/null
+++ b/include/boost/asio/error_handler.hpp
@@ -0,0 +1,122 @@
+//
+// error_handler.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ERROR_HANDLER_HPP
+#define BOOST_ASIO_ERROR_HANDLER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace detail {
+
+class ignore_error_t
+{
+public:
+  typedef void result_type;
+
+  template <typename Error>
+  void operator()(const Error&) const
+  {
+  }
+};
+
+class throw_error_t
+{
+public:
+  typedef void result_type;
+
+  template <typename Error>
+  void operator()(const Error& err) const
+  {
+    if (err)
+      boost::throw_exception(err);
+  }
+};
+
+template <typename Target>
+class assign_error_t
+{
+public:
+  typedef void result_type;
+
+  assign_error_t(Target& target)
+    : target_(&target)
+  {
+  }
+
+  template <typename Error>
+  void operator()(const Error& err) const
+  {
+    *target_ = err;
+  }
+
+private:
+  Target* target_;
+};
+
+} // namespace detail
+
+/**
+ * @defgroup error_handler Error Handler Function Objects
+ *
+ * Function objects for custom error handling.
+ */
+/*@{*/
+
+/// Return a function object that always ignores the error.
+#if defined(GENERATING_DOCUMENTATION)
+unspecified ignore_error();
+#else
+inline detail::ignore_error_t ignore_error()
+{
+  return detail::ignore_error_t();
+}
+#endif
+
+/// Return a function object that always throws the error.
+#if defined(GENERATING_DOCUMENTATION)
+unspecified throw_error();
+#else
+inline detail::throw_error_t throw_error()
+{
+  return detail::throw_error_t();
+}
+#endif
+
+/// Return a function object that assigns the error to a variable.
+#if defined(GENERATING_DOCUMENTATION)
+template <typename Target>
+unspecified assign_error(Target& target);
+#else
+template <typename Target>
+inline detail::assign_error_t<Target> assign_error(Target& target)
+{
+  return detail::assign_error_t<Target>(target);
+}
+#endif
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ERROR_HANDLER_HPP
diff --git a/include/boost/asio/handler_alloc_hook.hpp b/include/boost/asio/handler_alloc_hook.hpp
new file mode 100644
index 0000000000..1864b38333
--- /dev/null
+++ b/include/boost/asio/handler_alloc_hook.hpp
@@ -0,0 +1,90 @@
+//
+// handler_alloc_hook.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
+#define BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default allocation function for handlers.
+/**
+ * Asynchronous operations may need to allocate temporary objects. Since
+ * asynchronous operations have a handler function object, these temporary
+ * objects can be said to be associated with the handler.
+ *
+ * Implement asio_handler_allocate and asio_handler_deallocate for your own
+ * handlers to provide custom allocation for these temporary objects.
+ *
+ * This default implementation is simply:
+ * @code
+ * return ::operator new(bytes);
+ * @endcode
+ *
+ * @note All temporary objects associated with a handler will be deallocated
+ * before the upcall to the handler is performed. This allows the same memory to
+ * be reused for a subsequent asynchronous operation initiated by the handler.
+ *
+ * @par Example:
+ * @code
+ * class my_handler;
+ *
+ * void* asio_handler_allocate(std::size_t size, my_handler* context)
+ * {
+ *   return ::operator new(size);
+ * }
+ *
+ * void asio_handler_deallocate(void* pointer, std::size_t size,
+ *     my_handler* context)
+ * {
+ *   ::operator delete(pointer);
+ * }
+ * @endcode
+ */
+inline void* asio_handler_allocate(std::size_t size, ...)
+{
+  return ::operator new(size);
+}
+
+/// Default deallocation function for handlers.
+/**
+ * Implement asio_handler_allocate and asio_handler_deallocate for your own
+ * handlers to provide custom allocation for the associated temporary objects.
+ *
+ * This default implementation is simply:
+ * @code
+ * ::operator delete(pointer);
+ * @endcode
+ *
+ * @sa asio_handler_allocate.
+ */
+inline void asio_handler_deallocate(void* pointer, std::size_t size, ...)
+{
+  (void)(size);
+  return ::operator delete(pointer);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
diff --git a/include/boost/asio/impl/io_service.ipp b/include/boost/asio/impl/io_service.ipp
new file mode 100644
index 0000000000..a1c1e809be
--- /dev/null
+++ b/include/boost/asio/impl/io_service.ipp
@@ -0,0 +1,132 @@
+//
+// io_service.ipp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IO_SERVICE_IPP
+#define BOOST_ASIO_IO_SERVICE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/kqueue_reactor.hpp>
+#include <boost/asio/detail/select_reactor.hpp>
+#include <boost/asio/detail/task_io_service.hpp>
+#include <boost/asio/detail/win_iocp_io_service.hpp>
+
+namespace boost {
+namespace asio {
+
+inline io_service::io_service()
+  : service_registry_(*this),
+    impl_(service_registry_.use_service<impl_type>())
+{
+}
+
+inline void io_service::run()
+{
+  impl_.run();
+}
+
+inline void io_service::interrupt()
+{
+  impl_.interrupt();
+}
+
+inline void io_service::reset()
+{
+  impl_.reset();
+}
+
+template <typename Handler>
+inline void io_service::dispatch(Handler handler)
+{
+  impl_.dispatch(handler);
+}
+
+template <typename Handler>
+inline void io_service::post(Handler handler)
+{
+  impl_.post(handler);
+}
+
+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(io_service& io_service)
+  : impl_(io_service.impl_)
+{
+  impl_.work_started();
+}
+
+inline io_service::work::work(const work& other)
+  : impl_(other.impl_)
+{
+  impl_.work_started();
+}
+
+inline io_service::work::~work()
+{
+  impl_.work_finished();
+}
+
+inline io_service::service::service(io_service& owner)
+  : owner_(owner),
+    type_info_(0),
+    next_(0)
+{
+}
+
+inline io_service::service::~service()
+{
+}
+
+inline io_service& io_service::service::owner()
+{
+  return owner_;
+}
+
+template <typename Service>
+inline Service& use_service(io_service& ios)
+{
+  return ios.service_registry_.template use_service<Service>();
+}
+
+template <typename Service>
+void add_service(io_service& ios, Service* svc)
+{
+  if (&ios != &svc->owner())
+    boost::throw_exception(invalid_service_owner());
+  if (!ios.service_registry_.template add_service<Service>(svc))
+    boost::throw_exception(service_already_exists());
+}
+
+template <typename Service>
+bool has_service(io_service& ios)
+{
+  return ios.service_registry_.template has_service<Service>();
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IO_SERVICE_IPP
diff --git a/include/boost/asio/impl/read.ipp b/include/boost/asio/impl/read.ipp
new file mode 100644
index 0000000000..968871c45f
--- /dev/null
+++ b/include/boost/asio/impl/read.ipp
@@ -0,0 +1,153 @@
+//
+// read.ipp
+// ~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_READ_IPP
+#define BOOST_ASIO_READ_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Sync_Read_Stream, typename Mutable_Buffers,
+    typename Completion_Condition, typename Error_Handler>
+std::size_t read(Sync_Read_Stream& s, const Mutable_Buffers& buffers,
+    Completion_Condition completion_condition, Error_Handler error_handler)
+{
+  boost::asio::detail::consuming_buffers<
+    mutable_buffer, Mutable_Buffers> tmp(buffers);
+  std::size_t total_transferred = 0;
+  while (tmp.begin() != tmp.end())
+  {
+    typename Sync_Read_Stream::error_type e;
+    std::size_t bytes_transferred = s.read_some(tmp, assign_error(e));
+    tmp.consume(bytes_transferred);
+    total_transferred += bytes_transferred;
+    if (completion_condition(e, total_transferred))
+    {
+      error_handler(e);
+      return total_transferred;
+    }
+  }
+  typename Sync_Read_Stream::error_type e;
+  error_handler(e);
+  return total_transferred;
+}
+
+template <typename Sync_Read_Stream, typename Mutable_Buffers>
+inline std::size_t read(Sync_Read_Stream& s, const Mutable_Buffers& buffers)
+{
+  return read(s, buffers, transfer_all(), throw_error());
+}
+
+template <typename Sync_Read_Stream, typename Mutable_Buffers,
+    typename Completion_Condition>
+inline std::size_t read(Sync_Read_Stream& s, const Mutable_Buffers& buffers,
+    Completion_Condition completion_condition)
+{
+  return read(s, buffers, completion_condition, throw_error());
+}
+
+namespace detail
+{
+  template <typename Async_Read_Stream, typename Mutable_Buffers,
+      typename Completion_Condition, typename Handler>
+  class read_handler
+  {
+  public:
+    read_handler(Async_Read_Stream& stream, const Mutable_Buffers& buffers,
+        Completion_Condition completion_condition, Handler handler)
+      : stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        completion_condition_(completion_condition),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const typename Async_Read_Stream::error_type& e,
+        std::size_t bytes_transferred)
+    {
+      total_transferred_ += bytes_transferred;
+      buffers_.consume(bytes_transferred);
+      if (completion_condition_(e, total_transferred_)
+          || buffers_.begin() == buffers_.end())
+      {
+        stream_.io_service().dispatch(
+            detail::bind_handler(handler_, e, total_transferred_));
+      }
+      else
+      {
+        stream_.async_read_some(buffers_, *this);
+      }
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        read_handler<Async_Read_Stream, Mutable_Buffers,
+          Completion_Condition, Handler>* this_handler)
+    {
+      return boost_asio_handler_alloc_helpers::allocate(
+          size, &this_handler->handler_);
+    }
+
+    friend void asio_handler_deallocate(void* pointer, std::size_t size,
+        read_handler<Async_Read_Stream, Mutable_Buffers,
+          Completion_Condition, Handler>* this_handler)
+    {
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer, size, &this_handler->handler_);
+    }
+
+  private:
+    Async_Read_Stream& stream_;
+    boost::asio::detail::consuming_buffers<
+      mutable_buffer, Mutable_Buffers> buffers_;
+    std::size_t total_transferred_;
+    Completion_Condition completion_condition_;
+    Handler handler_;
+  };
+} // namespace detail
+
+template <typename Async_Read_Stream, typename Mutable_Buffers,
+    typename Completion_Condition, typename Handler>
+inline void async_read(Async_Read_Stream& s, const Mutable_Buffers& buffers,
+    Completion_Condition completion_condition, Handler handler)
+{
+  s.async_read_some(buffers,
+      detail::read_handler<Async_Read_Stream, Mutable_Buffers,
+        Completion_Condition, Handler>(
+          s, buffers, completion_condition, handler));
+}
+
+template <typename Async_Read_Stream, typename Mutable_Buffers,
+    typename Handler>
+inline void async_read(Async_Read_Stream& s, const Mutable_Buffers& buffers,
+    Handler handler)
+{
+  async_read(s, buffers, transfer_all(), handler);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_READ_IPP
diff --git a/include/boost/asio/impl/read_until.ipp b/include/boost/asio/impl/read_until.ipp
new file mode 100644
index 0000000000..00491ea5f3
--- /dev/null
+++ b/include/boost/asio/impl/read_until.ipp
@@ -0,0 +1,395 @@
+//
+// read_until.ipp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_READ_UNTIL_IPP
+#define BOOST_ASIO_READ_UNTIL_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <algorithm>
+#include <limits>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/const_buffers_iterator.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Sync_Read_Stream, typename Allocator>
+inline std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim)
+{
+  return read_until(s, b, delim, throw_error());
+}
+
+template <typename Sync_Read_Stream, typename Allocator, typename Error_Handler>
+std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim,
+    Error_Handler error_handler)
+{
+  std::size_t next_search_start = 0;
+  for (;;)
+  {
+    // Determine the range of the data to be searched.
+    typedef typename boost::asio::basic_streambuf<
+      Allocator>::const_buffers_type const_buffers_type;
+    typedef boost::asio::detail::const_buffers_iterator<
+      const_buffers_type> iterator;
+    const_buffers_type buffers = b.sbuffers();
+    iterator begin(buffers, next_search_start);
+    iterator end(buffers, (std::numeric_limits<std::size_t>::max)());
+
+    // Look for a match.
+    iterator iter = std::find(begin, end, delim);
+    if (iter != end)
+    {
+      // Found a match. We're done.
+      return iter.position() + 1;
+    }
+    else
+    {
+      // No match. Next search can start with the new data.
+      next_search_start = end.position();
+    }
+
+    // Need more data.
+    typename Sync_Read_Stream::error_type error;
+    b.spbump(s.read_some(b.spbuffers(512), boost::asio::assign_error(error)));
+    if (error)
+    {
+      error_handler(error);
+      return 0;
+    }
+  }
+}
+
+template <typename Sync_Read_Stream, typename Allocator>
+inline std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
+{
+  return read_until(s, b, expr, throw_error());
+}
+
+template <typename Sync_Read_Stream, typename Allocator, typename Error_Handler>
+std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    Error_Handler error_handler)
+{
+  std::size_t next_search_start = 0;
+  for (;;)
+  {
+    // Determine the range of the data to be searched.
+    typedef typename boost::asio::basic_streambuf<
+      Allocator>::const_buffers_type const_buffers_type;
+    typedef boost::asio::detail::const_buffers_iterator<
+      const_buffers_type> iterator;
+    const_buffers_type buffers = b.sbuffers();
+    iterator begin(buffers, next_search_start);
+    iterator end(buffers, (std::numeric_limits<std::size_t>::max)());
+
+    // Look for a match.
+    boost::match_results<iterator> match_results;
+    if (boost::regex_search(begin, end, match_results, expr,
+          boost::match_default | boost::match_partial))
+    {
+      if (match_results[0].matched)
+      {
+        // Full match. We're done.
+        return match_results[0].second.position();
+      }
+      else
+      {
+        // Partial match. Next search needs to start from beginning of match.
+        next_search_start = match_results[0].first.position();
+      }
+    }
+    else
+    {
+      // No match. Next search can start with the new data.
+      next_search_start = end.position();
+    }
+
+    // Need more data.
+    typename Sync_Read_Stream::error_type error;
+    b.spbump(s.read_some(b.spbuffers(512), boost::asio::assign_error(error)));
+    if (error)
+    {
+      error_handler(error);
+      return 0;
+    }
+  }
+}
+
+namespace detail
+{
+  template <typename Async_Read_Stream, typename Allocator, typename Handler>
+  class read_until_delim_handler
+  {
+  public:
+    read_until_delim_handler(Async_Read_Stream& stream,
+        boost::asio::basic_streambuf<Allocator>& streambuf, char delim,
+        std::size_t next_search_start, Handler handler)
+      : stream_(stream),
+        streambuf_(streambuf),
+        delim_(delim),
+        next_search_start_(next_search_start),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const typename Async_Read_Stream::error_type& e,
+        std::size_t bytes_transferred)
+    {
+      // Check for errors.
+      if (e)
+      {
+        std::size_t bytes = 0;
+        handler_(e, bytes);
+        return;
+      }
+
+      // Commit received data to streambuf's get area.
+      streambuf_.spbump(bytes_transferred);
+
+      // Determine the range of the data to be searched.
+      typedef typename boost::asio::basic_streambuf<
+        Allocator>::const_buffers_type const_buffers_type;
+      typedef boost::asio::detail::const_buffers_iterator<
+        const_buffers_type> iterator;
+      const_buffers_type buffers = streambuf_.sbuffers();
+      iterator begin(buffers, next_search_start_);
+      iterator end(buffers, (std::numeric_limits<std::size_t>::max)());
+
+      // Look for a match.
+      iterator iter = std::find(begin, end, delim_);
+      if (iter != end)
+      {
+        // Found a match. We're done.
+        std::size_t bytes = iter.position() + 1;
+        handler_(e, bytes);
+        return;
+      }
+
+      // No match. Start a new asynchronous read operation to obtain more data.
+      next_search_start_ = end.position();
+      stream_.async_read_some(streambuf_.spbuffers(512), *this);
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        read_until_delim_handler<Async_Read_Stream,
+          Allocator, Handler>* this_handler)
+    {
+      return boost_asio_handler_alloc_helpers::allocate(
+          size, &this_handler->handler_);
+    }
+
+    friend void asio_handler_deallocate(void* pointer, std::size_t size,
+        read_until_delim_handler<Async_Read_Stream,
+          Allocator, Handler>* this_handler)
+    {
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer, size, &this_handler->handler_);
+    }
+
+  private:
+    Async_Read_Stream& stream_;
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    char delim_;
+    std::size_t next_search_start_;
+    Handler handler_;
+  };
+} // namespace detail
+
+template <typename Async_Read_Stream, typename Allocator, typename Handler>
+void async_read_until(Async_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim, Handler handler)
+{
+  // Determine the range of the data to be searched.
+  typedef typename boost::asio::basic_streambuf<
+    Allocator>::const_buffers_type const_buffers_type;
+  typedef boost::asio::detail::const_buffers_iterator<
+    const_buffers_type> iterator;
+  const_buffers_type buffers = b.sbuffers();
+  iterator begin(buffers, 0);
+  iterator end(buffers, (std::numeric_limits<std::size_t>::max)());
+
+  // Look for a match.
+  iterator iter = std::find(begin, end, delim);
+  if (iter != end)
+  {
+    // Found a match. We're done.
+    typename Async_Read_Stream::error_type error;
+    std::size_t bytes = iter.position() + 1;
+    s.io_service().post(detail::bind_handler(handler, error, bytes));
+    return;
+  }
+
+  // No match. Start a new asynchronous read operation to obtain more data.
+  s.async_read_some(b.spbuffers(512),
+      detail::read_until_delim_handler<Async_Read_Stream, Allocator, Handler>(
+        s, b, delim, end.position(), handler));
+}
+
+namespace detail
+{
+  template <typename Async_Read_Stream, typename Allocator, typename Handler>
+  class read_until_expr_handler
+  {
+  public:
+    read_until_expr_handler(Async_Read_Stream& stream,
+        boost::asio::basic_streambuf<Allocator>& streambuf,
+        const boost::regex& expr, std::size_t next_search_start,
+        Handler handler)
+      : stream_(stream),
+        streambuf_(streambuf),
+        expr_(expr),
+        next_search_start_(next_search_start),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const typename Async_Read_Stream::error_type& e,
+        std::size_t bytes_transferred)
+    {
+      // Check for errors.
+      if (e)
+      {
+        std::size_t bytes = 0;
+        handler_(e, bytes);
+        return;
+      }
+
+      // Commit received data to streambuf's get area.
+      streambuf_.spbump(bytes_transferred);
+
+      // Determine the range of the data to be searched.
+      typedef typename boost::asio::basic_streambuf<
+        Allocator>::const_buffers_type const_buffers_type;
+      typedef boost::asio::detail::const_buffers_iterator<
+        const_buffers_type> iterator;
+      const_buffers_type buffers = streambuf_.sbuffers();
+      iterator begin(buffers, next_search_start_);
+      iterator end(buffers, (std::numeric_limits<std::size_t>::max)());
+
+      // Look for a match.
+      boost::match_results<iterator> match_results;
+      if (boost::regex_search(begin, end, match_results, expr_,
+            boost::match_default | boost::match_partial))
+      {
+        if (match_results[0].matched)
+        {
+          // Full match. We're done.
+          std::size_t bytes = match_results[0].second.position();
+          handler_(e, bytes);
+          return;
+        }
+        else
+        {
+          // Partial match. Next search needs to start from beginning of match.
+          next_search_start_ = match_results[0].first.position();
+        }
+      }
+      else
+      {
+        // No match. Next search can start with the new data.
+        next_search_start_ = end.position();
+      }
+
+      // No match. Start a new asynchronous read operation to obtain more data.
+      next_search_start_ = end.position();
+      stream_.async_read_some(streambuf_.spbuffers(512), *this);
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        read_until_expr_handler<Async_Read_Stream,
+          Allocator, Handler>* this_handler)
+    {
+      return boost_asio_handler_alloc_helpers::allocate(
+          size, &this_handler->handler_);
+    }
+
+    friend void asio_handler_deallocate(void* pointer, std::size_t size,
+        read_until_expr_handler<Async_Read_Stream,
+          Allocator, Handler>* this_handler)
+    {
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer, size, &this_handler->handler_);
+    }
+
+  private:
+    Async_Read_Stream& stream_;
+    boost::asio::basic_streambuf<Allocator>& streambuf_;
+    boost::regex expr_;
+    std::size_t next_search_start_;
+    Handler handler_;
+  };
+} // namespace detail
+
+template <typename Async_Read_Stream, typename Allocator, typename Handler>
+void async_read_until(Async_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    Handler handler)
+{
+  // Determine the range of the data to be searched.
+  typedef typename boost::asio::basic_streambuf<
+    Allocator>::const_buffers_type const_buffers_type;
+  typedef boost::asio::detail::const_buffers_iterator<
+    const_buffers_type> iterator;
+  const_buffers_type buffers = b.sbuffers();
+  iterator begin(buffers, 0);
+  iterator end(buffers, (std::numeric_limits<std::size_t>::max)());
+
+  // Look for a match.
+  std::size_t next_search_start;
+  boost::match_results<iterator> match_results;
+  if (boost::regex_search(begin, end, match_results, expr,
+        boost::match_default | boost::match_partial))
+  {
+    if (match_results[0].matched)
+    {
+      // Full match. We're done.
+      typename Async_Read_Stream::error_type error;
+      std::size_t bytes = match_results[0].second.position();
+      s.io_service().post(detail::bind_handler(handler, error, bytes));
+      return;
+    }
+    else
+    {
+      // Partial match. Next search needs to start from beginning of match.
+      next_search_start = match_results[0].first.position();
+    }
+  }
+  else
+  {
+    // No match. Next search can start with the new data.
+    next_search_start = end.position();
+  }
+
+  // No match. Start a new asynchronous read operation to obtain more data.
+  s.async_read_some(b.spbuffers(512),
+      detail::read_until_expr_handler<Async_Read_Stream, Allocator, Handler>(
+        s, b, expr, next_search_start, handler));
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_READ_UNTIL_IPP
diff --git a/include/boost/asio/impl/write.ipp b/include/boost/asio/impl/write.ipp
new file mode 100644
index 0000000000..46b787369f
--- /dev/null
+++ b/include/boost/asio/impl/write.ipp
@@ -0,0 +1,152 @@
+//
+// write.ipp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_WRITE_IPP
+#define BOOST_ASIO_WRITE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/completion_condition.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/consuming_buffers.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+
+namespace boost {
+namespace asio {
+
+template <typename Sync_Write_Stream, typename Const_Buffers,
+    typename Completion_Condition, typename Error_Handler>
+std::size_t write(Sync_Write_Stream& s, const Const_Buffers& buffers,
+    Completion_Condition completion_condition, Error_Handler error_handler)
+{
+  boost::asio::detail::consuming_buffers<
+    const_buffer, Const_Buffers> tmp(buffers);
+  std::size_t total_transferred = 0;
+  while (tmp.begin() != tmp.end())
+  {
+    typename Sync_Write_Stream::error_type e;
+    std::size_t bytes_transferred = s.write_some(tmp, assign_error(e));
+    tmp.consume(bytes_transferred);
+    total_transferred += bytes_transferred;
+    if (completion_condition(e, total_transferred))
+    {
+      error_handler(e);
+      return total_transferred;
+    }
+  }
+  typename Sync_Write_Stream::error_type e;
+  error_handler(e);
+  return total_transferred;
+}
+
+template <typename Sync_Write_Stream, typename Const_Buffers>
+inline std::size_t write(Sync_Write_Stream& s, const Const_Buffers& buffers)
+{
+  return write(s, buffers, transfer_all(), throw_error());
+}
+
+template <typename Sync_Write_Stream, typename Const_Buffers,
+    typename Completion_Condition>
+inline std::size_t write(Sync_Write_Stream& s, const Const_Buffers& buffers,
+    Completion_Condition completion_condition)
+{
+  return write(s, buffers, completion_condition, throw_error());
+}
+
+namespace detail
+{
+  template <typename Async_Write_Stream, typename Const_Buffers,
+      typename Completion_Condition, typename Handler>
+  class write_handler
+  {
+  public:
+    write_handler(Async_Write_Stream& stream, const Const_Buffers& buffers,
+        Completion_Condition completion_condition, Handler handler)
+      : stream_(stream),
+        buffers_(buffers),
+        total_transferred_(0),
+        completion_condition_(completion_condition),
+        handler_(handler)
+    {
+    }
+
+    void operator()(const typename Async_Write_Stream::error_type& e,
+        std::size_t bytes_transferred)
+    {
+      total_transferred_ += bytes_transferred;
+      buffers_.consume(bytes_transferred);
+      if (completion_condition_(e, total_transferred_)
+          || buffers_.begin() == buffers_.end())
+      {
+        stream_.io_service().dispatch(
+            detail::bind_handler(handler_, e, total_transferred_));
+      }
+      else
+      {
+        stream_.async_write_some(buffers_, *this);
+      }
+    }
+
+    friend void* asio_handler_allocate(std::size_t size,
+        write_handler<Async_Write_Stream, Const_Buffers,
+          Completion_Condition, Handler>* this_handler)
+    {
+      return boost_asio_handler_alloc_helpers::allocate(
+          size, &this_handler->handler_);
+    }
+
+    friend void asio_handler_deallocate(void* pointer, std::size_t size,
+        write_handler<Async_Write_Stream, Const_Buffers,
+          Completion_Condition, Handler>* this_handler)
+    {
+      boost_asio_handler_alloc_helpers::deallocate(
+          pointer, size, &this_handler->handler_);
+    }
+
+  private:
+    Async_Write_Stream& stream_;
+    boost::asio::detail::consuming_buffers<
+      const_buffer, Const_Buffers> buffers_;
+    std::size_t total_transferred_;
+    Completion_Condition completion_condition_;
+    Handler handler_;
+  };
+} // namespace detail
+
+template <typename Async_Write_Stream, typename Const_Buffers,
+  typename Completion_Condition, typename Handler>
+inline void async_write(Async_Write_Stream& s, const Const_Buffers& buffers,
+    Completion_Condition completion_condition, Handler handler)
+{
+  s.async_write_some(buffers,
+      detail::write_handler<Async_Write_Stream, Const_Buffers,
+        Completion_Condition, Handler>(
+          s, buffers, completion_condition, handler));
+}
+
+template <typename Async_Write_Stream, typename Const_Buffers, typename Handler>
+inline void async_write(Async_Write_Stream& s, const Const_Buffers& buffers,
+    Handler handler)
+{
+  async_write(s, buffers, transfer_all(), handler);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_WRITE_IPP
diff --git a/include/boost/asio/io_service.hpp b/include/boost/asio/io_service.hpp
new file mode 100644
index 0000000000..08386d3fa8
--- /dev/null
+++ b/include/boost/asio/io_service.hpp
@@ -0,0 +1,386 @@
+//
+// io_service.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IO_SERVICE_HPP
+#define BOOST_ASIO_IO_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <stdexcept>
+#include <typeinfo>
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/epoll_reactor_fwd.hpp>
+#include <boost/asio/detail/kqueue_reactor_fwd.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/select_reactor_fwd.hpp>
+#include <boost/asio/detail/service_registry.hpp>
+#include <boost/asio/detail/signal_init.hpp>
+#include <boost/asio/detail/task_io_service_fwd.hpp>
+#include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
+#include <boost/asio/detail/winsock_init.hpp>
+#include <boost/asio/detail/wrapped_handler.hpp>
+
+namespace boost {
+namespace asio {
+
+/// 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 boost::asio::ip::tcp::socket
+ * @li boost::asio::ip::tcp::acceptor
+ * @li boost::asio::ip::udp::socket
+ * @li boost::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 exception that calling reset()
+ * while there are unfinished run() calls results in undefined behaviour.
+ *
+ * @par Concepts:
+ * Dispatcher.
+ *
+ * @sa @ref io_service_handler_exception
+ */
+class io_service
+  : private noncopyable
+{
+private:
+  // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_io_service impl_type;
+#elif defined(BOOST_ASIO_HAS_EPOLL)
+  typedef detail::task_io_service<detail::epoll_reactor<false> > impl_type;
+#elif defined(BOOST_ASIO_HAS_KQUEUE)
+  typedef detail::task_io_service<detail::kqueue_reactor<false> > impl_type;
+#else
+  typedef detail::task_io_service<detail::select_reactor<false> > impl_type;
+#endif
+
+public:
+  class work;
+  friend class work;
+
+  class service;
+
+  /// Default constructor.
+  io_service();
+
+  /// Run the io_service'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
+   * interrupted.
+   *
+   * Multiple threads may call the run() function to set up a pool of threads
+   * from which the io_service may execute handlers.
+   *
+   * The run() function may be safely called again once it has completed only
+   * after a call to reset().
+   */
+  void run();
+
+  /// Interrupt the io_service's event processing loop.
+  /**
+   * This function does not block, but instead simply signals to the io_service
+   * that all invocations of its run() member function should return as soon as
+   * possible.
+   *
+   * Note that if the run() function is interrupted and is not called again
+   * later then its work may not have finished and handlers may not be
+   * delivered. In this case an io_service implementation is not required to
+   * make any guarantee that the resources associated with unfinished work will
+   * be cleaned up.
+   */
+  void interrupt();
+
+  /// 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() function. It allows the io_service to reset any
+   * internal state, such as an interrupt flag.
+   *
+   * This function must not be called while there are any unfinished calls to
+   * the run() function.
+   */
+  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() member function 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
+   */
+  template <typename Handler>
+  void dispatch(Handler 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() member function 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
+   */
+  template <typename Handler>
+  void post(Handler 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'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'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);
+
+  /// 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 boost::asio::service_already_exists Thrown if a service of the
+   * given type is already present in the io_service.
+   *
+   * @throws boost::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(BOOST_WINDOWS) || defined(__CYGWIN__)
+  detail::winsock_init<> init_;
+#elif defined(__sun) || defined(__QNX__)
+  detail::signal_init<> init_;
+#endif
+
+  // The service registry.
+  detail::service_registry<io_service> 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'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's run() function will not exit while the
+   * work is underway.
+   */
+  explicit work(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'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's
+   * run() function is permitted to exit.
+   */
+  ~work();
+
+private:
+  // Prevent assignment.
+  void operator=(const work& other);
+
+  // The io_service's implementation.
+  io_service::impl_type& impl_;
+};
+
+/// Base class for all io_service services.
+class io_service::service
+  : private noncopyable
+{
+public:
+  /// Get the io_service object that owns the service.
+  io_service& owner();
+
+protected:
+  /// Constructor.
+  /**
+   * @param owner The io_service object that owns the service.
+   */
+  service(io_service& owner);
+
+  /// Destructor.
+  virtual ~service();
+
+private:
+  /// Destroy all user-defined handler objects owned by the service.
+  virtual void shutdown_service() = 0;
+
+  friend class detail::service_registry<io_service>;
+  io_service& owner_;
+  const std::type_info* type_info_;
+  service* next_;
+};
+
+/// Exception thrown when trying to add a duplicate service to an io_service.
+class service_already_exists
+  : public std::logic_error
+{
+public:
+  service_already_exists()
+    : std::logic_error("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:
+  invalid_service_owner()
+    : std::logic_error("Invalid service owner.")
+  {
+  }
+};
+
+/**
+ * @page io_service_handler_exception 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
+ * boost::asio::io_service::run(). No other threads that are calling
+ * boost::asio::io_service::run() are affected. It is then the responsibility of
+ * the application to catch the exception.
+ *
+ * After the exception has been caught, the boost::asio::io_service::run() call
+ * may be restarted @em without the need for an intervening call to
+ * boost::asio::io_service::reset(). This allows the thread to rejoin the
+ * io_service's thread pool without impacting any other threads in the
+ * pool.
+ *
+ * @par Example:
+ * @code
+ * boost::asio::io_service io_service;
+ * ...
+ * for (;;)
+ * {
+ *   try
+ *   {
+ *     io_service.run();
+ *     break; // run() exited normally
+ *   }
+ *   catch (my_exception& e)
+ *   {
+ *     // Deal with exception as appropriate.
+ *   }
+ * }
+ * @endcode
+ */
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/impl/io_service.ipp>
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IO_SERVICE_HPP
diff --git a/include/boost/asio/ip/address.hpp b/include/boost/asio/ip/address.hpp
new file mode 100644
index 0000000000..810ec49a27
--- /dev/null
+++ b/include/boost/asio/ip/address.hpp
@@ -0,0 +1,286 @@
+//
+// address.hpp
+// ~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_ADDRESS_HPP
+#define BOOST_ASIO_IP_ADDRESS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <iosfwd>
+#include <string>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+#include <boost/asio/ip/address_v6.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Implements version-independent IP addresses.
+/**
+ * The boost::asio::ip::address class provides the ability to use either IP
+ * version 4 or version 6 addresses.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class address
+{
+public:
+  /// Default constructor.
+  address()
+    : type_(ipv4),
+      ipv4_address_(),
+      ipv6_address_()
+  {
+  }
+
+  /// Construct an address from an IPv4 address.
+  address(const boost::asio::ip::address_v4& ipv4_address)
+    : type_(ipv4),
+      ipv4_address_(ipv4_address),
+      ipv6_address_()
+  {
+  }
+
+  /// Construct an address from an IPv6 address.
+  address(const boost::asio::ip::address_v6& ipv6_address)
+    : type_(ipv6),
+      ipv4_address_(),
+      ipv6_address_(ipv6_address)
+  {
+  }
+
+  /// Copy constructor.
+  address(const address& other)
+    : type_(other.type_),
+      ipv4_address_(other.ipv4_address_),
+      ipv6_address_(other.ipv6_address_)
+  {
+  }
+
+  /// Assign from another address.
+  address& operator=(const address& other)
+  {
+    type_ = other.type_;
+    ipv4_address_ = other.ipv4_address_;
+    ipv6_address_ = other.ipv6_address_;
+    return *this;
+  }
+
+  /// Assign from an IPv4 address.
+  address& operator=(const boost::asio::ip::address_v4& ipv4_address)
+  {
+    type_ = ipv4;
+    ipv4_address_ = ipv4_address;
+    ipv6_address_ = boost::asio::ip::address_v6();
+    return *this;
+  }
+
+  /// Assign from an IPv6 address.
+  address& operator=(const boost::asio::ip::address_v6& ipv6_address)
+  {
+    type_ = ipv6;
+    ipv4_address_ = boost::asio::ip::address_v4();
+    ipv6_address_ = ipv6_address;
+    return *this;
+  }
+
+  /// Get whether the address is an IP version 4 address.
+  bool is_v4() const
+  {
+    return type_ == ipv4;
+  }
+
+  /// Get whether the address is an IP version 6 address.
+  bool is_v6() const
+  {
+    return type_ == ipv6;
+  }
+
+  /// Get the address as an IP version 4 address.
+  boost::asio::ip::address_v4 to_v4() const
+  {
+    if (type_ != ipv4)
+    {
+      boost::asio::error error(
+          boost::asio::error::address_family_not_supported);
+      boost::throw_exception(error);
+    }
+    return ipv4_address_;
+  }
+
+  /// Get the address as an IP version 6 address.
+  boost::asio::ip::address_v6 to_v6() const
+  {
+    if (type_ != ipv6)
+    {
+      boost::asio::error error(
+          boost::asio::error::address_family_not_supported);
+      boost::throw_exception(error);
+    }
+    return ipv6_address_;
+  }
+
+  /// Get the address as a string in dotted decimal format.
+  std::string to_string() const
+  {
+    if (type_ == ipv6)
+      return ipv6_address_.to_string();
+    return ipv4_address_.to_string();
+  }
+
+  /// Get the address as a string in dotted decimal format.
+  template <typename Error_Handler>
+  std::string to_string(Error_Handler error_handler) const
+  {
+    if (type_ == ipv6)
+      return ipv6_address_.to_string(error_handler);
+    return ipv4_address_.to_string(error_handler);
+  }
+
+  /// 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)
+  {
+    return from_string(str, boost::asio::throw_error());
+  }
+
+  /// Create an address from an IPv4 address string in dotted decimal form,
+  /// or from an IPv6 address in hexadecimal notation.
+  template <typename Error_Handler>
+  static address from_string(const char* str, Error_Handler error_handler)
+  {
+    boost::asio::error error;
+    boost::asio::ip::address_v6 ipv6_address =
+      boost::asio::ip::address_v6::from_string(str,
+        boost::asio::assign_error(error));
+    if (!error)
+    {
+      address tmp;
+      tmp.type_ = ipv6;
+      tmp.ipv6_address_ = ipv6_address;
+      error_handler(error);
+      return tmp;
+    }
+
+    error = boost::asio::error();
+    boost::asio::ip::address_v4 ipv4_address =
+      boost::asio::ip::address_v4::from_string(str,
+        boost::asio::assign_error(error));
+    if (!error)
+    {
+      address tmp;
+      tmp.type_ = ipv4;
+      tmp.ipv4_address_ = ipv4_address;
+      error_handler(error);
+      return tmp;
+    }
+
+    error_handler(error);
+    return 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)
+  {
+    return from_string(str.c_str(), boost::asio::throw_error());
+  }
+
+  /// Create an address from an IPv4 address string in dotted decimal form,
+  /// or from an IPv6 address in hexadecimal notation.
+  template <typename Error_Handler>
+  static address from_string(const std::string& str,
+      Error_Handler error_handler)
+  {
+    return from_string(str.c_str(), error_handler);
+  }
+
+  /// Compare two addresses for equality.
+  friend bool operator==(const address& a1, const address& a2)
+  {
+    if (a1.type_ != a2.type_)
+      return false;
+    if (a1.type_ == ipv6)
+      return a1.ipv6_address_ == a2.ipv6_address_;
+    return a1.ipv4_address_ == a2.ipv4_address_;
+  }
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const address& a1, const address& a2)
+  {
+    if (a1.type_ != a2.type_)
+      return true;
+    if (a1.type_ == ipv6)
+      return a1.ipv6_address_ != a2.ipv6_address_;
+    return a1.ipv4_address_ != a2.ipv4_address_;
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<(const address& a1, const address& a2)
+  {
+    if (a1.type_ < a2.type_)
+      return true;
+    if (a1.type_ > a2.type_)
+      return false;
+    if (a1.type_ == ipv6)
+      return a1.ipv6_address_ < a2.ipv6_address_;
+    return a1.ipv4_address_ < a2.ipv4_address_;
+  }
+
+private:
+  // The type of the address.
+  enum { ipv4, ipv6 } type_;
+
+  // The underlying IPv4 address.
+  boost::asio::ip::address_v4 ipv4_address_;
+
+  // The underlying IPv6 address.
+  boost::asio::ip::address_v6 ipv6_address_;
+};
+
+/// Output an address as a string.
+/**
+ * Used to output a human-readable string for a specified address.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param addr The address to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::address
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address& addr)
+{
+  os << addr.to_string();
+  return os;
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_ADDRESS_HPP
diff --git a/include/boost/asio/ip/address_v4.hpp b/include/boost/asio/ip/address_v4.hpp
new file mode 100644
index 0000000000..4061ba909a
--- /dev/null
+++ b/include/boost/asio/ip/address_v4.hpp
@@ -0,0 +1,263 @@
+//
+// address_v4.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_ADDRESS_V4_HPP
+#define BOOST_ASIO_IP_ADDRESS_V4_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <string>
+#include <boost/array.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Implements IP version 4 style addresses.
+/**
+ * The boost::asio::ip::address_v4 class provides the ability to use and
+ * manipulate IP version 4 addresses.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class address_v4
+{
+public:
+  /// The type used to represent an address as an array of bytes.
+  typedef boost::array<unsigned char, 4> bytes_type;
+
+  /// Default constructor.
+  address_v4()
+  {
+    addr_.s_addr = 0;
+  }
+
+  /// Construct an address from raw bytes.
+  explicit address_v4(const bytes_type& bytes)
+  {
+    using namespace std; // For memcpy.
+    memcpy(&addr_.s_addr, bytes.elems, 4);
+  }
+
+  /// Construct an address from a unsigned long in host byte order.
+  explicit address_v4(unsigned long addr)
+  {
+    addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(addr);
+  }
+
+  /// Copy constructor.
+  address_v4(const address_v4& other)
+    : addr_(other.addr_)
+  {
+  }
+
+  /// Assign from another address.
+  address_v4& operator=(const address_v4& other)
+  {
+    addr_ = other.addr_;
+    return *this;
+  }
+
+  /// Assign from an unsigned long.
+  address_v4& operator=(unsigned long addr)
+  {
+    addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(addr);
+    return *this;
+  }
+
+  /// Get the address in bytes.
+  bytes_type to_bytes() const
+  {
+    using namespace std; // For memcpy.
+    bytes_type bytes;
+    memcpy(bytes.elems, &addr_.s_addr, 4);
+    return bytes;
+  }
+
+  /// Get the address as an unsigned long in host byte order
+  unsigned long to_ulong() const
+  {
+    return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
+  }
+
+  /// Get the address as a string in dotted decimal format.
+  std::string to_string() const
+  {
+    return to_string(boost::asio::throw_error());
+  }
+
+  /// Get the address as a string in dotted decimal format.
+  template <typename Error_Handler>
+  std::string to_string(Error_Handler error_handler) const
+  {
+    char addr_str[boost::asio::detail::max_addr_v4_str_len];
+    const char* addr =
+      boost::asio::detail::socket_ops::inet_ntop(AF_INET, &addr_, addr_str,
+          boost::asio::detail::max_addr_v4_str_len);
+    if (addr == 0)
+    {
+      boost::asio::error e(boost::asio::detail::socket_ops::get_error());
+      error_handler(e);
+      return std::string();
+    }
+    boost::asio::error e;
+    error_handler(e);
+    return addr;
+  }
+
+  /// Create an address from an IP address string in dotted decimal form.
+  static address_v4 from_string(const char* str)
+  {
+    return from_string(str, boost::asio::throw_error());
+  }
+
+  /// Create an address from an IP address string in dotted decimal form.
+  template <typename Error_Handler>
+  static address_v4 from_string(const char* str, Error_Handler error_handler)
+  {
+    address_v4 tmp;
+    if (boost::asio::detail::socket_ops::inet_pton(
+          AF_INET, str, &tmp.addr_) <= 0)
+    {
+      boost::asio::error e(boost::asio::detail::socket_ops::get_error());
+      error_handler(e);
+      return address_v4();
+    }
+    boost::asio::error e;
+    error_handler(e);
+    return tmp;
+  }
+
+  /// Create an address from an IP address string in dotted decimal form.
+  static address_v4 from_string(const std::string& str)
+  {
+    return from_string(str.c_str(), boost::asio::throw_error());
+  }
+
+  /// Create an address from an IP address string in dotted decimal form.
+  template <typename Error_Handler>
+  static address_v4 from_string(const std::string& str,
+      Error_Handler error_handler)
+  {
+    return from_string(str.c_str(), error_handler);
+  }
+
+  /// Determine whether the address is a class A address.
+  bool is_class_A() const
+  {
+    return IN_CLASSA(to_ulong());
+  }
+
+  /// Determine whether the address is a class B address.
+  bool is_class_B() const
+  {
+    return IN_CLASSB(to_ulong());
+  }
+
+  /// Determine whether the address is a class C address.
+  bool is_class_C() const
+  {
+    return IN_CLASSC(to_ulong());
+  }
+
+  /// Determine whether the address is a class D address.
+  bool is_class_D() const
+  {
+    return IN_CLASSD(to_ulong());
+  }
+
+  /// Determine whether the address is a multicast address.
+  bool is_multicast() const
+  {
+    return IN_MULTICAST(to_ulong());
+  }
+
+  /// Compare two addresses for equality.
+  friend bool operator==(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.addr_.s_addr == a2.addr_.s_addr;
+  }
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.addr_.s_addr != a2.addr_.s_addr;
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<(const address_v4& a1, const address_v4& a2)
+  {
+    return a1.to_ulong() < a2.to_ulong();
+  }
+
+  /// Obtain an address object that represents any address.
+  static address_v4 any()
+  {
+    return address_v4(static_cast<unsigned long>(INADDR_ANY));
+  }
+
+  /// Obtain an address object that represents the loopback address.
+  static address_v4 loopback()
+  {
+    return address_v4(static_cast<unsigned long>(INADDR_LOOPBACK));
+  }
+
+  /// Obtain an address object that represents the broadcast address.
+  static address_v4 broadcast()
+  {
+    return address_v4(static_cast<unsigned long>(INADDR_BROADCAST));
+  }
+
+private:
+  // The underlying IPv4 address.
+  boost::asio::detail::in4_addr_type addr_;
+};
+
+/// Output an address as a string.
+/**
+ * Used to output a human-readable string for a specified address.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param addr The address to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::address_v4
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
+{
+  os << addr.to_string();
+  return os;
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_ADDRESS_V4_HPP
diff --git a/include/boost/asio/ip/address_v6.hpp b/include/boost/asio/ip/address_v6.hpp
new file mode 100644
index 0000000000..2da8a18493
--- /dev/null
+++ b/include/boost/asio/ip/address_v6.hpp
@@ -0,0 +1,330 @@
+//
+// address_v6.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_ADDRESS_V6_HPP
+#define BOOST_ASIO_IP_ADDRESS_V6_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstring>
+#include <string>
+#include <stdexcept>
+#include <boost/array.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Implements IP version 6 style addresses.
+/**
+ * The boost::asio::ip::address_v6 class provides the ability to use and
+ * manipulate IP version 6 addresses.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+class address_v6
+{
+public:
+  /// The type used to represent an address as an array of bytes.
+  typedef boost::array<unsigned char, 16> bytes_type;
+
+  /// Default constructor.
+  address_v6()
+    : scope_id_(0)
+  {
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+    addr_ = tmp_addr;
+  }
+
+  /// Construct an address from raw bytes and scope ID.
+  explicit address_v6(const bytes_type& bytes, unsigned long scope_id = 0)
+    : scope_id_(scope_id)
+  {
+    using namespace std; // For memcpy.
+    memcpy(addr_.s6_addr, bytes.elems, 16);
+  }
+
+  /// Copy constructor.
+  address_v6(const address_v6& other)
+    : addr_(other.addr_),
+      scope_id_(other.scope_id_)
+  {
+  }
+
+  /// Assign from another address.
+  address_v6& operator=(const address_v6& other)
+  {
+    addr_ = other.addr_;
+    scope_id_ = other.scope_id_;
+    return *this;
+  }
+
+  /// Get the scope ID of the address.
+  unsigned long scope_id() const
+  {
+    return scope_id_;
+  }
+
+  /// Set the scope ID of the address.
+  void scope_id(unsigned long id)
+  {
+    scope_id_ = id;
+  }
+
+  /// Get the address in bytes.
+  bytes_type to_bytes() const
+  {
+    using namespace std; // For memcpy.
+    bytes_type bytes;
+    memcpy(bytes.elems, addr_.s6_addr, 16);
+    return bytes;
+  }
+
+  /// Get the address as a string.
+  std::string to_string() const
+  {
+    return to_string(boost::asio::throw_error());
+  }
+
+  /// Get the address as a string.
+  template <typename Error_Handler>
+  std::string to_string(Error_Handler error_handler) const
+  {
+    char addr_str[boost::asio::detail::max_addr_v6_str_len];
+    const char* addr =
+      boost::asio::detail::socket_ops::inet_ntop(AF_INET6, &addr_, addr_str,
+          boost::asio::detail::max_addr_v6_str_len, scope_id_);
+    if (addr == 0)
+    {
+      boost::asio::error e(boost::asio::detail::socket_ops::get_error());
+      error_handler(e);
+      return std::string();
+    }
+    boost::asio::error e;
+    error_handler(e);
+    return addr;
+  }
+
+  /// Create an address from an IP address string.
+  static address_v6 from_string(const char* str)
+  {
+    return from_string(str, boost::asio::throw_error());
+  }
+
+  /// Create an address from an IP address string.
+  template <typename Error_Handler>
+  static address_v6 from_string(const char* str, Error_Handler error_handler)
+  {
+    address_v6 tmp;
+    if (boost::asio::detail::socket_ops::inet_pton(
+          AF_INET6, str, &tmp.addr_, &tmp.scope_id_) <= 0)
+    {
+      boost::asio::error e(boost::asio::detail::socket_ops::get_error());
+      error_handler(e);
+      return address_v6();
+    }
+    boost::asio::error e;
+    error_handler(e);
+    return tmp;
+  }
+
+  /// Create an address from an IP address string.
+  static address_v6 from_string(const std::string& str)
+  {
+    return from_string(str.c_str(), boost::asio::throw_error());
+  }
+
+  /// Create an address from an IP address string.
+  template <typename Error_Handler>
+  static address_v6 from_string(const std::string& str,
+      Error_Handler error_handler)
+  {
+    return from_string(str.c_str(), error_handler);
+  }
+
+  /// Determine whether the address is a loopback address.
+  bool is_loopback() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_LOOPBACK(&addr_) != 0;
+  }
+
+  /// Determine whether the address is unspecified.
+  bool is_unspecified() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_UNSPECIFIED(&addr_) != 0;
+  }
+
+  /// Determine whether the address is link local.
+  bool is_link_local() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_LINKLOCAL(&addr_) != 0;
+  }
+
+  /// Determine whether the address is site local.
+  bool is_site_local() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_SITELOCAL(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a mapped IPv4 address.
+  bool is_ipv4_mapped() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_V4MAPPED(&addr_) != 0;
+  }
+
+  /// Determine whether the address is an IPv4-compatible address.
+  bool is_ipv4_compatible() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_V4COMPAT(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a multicast address.
+  bool is_multicast() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_MULTICAST(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a global multicast address.
+  bool is_multicast_global() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_MC_GLOBAL(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a link-local multicast address.
+  bool is_multicast_link_local() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_MC_LINKLOCAL(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a node-local multicast address.
+  bool is_multicast_node_local() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_MC_NODELOCAL(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a org-local multicast address.
+  bool is_multicast_org_local() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_MC_ORGLOCAL(&addr_) != 0;
+  }
+
+  /// Determine whether the address is a site-local multicast address.
+  bool is_multicast_site_local() const
+  {
+    using namespace boost::asio::detail;
+    return IN6_IS_ADDR_MC_SITELOCAL(&addr_) != 0;
+  }
+
+  /// Compare two addresses for equality.
+  friend bool operator==(const address_v6& a1, const address_v6& a2)
+  {
+    using namespace std; // For memcmp.
+    return memcmp(&a1.addr_, &a2.addr_,
+        sizeof(boost::asio::detail::in6_addr_type)) == 0
+      && a1.scope_id_ == a2.scope_id_;
+  }
+
+  /// Compare two addresses for inequality.
+  friend bool operator!=(const address_v6& a1, const address_v6& a2)
+  {
+    using namespace std; // For memcmp.
+    return memcmp(&a1.addr_, &a2.addr_,
+        sizeof(boost::asio::detail::in6_addr_type)) != 0
+      || a1.scope_id_ != a2.scope_id_;
+  }
+
+  /// Compare addresses for ordering.
+  friend bool operator<(const address_v6& a1, const address_v6& a2)
+  {
+    using namespace std; // For memcmp.
+    int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
+        sizeof(boost::asio::detail::in6_addr_type)) < 0;
+    if (memcmp_result < 0)
+      return true;
+    if (memcmp_result > 0)
+      return false;
+    return a1.scope_id_ < a2.scope_id_;
+  }
+
+  /// Obtain an address object that represents any address.
+  static address_v6 any()
+  {
+    return address_v6();
+  }
+
+  /// Obtain an address object that represents the loopback address.
+  static address_v6 loopback()
+  {
+    address_v6 tmp;
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_LOOPBACK_INIT;
+    tmp.addr_ = tmp_addr;
+    return tmp;
+  }
+
+private:
+  // The underlying IPv6 address.
+  boost::asio::detail::in6_addr_type addr_;
+
+  // The scope ID associated with the address.
+  unsigned long scope_id_;
+};
+
+/// Output an address as a string.
+/**
+ * Used to output a human-readable string for a specified address.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param addr The address to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::address_v6
+ */
+template <typename Elem, typename Traits>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
+{
+  os << addr.to_string();
+  return os;
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_ADDRESS_V6_HPP
diff --git a/include/boost/asio/ip/basic_endpoint.hpp b/include/boost/asio/ip/basic_endpoint.hpp
new file mode 100644
index 0000000000..54adcf3af9
--- /dev/null
+++ b/include/boost/asio/ip/basic_endpoint.hpp
@@ -0,0 +1,357 @@
+//
+// basic_endpoint.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
+#define BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/workaround.hpp>
+#include <cstring>
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# include <iostream>
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Describes an endpoint for a version-independent IP socket.
+/**
+ * The boost::asio::ip::basic_endpoint class template describes an endpoint that
+ * may be associated with a particular socket.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Endpoint.
+ */
+template <typename Protocol>
+class basic_endpoint
+{
+public:
+  /// The protocol type associated with the endpoint.
+  typedef Protocol protocol_type;
+
+  /// The type of the endpoint structure. This type is dependent on the
+  /// underlying implementation of the socket layer.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined data_type;
+#else
+  typedef boost::asio::detail::socket_addr_type data_type;
+#endif
+
+  /// The type for the size of the endpoint structure. This type is dependent on
+  /// the underlying implementation of the socket layer.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined size_type;
+#else
+  typedef boost::asio::detail::socket_addr_len_type size_type;
+#endif
+
+  /// Default constructor.
+  basic_endpoint()
+  {
+    boost::asio::detail::sockaddr_in4_type& data
+      = reinterpret_cast<boost::asio::detail::sockaddr_in4_type&>(data_);
+    data.sin_family = AF_INET;
+    data.sin_port = 0;
+    data.sin_addr.s_addr = INADDR_ANY;
+  }
+
+  /// Construct an endpoint using a port number, specified in the host's byte
+  /// order. The IP address will be the any address (i.e. INADDR_ANY or
+  /// in6addr_any). This constructor would typically be used for accepting new
+  /// connections.
+  /**
+   * @par Examples:
+   * To initialise an IPv4 TCP endpoint for port 1234, use:
+   * @code
+   * boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), 1234);
+   * @endcode
+   *
+   * To specify an IPv6 UDP endpoint for port 9876, use:
+   * @code
+   * boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);
+   * @endcode
+   */
+  basic_endpoint(const Protocol& protocol, unsigned short port_num)
+  {
+    using namespace std; // For memcpy.
+    if (protocol.family() == PF_INET)
+    {
+      boost::asio::detail::sockaddr_in4_type& data
+        = reinterpret_cast<boost::asio::detail::sockaddr_in4_type&>(data_);
+      data.sin_family = AF_INET;
+      data.sin_port =
+        boost::asio::detail::socket_ops::host_to_network_short(port_num);
+      data.sin_addr.s_addr = INADDR_ANY;
+    }
+    else
+    {
+      boost::asio::detail::sockaddr_in6_type& data
+        = reinterpret_cast<boost::asio::detail::sockaddr_in6_type&>(data_);
+      data.sin6_family = AF_INET6;
+      data.sin6_port =
+        boost::asio::detail::socket_ops::host_to_network_short(port_num);
+      data.sin6_flowinfo = 0;
+      boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+      data.sin6_addr = tmp_addr;
+      data.sin6_scope_id = 0;
+    }
+  }
+
+  /// Construct an endpoint using a port number and an IP address. This
+  /// constructor may be used for accepting connections on a specific interface
+  /// or for making a connection to a remote endpoint.
+  basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
+  {
+    using namespace std; // For memcpy.
+    if (addr.is_v4())
+    {
+      boost::asio::detail::sockaddr_in4_type& data
+        = reinterpret_cast<boost::asio::detail::sockaddr_in4_type&>(data_);
+      data.sin_family = AF_INET;
+      data.sin_port =
+        boost::asio::detail::socket_ops::host_to_network_short(port_num);
+      data.sin_addr.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            addr.to_v4().to_ulong());
+    }
+    else
+    {
+      boost::asio::detail::sockaddr_in6_type& data
+        = reinterpret_cast<boost::asio::detail::sockaddr_in6_type&>(data_);
+      data.sin6_family = AF_INET6;
+      data.sin6_port =
+        boost::asio::detail::socket_ops::host_to_network_short(port_num);
+      data.sin6_flowinfo = 0;
+      boost::asio::ip::address_v6 v6_addr = addr.to_v6();
+      boost::asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
+      memcpy(data.sin6_addr.s6_addr, bytes.elems, 16);
+      data.sin6_scope_id = v6_addr.scope_id();
+    }
+  }
+
+  /// Copy constructor.
+  basic_endpoint(const basic_endpoint& other)
+    : data_(other.data_)
+  {
+  }
+
+  /// Assign from another endpoint.
+  basic_endpoint& operator=(const basic_endpoint& other)
+  {
+    data_ = other.data_;
+    return *this;
+  }
+
+  /// The protocol associated with the endpoint.
+  protocol_type protocol() const
+  {
+    if (data_.ss_family == AF_INET)
+      return Protocol::v4();
+    return Protocol::v6();
+  }
+
+  /// Get the underlying endpoint in the native type.
+  data_type* data()
+  {
+    return reinterpret_cast<data_type*>(&data_);
+  }
+
+  /// Get the underlying endpoint in the native type.
+  const data_type* data() const
+  {
+    return reinterpret_cast<const data_type*>(&data_);
+  }
+
+  /// Get the underlying size of the endpoint in the native type.
+  size_type size() const
+  {
+    if (data_.ss_family == AF_INET)
+      return sizeof(boost::asio::detail::sockaddr_in4_type);
+    else
+      return sizeof(boost::asio::detail::sockaddr_in6_type);
+  }
+
+  /// Set the underlying size of the endpoint in the native type.
+  void resize(size_type size)
+  {
+    if (size > size_type(sizeof(data_)))
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      boost::throw_exception(e);
+    }
+  }
+
+  /// Get the capacity of the endpoint in the native type.
+  size_type capacity() const
+  {
+    return sizeof(data_);
+  }
+
+  /// Get the port associated with the endpoint. The port number is always in
+  /// the host's byte order.
+  unsigned short port() const
+  {
+    if (data_.ss_family == AF_INET)
+    {
+      return boost::asio::detail::socket_ops::network_to_host_short(
+          reinterpret_cast<const boost::asio::detail::sockaddr_in4_type&>(
+            data_).sin_port);
+    }
+    else
+    {
+      return boost::asio::detail::socket_ops::network_to_host_short(
+          reinterpret_cast<const boost::asio::detail::sockaddr_in6_type&>(
+            data_).sin6_port);
+    }
+  }
+
+  /// Set the port associated with the endpoint. The port number is always in
+  /// the host's byte order.
+  void port(unsigned short port_num)
+  {
+    if (data_.ss_family == AF_INET)
+    {
+      reinterpret_cast<boost::asio::detail::sockaddr_in4_type&>(data_).sin_port
+        = boost::asio::detail::socket_ops::host_to_network_short(port_num);
+    }
+    else
+    {
+      reinterpret_cast<boost::asio::detail::sockaddr_in6_type&>(data_).sin6_port
+        = boost::asio::detail::socket_ops::host_to_network_short(port_num);
+    }
+  }
+
+  /// Get the IP address associated with the endpoint.
+  boost::asio::ip::address address() const
+  {
+    using namespace std; // For memcpy.
+    if (data_.ss_family == AF_INET)
+    {
+      const boost::asio::detail::sockaddr_in4_type& data
+        = reinterpret_cast<const boost::asio::detail::sockaddr_in4_type&>(
+            data_);
+      return boost::asio::ip::address_v4(
+          boost::asio::detail::socket_ops::network_to_host_long(
+            data.sin_addr.s_addr));
+    }
+    else
+    {
+      const boost::asio::detail::sockaddr_in6_type& data
+        = reinterpret_cast<const boost::asio::detail::sockaddr_in6_type&>(
+            data_);
+      boost::asio::ip::address_v6::bytes_type bytes;
+      memcpy(bytes.elems, data.sin6_addr.s6_addr, 16);
+      return boost::asio::ip::address_v6(bytes, data.sin6_scope_id);
+    }
+  }
+
+  /// Set the IP address associated with the endpoint.
+  void address(const boost::asio::ip::address& addr)
+  {
+    basic_endpoint<Protocol> tmp_endpoint(addr, port());
+    data_ = tmp_endpoint.data_;
+  }
+
+  /// Compare two endpoints for equality.
+  friend bool operator==(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return e1.address() == e2.address() && e1.port() == e2.port();
+  }
+
+  /// Compare two endpoints for inequality.
+  friend bool operator!=(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return e1.address() != e2.address() || e1.port() != e2.port();
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator<(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    if (e1.address() < e2.address())
+      return true;
+    if (e1.address() != e2.address())
+      return false;
+    return e1.port() < e2.port();
+  }
+
+private:
+  // The underlying IP socket address.
+  boost::asio::detail::sockaddr_storage_type data_;
+};
+
+/// Output an endpoint as a string.
+/**
+ * Used to output a human-readable string for a specified endpoint.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param endpoint The endpoint to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::ip::basic_endpoint
+ */
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <typename Protocol>
+std::ostream& operator<<(std::ostream& os,
+    const basic_endpoint<Protocol>& endpoint)
+{
+  const address& addr = endpoint.address();
+  if (addr.is_v4())
+    os << addr.to_string();
+  else
+    os << '[' << addr.to_string() << ']';
+  os << ':' << endpoint.port();
+  return os;
+}
+#else // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <typename Elem, typename Traits, typename Protocol>
+std::basic_ostream<Elem, Traits>& operator<<(
+    std::basic_ostream<Elem, Traits>& os,
+    const basic_endpoint<Protocol>& endpoint)
+{
+  const address& addr = endpoint.address();
+  if (addr.is_v4())
+    os << addr.to_string();
+  else
+    os << '[' << addr.to_string() << ']';
+  os << ':' << endpoint.port();
+  return os;
+}
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
diff --git a/include/boost/asio/ip/basic_resolver_entry.hpp b/include/boost/asio/ip/basic_resolver_entry.hpp
new file mode 100644
index 0000000000..9a7ca5f89b
--- /dev/null
+++ b/include/boost/asio/ip/basic_resolver_entry.hpp
@@ -0,0 +1,100 @@
+//
+// basic_resolver_entry.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <string>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// An entry produced by a resolver.
+/**
+ * The boost::asio::ip::basic_resolver_entry class template describes an entry
+ * as returned by a resolver.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Endpoint.
+ */
+template <typename Protocol>
+class basic_resolver_entry
+{
+public:
+  /// The protocol type associated with the endpoint entry.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type associated with the endpoint entry.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// Default constructor.
+  basic_resolver_entry()
+  {
+  }
+
+  /// Construct with specified endpoint, host name and service name.
+  basic_resolver_entry(const endpoint_type& endpoint,
+      const std::string& host_name, const std::string& service_name)
+    : endpoint_(endpoint),
+      host_name_(host_name),
+      service_name_(service_name)
+  {
+  }
+
+  /// Get the endpoint associated with the entry.
+  endpoint_type endpoint() const
+  {
+    return endpoint_;
+  }
+
+  /// Convert to the endpoint associated with the entry.
+  operator endpoint_type() const
+  {
+    return endpoint_;
+  }
+
+  /// Get the host name associated with the entry.
+  std::string host_name() const
+  {
+    return host_name_;
+  }
+
+  /// Get the service name associated with the entry.
+  std::string service_name() const
+  {
+    return service_name_;
+  }
+
+private:
+  endpoint_type endpoint_;
+  std::string host_name_;
+  std::string service_name_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
diff --git a/include/boost/asio/ip/basic_resolver_iterator.hpp b/include/boost/asio/ip/basic_resolver_iterator.hpp
new file mode 100644
index 0000000000..e5b4330a0f
--- /dev/null
+++ b/include/boost/asio/ip/basic_resolver_iterator.hpp
@@ -0,0 +1,153 @@
+//
+// basic_resolver_iterator.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/shared_ptr.hpp>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/ip/basic_resolver_entry.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// An iterator over the entries produced by a resolver.
+/**
+ * The boost::asio::ip::basic_resolver_iterator class template is used to define
+ * iterators over the results returned by a resolver.
+ *
+ * The iterator's value_type, obtained when the iterator is dereferenced, is:
+ * @code const basic_resolver_entry<Protocol> @endcode
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ */
+template <typename Protocol>
+class basic_resolver_iterator
+  : public boost::iterator_facade<
+        basic_resolver_iterator<Protocol>,
+        const basic_resolver_entry<Protocol>,
+        boost::forward_traversal_tag>
+{
+public:
+  /// Default constructor creates an end iterator.
+  basic_resolver_iterator()
+  {
+  }
+
+  /// Create an iterator from an addrinfo list returned by getaddrinfo.
+  static basic_resolver_iterator create(
+      boost::asio::detail::addrinfo_type* address_info,
+      const std::string& host_name, const std::string& service_name)
+  {
+    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 == PF_INET
+          || address_info->ai_family == PF_INET6)
+      {
+        using namespace std; // For memcpy.
+        typename Protocol::endpoint endpoint;
+        endpoint.resize(address_info->ai_addrlen);
+        memcpy(endpoint.data(), address_info->ai_addr,
+            address_info->ai_addrlen);
+        iter.values_->push_back(
+            basic_resolver_entry<Protocol>(endpoint,
+              actual_host_name, service_name));
+      }
+      address_info = address_info->ai_next;
+    }
+
+    if (iter.values_->size())
+      iter.iter_ = iter.values_->begin();
+    else
+      iter.values_.reset();
+
+    return iter;
+  }
+
+  /// Create an iterator from an endpoint, host name and service name.
+  static basic_resolver_iterator create(
+      const typename Protocol::endpoint& endpoint,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_iterator iter;
+    iter.values_.reset(new values_type);
+    iter.values_->push_back(
+        basic_resolver_entry<Protocol>(endpoint, host_name, service_name));
+    iter.iter_ = iter.values_->begin();
+    return iter;
+  }
+
+private:
+  friend class boost::iterator_core_access;
+
+  void increment()
+  {
+    if (++iter_ == values_->end())
+    {
+      // Reset state to match a default constructed end iterator.
+      values_.reset();
+      typedef typename values_type::const_iterator values_iterator_type;
+      iter_ = values_iterator_type();
+    }
+  }
+
+  bool equal(const basic_resolver_iterator& other) const
+  {
+    if (!values_ && !other.values_)
+      return true;
+    if (values_ != other.values_)
+      return false;
+    return iter_ == other.iter_;
+  }
+
+  const basic_resolver_entry<Protocol>& dereference() const
+  {
+    return *iter_;
+  }
+
+  typedef std::vector<basic_resolver_entry<Protocol> > values_type;
+  boost::shared_ptr<values_type> values_;
+  typename values_type::const_iterator iter_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
diff --git a/include/boost/asio/ip/basic_resolver_query.hpp b/include/boost/asio/ip/basic_resolver_query.hpp
new file mode 100644
index 0000000000..6d59f8346c
--- /dev/null
+++ b/include/boost/asio/ip/basic_resolver_query.hpp
@@ -0,0 +1,154 @@
+//
+// basic_resolver_query.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
+#define BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <string>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/ip/resolver_query_base.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// An query to be passed to a resolver.
+/**
+ * The boost::asio::ip::basic_resolver_query class template describes a query
+ * that can be passed to a resolver.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Endpoint.
+ */
+template <typename Protocol>
+class basic_resolver_query
+  : public resolver_query_base
+{
+public:
+  /// The protocol type associated with the endpoint query.
+  typedef Protocol protocol_type;
+
+  /// Construct with specified service name for any protocol.
+  basic_resolver_query(const std::string& service_name,
+      int flags = passive | address_configured)
+    : hints_(),
+      host_name_(),
+      service_name_(service_name)
+  {
+    typename Protocol::endpoint endpoint;
+    hints_.ai_flags = flags;
+    hints_.ai_family = PF_UNSPEC;
+    hints_.ai_socktype = endpoint.protocol().type();
+    hints_.ai_protocol = endpoint.protocol().protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Construct with specified service name for a given protocol.
+  basic_resolver_query(const protocol_type& protocol,
+      const std::string& service_name,
+      int flags = passive | address_configured)
+    : hints_(),
+      host_name_(),
+      service_name_(service_name)
+  {
+    hints_.ai_flags = flags;
+    hints_.ai_family = protocol.family();
+    hints_.ai_socktype = protocol.type();
+    hints_.ai_protocol = protocol.protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Construct with specified host name and service name for any protocol.
+  basic_resolver_query(const std::string& host_name,
+      const std::string& service_name, int flags = address_configured)
+    : hints_(),
+      host_name_(host_name),
+      service_name_(service_name)
+  {
+    typename Protocol::endpoint endpoint;
+    hints_.ai_flags = flags;
+    hints_.ai_family = PF_UNSPEC;
+    hints_.ai_socktype = endpoint.protocol().type();
+    hints_.ai_protocol = endpoint.protocol().protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Construct with specified host name and service name for a given protocol.
+  basic_resolver_query(const protocol_type& protocol,
+      const std::string& host_name, const std::string& service_name,
+      int flags = address_configured)
+    : hints_(),
+      host_name_(host_name),
+      service_name_(service_name)
+  {
+    hints_.ai_flags = flags;
+    hints_.ai_family = protocol.family();
+    hints_.ai_socktype = protocol.type();
+    hints_.ai_protocol = protocol.protocol();
+    hints_.ai_addrlen = 0;
+    hints_.ai_canonname = 0;
+    hints_.ai_addr = 0;
+    hints_.ai_next = 0;
+  }
+
+  /// Get the hints associated with the query.
+  const boost::asio::detail::addrinfo_type& hints() const
+  {
+    return hints_;
+  }
+
+  /// Get the host name associated with the query.
+  std::string host_name() const
+  {
+    return host_name_;
+  }
+
+  /// Get the service name associated with the query.
+  std::string service_name() const
+  {
+    return service_name_;
+  }
+
+private:
+  boost::asio::detail::addrinfo_type hints_;
+  std::string host_name_;
+  std::string service_name_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
diff --git a/include/boost/asio/ip/detail/socket_option.hpp b/include/boost/asio/ip/detail/socket_option.hpp
new file mode 100644
index 0000000000..a0c69d03c5
--- /dev/null
+++ b/include/boost/asio/ip/detail/socket_option.hpp
@@ -0,0 +1,408 @@
+//
+// socket_option.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
+#define BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <cstring>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace detail {
+namespace socket_option {
+
+// Helper template for implementing boolean-based options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class boolean
+{
+public:
+  // Default constructor.
+  boolean()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  boolean(bool value)
+    : value_(value ? 1 : 0)
+  {
+  }
+
+  // Set the value of the boolean.
+  void set(bool value)
+  {
+    value_ = value ? 1 : 0;
+  }
+
+  // Get the current value of the boolean.
+  bool get() const
+  {
+    return value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the boolean data.
+  template <typename Protocol>
+  int* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the boolean data.
+  template <typename Protocol>
+  const int* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the boolean data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+private:
+  int value_;
+};
+
+// Helper template for implementing integer options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class integer
+{
+public:
+  // Default constructor.
+  integer()
+    : value_(0)
+  {
+  }
+
+  // Construct with a specific option value.
+  integer(int value)
+    : value_(value)
+  {
+  }
+
+  // Set the value of the int option.
+  void set(int value)
+  {
+    value_ = value;
+  }
+
+  // Get the current value of the int option.
+  int get() const
+  {
+    return value_;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the int data.
+  template <typename Protocol>
+  int* data(const Protocol&)
+  {
+    return &value_;
+  }
+
+  // Get the address of the int data.
+  template <typename Protocol>
+  const int* data(const Protocol&) const
+  {
+    return &value_;
+  }
+
+  // Get the size of the int data.
+  template <typename Protocol>
+  std::size_t size(const Protocol&) const
+  {
+    return sizeof(value_);
+  }
+
+private:
+  int value_;
+};
+
+// Helper template for implementing ip_mreq-based options.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class multicast_request
+{
+public:
+  // Default constructor.
+  multicast_request()
+  {
+    ipv4_value_.imr_multiaddr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv4_value_.imr_interface.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+    ipv6_value_.ipv6mr_multiaddr = tmp_addr;
+    ipv6_value_.ipv6mr_interface = 0;
+  }
+
+  // Construct with multicast address only.
+  multicast_request(const boost::asio::ip::address& multicast_address)
+  {
+    if (multicast_address.is_v6())
+    {
+      ipv4_value_.imr_multiaddr.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            boost::asio::ip::address_v4::any().to_ulong());
+      ipv4_value_.imr_interface.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            boost::asio::ip::address_v4::any().to_ulong());
+
+      using namespace std; // For memcpy.
+      boost::asio::ip::address_v6 ipv6_address = multicast_address.to_v6();
+      boost::asio::ip::address_v6::bytes_type bytes = ipv6_address.to_bytes();
+      memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.elems, 16);
+      ipv6_value_.ipv6mr_interface = 0;
+    }
+    else
+    {
+      ipv4_value_.imr_multiaddr.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            multicast_address.to_v4().to_ulong());
+      ipv4_value_.imr_interface.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            boost::asio::ip::address_v4::any().to_ulong());
+
+      boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+      ipv6_value_.ipv6mr_multiaddr = tmp_addr;
+      ipv6_value_.ipv6mr_interface = 0;
+    }
+  }
+
+  // Construct with multicast address and IPv4 address specifying an interface.
+  multicast_request(const boost::asio::ip::address_v4& multicast_address,
+      const boost::asio::ip::address_v4& network_interface
+        = boost::asio::ip::address_v4::any())
+  {
+    ipv4_value_.imr_multiaddr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          multicast_address.to_ulong());
+    ipv4_value_.imr_interface.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          network_interface.to_ulong());
+
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+    ipv6_value_.ipv6mr_multiaddr = tmp_addr;
+    ipv6_value_.ipv6mr_interface = 0;
+  }
+
+  // Construct with multicast address and IPv6 network interface index.
+  multicast_request(const boost::asio::ip::address_v6& multicast_address,
+      unsigned long network_interface = 0)
+  {
+    ipv4_value_.imr_multiaddr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv4_value_.imr_interface.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+
+    using namespace std; // For memcpy.
+    boost::asio::ip::address_v6::bytes_type bytes =
+      multicast_address.to_bytes();
+    memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.elems, 16);
+    ipv6_value_.ipv6mr_interface = network_interface;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the option data.
+  template <typename Protocol>
+  void* data(const Protocol& protocol)
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the address of the option data.
+  template <typename Protocol>
+  const void* data(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the size of the option data.
+  template <typename Protocol>
+  std::size_t size(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return sizeof(ipv6_value_);
+    return sizeof(ipv4_value_);
+  }
+
+private:
+  boost::asio::detail::in4_mreq_type ipv4_value_;
+  boost::asio::detail::in6_mreq_type ipv6_value_;
+};
+
+// Helper template for implementing options that specify a network interface.
+template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
+class network_interface
+{
+public:
+  // Default constructor.
+  network_interface()
+  {
+    ipv4_value_.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv6_value_ = 0;
+  }
+
+  // Construct with IPv4 interface.
+  network_interface(const boost::asio::ip::address_v4& ipv4_interface)
+  {
+    ipv4_value_.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          ipv4_interface.to_ulong());
+    ipv6_value_ = 0;
+  }
+
+  // Construct with IPv6 interface.
+  network_interface(unsigned long ipv6_interface)
+  {
+    ipv4_value_.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv6_value_ = ipv6_interface;
+  }
+
+  // Get the level of the socket option.
+  template <typename Protocol>
+  int level(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Level;
+    return IPv4_Level;
+  }
+
+  // Get the name of the socket option.
+  template <typename Protocol>
+  int name(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return IPv6_Name;
+    return IPv4_Name;
+  }
+
+  // Get the address of the option data.
+  template <typename Protocol>
+  void* data(const Protocol& protocol)
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the address of the option data.
+  template <typename Protocol>
+  const void* data(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return &ipv6_value_;
+    return &ipv4_value_;
+  }
+
+  // Get the size of the option data.
+  template <typename Protocol>
+  std::size_t size(const Protocol& protocol) const
+  {
+    if (protocol.family() == PF_INET6)
+      return sizeof(ipv6_value_);
+    return sizeof(ipv4_value_);
+  }
+
+private:
+  boost::asio::detail::in4_addr_type ipv4_value_;
+  unsigned long ipv6_value_;
+};
+
+} // namespace socket_option
+} // namespace detail
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
diff --git a/include/boost/asio/ip/host_name.hpp b/include/boost/asio/ip/host_name.hpp
new file mode 100644
index 0000000000..ec5ceac88d
--- /dev/null
+++ b/include/boost/asio/ip/host_name.hpp
@@ -0,0 +1,62 @@
+//
+// host_name.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_HOST_NAME_HPP
+#define BOOST_ASIO_IP_HOST_NAME_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <string>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Get the current host name.
+std::string host_name();
+
+/// Get the current host name.
+template <typename Error_Handler>
+std::string host_name(Error_Handler error_handler);
+
+inline std::string host_name()
+{
+  return host_name(boost::asio::throw_error());
+}
+
+template <typename Error_Handler>
+std::string host_name(Error_Handler error_handler)
+{
+  char name[1024];
+  if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name)) != 0)
+  {
+    boost::asio::error error(boost::asio::detail::socket_ops::get_error());
+    error_handler(error);
+    return std::string();
+  }
+  return std::string(name);
+}
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_HOST_NAME_HPP
diff --git a/include/boost/asio/ip/multicast.hpp b/include/boost/asio/ip/multicast.hpp
new file mode 100644
index 0000000000..71cb6f336c
--- /dev/null
+++ b/include/boost/asio/ip/multicast.hpp
@@ -0,0 +1,183 @@
+//
+// multicast.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_MULTICAST_HPP
+#define BOOST_ASIO_IP_MULTICAST_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ip/detail/socket_option.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+namespace multicast {
+
+/// Socket option to join a multicast group on a specified interface.
+/**
+ * Implements the IPPROTO_IP/IP_ADD_MEMBERSHIP socket option.
+ *
+ * @par Examples:
+ * Setting the option to join a multicast group:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::address multicast_address =
+ *   boost::asio::ip::address::from_string("225.0.0.1");
+ * boost::asio::ip::multicast::join_group option(multicast_address);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par Concepts:
+ * Socket_Option, IP_MReq_Socket_Option.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined join_group;
+#else
+typedef boost::asio::ip::detail::socket_option::multicast_request<
+  IPPROTO_IP, IP_ADD_MEMBERSHIP, IPPROTO_IPV6, IPV6_JOIN_GROUP> join_group;
+#endif
+
+/// Socket option to leave a multicast group on a specified interface.
+/**
+ * Implements the IPPROTO_IP/IP_DROP_MEMBERSHIP socket option.
+ *
+ * @par Examples:
+ * Setting the option to leave a multicast group:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::address multicast_address =
+ *   boost::asio::ip::address::from_string("225.0.0.1");
+ * boost::asio::ip::multicast::leave_group option(multicast_address);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par Concepts:
+ * Socket_Option, IP_MReq_Socket_Option.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined leave_group;
+#else
+typedef boost::asio::ip::detail::socket_option::multicast_request<
+  IPPROTO_IP, IP_DROP_MEMBERSHIP, IPPROTO_IPV6, IPV6_LEAVE_GROUP> leave_group;
+#endif
+
+/// Socket option for local interface to use for outgoing multicast packets.
+/**
+ * Implements the IPPROTO_IP/IP_MULTICAST_IF socket option.
+ *
+ * @par Examples:
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::address_v4 local_interface =
+ *   boost::asio::ip::address_v4::from_string("1.2.3.4");
+ * boost::asio::ip::multicast::outbound_interface option(local_interface);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par Concepts:
+ * Socket_Option, IP_Network_Interface_Socket_Option.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined outbound_interface;
+#else
+typedef boost::asio::ip::detail::socket_option::network_interface<
+  IPPROTO_IP, IP_MULTICAST_IF, IPPROTO_IPV6, IPV6_MULTICAST_IF>
+  outbound_interface;
+#endif
+
+/// Socket option for time-to-live associated with outgoing multicast packets.
+/**
+ * Implements the IPPROTO_IP/IP_MULTICAST_TTL socket option.
+ *
+ * @par Examples:
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::hops option(4);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par
+ * Getting the current option value:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::hops option;
+ * socket.get_option(option);
+ * int ttl = option.get();
+ * @endcode
+ *
+ * @par Concepts:
+ * Socket_Option, Integer_Socket_Option.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined hops;
+#else
+typedef boost::asio::ip::detail::socket_option::integer<
+  IPPROTO_IP, IP_MULTICAST_TTL, IPPROTO_IPV6, IPV6_MULTICAST_HOPS> hops;
+#endif
+
+/// Socket option determining whether outgoing multicast packets will be
+/// received on the same socket if it is a member of the multicast group.
+/**
+ * Implements the IPPROTO_IP/IP_MULTICAST_LOOP socket option.
+ *
+ * @par Examples:
+ * Setting the option:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::enable_loopback option(true);
+ * socket.set_option(option);
+ * @endcode
+ *
+ * @par
+ * Getting the current option value:
+ * @code
+ * boost::asio::ip::udp::socket socket(io_service); 
+ * ...
+ * boost::asio::ip::multicast::enable_loopback option;
+ * socket.get_option(option);
+ * bool is_set = option.get();
+ * @endcode
+ *
+ * @par Concepts:
+ * Socket_Option, Boolean_Socket_Option.
+ */
+#if defined(GENERATING_DOCUMENTATION)
+typedef implementation_defined enable_loopback;
+#else
+typedef boost::asio::ip::detail::socket_option::boolean<
+  IPPROTO_IP, IP_MULTICAST_LOOP, IPPROTO_IPV6, IPV6_MULTICAST_LOOP>
+  enable_loopback;
+#endif
+
+} // namespace multicast
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_MULTICAST_HPP
diff --git a/include/boost/asio/ip/resolver_query_base.hpp b/include/boost/asio/ip/resolver_query_base.hpp
new file mode 100644
index 0000000000..588e1fcd12
--- /dev/null
+++ b/include/boost/asio/ip/resolver_query_base.hpp
@@ -0,0 +1,109 @@
+//
+// resolver_query_base.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
+#define BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+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
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// Determine the canonical name of the host specified in the query.
+  static const int canonical_name = implementation_defined;
+
+  /// Indicate that returned endpoint is intended for use as a locally bound
+  /// socket endpoint.
+  static const int 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 int 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 int 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 int v4_mapped = implementation_defined;
+
+  /// If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
+  static const int 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 int address_configured = implementation_defined;
+#else
+  BOOST_STATIC_CONSTANT(int, canonical_name = AI_CANONNAME);
+  BOOST_STATIC_CONSTANT(int, passive = AI_PASSIVE);
+  BOOST_STATIC_CONSTANT(int, numeric_host = AI_NUMERICHOST);
+# if defined(AI_NUMERICSERV)
+  BOOST_STATIC_CONSTANT(int, numeric_service = AI_NUMERICSERV);
+# else
+  BOOST_STATIC_CONSTANT(int, numeric_service = 0);
+# endif
+# if defined(AI_V4MAPPED)
+  BOOST_STATIC_CONSTANT(int, v4_mapped = AI_V4MAPPED);
+# else
+  BOOST_STATIC_CONSTANT(int, v4_mapped = 0);
+# endif
+# if defined(AI_ALL)
+  BOOST_STATIC_CONSTANT(int, all_matching = AI_ALL);
+# else
+  BOOST_STATIC_CONSTANT(int, all_matching = 0);
+# endif
+# if defined(AI_ADDRCONFIG)
+  BOOST_STATIC_CONSTANT(int, address_configured = AI_ADDRCONFIG);
+# else
+  BOOST_STATIC_CONSTANT(int, address_configured = 0);
+# endif
+#endif
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~resolver_query_base()
+  {
+  }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+private:
+  // Workaround to enable the empty base optimisation with Borland C++.
+  char dummy_;
+#endif
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_RESOLVER_QUERY_BASE_HPP
diff --git a/include/boost/asio/ip/tcp.hpp b/include/boost/asio/ip/tcp.hpp
new file mode 100644
index 0000000000..0cacd1c196
--- /dev/null
+++ b/include/boost/asio/ip/tcp.hpp
@@ -0,0 +1,148 @@
+//
+// tcp.hpp
+// ~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_TCP_HPP
+#define BOOST_ASIO_IP_TCP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_resolver.hpp>
+#include <boost/asio/basic_socket_acceptor.hpp>
+#include <boost/asio/basic_socket_iostream.hpp>
+#include <boost/asio/basic_stream_socket.hpp>
+#include <boost/asio/ip/basic_endpoint.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/detail/socket_option.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Encapsulates the flags needed for TCP.
+/**
+ * The boost::asio::ip::tcp class contains flags necessary for TCP sockets.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol.
+ */
+class tcp
+{
+public:
+  /// The type of a TCP endpoint.
+  typedef basic_endpoint<tcp> endpoint;
+
+  /// The type of a resolver query.
+  typedef basic_resolver_query<tcp> resolver_query;
+
+  /// The type of a resolver iterator.
+  typedef basic_resolver_iterator<tcp> resolver_iterator;
+
+  /// Construct to represent the IPv4 TCP protocol.
+  static tcp v4()
+  {
+    return tcp(PF_INET);
+  }
+
+  /// Construct to represent the IPv4 TCP protocol.
+  static tcp v6()
+  {
+    return tcp(PF_INET6);
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return SOCK_STREAM;
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return IPPROTO_TCP;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// The TCP socket type.
+  typedef basic_stream_socket<tcp> socket;
+
+  /// The TCP acceptor type.
+  typedef basic_socket_acceptor<tcp> acceptor;
+
+  /// The TCP resolver type.
+  typedef basic_resolver<tcp> resolver;
+
+  /// The TCP iostream type.
+  typedef basic_socket_iostream<tcp> iostream;
+
+  /// Socket option for disabling the Nagle algorithm.
+  /**
+   * Implements the IPPROTO_TCP/TCP_NODELAY socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ipv6::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::ipv6::tcp::no_delay option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ipv6::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::ipv6::tcp::no_delay option;
+   * socket.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined no_delay;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    IPPROTO_TCP, TCP_NODELAY> no_delay;
+#endif
+
+private:
+  // Construct with a specific family.
+  explicit tcp(int family)
+    : family_(family)
+  {
+  }
+
+  int family_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_TCP_HPP
diff --git a/include/boost/asio/ip/udp.hpp b/include/boost/asio/ip/udp.hpp
new file mode 100644
index 0000000000..4f53c0c259
--- /dev/null
+++ b/include/boost/asio/ip/udp.hpp
@@ -0,0 +1,106 @@
+//
+// udp.hpp
+// ~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IP_UDP_HPP
+#define BOOST_ASIO_IP_UDP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_datagram_socket.hpp>
+#include <boost/asio/basic_resolver.hpp>
+#include <boost/asio/ip/basic_endpoint.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ip {
+
+/// Encapsulates the flags needed for UDP.
+/**
+ * The boost::asio::ip::udp class contains flags necessary for UDP sockets.
+ *
+ * @par Thread Safety:
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol.
+ */
+class udp
+{
+public:
+  /// The type of a UDP endpoint.
+  typedef basic_endpoint<udp> endpoint;
+
+  /// The type of a resolver query.
+  typedef basic_resolver_query<udp> resolver_query;
+
+  /// The type of a resolver iterator.
+  typedef basic_resolver_iterator<udp> resolver_iterator;
+
+  /// Construct to represent the IPv4 UDP protocol.
+  static udp v4()
+  {
+    return udp(PF_INET);
+  }
+
+  /// Construct to represent the IPv4 UDP protocol.
+  static udp v6()
+  {
+    return udp(PF_INET6);
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return SOCK_DGRAM;
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return IPPROTO_UDP;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// The IPv4 UDP socket type.
+  typedef basic_datagram_socket<udp> socket;
+
+  /// The UDP resolver type.
+  typedef basic_resolver<udp> resolver;
+
+private:
+  // Construct with a specific family.
+  explicit udp(int family)
+    : family_(family)
+  {
+  }
+
+  int family_;
+};
+
+} // namespace ip
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IP_UDP_HPP
diff --git a/include/boost/asio/is_read_buffered.hpp b/include/boost/asio/is_read_buffered.hpp
new file mode 100644
index 0000000000..9c29f1026e
--- /dev/null
+++ b/include/boost/asio/is_read_buffered.hpp
@@ -0,0 +1,64 @@
+//
+// is_read_buffered.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IS_READ_BUFFERED_HPP
+#define BOOST_ASIO_IS_READ_BUFFERED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffered_read_stream_fwd.hpp>
+#include <boost/asio/buffered_stream_fwd.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace detail {
+
+template <typename Stream>
+char is_read_buffered_helper(buffered_stream<Stream>* s);
+
+template <typename Stream>
+char is_read_buffered_helper(buffered_read_stream<Stream>* s);
+
+struct is_read_buffered_big_type { char data[10]; };
+is_read_buffered_big_type is_read_buffered_helper(...);
+
+} // namespace detail
+
+/// The is_read_buffered class is a traits class that may be used to determine
+/// whether a stream type supports buffering of read data.
+template <typename Stream>
+class is_read_buffered
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// The value member is true only if the Stream type supports buffering of
+  /// read data.
+  static const bool value;
+#else
+  BOOST_STATIC_CONSTANT(bool,
+      value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1);
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IS_READ_BUFFERED_HPP
diff --git a/include/boost/asio/is_write_buffered.hpp b/include/boost/asio/is_write_buffered.hpp
new file mode 100644
index 0000000000..c451438105
--- /dev/null
+++ b/include/boost/asio/is_write_buffered.hpp
@@ -0,0 +1,64 @@
+//
+// is_write_buffered.hpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_IS_WRITE_BUFFERED_HPP
+#define BOOST_ASIO_IS_WRITE_BUFFERED_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffered_stream_fwd.hpp>
+#include <boost/asio/buffered_write_stream_fwd.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace detail {
+
+template <typename Stream>
+char is_write_buffered_helper(buffered_stream<Stream>* s);
+
+template <typename Stream>
+char is_write_buffered_helper(buffered_write_stream<Stream>* s);
+
+struct is_write_buffered_big_type { char data[10]; };
+is_write_buffered_big_type is_write_buffered_helper(...);
+
+} // namespace detail
+
+/// The is_write_buffered class is a traits class that may be used to determine
+/// whether a stream type supports buffering of written data.
+template <typename Stream>
+class is_write_buffered
+{
+public:
+#if defined(GENERATING_DOCUMENTATION)
+  /// The value member is true only if the Stream type supports buffering of
+  /// written data.
+  static const bool value;
+#else
+  BOOST_STATIC_CONSTANT(bool,
+      value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1);
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IS_WRITE_BUFFERED_HPP
diff --git a/include/boost/asio/placeholders.hpp b/include/boost/asio/placeholders.hpp
new file mode 100644
index 0000000000..424755817d
--- /dev/null
+++ b/include/boost/asio/placeholders.hpp
@@ -0,0 +1,82 @@
+//
+// placeholders.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_ARG_HPP
+#define BOOST_ASIO_ARG_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/bind/arg.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+namespace placeholders {
+
+namespace {
+
+#if defined(__BORLANDC__)
+
+static inline boost::arg<1> error()
+{
+  return boost::arg<1>();
+}
+
+static inline boost::arg<2> bytes_transferred()
+{
+  return boost::arg<2>();
+}
+
+static inline boost::arg<2> iterator()
+{
+  return boost::arg<2>();
+}
+
+#elif defined(_MSC_VER) && (_MSC_VER < 1400)
+
+static boost::arg<1> error;
+static boost::arg<2> bytes_transferred;
+static boost::arg<2> iterator;
+
+#else
+
+/// An argument placeholder, for use with @ref boost_bind, that corresponds to
+/// the error argument of a handler for any of the asynchronous functions.
+boost::arg<1> error;
+
+/// An argument placeholder, for use with @ref boost_bind, that corresponds to
+/// the bytes_transferred argument of a handler for asynchronous functions such
+/// as boost::asio::basic_stream_socket::async_write_some or
+/// boost::asio::async_write.
+boost::arg<2> bytes_transferred;
+
+/// An argument placeholder, for use with @ref boost_bind, that corresponds to
+/// the iterator argument of a handler for asynchronous functions such as
+/// boost::asio::basic_resolver::resolve.
+boost::arg<2> iterator;
+
+#endif
+
+} // namespace
+
+} // namespace placeholders
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_ARG_HPP
diff --git a/include/boost/asio/read.hpp b/include/boost/asio/read.hpp
new file mode 100644
index 0000000000..0effdf8ab0
--- /dev/null
+++ b/include/boost/asio/read.hpp
@@ -0,0 +1,326 @@
+//
+// read.hpp
+// ~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_READ_HPP
+#define BOOST_ASIO_READ_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/**
+ * @defgroup read boost::asio::read
+ */
+/*@{*/
+
+/// Attempt to read a certain amount of data from a stream before returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * stream. The call will block until one of the following conditions is true:
+ *
+ * @li The supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of one 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 Sync_Read_Stream concept.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * stream.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws Sync_Read_Stream::error_type Thrown on failure.
+ *
+ * @par Example:
+ * To read into a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::read(s, boost::asio::buffer(data, size)); @endcode
+ * See the @ref buffer documentation for information on reading into multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read(
+ *     s, buffers,
+ *     boost::asio::transfer_all(),
+ *     boost::asio::throw_error()); @endcode
+ */
+template <typename Sync_Read_Stream, typename Mutable_Buffers>
+std::size_t read(Sync_Read_Stream& s, const Mutable_Buffers& buffers);
+
+/// Attempt to read a certain amount of data from a stream before returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * stream. The call will block until one of the following conditions is true:
+ *
+ * @li The supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
+ * @li The completion_condition function object returns true.
+ *
+ * This operation is implemented in terms of one 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 Sync_Read_Stream concept.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * stream.
+ *
+ * @param 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 bool completion_condition(
+ *   const Sync_Read_Stream::error_type& error, // Result of latest read_some
+ *                                              // operation.
+ *
+ *   std::size_t bytes_transferred              // Number of bytes transferred
+ *                                              // so far.
+ * ); @endcode
+ * A return value of true indicates that the read operation is complete. False
+ * indicates that further calls to the stream's read_some function are required.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws Sync_Read_Stream::error_type Thrown on failure.
+ *
+ * @par Example:
+ * To read into a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::read(s, boost::asio::buffer(data, size),
+ *     boost::asio::transfer_at_least(32)); @endcode
+ * See the @ref buffer documentation for information on reading into multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read(
+ *     s, buffers, completion_condition,
+ *     boost::asio::throw_error()); @endcode
+ */
+template <typename Sync_Read_Stream, typename Mutable_Buffers,
+  typename Completion_Condition>
+std::size_t read(Sync_Read_Stream& s, const Mutable_Buffers& buffers,
+    Completion_Condition completion_condition);
+
+/// Attempt to read a certain amount of data from a stream before returning.
+/**
+ * This function is used to read a certain number of bytes of data from a
+ * stream. The call will block until one of the following conditions is true:
+ *
+ * @li The supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
+ * @li The completion_condition function object returns true.
+ *
+ * This operation is implemented in terms of one 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 Sync_Read_Stream concept.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * stream.
+ *
+ * @param 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 bool completion_condition(
+ *   const Sync_Read_Stream::error_type& error, // Result of latest read_some
+ *                                              // operation.
+ *
+ *   std::size_t bytes_transferred              // Number of bytes transferred
+ *                                              // so far.
+ * ); @endcode
+ * A return value of true indicates that the read operation is complete. False
+ * indicates that further calls to the stream's read_some function are required.
+ *
+ * @param error_handler A handler to be called when the operation completes,
+ * to indicate whether or not an error has occurred. Copies will be made of
+ * the handler as required. The function signature of the handler must be:
+ * @code void error_handler(
+ *   const Sync_Read_Stream::error_type& error // Result of operation.
+ * ); @endcode
+ * The error handler is only called if the completion_condition indicates that
+ * the operation is complete.
+ *
+ * @returns The number of bytes read. If an error occurs, and the error handler
+ * does not throw an exception, returns the total number of bytes successfully
+ * transferred prior to the error.
+ */
+template <typename Sync_Read_Stream, typename Mutable_Buffers,
+    typename Completion_Condition, typename Error_Handler>
+std::size_t read(Sync_Read_Stream& s, const Mutable_Buffers& buffers,
+    Completion_Condition completion_condition, Error_Handler error_handler);
+
+/*@}*/
+/**
+ * @defgroup async_read boost::asio::async_read
+ */
+/*@{*/
+
+/// 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 supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of one or more calls to the stream's
+ * async_read_some function.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the Async_Read_Stream concept.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * stream. 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 Async_Read_Stream::error_type& 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
+ * boost::asio::io_service::post().
+ *
+ * @par Example:
+ * To read into a single data buffer use the @ref buffer function as follows:
+ * @code
+ * boost::asio::async_read(s, boost::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.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::async_read(
+ *     s, buffers,
+ *     boost::asio::transfer_all(),
+ *     handler); @endcode
+ */
+template <typename Async_Read_Stream, typename Mutable_Buffers,
+    typename Handler>
+void async_read(Async_Read_Stream& s, const Mutable_Buffers& buffers,
+    Handler handler);
+
+/// 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 supplied buffers are full. That is, the bytes transferred is equal to
+ * the sum of the buffer sizes.
+ *
+ * @li The completion_condition function object returns true.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the Async_Read_Stream concept.
+ *
+ * @param buffers One or more buffers into which the data will be read. The sum
+ * of the buffer sizes indicates the maximum number of bytes to read from the
+ * stream. 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 bool completion_condition(
+ *   const Async_Read_Stream::error_type& error, // Result of latest read_some
+ *                                               // operation.
+ *
+ *   std::size_t bytes_transferred               // Number of bytes transferred
+ *                                               // so far.
+ * ); @endcode
+ * A return value of true indicates that the read operation is complete. False
+ * indicates that further calls to the stream's async_read_some function are
+ * required.
+ *
+ * @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 Async_Read_Stream::error_type& 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
+ * boost::asio::io_service::post().
+ *
+ * @par Example:
+ * To read into a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::async_read(s,
+ *     boost::asio::buffer(data, size),
+ *     boost::asio::transfer_at_least(32),
+ *     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 Async_Read_Stream, typename Mutable_Buffers,
+    typename Completion_Condition, typename Handler>
+void async_read(Async_Read_Stream& s, const Mutable_Buffers& buffers,
+    Completion_Condition completion_condition, Handler handler);
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/impl/read.ipp>
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_READ_HPP
diff --git a/include/boost/asio/read_until.hpp b/include/boost/asio/read_until.hpp
new file mode 100644
index 0000000000..fd3ba44788
--- /dev/null
+++ b/include/boost/asio/read_until.hpp
@@ -0,0 +1,343 @@
+//
+// read_until.hpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_READ_UNTIL_HPP
+#define BOOST_ASIO_READ_UNTIL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/regex.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/basic_streambuf.hpp>
+
+namespace boost {
+namespace asio {
+
+/**
+ * @defgroup read_until boost::asio::read_until
+ */
+/*@{*/
+
+/// Read data into a streambuf until a delimiter is encountered.
+/**
+ * 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 Sync_Read_Stream concept.
+ *
+ * @param b A streambuf object into which the data will be written.
+ *
+ * @param delim The delimiter character.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the delimiter.
+ *
+ * @throws Sync_Read_Stream::error_type Thrown on failure.
+ *
+ * @par Example:
+ * To read data into a streambuf until a newline is encountered:
+ * @code boost::asio::streambuf b;
+ * boost::asio::read_until(s, b, '\n');
+ * std::istream is(&b);
+ * std::string line;
+ * std::getline(is, line); @endcode
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read_until(
+ *     s, b, delim,
+ *     boost::asio::throw_error()); @endcode
+ */
+template <typename Sync_Read_Stream, typename Allocator>
+std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim);
+
+/// Read data into a streambuf until a delimiter is encountered.
+/**
+ * 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 Sync_Read_Stream concept.
+ *
+ * @param b A streambuf object into which the data will be written.
+ *
+ * @param delim The delimiter character.
+ *
+ * @param error_handler A handler to be called when the operation completes,
+ * to indicate whether or not an error has occurred. Copies will be made of
+ * the handler as required. The function signature of the handler must be:
+ * @code void error_handler(
+ *   const Sync_Read_Stream::error_type& error // Result of operation.
+ * ); @endcode
+ * The error handler is only called if the completion_condition indicates that
+ * the operation is complete.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the delimiter. Returns 0 if an error occurred and the error handler did not
+ * throw an exception.
+ */
+template <typename Sync_Read_Stream, typename Allocator, typename Error_Handler>
+std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim,
+    Error_Handler error_handler);
+
+/// Read data into a streambuf until a regular expression is located.
+/**
+ * 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 Sync_Read_Stream concept.
+ *
+ * @param b A streambuf object into which the data will be written.
+ *
+ * @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 Sync_Read_Stream::error_type Thrown on failure.
+ *
+ * @par Example:
+ * To read data into a streambuf until a CR-LF sequence is encountered:
+ * @code boost::asio::streambuf b;
+ * boost::asio::read_until(s, b, boost::regex("\r\n"));
+ * std::istream is(&b);
+ * std::string line;
+ * std::getline(is, line); @endcode
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::read_until(
+ *     s, b, expr,
+ *     boost::asio::throw_error()); @endcode
+ */
+template <typename Sync_Read_Stream, typename Allocator>
+std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
+
+/// Read data into a streambuf until a regular expression is located.
+/**
+ * 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 Sync_Read_Stream concept.
+ *
+ * @param b A streambuf object into which the data will be written.
+ *
+ * @param expr The regular expression.
+ *
+ * @param error_handler A handler to be called when the operation completes,
+ * to indicate whether or not an error has occurred. Copies will be made of
+ * the handler as required. The function signature of the handler must be:
+ * @code void error_handler(
+ *   const Sync_Read_Stream::error_type& error // Result of operation.
+ * ); @endcode
+ * The error handler is only called if the completion_condition indicates that
+ * the operation is complete.
+ *
+ * @returns The number of bytes in the streambuf's get area up to and including
+ * the substring that matches the regular expression.
+ */
+template <typename Sync_Read_Stream, typename Allocator, typename Error_Handler>
+std::size_t read_until(Sync_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    Error_Handler error_handler);
+
+/*@}*/
+/**
+ * @defgroup async_read_until boost::asio::async_read_until
+ */
+/*@{*/
+
+/// Start an asynchronous operation to read data into a streambuf until a
+/// delimiter is encountered.
+/**
+ * This function is used to asynchronously read data into the specified
+ * streambuf until the streambuf'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 streambuf 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. If the streambuf's get area already contains the
+ * delimiter, the asynchronous operation completes immediately.
+ *
+ * @param s The stream from which the data is to be read. The type must support
+ * the Async_Read_Stream concept.
+ *
+ * @param b A streambuf object into which the data will be written. Ownership of
+ * the streambuf is retained by the caller, which must guarantee that it remains
+ * 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(
+ *   const Async_Read_Stream::error_type& error, // Result of operation.
+ *
+ *   std::size_t bytes_transferred               // The number of bytes in the
+ *                                               // streambuf's get area up to
+ *                                               // and including the delimiter.
+ *                                               // 0 if an error occurred.
+ * ); @endcode
+ * Regardless of whether the asynchronous operation completes immediately or
+ * not, the handler will not be invoked from within this function. Invocation of
+ * the handler will be performed in a manner equivalent to using
+ * boost::asio::io_service::post().
+ *
+ * @par Example:
+ * To asynchronously read data into a streambuf until a newline is encountered:
+ * @code boost::asio::streambuf b;
+ * ...
+ * void handler(const boost::asio::error& e, std::size_t size)
+ * {
+ *   if (!e)
+ *   {
+ *     std::istream is(&b);
+ *     std::string line;
+ *     std::getline(is, line);
+ *     ...
+ *   }
+ * }
+ * ...
+ * boost::asio::async_read_until(s, b, '\n', handler); @endcode
+ */
+template <typename Async_Read_Stream, typename Allocator, typename Handler>
+void async_read_until(Async_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, char delim, Handler handler);
+
+/// Start an asynchronous operation to read data into a streambuf until a
+/// regular expression is located.
+/**
+ * This function is used to asynchronously read data into the specified
+ * streambuf until the streambuf'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 An error occurred.
+ *
+ * This operation is implemented in terms of zero or more calls to the stream's
+ * async_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 Async_Read_Stream concept.
+ *
+ * @param b A streambuf object into which the data will be written. Ownership of
+ * the streambuf is retained by the caller, which must guarantee that it remains
+ * valid until the handler is called.
+ *
+ * @param expr 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(
+ *   const Async_Read_Stream::error_type& error, // Result of operation.
+ *
+ *   std::size_t bytes_transferred               // The number of bytes in the
+ *                                               // streambuf's get area up to
+ *                                               // and including the substring
+ *                                               // that matches the regular
+ *                                               // expression. 0 if an error
+ *                                               // occurred.
+ * ); @endcode
+ * Regardless of whether the asynchronous operation completes immediately or
+ * not, the handler will not be invoked from within this function. Invocation of
+ * the handler will be performed in a manner equivalent to using
+ * boost::asio::io_service::post().
+ *
+ * @par Example:
+ * To asynchronously read data into a streambuf until a CR-LF sequence is
+ * encountered:
+ * @code boost::asio::streambuf b;
+ * ...
+ * void handler(const boost::asio::error& e, std::size_t size)
+ * {
+ *   if (!e)
+ *   {
+ *     std::istream is(&b);
+ *     std::string line;
+ *     std::getline(is, line);
+ *     ...
+ *   }
+ * }
+ * ...
+ * boost::asio::async_read_until(s, b, boost::regex("\r\n"), handler); @endcode
+ */
+template <typename Async_Read_Stream, typename Allocator, typename Handler>
+void async_read_until(Async_Read_Stream& s,
+    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
+    Handler handler);
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/impl/read_until.ipp>
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_READ_UNTIL_HPP
diff --git a/include/boost/asio/resolver_service.hpp b/include/boost/asio/resolver_service.hpp
new file mode 100644
index 0000000000..cd7e7544ab
--- /dev/null
+++ b/include/boost/asio/resolver_service.hpp
@@ -0,0 +1,128 @@
+//
+// resolver_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_RESOLVER_SERVICE_HPP
+#define BOOST_ASIO_RESOLVER_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/resolver_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a resolver.
+template <typename Protocol>
+class resolver_service
+  : public boost::asio::io_service::service
+{
+public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  /// The query type.
+  typedef typename Protocol::resolver_query query_type;
+
+  /// The iterator type.
+  typedef typename Protocol::resolver_iterator iterator_type;
+
+private:
+  // The type of the platform-specific implementation.
+  typedef detail::resolver_service<Protocol> service_impl_type;
+
+public:
+  /// The type of a resolver implementation.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// Construct a new resolver service for the specified io_service.
+  explicit resolver_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new resolver implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a resolver implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Cancel pending asynchronous operations.
+  void cancel(implementation_type& impl)
+  {
+    service_impl_.cancel(impl);
+  }
+
+  /// Resolve a query to a list of entries.
+  template <typename Error_Handler>
+  iterator_type resolve(implementation_type& impl, const query_type& query,
+      Error_Handler error_handler)
+  {
+    return service_impl_.resolve(impl, query, error_handler);
+  }
+
+  /// Asynchronously resolve a query to a list of entries.
+  template <typename Handler>
+  void async_resolve(implementation_type& impl, const query_type& query,
+      Handler handler)
+  {
+    service_impl_.async_resolve(impl, query, handler);
+  }
+
+  /// Resolve an endpoint to a list of entries.
+  template <typename Error_Handler>
+  iterator_type resolve(implementation_type& impl,
+      const endpoint_type& endpoint, Error_Handler error_handler)
+  {
+    return service_impl_.resolve(impl, endpoint, error_handler);
+  }
+
+  /// Asynchronously resolve an endpoint to a list of entries.
+  template <typename Handler>
+  void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
+      Handler handler)
+  {
+    return service_impl_.async_resolve(impl, endpoint, handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_RESOLVER_SERVICE_HPP
diff --git a/include/boost/asio/socket_acceptor_service.hpp b/include/boost/asio/socket_acceptor_service.hpp
new file mode 100644
index 0000000000..aaa868d030
--- /dev/null
+++ b/include/boost/asio/socket_acceptor_service.hpp
@@ -0,0 +1,214 @@
+//
+// socket_acceptor_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
+#define BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_socket.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/kqueue_reactor.hpp>
+#include <boost/asio/detail/select_reactor.hpp>
+#include <boost/asio/detail/reactive_socket_service.hpp>
+#include <boost/asio/detail/win_iocp_socket_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a socket acceptor.
+template <typename Protocol>
+class socket_acceptor_service
+  : public boost::asio::io_service::service
+{
+public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename protocol_type::endpoint endpoint_type;
+
+private:
+  // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_EPOLL)
+  typedef detail::reactive_socket_service<
+      Protocol, detail::epoll_reactor<false> > service_impl_type;
+#elif defined(BOOST_ASIO_HAS_KQUEUE)
+  typedef detail::reactive_socket_service<
+      Protocol, detail::kqueue_reactor<false> > service_impl_type;
+#else
+  typedef detail::reactive_socket_service<
+      Protocol, detail::select_reactor<false> > service_impl_type;
+#endif
+
+public:
+  /// The native type of the socket acceptor.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// The native acceptor type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_type;
+#else
+  typedef typename service_impl_type::native_type native_type;
+#endif
+
+  /// Construct a new socket acceptor service for the specified io_service.
+  explicit socket_acceptor_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new socket acceptor implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a socket acceptor implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Open a new socket acceptor implementation.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const protocol_type& protocol,
+      Error_Handler error_handler)
+  {
+    service_impl_.open(impl, protocol, error_handler);
+  }
+
+  /// Assign an existing native acceptor to a socket acceptor.
+  template <typename Error_Handler>
+  void assign(implementation_type& impl, const protocol_type& protocol,
+      const native_type& native_acceptor, Error_Handler error_handler)
+  {
+    service_impl_.assign(impl, protocol, native_acceptor, error_handler);
+  }
+
+  /// Bind the socket acceptor to the specified local endpoint.
+  template <typename Error_Handler>
+  void bind(implementation_type& impl, const endpoint_type& endpoint,
+      Error_Handler error_handler)
+  {
+    service_impl_.bind(impl, endpoint, error_handler);
+  }
+
+  /// Place the socket acceptor into the state where it will listen for new
+  /// connections.
+  template <typename Error_Handler>
+  void listen(implementation_type& impl, int backlog,
+      Error_Handler error_handler)
+  {
+    service_impl_.listen(impl, backlog, error_handler);
+  }
+
+  /// Close a socket acceptor implementation.
+  template <typename Error_Handler>
+  void close(implementation_type& impl, Error_Handler error_handler)
+  {
+    service_impl_.close(impl, error_handler);
+  }
+
+  /// Get the native acceptor implementation.
+  native_type native(implementation_type& impl)
+  {
+    return service_impl_.native(impl);
+  }
+
+  /// Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void set_option(implementation_type& impl, const Option& option,
+      Error_Handler error_handler)
+  {
+    service_impl_.set_option(impl, option, error_handler);
+  }
+
+  /// Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void get_option(implementation_type& impl, Option& option,
+      Error_Handler error_handler)
+  {
+    service_impl_.get_option(impl, option, error_handler);
+  }
+
+  /// Get the local endpoint.
+  template <typename Error_Handler>
+  endpoint_type local_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    endpoint_type endpoint;
+    service_impl_.get_local_endpoint(impl, endpoint, error_handler);
+    return endpoint;
+  }
+
+  /// Accept a new connection.
+  template <typename Socket_Service, typename Error_Handler>
+  void accept(implementation_type& impl,
+      basic_socket<protocol_type, Socket_Service>& peer,
+      Error_Handler error_handler)
+  {
+    service_impl_.accept(impl, peer, error_handler);
+  }
+
+  /// Accept a new connection.
+  template <typename Socket_Service, typename Error_Handler>
+  void accept_endpoint(implementation_type& impl,
+      basic_socket<protocol_type, Socket_Service>& peer,
+      endpoint_type& peer_endpoint, Error_Handler error_handler)
+  {
+    service_impl_.accept_endpoint(impl, peer, peer_endpoint, error_handler);
+  }
+
+  /// Start an asynchronous accept.
+  template <typename Socket_Service, typename Handler>
+  void async_accept(implementation_type& impl,
+      basic_socket<protocol_type, Socket_Service>& peer, Handler handler)
+  {
+    service_impl_.async_accept(impl, peer, handler);
+  }
+
+  /// Start an asynchronous accept.
+  template <typename Socket_Service, typename Handler>
+  void async_accept_endpoint(implementation_type& impl,
+      basic_socket<protocol_type, Socket_Service>& peer,
+      endpoint_type& peer_endpoint, Handler handler)
+  {
+    service_impl_.async_accept_endpoint(impl, peer, peer_endpoint, handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
diff --git a/include/boost/asio/socket_base.hpp b/include/boost/asio/socket_base.hpp
new file mode 100644
index 0000000000..fae285c3ca
--- /dev/null
+++ b/include/boost/asio/socket_base.hpp
@@ -0,0 +1,477 @@
+//
+// socket_base.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SOCKET_BASE_HPP
+#define BOOST_ASIO_SOCKET_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/io_control.hpp>
+#include <boost/asio/detail/socket_option.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+
+namespace boost {
+namespace asio {
+
+/// The socket_base class is used as a base for the basic_stream_socket and
+/// basic_datagram_socket class templates so that we have a common place to
+/// define the shutdown_type and enum.
+class socket_base
+{
+public:
+  /// Different ways a socket may be shutdown.
+  enum shutdown_type
+  {
+#if defined(GENERATING_DOCUMENTATION)
+    /// Shutdown the receive side of the socket.
+    shutdown_receive = implementation_defined,
+
+    /// Shutdown the send side of the socket.
+    shutdown_send = implementation_defined,
+
+    /// Shutdown both send and receive on the socket.
+    shutdown_both = implementation_defined
+#else
+    shutdown_receive = boost::asio::detail::shutdown_receive,
+    shutdown_send = boost::asio::detail::shutdown_send,
+    shutdown_both = boost::asio::detail::shutdown_both
+#endif
+  };
+
+  /// Bitmask type for flags that can be passed to send and receive operations.
+  typedef int message_flags;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// Peek at incoming data without removing it from the input queue.
+  static const int message_peek = implementation_defined;
+
+  /// Process out-of-band data.
+  static const int message_out_of_band = implementation_defined;
+
+  /// Specify that the data should not be subject to routing.
+  static const int message_do_not_route = implementation_defined;
+#else
+  BOOST_STATIC_CONSTANT(int,
+      message_peek = boost::asio::detail::message_peek);
+  BOOST_STATIC_CONSTANT(int,
+      message_out_of_band = boost::asio::detail::message_out_of_band);
+  BOOST_STATIC_CONSTANT(int,
+      message_do_not_route = boost::asio::detail::message_do_not_route);
+#endif
+
+  /// Socket option to permit sending of broadcast messages.
+  /**
+   * Implements the SOL_SOCKET/SO_BROADCAST socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::udp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::broadcast option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::udp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::broadcast option;
+   * socket.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined broadcast;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    SOL_SOCKET, SO_BROADCAST> broadcast;
+#endif
+
+  /// Socket option to prevent routing, use local interfaces only.
+  /**
+   * Implements the SOL_SOCKET/SO_DONTROUTE socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::udp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::do_not_route option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::udp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::do_not_route option;
+   * socket.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined do_not_route;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    SOL_SOCKET, SO_DONTROUTE> do_not_route;
+#endif
+
+  /// Socket option to send keep-alives.
+  /**
+   * Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::keep_alive option(true);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::keep_alive option;
+   * socket.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined keep_alive;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    SOL_SOCKET, SO_KEEPALIVE> keep_alive;
+#endif
+
+  /// Socket option for the send buffer size of a socket.
+  /**
+   * Implements the SOL_SOCKET/SO_SNDBUF socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::send_buffer_size option(8192);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::send_buffer_size option;
+   * socket.get_option(option);
+   * int size = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined send_buffer_size;
+#else
+  typedef boost::asio::detail::socket_option::integer<
+    SOL_SOCKET, SO_SNDBUF> send_buffer_size;
+#endif
+
+  /// Socket option for the send low watermark.
+  /**
+   * Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::send_low_watermark option(1024);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::send_low_watermark option;
+   * socket.get_option(option);
+   * int size = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined send_low_watermark;
+#else
+  typedef boost::asio::detail::socket_option::integer<
+    SOL_SOCKET, SO_SNDLOWAT> send_low_watermark;
+#endif
+
+  /// Socket option for the receive buffer size of a socket.
+  /**
+   * Implements the SOL_SOCKET/SO_RCVBUF socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::receive_buffer_size option(8192);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::receive_buffer_size option;
+   * socket.get_option(option);
+   * int size = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined receive_buffer_size;
+#else
+  typedef boost::asio::detail::socket_option::integer<
+    SOL_SOCKET, SO_RCVBUF> receive_buffer_size;
+#endif
+
+  /// Socket option for the receive low watermark.
+  /**
+   * Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::receive_low_watermark option(1024);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::receive_low_watermark option;
+   * socket.get_option(option);
+   * int size = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Integer_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined receive_low_watermark;
+#else
+  typedef boost::asio::detail::socket_option::integer<
+    SOL_SOCKET, SO_RCVLOWAT> receive_low_watermark;
+#endif
+
+  /// Socket option to allow the socket to be bound to an address that is
+  /// already in use.
+  /**
+   * Implements the SOL_SOCKET/SO_REUSEADDR socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::socket_acceptor acceptor(io_service); 
+   * ...
+   * boost::asio::socket_base::reuse_address option(true);
+   * acceptor.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::socket_acceptor acceptor(io_service); 
+   * ...
+   * boost::asio::socket_base::reuse_address option;
+   * acceptor.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined reuse_address;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    SOL_SOCKET, SO_REUSEADDR> reuse_address;
+#endif
+
+  /// Socket option to specify whether the socket lingers on close if unsent
+  /// data is present.
+  /**
+   * Implements the SOL_SOCKET/SO_LINGER socket option.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::linger option(true, 30);
+   * socket.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::linger option;
+   * socket.get_option(option);
+   * bool is_set = option.enabled();
+   * unsigned short timeout = option.timeout();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Linger_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined linger;
+#else
+  typedef boost::asio::detail::socket_option::linger<
+    SOL_SOCKET, SO_LINGER> linger;
+#endif
+
+  /// Socket option to report aborted connections on accept.
+  /**
+   * Implements a custom socket option that determines whether or not an accept
+   * operation is permitted to fail with boost::asio::error::connection_aborted.
+   * By default the option is false.
+   *
+   * @par Examples:
+   * Setting the option:
+   * @code
+   * boost::asio::ip::tcp::acceptor acceptor(io_service); 
+   * ...
+   * boost::asio::socket_base::enable_connection_aborted option(true);
+   * acceptor.set_option(option);
+   * @endcode
+   *
+   * @par
+   * Getting the current option value:
+   * @code
+   * boost::asio::ip::tcp::acceptor acceptor(io_service); 
+   * ...
+   * boost::asio::socket_base::enable_connection_aborted option;
+   * acceptor.get_option(option);
+   * bool is_set = option.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * Socket_Option, Boolean_Socket_Option.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined enable_connection_aborted;
+#else
+  typedef boost::asio::detail::socket_option::boolean<
+    boost::asio::detail::custom_socket_option_level,
+    boost::asio::detail::enable_connection_aborted_option>
+    enable_connection_aborted;
+#endif
+
+  /// IO control command to set the blocking mode of the socket.
+  /**
+   * Implements the FIONBIO IO control command.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::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 boost::asio::detail::io_control::boolean<FIONBIO> non_blocking_io;
+#endif
+
+  /// IO control command to get the amount of data that can be read without
+  /// blocking.
+  /**
+   * Implements the FIONREAD IO control command.
+   *
+   * @par Example:
+   * @code
+   * boost::asio::ip::tcp::socket socket(io_service); 
+   * ...
+   * boost::asio::socket_base::bytes_readable command(true);
+   * socket.io_control(command);
+   * std::size_t bytes_readable = command.get();
+   * @endcode
+   *
+   * @par Concepts:
+   * IO_Control_Command, Size_IO_Control_Command.
+   */
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined bytes_readable;
+#else
+  typedef boost::asio::detail::io_control::size<FIONREAD> bytes_readable;
+#endif
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~socket_base()
+  {
+  }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+private:
+  // Workaround to enable the empty base optimisation with Borland C++.
+  char dummy_;
+#endif
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SOCKET_BASE_HPP
diff --git a/include/boost/asio/ssl.hpp b/include/boost/asio/ssl.hpp
new file mode 100644
index 0000000000..f751bd64ec
--- /dev/null
+++ b/include/boost/asio/ssl.hpp
@@ -0,0 +1,26 @@
+//
+// ssl.hpp
+// ~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_HPP
+#define BOOST_ASIO_SSL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/ssl/basic_context.hpp>
+#include <boost/asio/ssl/context.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+#include <boost/asio/ssl/context_service.hpp>
+#include <boost/asio/ssl/stream.hpp>
+#include <boost/asio/ssl/stream_base.hpp>
+#include <boost/asio/ssl/stream_service.hpp>
+
+#endif // BOOST_ASIO_SSL_HPP
diff --git a/include/boost/asio/ssl/basic_context.hpp b/include/boost/asio/ssl/basic_context.hpp
new file mode 100644
index 0000000000..2998f4a057
--- /dev/null
+++ b/include/boost/asio/ssl/basic_context.hpp
@@ -0,0 +1,421 @@
+//
+// basic_context.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_BASIC_CONTEXT_HPP
+#define BOOST_ASIO_SSL_BASIC_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <string>
+#include <boost/noncopyable.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// 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 locking dispatcher.
+  typedef typename service_type::impl_type impl_type;
+
+  /// Constructor.
+  basic_context(boost::asio::io_service& io_service, method m)
+    : service_(boost::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 boost::asio::error Thrown on failure.
+   */
+  void set_options(options o)
+  {
+    service_.set_options(impl_, o, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void set_options(options o, Error_Handler error_handler)
+  {
+    service_.set_options(impl_, o, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void set_verify_mode(verify_mode v)
+  {
+    service_.set_verify_mode(impl_, v, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void set_verify_mode(verify_mode v, Error_Handler error_handler)
+  {
+    service_.set_verify_mode(impl_, v, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void load_verify_file(const std::string& filename)
+  {
+    service_.load_verify_file(impl_, filename, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void load_verify_file(const std::string& filename,
+      Error_Handler error_handler)
+  {
+    service_.load_verify_file(impl_, filename, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void add_verify_path(const std::string& path)
+  {
+    service_.add_verify_path(impl_, path, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void add_verify_path(const std::string& path, Error_Handler error_handler)
+  {
+    service_.add_verify_path(impl_, path, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void use_certificate_file(const std::string& filename, file_format format)
+  {
+    service_.use_certificate_file(impl_, filename, format, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void use_certificate_file(const std::string& filename, file_format format,
+      Error_Handler error_handler)
+  {
+    service_.use_certificate_file(impl_, filename, format, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void use_certificate_chain_file(const std::string& filename)
+  {
+    service_.use_certificate_chain_file(impl_, filename, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void use_certificate_chain_file(const std::string& filename,
+      Error_Handler error_handler)
+  {
+    service_.use_certificate_chain_file(impl_, filename, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void use_private_key_file(const std::string& filename, file_format format)
+  {
+    service_.use_private_key_file(impl_, filename, format, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void use_private_key_file(const std::string& filename, file_format format,
+      Error_Handler error_handler)
+  {
+    service_.use_private_key_file(impl_, filename, format, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void use_rsa_private_key_file(const std::string& filename, file_format format)
+  {
+    service_.use_rsa_private_key_file(impl_, filename, format, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void use_rsa_private_key_file(const std::string& filename, file_format format,
+      Error_Handler error_handler)
+  {
+    service_.use_rsa_private_key_file(impl_, filename, format, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  void use_tmp_dh_file(const std::string& filename)
+  {
+    service_.use_tmp_dh_file(impl_, filename, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void use_tmp_dh_file(const std::string& filename, Error_Handler error_handler)
+  {
+    service_.use_tmp_dh_file(impl_, filename, error_handler);
+  }
+
+private:
+  /// The backend service implementation.
+  service_type& service_;
+
+  /// The underlying native implementation.
+  impl_type impl_;
+};
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_BASIC_CONTEXT_HPP
diff --git a/include/boost/asio/ssl/context.hpp b/include/boost/asio/ssl/context.hpp
new file mode 100644
index 0000000000..6a18d67e57
--- /dev/null
+++ b/include/boost/asio/ssl/context.hpp
@@ -0,0 +1,37 @@
+//
+// context.hpp
+// ~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_CONTEXT_HPP
+#define BOOST_ASIO_SSL_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/ssl/basic_context.hpp>
+#include <boost/asio/ssl/context_service.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// Typedef for the typical usage of context.
+typedef basic_context<context_service> context;
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_CONTEXT_HPP
diff --git a/include/boost/asio/ssl/context_base.hpp b/include/boost/asio/ssl/context_base.hpp
new file mode 100644
index 0000000000..cb94a76dd8
--- /dev/null
+++ b/include/boost/asio/ssl/context_base.hpp
@@ -0,0 +1,156 @@
+//
+// context_base.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_CONTEXT_BASE_HPP
+#define BOOST_ASIO_SSL_CONTEXT_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/ssl/detail/openssl_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// The context_base class is used as a base for the basic_context class
+/// template so that we have a common place to define various enums.
+class context_base
+{
+public:
+  /// Different methods supported by a context.
+  enum method
+  {
+    /// Generic SSL version 2.
+    sslv2,
+
+    /// SSL version 2 client.
+    sslv2_client,
+
+    /// SSL version 2 server.
+    sslv2_server,
+
+    /// Generic SSL version 3.
+    sslv3,
+
+    /// SSL version 3 client.
+    sslv3_client,
+
+    /// SSL version 3 server.
+    sslv3_server,
+
+    /// Generic TLS version 1.
+    tlsv1,
+
+    /// TLS version 1 client.
+    tlsv1_client,
+
+    /// TLS version 1 server.
+    tlsv1_server,
+
+    /// Generic SSL/TLS.
+    sslv23,
+
+    /// SSL/TLS client.
+    sslv23_client,
+
+    /// SSL/TLS server.
+    sslv23_server
+  };
+
+  /// Bitmask type for SSL options.
+  typedef int options;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// Implement various bug workarounds.
+  static const int default_workarounds = implementation_defined;
+
+  /// Always create a new key when using tmp_dh parameters.
+  static const int single_dh_use = implementation_defined;
+
+  /// Disable SSL v2.
+  static const int no_sslv2 = implementation_defined;
+
+  /// Disable SSL v3.
+  static const int no_sslv3 = implementation_defined;
+
+  /// Disable TLS v1.
+  static const int no_tlsv1 = implementation_defined;
+#else
+  BOOST_STATIC_CONSTANT(int, default_workarounds = SSL_OP_ALL);
+  BOOST_STATIC_CONSTANT(int, single_dh_use = SSL_OP_SINGLE_DH_USE);
+  BOOST_STATIC_CONSTANT(int, no_sslv2 = SSL_OP_NO_SSLv2);
+  BOOST_STATIC_CONSTANT(int, no_sslv3 = SSL_OP_NO_SSLv3);
+  BOOST_STATIC_CONSTANT(int, no_tlsv1 = SSL_OP_NO_TLSv1);
+#endif
+
+  /// File format types.
+  enum file_format
+  {
+    /// ASN.1 file.
+    asn1,
+
+    /// PEM file.
+    pem
+  };
+
+  /// Bitmask type for peer verification.
+  typedef int verify_mode;
+
+#if defined(GENERATING_DOCUMENTATION)
+  /// No verification.
+  static const int verify_none = implementation_defined;
+
+  /// Verify the peer.
+  static const int verify_peer = implementation_defined;
+
+  /// Fail verification if the peer has no certificate. Ignored unless
+  /// verify_peer is set.
+  static const int verify_fail_if_no_peer_cert = implementation_defined;
+
+  /// Do not request client certificate on renegotiation. Ignored unless
+  /// verify_peer is set.
+  static const int verify_client_once = implementation_defined;
+#else
+  BOOST_STATIC_CONSTANT(int, verify_none = SSL_VERIFY_NONE);
+  BOOST_STATIC_CONSTANT(int, verify_peer = SSL_VERIFY_PEER);
+  BOOST_STATIC_CONSTANT(int,
+      verify_fail_if_no_peer_cert = SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
+  BOOST_STATIC_CONSTANT(int, verify_client_once = SSL_VERIFY_CLIENT_ONCE);
+#endif
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~context_base()
+  {
+  }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+private:
+  // Workaround to enable the empty base optimisation with Borland C++.
+  char dummy_;
+#endif
+};
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_CONTEXT_BASE_HPP
diff --git a/include/boost/asio/ssl/context_service.hpp b/include/boost/asio/ssl/context_service.hpp
new file mode 100644
index 0000000000..a9acb0de56
--- /dev/null
+++ b/include/boost/asio/ssl/context_service.hpp
@@ -0,0 +1,165 @@
+//
+// context_service.hpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_CONTEXT_SERVICE_HPP
+#define BOOST_ASIO_SSL_CONTEXT_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <string>
+#include <boost/noncopyable.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+#include <boost/asio/ssl/detail/openssl_context_service.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// Default service implementation for a context.
+class context_service
+  : public boost::asio::io_service::service
+{
+private:
+  // The type of the platform-specific implementation.
+  typedef detail::openssl_context_service service_impl_type;
+
+public:
+  /// 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(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_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.
+  template <typename Error_Handler>
+  void set_options(impl_type& impl, context_base::options o,
+      Error_Handler error_handler)
+  {
+    service_impl_.set_options(impl, o, error_handler);
+  }
+
+  /// Set peer verification mode.
+  template <typename Error_Handler>
+  void set_verify_mode(impl_type& impl, context_base::verify_mode v,
+      Error_Handler error_handler)
+  {
+    service_impl_.set_verify_mode(impl, v, error_handler);
+  }
+
+  /// Load a certification authority file for performing verification.
+  template <typename Error_Handler>
+  void load_verify_file(impl_type& impl, const std::string& filename,
+      Error_Handler error_handler)
+  {
+    service_impl_.load_verify_file(impl, filename, error_handler);
+  }
+
+  /// Add a directory containing certification authority files to be used for
+  /// performing verification.
+  template <typename Error_Handler>
+  void add_verify_path(impl_type& impl, const std::string& path,
+      Error_Handler error_handler)
+  {
+    service_impl_.add_verify_path(impl, path, error_handler);
+  }
+
+  /// Use a certificate from a file.
+  template <typename Error_Handler>
+  void use_certificate_file(impl_type& impl, const std::string& filename,
+      context_base::file_format format, Error_Handler error_handler)
+  {
+    service_impl_.use_certificate_file(impl, filename, format, error_handler);
+  }
+
+  /// Use a certificate chain from a file.
+  template <typename Error_Handler>
+  void use_certificate_chain_file(impl_type& impl, const std::string& filename,
+      Error_Handler error_handler)
+  {
+    service_impl_.use_certificate_chain_file(impl, filename, error_handler);
+  }
+
+  /// Use a private key from a file.
+  template <typename Error_Handler>
+  void use_private_key_file(impl_type& impl, const std::string& filename,
+      context_base::file_format format, Error_Handler error_handler)
+  {
+    service_impl_.use_private_key_file(impl, filename, format, error_handler);
+  }
+
+  /// Use an RSA private key from a file.
+  template <typename Error_Handler>
+  void use_rsa_private_key_file(impl_type& impl, const std::string& filename,
+      context_base::file_format format, Error_Handler error_handler)
+  {
+    service_impl_.use_rsa_private_key_file(impl, filename, format,
+        error_handler);
+  }
+
+  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
+  template <typename Error_Handler>
+  void use_tmp_dh_file(impl_type& impl, const std::string& filename,
+      Error_Handler error_handler)
+  {
+    service_impl_.use_tmp_dh_file(impl, filename, error_handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_CONTEXT_SERVICE_HPP
diff --git a/include/boost/asio/ssl/detail/openssl_context_service.hpp b/include/boost/asio/ssl/detail/openssl_context_service.hpp
new file mode 100644
index 0000000000..7a8955864d
--- /dev/null
+++ b/include/boost/asio/ssl/detail/openssl_context_service.hpp
@@ -0,0 +1,303 @@
+//
+// openssl_context_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_DETAIL_OPENSSL_CONTEXT_SERVICE_HPP
+#define BOOST_ASIO_SSL_DETAIL_OPENSSL_CONTEXT_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <string>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+#include <boost/asio/ssl/detail/openssl_init.hpp>
+#include <boost/asio/ssl/detail/openssl_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+namespace detail {
+
+class openssl_context_service
+  : public boost::asio::io_service::service
+{
+public:
+  // The native type of the context.
+  typedef ::SSL_CTX* impl_type;
+
+  // Constructor.
+  openssl_context_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::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)
+  {
+    ::SSL_METHOD* ssl_method = 0;
+    switch (m)
+    {
+    case context_base::sslv2:
+      ssl_method = ::SSLv2_method();
+      break;
+    case context_base::sslv2_client:
+      ssl_method = ::SSLv2_client_method();
+      break;
+    case context_base::sslv2_server:
+      ssl_method = ::SSLv2_server_method();
+      break;
+    case context_base::sslv3:
+      ssl_method = ::SSLv3_method();
+      break;
+    case context_base::sslv3_client:
+      ssl_method = ::SSLv3_client_method();
+      break;
+    case context_base::sslv3_server:
+      ssl_method = ::SSLv3_server_method();
+      break;
+    case context_base::tlsv1:
+      ssl_method = ::TLSv1_method();
+      break;
+    case context_base::tlsv1_client:
+      ssl_method = ::TLSv1_client_method();
+      break;
+    case context_base::tlsv1_server:
+      ssl_method = ::TLSv1_server_method();
+      break;
+    case context_base::sslv23:
+      ssl_method = ::SSLv23_method();
+      break;
+    case context_base::sslv23_client:
+      ssl_method = ::SSLv23_client_method();
+      break;
+    case context_base::sslv23_server:
+      ssl_method = ::SSLv23_server_method();
+      break;
+    default:
+      break;
+    }
+    impl = ::SSL_CTX_new(ssl_method);
+  }
+
+  // Destroy a context implementation.
+  void destroy(impl_type& impl)
+  {
+    if (impl != null())
+    {
+      ::SSL_CTX_free(impl);
+      impl = null();
+    }
+  }
+
+  // Set options on the context.
+  template <typename Error_Handler>
+  void set_options(impl_type& impl, context_base::options o,
+      Error_Handler error_handler)
+  {
+    ::SSL_CTX_set_options(impl, o);
+  }
+
+  // Set peer verification mode.
+  template <typename Error_Handler>
+  void set_verify_mode(impl_type& impl, context_base::verify_mode v,
+      Error_Handler error_handler)
+  {
+    ::SSL_CTX_set_verify(impl, v, 0);
+  }
+
+  // Load a certification authority file for performing verification.
+  template <typename Error_Handler>
+  void load_verify_file(impl_type& impl, const std::string& filename,
+      Error_Handler error_handler)
+  {
+    if (::SSL_CTX_load_verify_locations(impl, filename.c_str(), 0) != 1)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+  // Add a directory containing certification authority files to be used for
+  // performing verification.
+  template <typename Error_Handler>
+  void add_verify_path(impl_type& impl, const std::string& path,
+      Error_Handler error_handler)
+  {
+    if (::SSL_CTX_load_verify_locations(impl, 0, path.c_str()) != 1)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+  // Use a certificate from a file.
+  template <typename Error_Handler>
+  void use_certificate_file(impl_type& impl, const std::string& filename,
+      context_base::file_format format, Error_Handler error_handler)
+  {
+    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:
+      {
+        boost::asio::error e(boost::asio::error::invalid_argument);
+        error_handler(e);
+        return;
+      }
+    }
+
+    if (::SSL_CTX_use_certificate_file(impl, filename.c_str(), file_type) != 1)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+  // Use a certificate chain from a file.
+  template <typename Error_Handler>
+  void use_certificate_chain_file(impl_type& impl, const std::string& filename,
+      Error_Handler error_handler)
+  {
+    if (::SSL_CTX_use_certificate_chain_file(impl, filename.c_str()) != 1)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+  // Use a private key from a file.
+  template <typename Error_Handler>
+  void use_private_key_file(impl_type& impl, const std::string& filename,
+      context_base::file_format format, Error_Handler error_handler)
+  {
+    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:
+      {
+        boost::asio::error e(boost::asio::error::invalid_argument);
+        error_handler(e);
+        return;
+      }
+    }
+
+    if (::SSL_CTX_use_PrivateKey_file(impl, filename.c_str(), file_type) != 1)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+  // Use an RSA private key from a file.
+  template <typename Error_Handler>
+  void use_rsa_private_key_file(impl_type& impl, const std::string& filename,
+      context_base::file_format format, Error_Handler error_handler)
+  {
+    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:
+      {
+        boost::asio::error e(boost::asio::error::invalid_argument);
+        error_handler(e);
+        return;
+      }
+    }
+
+    if (::SSL_CTX_use_RSAPrivateKey_file(
+          impl, filename.c_str(), file_type) != 1)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+  // Use the specified file to obtain the temporary Diffie-Hellman parameters.
+  template <typename Error_Handler>
+  void use_tmp_dh_file(impl_type& impl, const std::string& filename,
+      Error_Handler error_handler)
+  {
+    ::BIO* bio = ::BIO_new_file(filename.c_str(), "r");
+    if (!bio)
+    {
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+      return;
+    }
+
+    ::DH* dh = ::PEM_read_bio_DHparams(bio, 0, 0, 0);
+    if (!dh)
+    {
+      ::BIO_free(bio);
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+      return;
+    }
+
+    ::BIO_free(bio);
+    int result = ::SSL_CTX_set_tmp_dh(impl, dh);
+    if (result != 1)
+    {
+      ::DH_free(dh);
+      boost::asio::error e(boost::asio::error::invalid_argument);
+      error_handler(e);
+    }
+  }
+
+private:
+  // Ensure openssl is initialised.
+  openssl_init<> init_;
+};
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_DETAIL_OPENSSL_CONTEXT_SERVICE_HPP
diff --git a/include/boost/asio/ssl/detail/openssl_init.hpp b/include/boost/asio/ssl/detail/openssl_init.hpp
new file mode 100644
index 0000000000..66002255bf
--- /dev/null
+++ b/include/boost/asio/ssl/detail/openssl_init.hpp
@@ -0,0 +1,124 @@
+//
+// openssl_init.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
+#define BOOST_ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <vector>
+#include <boost/shared_ptr.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/ssl/detail/openssl_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+namespace detail {
+
+template <bool Do_Init = true>
+class openssl_init
+  : private boost::noncopyable
+{
+private:
+  // Structure to perform the actual initialisation.
+  class do_init
+  {
+  public:
+    do_init()
+    {
+      if (Do_Init)
+      {
+        ::SSL_library_init();
+        ::SSL_load_error_strings();        
+
+        mutexes_.resize(::CRYPTO_num_locks());
+        for (size_t i = 0; i < mutexes_.size(); ++i)
+          mutexes_[i].reset(new boost::asio::detail::mutex);
+        ::CRYPTO_set_locking_callback(&do_init::openssl_locking_func);
+
+        ::OpenSSL_add_ssl_algorithms();
+      }
+    }
+
+    ~do_init()
+    {
+      if (Do_Init)
+      {
+        ::CRYPTO_set_locking_callback(0);
+      }
+    }
+
+    // Helper function to manage a do_init singleton. The static instance of the
+    // openssl_init object ensures that this function is always called before
+    // main, and therefore before any other threads can get started. The do_init
+    // instance must be static in this function to ensure that it gets
+    // initialised before any other global objects try to use it.
+    static boost::shared_ptr<do_init> instance()
+    {
+      static boost::shared_ptr<do_init> init(new do_init);
+      return init;
+    }
+
+  private:
+    static void openssl_locking_func(int mode, int n, 
+      const char *file, int line)
+    {
+  	  if (mode & CRYPTO_LOCK)
+        instance()->mutexes_[n]->lock();
+	    else
+        instance()->mutexes_[n]->unlock();
+    }
+
+    // Mutexes to be used in locking callbacks.
+    std::vector<boost::shared_ptr<boost::asio::detail::mutex> > mutexes_;
+  };
+
+public:
+  // Constructor.
+  openssl_init()
+    : ref_(do_init::instance())
+  {
+    while (&instance_ == 0); // Ensure openssl_init::instance_ is linked in.
+  }
+
+  // Destructor.
+  ~openssl_init()
+  {
+  }
+
+private:
+  // Instance to force initialisation of openssl at global scope.
+  static openssl_init instance_;
+
+  // Reference to singleton do_init object to ensure that openssl does not get
+  // cleaned up until the last user has finished with it.
+  boost::shared_ptr<do_init> ref_;
+};
+
+template <bool Do_Init>
+openssl_init<Do_Init> openssl_init<Do_Init>::instance_;
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
diff --git a/include/boost/asio/ssl/detail/openssl_operation.hpp b/include/boost/asio/ssl/detail/openssl_operation.hpp
new file mode 100644
index 0000000000..7180b63a7d
--- /dev/null
+++ b/include/boost/asio/ssl/detail/openssl_operation.hpp
@@ -0,0 +1,428 @@
+//
+// 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 BOOST_ASIO_SSL_DETAIL_OPENSSL_OPERATION_HPP
+#define BOOST_ASIO_SSL_DETAIL_OPENSSL_OPERATION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/placeholders.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/asio/ssl/detail/openssl_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+namespace detail {
+
+typedef boost::function<int (::SSL*)> ssl_primitive_func; 
+typedef boost::function<void (const error&, 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,
+                    SSL* session,
+                    BIO* ssl_bio,
+                    user_handler_func  handler
+                    )
+    : primitive_(primitive)
+    , user_handler_(handler)
+    , socket_(socket)
+    , ssl_bio_(ssl_bio)
+    , session_(session)
+  {
+    write_ = boost::bind(
+      &openssl_operation::do_async_write, 
+      this, boost::arg<1>(), boost::arg<2>()
+    );
+    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,
+                    SSL* session,
+                    BIO* ssl_bio)
+    : primitive_(primitive)
+    , socket_(socket)
+    , ssl_bio_(ssl_bio)
+    , session_(session)
+  {      
+    write_ = boost::bind(
+      &openssl_operation::do_sync_write, 
+      this, boost::arg<1>(), boost::arg<2>()
+    );
+    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, is is done when retcode > 0
+
+    int error_code =  !is_operation_done ?
+          ::SSL_get_error( session_, rc ) :
+          0;        
+    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)
+      // SSL connection is shut down cleanly
+      return handler_(boost::asio::error(), 1);
+
+    if (is_shut_down_received && !is_write_needed)
+      return handler_(boost::asio::error(boost::asio::error::eof), 0);
+
+    if (is_shut_down_received)
+      // Shutdown has been requested, while we were reading or writing...
+      // abort our action...
+      return handler_(boost::asio::error(boost::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...
+      return handler_(boost::asio::error(error_code), rc); 
+
+    // Continue with operation, flush any SSL data out to network...
+    return write_(is_operation_done, rc); 
+  }
+
+// Private implementation
+private:
+  typedef boost::function<int (const boost::asio::error&, int)>
+    int_handler_func;
+  typedef boost::function<int (bool, int)> write_func;
+
+  ssl_primitive_func  primitive_;
+  user_handler_func  user_handler_;
+  write_func  write_;
+  int_handler_func handler_;
+    
+  net_buffer send_buf_; // buffers for network IO
+  net_buffer recv_buf_; 
+
+  Stream& socket_;
+  BIO*    ssl_bio_;
+  SSL*    session_;
+
+  //
+  int sync_user_handler(const boost::asio::error& error, int rc)
+  {
+    if (!error)
+      return rc;
+
+    throw error;
+  }
+    
+  int async_user_handler(const boost::asio::error& error, int rc)
+  {
+    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);
+   
+        boost::asio::async_write
+        ( 
+          socket_, 
+          boost::asio::buffer(data_start, len),
+          boost::bind
+          (
+            &openssl_operation::async_write_handler, 
+            this, 
+            is_operation_done,
+            rc, 
+            boost::asio::placeholders::error, 
+            boost::asio::placeholders::bytes_transferred
+          )
+        );
+                  
+        return 0;
+      }
+      else if (!BIO_should_retry(ssl_bio_))
+      {
+        // Seems like fatal error
+        // reading from SSL BIO has failed...
+        handler_(boost::asio::error(boost::asio::error::no_recovery), 0);
+        return 0;
+      }
+    }
+    
+    if (is_operation_done)
+    {
+      // Finish the operation, with success
+      handler_(boost::asio::error(), rc);
+      return 0;
+    }
+    
+    // OPeration is not done and writing to net has been made...
+    // start reading...
+    do_async_read();
+          
+    return 0;
+  }
+
+  void async_write_handler(bool is_operation_done, int rc, 
+    const boost::asio::error& error, size_t bytes_sent)
+  {
+    if (!error)
+    {
+      // Remove data from send buffer
+      send_buf_.data_removed(bytes_sent);
+
+      if (is_operation_done)
+        handler_(boost::asio::error(), rc);
+      else
+        // Since the operation was not completed, try it again...
+        start();
+    }
+    else 
+      handler_(error, rc);
+  }
+
+  void do_async_read()
+  {
+    // Wait for new data
+    socket_.async_read_some
+    ( 
+      boost::asio::buffer(recv_buf_.get_unused_start(),
+        recv_buf_.get_unused_len()),
+      boost::bind
+      (
+        &openssl_operation::async_read_handler, 
+        this, 
+        boost::asio::placeholders::error, 
+        boost::asio::placeholders::bytes_transferred
+      ) 
+    );
+  }
+
+  void async_read_handler(const boost::asio::error& 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_(boost::asio::error(boost::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 = boost::asio::write( 
+                  socket_, 
+                  boost::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 boost::asio::error(boost::asio::error::no_recovery);
+      }
+    }
+    
+    if (is_operation_done)
+      // Finish the operation, with success
+      return rc;
+                
+    // Operation is not finished, read data from net...
+    return do_sync_read();
+  }
+
+  int do_sync_read()
+  {
+    size_t len = socket_.read_some
+      ( 
+        boost::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 boost::asio::error(boost::asio::error::no_recovery);
+      }
+    }
+
+    // Try the operation again
+    return start();
+  }
+}; // class openssl_operation
+
+} // namespace detail
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_DETAIL_OPENSSL_OPERATION_HPP
diff --git a/include/boost/asio/ssl/detail/openssl_stream_service.hpp b/include/boost/asio/ssl/detail/openssl_stream_service.hpp
new file mode 100644
index 0000000000..0e0aa68c45
--- /dev/null
+++ b/include/boost/asio/ssl/detail/openssl_stream_service.hpp
@@ -0,0 +1,444 @@
+//
+// stream_service.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_DETAIL_OPENSSL_STREAM_SERVICE_HPP
+#define BOOST_ASIO_SSL_DETAIL_OPENSSL_STREAM_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ssl/basic_context.hpp>
+#include <boost/asio/ssl/stream_base.hpp>
+#include <boost/asio/ssl/detail/openssl_operation.hpp>
+#include <boost/asio/ssl/detail/openssl_types.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+namespace detail {
+
+class openssl_stream_service
+  : public boost::asio::io_service::service
+{
+private:
+  //Base handler for asyncrhonous operations
+  template <typename Stream>
+  class base_handler
+  {
+  public:
+    typedef boost::function<void (const boost::asio::error&, size_t)> func_t;
+
+    base_handler(boost::asio::io_service& io_service)
+      : op_(NULL)
+      , io_service_(io_service)
+      , work_(io_service)
+    {}
+    
+    void do_func(const boost::asio::error& 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_;
+    boost::asio::io_service& io_service_;
+    boost::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, boost::asio::io_service& io_service)
+      : base_handler<Stream>(io_service)
+      , handler_(handler)
+    {
+      set_func(boost::bind(
+        &io_handler<Stream, Handler>::handler_impl, 
+        this, boost::arg<1>(), boost::arg<2>() ));
+    }
+
+  private:
+    Handler handler_;
+    void handler_impl(const boost::asio::error& error, size_t size)
+    {
+      handler_(error, size);
+      delete this;
+    }
+  };  // 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, boost::asio::io_service& io_service)
+      : base_handler<Stream>(io_service)
+      , handler_(handler)
+    {
+      set_func(boost::bind(
+        &handshake_handler<Stream, Handler>::handler_impl, 
+        this, boost::arg<1>(), boost::arg<2>() ));
+    }
+
+  private:
+    Handler handler_;
+    void handler_impl(const boost::asio::error& error, size_t)
+    {
+      handler_(error);
+      delete this;
+    }
+
+  };  // class handshake_handler
+
+  // Handler for asyncrhonous shutdown
+  template <typename Stream, typename Handler>
+  class shutdown_handler
+    : public base_handler<Stream>
+  {
+  public:
+    shutdown_handler(Handler handler, boost::asio::io_service& io_service)
+      : base_handler<Stream>(io_service),
+        handler_(handler)
+    { 
+      set_func(boost::bind(
+        &shutdown_handler<Stream, Handler>::handler_impl, 
+        this, boost::arg<1>(), boost::arg<2>() ));
+    }
+
+  private:
+    Handler handler_;
+    void handler_impl(const boost::asio::error& error, size_t)
+    {
+      handler_(error);
+      delete this;
+    }
+  };  // class shutdown_handler
+
+public:
+  // The implementation type.
+  typedef struct impl_struct
+  {
+    ::SSL* ssl;
+    ::BIO* ext_bio;
+  } * impl_type;
+
+  // Construct a new stream socket service for the specified io_service.
+  explicit openssl_stream_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(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);
+    ::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, typename Error_Handler>
+  void handshake(impl_type& impl, Stream& next_layer,
+      stream_base::handshake_type type, Error_Handler error_handler)
+  {
+    openssl_operation<Stream> op(
+      type == stream_base::client ?
+        &ssl_wrap<mutex_type>::SSL_connect:
+        &ssl_wrap<mutex_type>::SSL_accept,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio);
+    op.start();
+  }
+
+  // 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, owner());
+
+    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->ssl,
+      impl->ext_bio,
+      boost::bind
+      (
+        &base_handler<Stream>::do_func, 
+        local_handler,
+        boost::arg<1>(),
+        boost::arg<2>()
+      )
+    );
+    local_handler->set_operation(op);
+
+    owner().post(boost::bind(&openssl_operation<Stream>::start, op));
+  }
+
+  // Shut down SSL on the stream.
+  template <typename Stream, typename Error_Handler>
+  void shutdown(impl_type& impl, Stream& next_layer,
+      Error_Handler error_handler)
+  {
+    openssl_operation<Stream> op(
+      &ssl_wrap<mutex_type>::SSL_shutdown,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio);
+    op.start();
+  }
+
+  // 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, owner());
+
+    openssl_operation<Stream>* op = new openssl_operation<Stream>
+    (
+      &ssl_wrap<mutex_type>::SSL_shutdown,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio,
+      boost::bind
+      (
+        &base_handler<Stream>::do_func, 
+        local_handler, 
+        boost::arg<1>(),
+        boost::arg<2>()
+      )
+    );
+    local_handler->set_operation(op);
+
+    owner().post(boost::bind(&openssl_operation<Stream>::start, op));        
+  }
+
+  // Write some data to the stream.
+  template <typename Stream, typename Const_Buffers, typename Error_Handler>
+  std::size_t write_some(impl_type& impl, Stream& next_layer,
+      const Const_Buffers& buffers, Error_Handler error_handler)
+  {
+    boost::function<int (SSL*)> send_func =
+      boost::bind(&::SSL_write, boost::arg<1>(),  
+          boost::asio::buffer_cast<const void*>(*buffers.begin()),
+          static_cast<int>(boost::asio::buffer_size(*buffers.begin())));
+    openssl_operation<Stream> op(
+      send_func,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio
+    );
+    return static_cast<size_t>(op.start());
+  }
+
+  // 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;
+
+    send_handler* local_handler = new send_handler(handler, owner());
+
+    boost::function<int (SSL*)> send_func =
+      boost::bind(&::SSL_write, boost::arg<1>(),
+          boost::asio::buffer_cast<const void*>(*buffers.begin()),
+          static_cast<int>(boost::asio::buffer_size(*buffers.begin())));
+
+    openssl_operation<Stream>* op = new openssl_operation<Stream>
+    (
+      send_func,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio,
+      boost::bind
+      (
+        &base_handler<Stream>::do_func, 
+        local_handler, 
+        boost::arg<1>(),
+        boost::arg<2>()
+      )
+    );
+    local_handler->set_operation(op);
+
+    owner().post(boost::bind(&openssl_operation<Stream>::start, op));        
+  }
+
+  // Read some data from the stream.
+  template <typename Stream, typename Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(impl_type& impl, Stream& next_layer,
+      const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    boost::function<int (SSL*)> recv_func =
+      boost::bind(&::SSL_read, boost::arg<1>(),
+          boost::asio::buffer_cast<void*>(*buffers.begin()),
+          boost::asio::buffer_size(*buffers.begin()));
+    openssl_operation<Stream> op(recv_func,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio
+    );
+
+    return static_cast<size_t>(op.start());
+  }
+
+  // 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;
+
+    recv_handler* local_handler = new recv_handler(handler, owner());
+
+    boost::function<int (SSL*)> recv_func =
+      boost::bind(&::SSL_read, boost::arg<1>(),
+          boost::asio::buffer_cast<void*>(*buffers.begin()),
+          boost::asio::buffer_size(*buffers.begin()));
+
+    openssl_operation<Stream>* op = new openssl_operation<Stream>
+    (
+      recv_func,
+      next_layer,
+      impl->ssl,
+      impl->ext_bio,
+      boost::bind
+      (
+        &base_handler<Stream>::do_func, 
+        local_handler, 
+        boost::arg<1>(),
+        boost::arg<2>()
+      )
+    );
+    local_handler->set_operation(op);
+
+    owner().post(boost::bind(&openssl_operation<Stream>::start, op));        
+  }
+
+  // Peek at the incoming data on the stream.
+  template <typename Stream, typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(impl_type& impl, Stream& next_layer,
+      const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return 0;
+  }
+
+  // Determine the amount of data that may be read without blocking.
+  template <typename Stream, typename Error_Handler>
+  std::size_t in_avail(impl_type& impl, Stream& next_layer,
+      Error_Handler error_handler)
+  {
+    return 0;
+  }
+private:  
+  typedef boost::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 ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_DETAIL_OPENSSL_STREAM_SERVICE_HPP
diff --git a/include/boost/asio/ssl/detail/openssl_types.hpp b/include/boost/asio/ssl/detail/openssl_types.hpp
new file mode 100644
index 0000000000..c96ee2efaf
--- /dev/null
+++ b/include/boost/asio/ssl/detail/openssl_types.hpp
@@ -0,0 +1,26 @@
+//
+// openssl_types.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
+#define BOOST_ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <openssl/ssl.h>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
diff --git a/include/boost/asio/ssl/stream.hpp b/include/boost/asio/ssl/stream.hpp
new file mode 100644
index 0000000000..3ccb2fe30a
--- /dev/null
+++ b/include/boost/asio/ssl/stream.hpp
@@ -0,0 +1,511 @@
+//
+// stream.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_STREAM_HPP
+#define BOOST_ASIO_SSL_STREAM_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/error_handler.hpp>
+#include <boost/asio/ssl/basic_context.hpp>
+#include <boost/asio/ssl/stream_base.hpp>
+#include <boost/asio/ssl/stream_service.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// 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 a stream_socket, you would write:
+ * @code
+ * boost::asio::io_service io_service;
+ * boost::asio::ssl::context context(io_service, boost::asio::ssl::context::sslv23);
+ * boost::asio::ssl::stream<boost::asio::stream_socket> sock(io_service, context);
+ * @endcode
+ *
+ * @par Concepts:
+ * Async_Object, Async_Read_Stream, Async_Write_Stream, Error_Source, Stream,
+ * Sync_Read_Stream, Sync_Write_Stream.
+ */
+template <typename Stream, typename Service = stream_service>
+class stream
+  : public stream_base,
+    private boost::noncopyable
+{
+public:
+  /// The type of the next layer.
+  typedef typename boost::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 used for reporting errors.
+  typedef typename next_layer_type::error_type error_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_(boost::asio::use_service<Service>(next_layer_.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.
+   */
+  boost::asio::io_service& io_service()
+  {
+    return next_layer_.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 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 boost::asio::error Thrown on failure.
+   */
+  void handshake(handshake_type type)
+  {
+    service_.handshake(impl_, next_layer_, type, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void handshake(handshake_type type, Error_Handler error_handler)
+  {
+    service_.handshake(impl_, next_layer_, type, error_handler);
+  }
+
+  /// 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 boost::asio::error& error,     // Result of operation
+   * ); @endcode
+   */
+  template <typename Handler>
+  void async_handshake(handshake_type type, Handler 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 boost::asio::error Thrown on failure.
+   */
+  void shutdown()
+  {
+    service_.shutdown(impl_, next_layer_, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   */
+  template <typename Error_Handler>
+  void shutdown(Error_Handler error_handler)
+  {
+    service_.shutdown(impl_, next_layer_, error_handler);
+  }
+
+  /// 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 boost::asio::error& error,     // Result of operation
+   * ); @endcode
+   */
+  template <typename Handler>
+  void async_shutdown(Handler 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 boost::asio::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 Const_Buffers>
+  std::size_t write_some(const Const_Buffers& buffers)
+  {
+    return service_.write_some(impl_, next_layer_, buffers, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes written. Returns 0 if an error occurred and
+   * the error handler did not throw an exception.
+   *
+   * @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 Const_Buffers, typename Error_Handler>
+  std::size_t write_some(const Const_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return service_.write_some(impl_, next_layer_, buffers, error_handler);
+  }
+
+  /// 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 boost::asio::error& 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 Const_Buffers, typename Handler>
+  void async_write_some(const Const_Buffers& buffers, Handler 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 boost::asio::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 Mutable_Buffers>
+  std::size_t read_some(const Mutable_Buffers& buffers)
+  {
+    return service_.read_some(impl_, next_layer_, buffers, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred and the
+   * error handler did not throw an exception.
+   *
+   * @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 Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(const Mutable_Buffers& buffers,
+      Error_Handler error_handler)
+  {
+    return service_.read_some(impl_, next_layer_, buffers, error_handler);
+  }
+
+  /// 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 boost::asio::error& 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 Mutable_Buffers, typename Handler>
+  void async_read_some(const Mutable_Buffers& buffers, Handler 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 boost::asio::error Thrown on failure.
+   */
+  template <typename Mutable_Buffers>
+  std::size_t peek(const Mutable_Buffers& buffers)
+  {
+    return service_.peek(impl_, next_layer_, buffers, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation.
+   * ); @endcode
+   *
+   * @returns The number of bytes read. Returns 0 if an error occurred and the
+   * error handler did not throw an exception.
+   */
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return service_.peek(impl_, next_layer_, buffers, error_handler);
+  }
+
+  /// 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 boost::asio::error Thrown on failure.
+   */
+  std::size_t in_avail()
+  {
+    return service_.in_avail(impl_, next_layer_, throw_error());
+  }
+
+  /// 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 error_handler A handler to be called when the operation completes,
+   * to indicate whether or not an error has occurred. Copies will be made of
+   * the handler as required. The function signature of the handler must be:
+   * @code void error_handler(
+   *   const boost::asio::error& error // Result of operation
+   * ); @endcode
+   *
+   * @returns The number of bytes of data that can be read without blocking.
+   */
+  template <typename Error_Handler>
+  std::size_t in_avail(Error_Handler error_handler)
+  {
+    return service_.in_avail(impl_, next_layer_, error_handler);
+  }
+
+private:
+  /// The next layer.
+  Stream next_layer_;
+
+  /// The backend service implementation.
+  service_type& service_;
+
+  /// The underlying native implementation.
+  impl_type impl_;
+};
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_STREAM_HPP
diff --git a/include/boost/asio/ssl/stream_base.hpp b/include/boost/asio/ssl/stream_base.hpp
new file mode 100644
index 0000000000..b1b79e2f6d
--- /dev/null
+++ b/include/boost/asio/ssl/stream_base.hpp
@@ -0,0 +1,62 @@
+//
+// stream_base.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_STREAM_BASE_HPP
+#define BOOST_ASIO_SSL_STREAM_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// The stream_base class is used as a base for the boost::asio::ssl::stream
+/// class template so that we have a common place to define various enums.
+class stream_base
+{
+public:
+  /// Different handshake types.
+  enum handshake_type
+  {
+    /// Perform handshaking as a client.
+    client,
+
+    /// Perform handshaking as a server.
+    server
+  };
+
+protected:
+  /// Protected destructor to prevent deletion through this type.
+  ~stream_base()
+  {
+  }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+private:
+  // Workaround to enable the empty base optimisation with Borland C++.
+  char dummy_;
+#endif
+};
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_STREAM_BASE_HPP
diff --git a/include/boost/asio/ssl/stream_service.hpp b/include/boost/asio/ssl/stream_service.hpp
new file mode 100644
index 0000000000..def8554dee
--- /dev/null
+++ b/include/boost/asio/ssl/stream_service.hpp
@@ -0,0 +1,175 @@
+//
+// stream_service.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SSL_STREAM_SERVICE_HPP
+#define BOOST_ASIO_SSL_STREAM_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ssl/basic_context.hpp>
+#include <boost/asio/ssl/stream_base.hpp>
+#include <boost/asio/ssl/detail/openssl_stream_service.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+/// Default service implementation for an SSL stream.
+class stream_service
+  : public boost::asio::io_service::service
+{
+private:
+  // The type of the platform-specific implementation.
+  typedef detail::openssl_stream_service service_impl_type;
+
+public:
+  /// 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(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(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 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, typename Error_Handler>
+  void handshake(impl_type& impl, Stream& next_layer,
+      stream_base::handshake_type type, Error_Handler error_handler)
+  {
+    service_impl_.handshake(impl, next_layer, type, error_handler);
+  }
+
+  /// 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)
+  {
+    service_impl_.async_handshake(impl, next_layer, type, handler);
+  }
+
+  /// Shut down SSL on the stream.
+  template <typename Stream, typename Error_Handler>
+  void shutdown(impl_type& impl, Stream& next_layer,
+      Error_Handler error_handler)
+  {
+    service_impl_.shutdown(impl, next_layer, error_handler);
+  }
+
+  /// Asynchronously shut down SSL on the stream.
+  template <typename Stream, typename Handler>
+  void async_shutdown(impl_type& impl, Stream& next_layer, Handler handler)
+  {
+    service_impl_.async_shutdown(impl, next_layer, handler);
+  }
+
+  /// Write some data to the stream.
+  template <typename Stream, typename Const_Buffers, typename Error_Handler>
+  std::size_t write_some(impl_type& impl, Stream& next_layer,
+      const Const_Buffers& buffers, Error_Handler error_handler)
+  {
+    return service_impl_.write_some(impl, next_layer, buffers, error_handler);
+  }
+
+  /// 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)
+  {
+    service_impl_.async_write_some(impl, next_layer, buffers, handler);
+  }
+
+  /// Read some data from the stream.
+  template <typename Stream, typename Mutable_Buffers, typename Error_Handler>
+  std::size_t read_some(impl_type& impl, Stream& next_layer,
+      const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return service_impl_.read_some(impl, next_layer, buffers, error_handler);
+  }
+
+  /// 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)
+  {
+    service_impl_.async_read_some(impl, next_layer, buffers, handler);
+  }
+
+  /// Peek at the incoming data on the stream.
+  template <typename Stream, typename Mutable_Buffers, typename Error_Handler>
+  std::size_t peek(impl_type& impl, Stream& next_layer,
+      const Mutable_Buffers& buffers, Error_Handler error_handler)
+  {
+    return service_impl_.peek(impl, next_layer, buffers, error_handler);
+  }
+
+  /// Determine the amount of data that may be read without blocking.
+  template <typename Stream, typename Error_Handler>
+  std::size_t in_avail(impl_type& impl, Stream& next_layer,
+      Error_Handler error_handler)
+  {
+    return service_impl_.in_avail(impl, next_layer, error_handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_STREAM_SERVICE_HPP
diff --git a/include/boost/asio/strand.hpp b/include/boost/asio/strand.hpp
new file mode 100644
index 0000000000..383110a1d4
--- /dev/null
+++ b/include/boost/asio/strand.hpp
@@ -0,0 +1,33 @@
+//
+// strand.hpp
+// ~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_STRAND_HPP
+#define BOOST_ASIO_STRAND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_strand.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of strand.
+typedef basic_strand<> strand;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_STRAND_HPP
diff --git a/include/boost/asio/strand_service.hpp b/include/boost/asio/strand_service.hpp
new file mode 100644
index 0000000000..4bfe056ec4
--- /dev/null
+++ b/include/boost/asio/strand_service.hpp
@@ -0,0 +1,90 @@
+//
+// strand_service.hpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_STRAND_SERVICE_HPP
+#define BOOST_ASIO_STRAND_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/strand_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a strand.
+class strand_service
+  : public boost::asio::io_service::service
+{
+private:
+  // The type of the platform-specific implementation.
+  typedef detail::strand_service service_impl_type;
+
+public:
+  /// The implementation type of the strand.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// Construct a new timer service for the specified io_service.
+  explicit strand_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new timer implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a timer implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Request the io_service to invoke the given handler.
+  template <typename Handler>
+  void dispatch(implementation_type& impl, Handler handler)
+  {
+    service_impl_.dispatch(impl, handler);
+  }
+
+  /// Request the io_service to invoke the given handler and return immediately.
+  template <typename Handler>
+  void post(implementation_type& impl, Handler handler)
+  {
+    service_impl_.post(impl, handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_STRAND_SERVICE_HPP
diff --git a/include/boost/asio/stream_socket_service.hpp b/include/boost/asio/stream_socket_service.hpp
new file mode 100644
index 0000000000..592de1c73b
--- /dev/null
+++ b/include/boost/asio/stream_socket_service.hpp
@@ -0,0 +1,251 @@
+//
+// stream_socket_service.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/kqueue_reactor.hpp>
+#include <boost/asio/detail/select_reactor.hpp>
+#include <boost/asio/detail/win_iocp_socket_service.hpp>
+#include <boost/asio/detail/reactive_socket_service.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default service implementation for a stream socket.
+template <typename Protocol>
+class stream_socket_service
+  : public boost::asio::io_service::service
+{
+public:
+  /// The protocol type.
+  typedef Protocol protocol_type;
+
+  /// The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+private:
+  // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_HAS_IOCP)
+  typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_EPOLL)
+  typedef detail::reactive_socket_service<
+      Protocol, detail::epoll_reactor<false> > service_impl_type;
+#elif defined(BOOST_ASIO_HAS_KQUEUE)
+  typedef detail::reactive_socket_service<
+      Protocol, detail::kqueue_reactor<false> > service_impl_type;
+#else
+  typedef detail::reactive_socket_service<
+      Protocol, detail::select_reactor<false> > service_impl_type;
+#endif
+
+public:
+  /// The type of a stream socket implementation.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined implementation_type;
+#else
+  typedef typename service_impl_type::implementation_type implementation_type;
+#endif
+
+  /// The native socket type.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined native_type;
+#else
+  typedef typename service_impl_type::native_type native_type;
+#endif
+
+  /// Construct a new stream socket service for the specified io_service.
+  explicit stream_socket_service(boost::asio::io_service& io_service)
+    : boost::asio::io_service::service(io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  {
+  }
+
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  /// Construct a new stream socket implementation.
+  void construct(implementation_type& impl)
+  {
+    service_impl_.construct(impl);
+  }
+
+  /// Destroy a stream socket implementation.
+  void destroy(implementation_type& impl)
+  {
+    service_impl_.destroy(impl);
+  }
+
+  /// Open a stream socket.
+  template <typename Error_Handler>
+  void open(implementation_type& impl, const protocol_type& protocol,
+      Error_Handler error_handler)
+  {
+    if (protocol.type() == SOCK_STREAM)
+      service_impl_.open(impl, protocol, error_handler);
+    else
+      error_handler(boost::asio::error(boost::asio::error::invalid_argument));
+  }
+
+  /// Assign an existing native socket to a stream socket.
+  template <typename Error_Handler>
+  void assign(implementation_type& impl, const protocol_type& protocol,
+      const native_type& native_socket, Error_Handler error_handler)
+  {
+    service_impl_.assign(impl, protocol, native_socket, error_handler);
+  }
+
+  /// Close a stream socket implementation.
+  template <typename Error_Handler>
+  void close(implementation_type& impl, Error_Handler error_handler)
+  {
+    service_impl_.close(impl, error_handler);
+  }
+
+  /// Get the native socket implementation.
+  native_type native(implementation_type& impl)
+  {
+    return service_impl_.native(impl);
+  }
+
+  /// Bind the stream socket to the specified local endpoint.
+  template <typename Error_Handler>
+  void bind(implementation_type& impl, const endpoint_type& endpoint,
+      Error_Handler error_handler)
+  {
+    service_impl_.bind(impl, endpoint, error_handler);
+  }
+
+  /// Connect the stream socket to the specified endpoint.
+  template <typename Error_Handler>
+  void connect(implementation_type& impl, const endpoint_type& peer_endpoint,
+      Error_Handler error_handler)
+  {
+    service_impl_.connect(impl, peer_endpoint, error_handler);
+  }
+
+  /// Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, Handler handler)
+  {
+    service_impl_.async_connect(impl, peer_endpoint, handler);
+  }
+
+  /// Set a socket option.
+  template <typename Option, typename Error_Handler>
+  void set_option(implementation_type& impl, const Option& option,
+      Error_Handler error_handler)
+  {
+    service_impl_.set_option(impl, option, error_handler);
+  }
+
+  /// Get a socket option.
+  template <typename Option, typename Error_Handler>
+  void get_option(const implementation_type& impl, Option& option,
+      Error_Handler error_handler) const
+  {
+    service_impl_.get_option(impl, option, error_handler);
+  }
+
+  /// Perform an IO control command on the socket.
+  template <typename IO_Control_Command, typename Error_Handler>
+  void io_control(implementation_type& impl, IO_Control_Command& command,
+      Error_Handler error_handler)
+  {
+    service_impl_.io_control(impl, command, error_handler);
+  }
+
+  /// Get the local endpoint.
+  template <typename Error_Handler>
+  endpoint_type local_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    endpoint_type endpoint;
+    service_impl_.get_local_endpoint(impl, endpoint, error_handler);
+    return endpoint;
+  }
+
+  /// Get the remote endpoint.
+  template <typename Error_Handler>
+  endpoint_type remote_endpoint(const implementation_type& impl,
+      Error_Handler error_handler) const
+  {
+    endpoint_type endpoint;
+    service_impl_.get_remote_endpoint(impl, endpoint, error_handler);
+    return endpoint;
+  }
+
+  /// Disable sends or receives on the socket.
+  template <typename Error_Handler>
+  void shutdown(implementation_type& impl, socket_base::shutdown_type what,
+      Error_Handler error_handler)
+  {
+    service_impl_.shutdown(impl, what, error_handler);
+  }
+
+  /// Send the given data to the peer.
+  template <typename Const_Buffers, typename Error_Handler>
+  std::size_t send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return service_impl_.send(impl, buffers, flags, error_handler);
+  }
+
+  /// Start an asynchronous send.
+  template <typename Const_Buffers, typename Handler>
+  void async_send(implementation_type& impl, const Const_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    service_impl_.async_send(impl, buffers, flags, handler);
+  }
+
+  /// Receive some data from the peer.
+  template <typename Mutable_Buffers, typename Error_Handler>
+  std::size_t receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Error_Handler error_handler)
+  {
+    return service_impl_.receive(impl, buffers, flags, error_handler);
+  }
+
+  /// Start an asynchronous receive.
+  template <typename Mutable_Buffers, typename Handler>
+  void async_receive(implementation_type& impl, const Mutable_Buffers& buffers,
+      socket_base::message_flags flags, Handler handler)
+  {
+    service_impl_.async_receive(impl, buffers, flags, handler);
+  }
+
+private:
+  // The service that provides the platform-specific implementation.
+  service_impl_type& service_impl_;
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
diff --git a/include/boost/asio/streambuf.hpp b/include/boost/asio/streambuf.hpp
new file mode 100644
index 0000000000..b9a2f8788b
--- /dev/null
+++ b/include/boost/asio/streambuf.hpp
@@ -0,0 +1,33 @@
+//
+// streambuf.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_STREAMBUF_HPP
+#define BOOST_ASIO_STREAMBUF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/basic_streambuf.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Typedef for the typical usage of basic_streambuf.
+typedef basic_streambuf<> streambuf;
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_STREAMBUF_HPP
diff --git a/include/boost/asio/system_exception.hpp b/include/boost/asio/system_exception.hpp
new file mode 100644
index 0000000000..a0d9e26278
--- /dev/null
+++ b/include/boost/asio/system_exception.hpp
@@ -0,0 +1,199 @@
+//
+// error.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_SYSTEM_EXCEPTION_HPP
+#define BOOST_ASIO_SYSTEM_EXCEPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/config.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <cerrno>
+#include <cstring>
+#include <exception>
+#include <string>
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# include <iostream>
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/win_local_free_on_block_exit.hpp>
+
+namespace boost {
+namespace asio {
+
+/// The system_exception class is used to represent system conditions that
+/// prevent the library from operating correctly.
+class system_exception
+  : public std::exception
+{
+public:
+  /// Construct with a specific context and error code.
+  system_exception(const std::string& context, int code)
+    : context_(context),
+      code_(code)
+  {
+  }
+
+  /// Copy constructor.
+  system_exception(const system_exception& e)
+    : std::exception(e),
+      context_(e.context_),
+      code_(e.code_)
+  {
+  }
+
+  /// Destructor.
+  virtual ~system_exception() throw ()
+  {
+  }
+
+  /// Assignment operator.
+  system_exception& operator=(const system_exception& e)
+  {
+    context_ = e.context_;
+    code_ = e.code_;
+    what_.reset();
+    return *this;
+  }
+
+  /// Get a string representation of the exception.
+  virtual const char* what() const throw ()
+  {
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+    try
+    {
+      if (!what_)
+      {
+        char* msg = 0;
+        DWORD length = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
+            | FORMAT_MESSAGE_FROM_SYSTEM
+            | FORMAT_MESSAGE_IGNORE_INSERTS, 0, code_,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, 0);
+        detail::win_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)
+        {
+          std::string tmp(context_);
+          tmp += ": ";
+          tmp += msg;
+          what_.reset(new std::string(tmp));
+        }
+        else
+        {
+          return "asio system_exception";
+        }
+      }
+      return what_->c_str();
+    }
+    catch (std::exception&)
+    {
+      return "asio system_exception";
+    }
+#elif defined(__sun) || defined(__QNX__)
+    return strerror(code_);
+#elif defined(__MACH__) && defined(__APPLE__)
+    try
+    {
+      char buf[256] = "";
+      strerror_r(code_, buf, sizeof(buf));
+      std::string tmp(context_);
+      tmp += ": ";
+      tmp += buf;
+      what_.reset(new std::string(tmp));
+      return what_->c_str();
+    }
+    catch (std::exception&)
+    {
+      return "asio system_exception";
+    }
+#else
+    try
+    {
+      char buf[256] = "";
+      std::string tmp(context_);
+      tmp += ": ";
+      tmp += strerror_r(code_, buf, sizeof(buf));
+      what_.reset(new std::string(tmp));
+      return what_->c_str();
+    }
+    catch (std::exception&)
+    {
+      return "asio system_exception";
+    }
+#endif
+  }
+
+  /// Get the implementation-defined context associated with the exception.
+  const std::string& context() const
+  {
+    return context_;
+  }
+
+  /// Get the implementation-defined code associated with the exception.
+  int code() const
+  {
+    return code_;
+  }
+
+private:
+  // The context associated with the error.
+  std::string context_;
+
+  // The code associated with the error.
+  int code_;
+
+  // The string representation of the error.
+  mutable boost::scoped_ptr<std::string> what_;
+};
+
+/// Output the string associated with a system exception.
+/**
+ * Used to output a human-readable string that is associated with a system
+ * exception.
+ *
+ * @param os The output stream to which the string will be written.
+ *
+ * @param e The exception to be written.
+ *
+ * @return The output stream.
+ *
+ * @relates boost::asio::system_exception
+ */
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+std::ostream& operator<<(std::ostream& os, const system_exception& e)
+{
+  os << e.what();
+  return os;
+}
+#else // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template <typename Ostream>
+Ostream& operator<<(Ostream& os, const system_exception& e)
+{
+  os << e.what();
+  return os;
+}
+#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SYSTEM_EXCEPTION_HPP
diff --git a/include/boost/asio/time_traits.hpp b/include/boost/asio/time_traits.hpp
new file mode 100644
index 0000000000..d139e0d7f8
--- /dev/null
+++ b/include/boost/asio/time_traits.hpp
@@ -0,0 +1,79 @@
+//
+// time_traits.hpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_TIME_TRAITS_HPP
+#define BOOST_ASIO_TIME_TRAITS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/socket_types.hpp> // Must come before posix_time.
+
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Time traits suitable for use with the deadline timer.
+template <typename Time>
+struct time_traits;
+
+/// Time traits specialised for posix_time.
+template <>
+struct time_traits<boost::posix_time::ptime>
+{
+  /// The time type.
+  typedef boost::posix_time::ptime time_type;
+
+  /// The duration type.
+  typedef boost::posix_time::time_duration duration_type;
+
+  /// Get the current time.
+  static time_type now()
+  {
+    return boost::posix_time::microsec_clock::universal_time();
+  }
+
+  /// Add a duration to a time.
+  static time_type add(const time_type& t, const duration_type& d)
+  {
+    return t + d;
+  }
+
+  /// Subtract one time from another.
+  static duration_type subtract(const time_type& t1, const time_type& t2)
+  {
+    return t1 - t2;
+  }
+
+  /// Convert to UTC in the posix time type.
+  static boost::posix_time::ptime to_utc(const time_type& t)
+  {
+    return t;
+  }
+
+  /// Convert from UTC in the posix time type.
+  static time_type from_utc(const boost::posix_time::ptime& t)
+  {
+    return t;
+  }
+};
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_TIME_TRAITS_HPP
diff --git a/include/boost/asio/write.hpp b/include/boost/asio/write.hpp
new file mode 100644
index 0000000000..4a5d431375
--- /dev/null
+++ b/include/boost/asio/write.hpp
@@ -0,0 +1,319 @@
+//
+// write.hpp
+// ~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_WRITE_HPP
+#define BOOST_ASIO_WRITE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/push_options.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+#include <cstddef>
+#include <boost/config.hpp>
+#include <boost/asio/detail/pop_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/**
+ * @defgroup write boost::asio::write
+ */
+/*@{*/
+
+/// Write all of the supplied data to a stream before returning.
+/**
+ * This function is used to write a certain number of bytes of data to a stream.
+ * The call will block until one of the following conditions is true:
+ *
+ * @li All of the data in the supplied buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of one 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 Sync_Write_Stream concept.
+ *
+ * @param buffers One or more buffers containing the data to be written. The sum
+ * of the buffer sizes indicates the maximum number of bytes to write to the
+ * stream.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws Sync_Write_Stream::error_type Thrown on failure.
+ *
+ * @par Example:
+ * To write a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::write(s, boost::asio::buffer(data, size)); @endcode
+ * See the @ref buffer documentation for information on writing multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::write(
+ *     s, buffers,
+ *     boost::asio::transfer_all(),
+ *     boost::asio::throw_error()); @endcode
+ */
+template <typename Sync_Write_Stream, typename Const_Buffers>
+std::size_t write(Sync_Write_Stream& s, const Const_Buffers& buffers);
+
+/// 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 buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li The completion_condition function object returns true.
+ *
+ * This operation is implemented in terms of one 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 Sync_Write_Stream concept.
+ *
+ * @param buffers One or more buffers containing the data to be written. The sum
+ * of the buffer sizes indicates the maximum number of bytes to write to the
+ * stream.
+ *
+ * @param 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 bool completion_condition(
+ *   const Sync_Write_Stream::error_type& error, // Result of latest write_some
+ *                                               // operation.
+ *
+ *   std::size_t bytes_transferred               // Number of bytes transferred
+ *                                               // so far.
+ * ); @endcode
+ * A return value of true indicates that the write operation is complete. False
+ * indicates that further calls to the stream's write_some function are
+ * required.
+ *
+ * @returns The number of bytes transferred.
+ *
+ * @throws Sync_Write_Stream::error_type Thrown on failure.
+ *
+ * @par Example:
+ * To write a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::write(s, boost::asio::buffer(data, size),
+ *     boost::asio::transfer_at_least(32)); @endcode
+ * See the @ref buffer documentation for information on writing multiple
+ * buffers in one go, and how to use it with arrays, boost::array or
+ * std::vector.
+ *
+ * @note This overload is equivalent to calling:
+ * @code boost::asio::write(
+ *     s, buffers,
+ *     completion_condition,
+ *     boost::asio::throw_error()); @endcode
+ */
+template <typename Sync_Write_Stream, typename Const_Buffers,
+    typename Completion_Condition>
+std::size_t write(Sync_Write_Stream& s, const Const_Buffers& buffers,
+    Completion_Condition completion_condition);
+
+/// 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 buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li The completion_condition function object returns true.
+ *
+ * This operation is implemented in terms of one 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 Sync_Write_Stream concept.
+ *
+ * @param buffers One or more buffers containing the data to be written. The sum
+ * of the buffer sizes indicates the maximum number of bytes to write to the
+ * stream.
+ *
+ * @param 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 bool completion_condition(
+ *   const Sync_Write_Stream::error_type& error, // Result of latest write_some
+ *                                               // operation.
+ *
+ *   std::size_t bytes_transferred               // Number of bytes transferred
+ *                                               // so far.
+ * ); @endcode
+ * A return value of true indicates that the write operation is complete. False
+ * indicates that further calls to the stream's write_some function are
+ * required.
+ *
+ * @param error_handler A handler to be called when the operation completes,
+ * to indicate whether or not an error has occurred. Copies will be made of
+ * the handler as required. The function signature of the handler must be:
+ * @code void error_handler(
+ *   const Sync_Write_Stream::error_type& error // Result of operation.
+ * ); @endcode
+ *
+ * @returns The number of bytes written. If an error occurs, and the error
+ * handler does not throw an exception, returns the total number of bytes
+ * successfully transferred prior to the error.
+ */
+template <typename Sync_Write_Stream, typename Const_Buffers,
+    typename Completion_Condition, typename Error_Handler>
+std::size_t write(Sync_Write_Stream& s, const Const_Buffers& buffers,
+    Completion_Condition completion_condition, Error_Handler error_handler);
+
+/*@}*/
+/**
+ * @defgroup async_write boost::asio::async_write
+ */
+/*@{*/
+
+/// Start an asynchronous operation to write of 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 buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li An error occurred.
+ *
+ * This operation is implemented in terms of one or more calls to the stream's
+ * async_write_some function.
+ *
+ * @param s The stream to which the data is to be written. The type must support
+ * the Async_Write_Stream concept.
+ *
+ * @param buffers One or more buffers containing the data to 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.
+ *
+ * @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 Async_Write_Stream::error_type& 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
+ * boost::asio::io_service::post().
+ *
+ * @par Example:
+ * To write a single data buffer use the @ref buffer function as follows:
+ * @code
+ * boost::asio::async_write(s, boost::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 Async_Write_Stream, typename Const_Buffers, typename Handler>
+void async_write(Async_Write_Stream& s, const Const_Buffers& buffers,
+    Handler handler);
+
+/// 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 buffers has been written. That is, the
+ * bytes transferred is equal to the sum of the buffer sizes.
+ *
+ * @li The completion_condition function object returns true.
+ *
+ * This operation is implemented in terms of one or more calls to the stream's
+ * async_write_some function.
+ *
+ * @param s The stream to which the data is to be written. The type must support
+ * the Async_Write_Stream concept.
+ *
+ * @param buffers One or more buffers containing the data to 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.
+ *
+ * @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 bool completion_condition(
+ *   const Async_Write_Stream::error_type& error, // Result of latest write_some
+ *                                                // operation.
+ *
+ *   std::size_t bytes_transferred                // Number of bytes transferred
+ *                                                // so far.
+ * ); @endcode
+ * A return value of true indicates that the write operation is complete. False
+ * indicates that further calls to the stream's async_write_some function are
+ * required.
+ *
+ * @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 Async_Write_Stream::error_type& 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
+ * boost::asio::io_service::post().
+ *
+ * @par Example:
+ * To write a single data buffer use the @ref buffer function as follows:
+ * @code boost::asio::async_write(s,
+ *     boost::asio::buffer(data, size),
+ *     boost::asio::transfer_at_least(32),
+ *     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 Async_Write_Stream, typename Const_Buffers,
+    typename Completion_Condition, typename Handler>
+void async_write(Async_Write_Stream& s, const Const_Buffers& buffers,
+    Completion_Condition completion_condition, Handler handler);
+
+/*@}*/
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/impl/write.ipp>
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_WRITE_HPP
diff --git a/index.html b/index.html
new file mode 100644
index 0000000000..d7ffef20e5
--- /dev/null
+++ b/index.html
@@ -0,0 +1,9 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/html/index.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="doc/html/index.html">doc/html/index.html</a>
+</body>
+</html>
diff --git a/test/Jamfile b/test/Jamfile
new file mode 100644
index 0000000000..ba1bbcb4fa
--- /dev/null
+++ b/test/Jamfile
@@ -0,0 +1,69 @@
+subproject libs/asio/test ;
+
+# bring in the rules for testing
+import testing ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+template unit_test
+  : <lib>@boost/libs/thread/build/boost_thread
+  : <include>../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+run basic_datagram_socket_test.cpp <template>unit_test ;
+run basic_deadline_timer_test.cpp <template>unit_test ;
+run basic_resolver_test.cpp <template>unit_test ;
+run basic_socket_acceptor_test.cpp <template>unit_test ;
+run basic_strand_test.cpp <template>unit_test ;
+run basic_stream_socket_test.cpp <template>unit_test ;
+run buffer_test.cpp <template>unit_test ;
+run buffered_read_stream_test.cpp <template>unit_test ;
+run buffered_stream_test.cpp <template>unit_test ;
+run buffered_write_stream_test.cpp <template>unit_test ;
+run completion_condition_test.cpp <template>unit_test ;
+run datagram_socket_service_test.cpp <template>unit_test ;
+run deadline_timer_service_test.cpp <template>unit_test ;
+run deadline_timer_test.cpp <template>unit_test ;
+run error_handler_test.cpp <template>unit_test ;
+run error_test.cpp <template>unit_test ;
+run io_service_test.cpp <template>unit_test ;
+run ip/address_test.cpp <template>unit_test ;
+run ip/address_v4_test.cpp <template>unit_test ;
+run ip/address_v6_test.cpp <template>unit_test ;
+run ip/basic_endpoint_test.cpp <template>unit_test ;
+run ip/basic_resolver_entry_test.cpp <template>unit_test ;
+run ip/basic_resolver_iterator_test.cpp <template>unit_test ;
+run ip/basic_resolver_query_test.cpp <template>unit_test ;
+run ip/host_name_test.cpp <template>unit_test ;
+run ip/multicast_test.cpp <template>unit_test ;
+run ip/resolver_query_base_test.cpp <template>unit_test ;
+run ip/tcp_test.cpp <template>unit_test ;
+run ip/udp_test.cpp <template>unit_test ;
+run is_read_buffered_test.cpp <template>unit_test ;
+run is_write_buffered_test.cpp <template>unit_test ;
+run placeholders_test.cpp <template>unit_test ;
+run read_test.cpp <template>unit_test ;
+run resolver_service_test.cpp <template>unit_test ;
+run socket_acceptor_service_test.cpp <template>unit_test ;
+run socket_base_test.cpp <template>unit_test ;
+run strand_service_test.cpp <template>unit_test ;
+run strand_test.cpp <template>unit_test ;
+run stream_socket_service_test.cpp <template>unit_test ;
+run time_traits_test.cpp <template>unit_test ;
+run write_test.cpp <template>unit_test ;
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
new file mode 100644
index 0000000000..5bca8fc62f
--- /dev/null
+++ b/test/Jamfile.v2
@@ -0,0 +1,116 @@
+import os ;
+import feature ;
+
+if [ os.name ] = SOLARIS
+{
+  lib socket ;
+  lib nsl ;
+}
+else if [ os.name ] = NT
+{
+  lib ws2_32 ;
+  lib mswsock ;
+}
+
+local USE_SELECT =
+  <define>BOOST_ASIO_DISABLE_EPOLL
+  <define>BOOST_ASIO_DISABLE_KQUEUE
+  <define>BOOST_ASIO_DISABLE_IOCP
+  ;
+
+project
+  : requirements
+    <library>/boost/date_time//boost_date_time
+    <library>/boost/thread//boost_thread
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <os>SOLARIS:<library>socket
+    <os>SOLARIS:<library>nsl
+    <os>NT<toolset>gcc:<library>ws2_32
+    <os>NT<toolset>gcc:<library>mswsock
+  ;
+
+test-suite "asio" :
+  [ compile basic_datagram_socket_test.cpp ]
+  [ compile basic_datagram_socket_test.cpp : $(USE_SELECT) : basic_datagram_socket_test_select ]
+  [ compile basic_deadline_timer_test.cpp ]
+  [ compile basic_deadline_timer_test.cpp : $(USE_SELECT) : basic_deadline_timer_test_select ]
+  [ compile basic_resolver_test.cpp ]
+  [ compile basic_resolver_test.cpp : $(USE_SELECT) : basic_resolver_test_select ]
+  [ compile basic_socket_acceptor_test.cpp ]
+  [ compile basic_socket_acceptor_test.cpp : $(USE_SELECT) : basic_socket_acceptor_test_select ]
+  [ compile basic_strand_test.cpp ]
+  [ compile basic_strand_test.cpp : $(USE_SELECT) : basic_strand_test_select ]
+  [ compile basic_stream_socket_test.cpp ]
+  [ compile basic_stream_socket_test.cpp : $(USE_SELECT) : basic_stream_socket_test_select ]
+  [ run buffer_test.cpp ]
+  [ run buffer_test.cpp : : : $(USE_SELECT) : buffer_test_select ]
+  [ run buffered_read_stream_test.cpp ]
+  [ run buffered_read_stream_test.cpp : : : $(USE_SELECT) : buffered_read_stream_test_select ]
+  [ run buffered_stream_test.cpp ]
+  [ run buffered_stream_test.cpp : : : $(USE_SELECT) : buffered_stream_test_select ]
+  [ run buffered_write_stream_test.cpp ]
+  [ run buffered_write_stream_test.cpp : : : $(USE_SELECT) : buffered_write_stream_test_select ]
+  [ compile completion_condition_test.cpp ]
+  [ compile completion_condition_test.cpp : $(USE_SELECT) : completion_condition_test_select ]
+  [ compile datagram_socket_service_test.cpp ]
+  [ compile datagram_socket_service_test.cpp : $(USE_SELECT) : datagram_socket_service_test_select ]
+  [ compile deadline_timer_service_test.cpp ]
+  [ compile deadline_timer_service_test.cpp : $(USE_SELECT) : deadline_timer_service_test_select ]
+  [ run deadline_timer_test.cpp ]
+  [ run deadline_timer_test.cpp : : : $(USE_SELECT) : deadline_timer_test_select ]
+  [ run error_handler_test.cpp ]
+  [ run error_handler_test.cpp : : : $(USE_SELECT) : error_handler_test_select ]
+  [ run error_test.cpp ]
+  [ run error_test.cpp : : : $(USE_SELECT) : error_test_select ]
+  [ run io_service_test.cpp ]
+  [ run io_service_test.cpp : : : $(USE_SELECT) : io_service_test_select ]
+  [ compile ip/address_test.cpp ]
+  [ compile ip/address_test.cpp : $(USE_SELECT) : ip/address_test_select ]
+  [ compile ip/address_v4_test.cpp ]
+  [ compile ip/address_v4_test.cpp : $(USE_SELECT) : ip/address_v4_test_select ]
+  [ compile ip/address_v6_test.cpp ]
+  [ compile ip/address_v6_test.cpp : $(USE_SELECT) : ip/address_v6_test_select ]
+  [ compile ip/basic_endpoint_test.cpp ]
+  [ compile ip/basic_endpoint_test.cpp : $(USE_SELECT) : ip/basic_endpoint_test_select ]
+  [ compile ip/basic_resolver_entry_test.cpp ]
+  [ compile ip/basic_resolver_entry_test.cpp : $(USE_SELECT) : ip/basic_resolver_entry_test_select ]
+  [ compile ip/basic_resolver_iterator_test.cpp ]
+  [ compile ip/basic_resolver_iterator_test.cpp : $(USE_SELECT) : ip/basic_resolver_iterator_test_select ]
+  [ compile ip/basic_resolver_query_test.cpp ]
+  [ compile ip/basic_resolver_query_test.cpp : $(USE_SELECT) : ip/basic_resolver_query_test_select ]
+  [ run ip/host_name_test.cpp ]
+  [ run ip/host_name_test.cpp : : : $(USE_SELECT) : ip/host_name_test_select ]
+  [ compile ip/multicast_test.cpp ]
+  [ compile ip/multicast_test.cpp : $(USE_SELECT) : ip/multicast_test_select ]
+  [ compile ip/resolver_query_base_test.cpp ]
+  [ compile ip/resolver_query_base_test.cpp : $(USE_SELECT) : ip/resolver_query_base_test_select ]
+  [ run ip/tcp_test.cpp ]
+  [ run ip/tcp_test.cpp : : : $(USE_SELECT) : ip/tcp_test_select ]
+  [ run ip/udp_test.cpp ]
+  [ run ip/udp_test.cpp : : : $(USE_SELECT) : ip/udp_test_select ]
+  [ run is_read_buffered_test.cpp ]
+  [ run is_read_buffered_test.cpp : : : $(USE_SELECT) : is_read_buffered_test_select ]
+  [ run is_write_buffered_test.cpp ]
+  [ run is_write_buffered_test.cpp : : : $(USE_SELECT) : is_write_buffered_test_select ]
+  [ compile placeholders_test.cpp ]
+  [ compile placeholders_test.cpp : $(USE_SELECT) : placeholders_test_select ]
+  [ run read_test.cpp ]
+  [ run read_test.cpp : : : $(USE_SELECT) : read_test_select ]
+  [ compile resolver_service_test.cpp ]
+  [ compile resolver_service_test.cpp : $(USE_SELECT) : resolver_service_test_select ]
+  [ compile socket_acceptor_service_test.cpp ]
+  [ compile socket_acceptor_service_test.cpp : $(USE_SELECT) : socket_acceptor_service_test_select ]
+  [ compile socket_base_test.cpp ]
+  [ compile socket_base_test.cpp : $(USE_SELECT) : socket_base_test_select ]
+  [ compile strand_service_test.cpp ]
+  [ compile strand_service_test.cpp : $(USE_SELECT) : strand_service_test_select ]
+  [ run strand_test.cpp ]
+  [ run strand_test.cpp : : : $(USE_SELECT) : strand_test_select ]
+  [ compile stream_socket_service_test.cpp ]
+  [ compile stream_socket_service_test.cpp : $(USE_SELECT) : stream_socket_service_test_select ]
+  [ compile time_traits_test.cpp ]
+  [ compile time_traits_test.cpp : $(USE_SELECT) : time_traits_test_select ]
+  [ run write_test.cpp ]
+  [ run write_test.cpp : : : $(USE_SELECT) : write_test_select ]
+  ;
diff --git a/test/basic_datagram_socket_test.cpp b/test/basic_datagram_socket_test.cpp
new file mode 100644
index 0000000000..3f863b4a3e
--- /dev/null
+++ b/test/basic_datagram_socket_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_datagram_socket_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/basic_datagram_socket.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("basic_datagram_socket");
+  return test;
+}
diff --git a/test/basic_deadline_timer_test.cpp b/test/basic_deadline_timer_test.cpp
new file mode 100644
index 0000000000..0d2d06864f
--- /dev/null
+++ b/test/basic_deadline_timer_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_deadline_timer_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/basic_deadline_timer.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("basic_deadline_timer");
+  return test;
+}
diff --git a/test/basic_resolver_test.cpp b/test/basic_resolver_test.cpp
new file mode 100644
index 0000000000..7b4ecff129
--- /dev/null
+++ b/test/basic_resolver_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_resolver_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/basic_resolver.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("basic_resolver");
+  return test;
+}
diff --git a/test/basic_socket_acceptor_test.cpp b/test/basic_socket_acceptor_test.cpp
new file mode 100644
index 0000000000..6f5637cd46
--- /dev/null
+++ b/test/basic_socket_acceptor_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_socket_acceptor_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/basic_socket_acceptor.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("basic_socket_acceptor");
+  return test;
+}
diff --git a/test/basic_strand_test.cpp b/test/basic_strand_test.cpp
new file mode 100644
index 0000000000..85b4e4c1e3
--- /dev/null
+++ b/test/basic_strand_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_strand.cpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/basic_strand.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("basic_strand");
+  return test;
+}
diff --git a/test/basic_stream_socket_test.cpp b/test/basic_stream_socket_test.cpp
new file mode 100644
index 0000000000..145a41cd90
--- /dev/null
+++ b/test/basic_stream_socket_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_stream_socket_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/basic_stream_socket.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("basic_stream_socket");
+  return test;
+}
diff --git a/test/buffer_test.cpp b/test/buffer_test.cpp
new file mode 100644
index 0000000000..dbd8eb69fa
--- /dev/null
+++ b/test/buffer_test.cpp
@@ -0,0 +1,147 @@
+//
+// buffer_test.cpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/buffer.hpp>
+
+#include "unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// buffer_compile test
+// ~~~~~~~~~~~~~~~~~~~
+// The following test checks that all overloads of the buffer function compile
+// and link correctly. Runtime failures are ignored.
+
+namespace buffer_compile {
+
+using namespace boost::asio;
+
+void test()
+{
+  try
+  {
+    char raw_data[1024];
+    const char const_raw_data[1024] = "";
+    void* void_ptr_data = raw_data;
+    const void* const_void_ptr_data = const_raw_data;
+    boost::array<char, 1024> array_data;
+    const boost::array<char, 1024>& const_array_data_1 = array_data;
+    boost::array<const char, 1024> const_array_data_2 = { 0 };
+    std::vector<char> vector_data(1024);
+    const std::vector<char>& const_vector_data = vector_data;
+    const std::string string_data(1024, ' ');
+
+    // mutable_buffer constructors.
+
+    mutable_buffer mb1;
+    mutable_buffer mb2(void_ptr_data, 1024);
+    mutable_buffer mb3(mb1);
+
+    // mutable_buffer functions.
+
+    void* ptr1 = buffer_cast<void*>(mb1);
+    (void)ptr1;
+    std::size_t size1 = buffer_size(mb1);
+    (void)size1;
+
+    // mutable_buffer operators.
+
+    mb1 = mb2 + 128;
+    mb1 = 128 + mb2;
+
+    // mutable_buffer_container_1 constructors.
+
+    mutable_buffer_container_1 mbc1(mb1);
+    mutable_buffer_container_1 mbc2(mbc1);
+
+    // mutable_buffer_container_1 functions.
+
+    mutable_buffer_container_1::const_iterator iter1 = mbc1.begin();
+    (void)iter1;
+    mutable_buffer_container_1::const_iterator iter2 = mbc1.end();
+    (void)iter2;
+
+    // const_buffer constructors.
+
+    const_buffer cb1;
+    const_buffer cb2(const_void_ptr_data, 1024);
+    const_buffer cb3(cb1);
+    const_buffer cb4(mb1);
+
+    // const_buffer functions.
+
+    const void* ptr2 = buffer_cast<const void*>(cb1);
+    (void)ptr2;
+    std::size_t size2 = buffer_size(cb1);
+    (void)size2;
+
+    // const_buffer operators.
+
+    cb1 = cb2 + 128;
+    cb1 = 128 + cb2;
+
+    // const_buffer_container_1 constructors.
+
+    const_buffer_container_1 cbc1(cb1);
+    const_buffer_container_1 cbc2(cbc1);
+
+    // const_buffer_container_1 functions.
+
+    const_buffer_container_1::const_iterator iter3 = cbc1.begin();
+    (void)iter3;
+    const_buffer_container_1::const_iterator iter4 = cbc1.end();
+    (void)iter4;
+
+    // buffer function overloads.
+
+    mb1 = buffer(mb2);
+    mb1 = buffer(mb2, 128);
+    cb1 = buffer(cb2);
+    cb1 = buffer(cb2, 128);
+    mb1 = buffer(void_ptr_data, 1024);
+    cb1 = buffer(const_void_ptr_data, 1024);
+    mb1 = buffer(raw_data);
+    mb1 = buffer(raw_data, 1024);
+    cb1 = buffer(const_raw_data);
+    cb1 = buffer(const_raw_data, 1024);
+    mb1 = buffer(array_data);
+    mb1 = buffer(array_data, 1024);
+    cb1 = buffer(const_array_data_1);
+    cb1 = buffer(const_array_data_1, 1024);
+    cb1 = buffer(const_array_data_2);
+    cb1 = buffer(const_array_data_2, 1024);
+    mb1 = buffer(vector_data);
+    mb1 = buffer(vector_data, 1024);
+    cb1 = buffer(const_vector_data);
+    cb1 = buffer(const_vector_data, 1024);
+    cb1 = buffer(string_data);
+    cb1 = buffer(string_data, 1024);
+  }
+  catch (std::exception&)
+  {
+  }
+}
+
+} // namespace buffer_compile
+
+//------------------------------------------------------------------------------
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("buffer");
+  test->add(BOOST_TEST_CASE(&buffer_compile::test));
+  return test;
+}
diff --git a/test/buffered_read_stream_test.cpp b/test/buffered_read_stream_test.cpp
new file mode 100644
index 0000000000..ab5a5ef2db
--- /dev/null
+++ b/test/buffered_read_stream_test.cpp
@@ -0,0 +1,221 @@
+//
+// buffered_read_stream_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/buffered_read_stream.hpp>
+
+#include <boost/bind.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+typedef boost::asio::buffered_read_stream<
+    boost::asio::ip::tcp::socket> stream_type;
+
+void test_sync_operations()
+{
+  using namespace std; // For memcmp.
+
+  boost::asio::io_service io_service;
+
+  boost::asio::ip::tcp::acceptor acceptor(io_service,
+      boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
+  boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(boost::asio::ip::address_v4::loopback());
+
+  stream_type client_socket(io_service);
+  client_socket.lowest_layer().connect(server_endpoint);
+
+  stream_type server_socket(io_service);
+  acceptor.accept(server_socket.lowest_layer());
+
+  const char write_data[]
+    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const boost::asio::const_buffer write_buf = boost::asio::buffer(write_data);
+
+  std::size_t bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    bytes_written += client_socket.write_some(
+        boost::asio::buffer(write_buf + bytes_written));
+  }
+
+  char read_data[sizeof(write_data)];
+  const boost::asio::mutable_buffer read_buf = boost::asio::buffer(read_data);
+
+  std::size_t bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    bytes_read += server_socket.read_some(
+        boost::asio::buffer(read_buf + bytes_read));
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    bytes_written += server_socket.write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::asio::throw_error());
+  }
+
+  bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    bytes_read += client_socket.read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::asio::throw_error());
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  server_socket.close();
+  boost::asio::error error;
+  bytes_read = client_socket.read_some(
+      boost::asio::buffer(read_buf),
+      boost::asio::assign_error(error));
+
+  BOOST_CHECK(bytes_read == 0);
+  BOOST_CHECK(error == boost::asio::error::eof);
+
+  client_socket.close(boost::asio::throw_error());
+}
+
+void handle_accept(const boost::asio::error& e)
+{
+  BOOST_CHECK(!e);
+}
+
+void handle_write(const boost::asio::error& e,
+    std::size_t bytes_transferred,
+    std::size_t* total_bytes_written)
+{
+  BOOST_CHECK(!e);
+  if (e)
+    throw e; // Terminate test.
+  *total_bytes_written += bytes_transferred;
+}
+
+void handle_read(const boost::asio::error& e,
+    std::size_t bytes_transferred,
+    std::size_t* total_bytes_read)
+{
+  BOOST_CHECK(!e);
+  if (e)
+    throw e; // Terminate test.
+  *total_bytes_read += bytes_transferred;
+}
+
+void handle_read_eof(const boost::asio::error& e,
+    std::size_t bytes_transferred)
+{
+  BOOST_CHECK(e == boost::asio::error::eof);
+  BOOST_CHECK(bytes_transferred == 0);
+}
+
+void test_async_operations()
+{
+  using namespace std; // For memcmp.
+
+  boost::asio::io_service io_service;
+
+  boost::asio::ip::tcp::acceptor acceptor(io_service,
+      boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
+  boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(boost::asio::ip::address_v4::loopback());
+
+  stream_type client_socket(io_service);
+  client_socket.lowest_layer().connect(server_endpoint);
+
+  stream_type server_socket(io_service);
+  acceptor.async_accept(server_socket.lowest_layer(), handle_accept);
+  io_service.run();
+  io_service.reset();
+
+  const char write_data[]
+    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const boost::asio::const_buffer write_buf = boost::asio::buffer(write_data);
+
+  std::size_t bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    client_socket.async_write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::bind(handle_write, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_written));
+    io_service.run();
+    io_service.reset();
+  }
+
+  char read_data[sizeof(write_data)];
+  const boost::asio::mutable_buffer read_buf = boost::asio::buffer(read_data);
+
+  std::size_t bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    server_socket.async_read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::bind(handle_read, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_read));
+    io_service.run();
+    io_service.reset();
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    server_socket.async_write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::bind(handle_write, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_written));
+    io_service.run();
+    io_service.reset();
+  }
+
+  bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    client_socket.async_read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::bind(handle_read, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_read));
+    io_service.run();
+    io_service.reset();
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  server_socket.close();
+  client_socket.async_read_some(boost::asio::buffer(read_buf), handle_read_eof);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("buffered_read_stream");
+  test->add(BOOST_TEST_CASE(&test_sync_operations));
+  test->add(BOOST_TEST_CASE(&test_async_operations));
+  return test;
+}
diff --git a/test/buffered_stream_test.cpp b/test/buffered_stream_test.cpp
new file mode 100644
index 0000000000..e9f962ffc0
--- /dev/null
+++ b/test/buffered_stream_test.cpp
@@ -0,0 +1,236 @@
+//
+// buffered_stream_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/buffered_stream.hpp>
+
+#include <boost/bind.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+typedef boost::asio::buffered_stream<
+    boost::asio::ip::tcp::socket> stream_type;
+
+void test_sync_operations()
+{
+  using namespace std; // For memcmp.
+
+  boost::asio::io_service io_service;
+
+  boost::asio::ip::tcp::acceptor acceptor(io_service,
+      boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
+  boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(boost::asio::ip::address_v4::loopback());
+
+  stream_type client_socket(io_service);
+  client_socket.lowest_layer().connect(server_endpoint);
+
+  stream_type server_socket(io_service);
+  acceptor.accept(server_socket.lowest_layer());
+
+  const char write_data[]
+    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const boost::asio::const_buffer write_buf = boost::asio::buffer(write_data);
+
+  std::size_t bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    bytes_written += client_socket.write_some(
+        boost::asio::buffer(write_buf + bytes_written));
+    client_socket.flush();
+  }
+
+  char read_data[sizeof(write_data)];
+  const boost::asio::mutable_buffer read_buf = boost::asio::buffer(read_data);
+
+  std::size_t bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    bytes_read += server_socket.read_some(
+        boost::asio::buffer(read_buf + bytes_read));
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    bytes_written += server_socket.write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::asio::throw_error());
+    server_socket.flush(boost::asio::throw_error());
+  }
+
+  bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    bytes_read += client_socket.read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::asio::throw_error());
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  server_socket.close();
+  boost::asio::error error;
+  bytes_read = client_socket.read_some(
+      boost::asio::buffer(read_buf),
+      boost::asio::assign_error(error));
+
+  BOOST_CHECK(bytes_read == 0);
+  BOOST_CHECK(error == boost::asio::error::eof);
+
+  client_socket.close(boost::asio::throw_error());
+}
+
+void handle_accept(const boost::asio::error& e)
+{
+  BOOST_CHECK(!e);
+}
+
+void handle_write(const boost::asio::error& e,
+    std::size_t bytes_transferred,
+    std::size_t* total_bytes_written)
+{
+  BOOST_CHECK(!e);
+  if (e)
+    throw e; // Terminate test.
+  *total_bytes_written += bytes_transferred;
+}
+
+void handle_flush(const boost::asio::error& e)
+{
+  BOOST_CHECK(!e);
+}
+
+void handle_read(const boost::asio::error& e,
+    std::size_t bytes_transferred,
+    std::size_t* total_bytes_read)
+{
+  BOOST_CHECK(!e);
+  if (e)
+    throw e; // Terminate test.
+  *total_bytes_read += bytes_transferred;
+}
+
+void handle_read_eof(const boost::asio::error& e,
+    std::size_t bytes_transferred)
+{
+  BOOST_CHECK(e == boost::asio::error::eof);
+  BOOST_CHECK(bytes_transferred == 0);
+}
+
+void test_async_operations()
+{
+  using namespace std; // For memcmp.
+
+  boost::asio::io_service io_service;
+
+  boost::asio::ip::tcp::acceptor acceptor(io_service,
+      boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
+  boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(boost::asio::ip::address_v4::loopback());
+
+  stream_type client_socket(io_service);
+  client_socket.lowest_layer().connect(server_endpoint);
+
+  stream_type server_socket(io_service);
+  acceptor.async_accept(server_socket.lowest_layer(), handle_accept);
+  io_service.run();
+  io_service.reset();
+
+  const char write_data[]
+    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const boost::asio::const_buffer write_buf = boost::asio::buffer(write_data);
+
+  std::size_t bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    client_socket.async_write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::bind(handle_write, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_written));
+    io_service.run();
+    io_service.reset();
+    client_socket.async_flush(
+        boost::bind(handle_flush, boost::asio::placeholders::error));
+    io_service.run();
+    io_service.reset();
+  }
+
+  char read_data[sizeof(write_data)];
+  const boost::asio::mutable_buffer read_buf = boost::asio::buffer(read_data);
+
+  std::size_t bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    server_socket.async_read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::bind(handle_read, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_read));
+    io_service.run();
+    io_service.reset();
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    server_socket.async_write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::bind(handle_write, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_written));
+    io_service.run();
+    io_service.reset();
+    server_socket.async_flush(
+        boost::bind(handle_flush, boost::asio::placeholders::error));
+    io_service.run();
+    io_service.reset();
+  }
+
+  bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    client_socket.async_read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::bind(handle_read, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_read));
+    io_service.run();
+    io_service.reset();
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  server_socket.close();
+  client_socket.async_read_some(boost::asio::buffer(read_buf), handle_read_eof);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("buffered_stream");
+  test->add(BOOST_TEST_CASE(&test_sync_operations));
+  test->add(BOOST_TEST_CASE(&test_async_operations));
+  return test;
+}
diff --git a/test/buffered_write_stream_test.cpp b/test/buffered_write_stream_test.cpp
new file mode 100644
index 0000000000..774d360018
--- /dev/null
+++ b/test/buffered_write_stream_test.cpp
@@ -0,0 +1,236 @@
+//
+// buffered_write_stream_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/buffered_write_stream.hpp>
+
+#include <boost/bind.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+typedef boost::asio::buffered_write_stream<
+    boost::asio::ip::tcp::socket> stream_type;
+
+void test_sync_operations()
+{
+  using namespace std; // For memcmp.
+
+  boost::asio::io_service io_service;
+
+  boost::asio::ip::tcp::acceptor acceptor(io_service,
+      boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
+  boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(boost::asio::ip::address_v4::loopback());
+
+  stream_type client_socket(io_service);
+  client_socket.lowest_layer().connect(server_endpoint);
+
+  stream_type server_socket(io_service);
+  acceptor.accept(server_socket.lowest_layer());
+
+  const char write_data[]
+    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const boost::asio::const_buffer write_buf = boost::asio::buffer(write_data);
+
+  std::size_t bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    bytes_written += client_socket.write_some(
+        boost::asio::buffer(write_buf + bytes_written));
+    client_socket.flush();
+  }
+
+  char read_data[sizeof(write_data)];
+  const boost::asio::mutable_buffer read_buf = boost::asio::buffer(read_data);
+
+  std::size_t bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    bytes_read += server_socket.read_some(
+        boost::asio::buffer(read_buf + bytes_read));
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    bytes_written += server_socket.write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::asio::throw_error());
+    server_socket.flush(boost::asio::throw_error());
+  }
+
+  bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    bytes_read += client_socket.read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::asio::throw_error());
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  server_socket.close();
+  boost::asio::error error;
+  bytes_read = client_socket.read_some(
+      boost::asio::buffer(read_buf),
+      boost::asio::assign_error(error));
+
+  BOOST_CHECK(bytes_read == 0);
+  BOOST_CHECK(error == boost::asio::error::eof);
+
+  client_socket.close(boost::asio::throw_error());
+}
+
+void handle_accept(const boost::asio::error& e)
+{
+  BOOST_CHECK(!e);
+}
+
+void handle_write(const boost::asio::error& e,
+    std::size_t bytes_transferred,
+    std::size_t* total_bytes_written)
+{
+  BOOST_CHECK(!e);
+  if (e)
+    throw e; // Terminate test.
+  *total_bytes_written += bytes_transferred;
+}
+
+void handle_flush(const boost::asio::error& e)
+{
+  BOOST_CHECK(!e);
+}
+
+void handle_read(const boost::asio::error& e,
+    std::size_t bytes_transferred,
+    std::size_t* total_bytes_read)
+{
+  BOOST_CHECK(!e);
+  if (e)
+    throw e; // Terminate test.
+  *total_bytes_read += bytes_transferred;
+}
+
+void handle_read_eof(const boost::asio::error& e,
+    std::size_t bytes_transferred)
+{
+  BOOST_CHECK(e == boost::asio::error::eof);
+  BOOST_CHECK(bytes_transferred == 0);
+}
+
+void test_async_operations()
+{
+  using namespace std; // For memcmp.
+
+  boost::asio::io_service io_service;
+
+  boost::asio::ip::tcp::acceptor acceptor(io_service,
+      boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0));
+  boost::asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(boost::asio::ip::address_v4::loopback());
+
+  stream_type client_socket(io_service);
+  client_socket.lowest_layer().connect(server_endpoint);
+
+  stream_type server_socket(io_service);
+  acceptor.async_accept(server_socket.lowest_layer(), handle_accept);
+  io_service.run();
+  io_service.reset();
+
+  const char write_data[]
+    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const boost::asio::const_buffer write_buf = boost::asio::buffer(write_data);
+
+  std::size_t bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    client_socket.async_write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::bind(handle_write, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_written));
+    io_service.run();
+    io_service.reset();
+    client_socket.async_flush(
+        boost::bind(handle_flush, boost::asio::placeholders::error));
+    io_service.run();
+    io_service.reset();
+  }
+
+  char read_data[sizeof(write_data)];
+  const boost::asio::mutable_buffer read_buf = boost::asio::buffer(read_data);
+
+  std::size_t bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    server_socket.async_read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::bind(handle_read, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_read));
+    io_service.run();
+    io_service.reset();
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  bytes_written = 0;
+  while (bytes_written < sizeof(write_data))
+  {
+    server_socket.async_write_some(
+        boost::asio::buffer(write_buf + bytes_written),
+        boost::bind(handle_write, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_written));
+    io_service.run();
+    io_service.reset();
+    server_socket.async_flush(
+        boost::bind(handle_flush, boost::asio::placeholders::error));
+    io_service.run();
+    io_service.reset();
+  }
+
+  bytes_read = 0;
+  while (bytes_read < sizeof(read_data))
+  {
+    client_socket.async_read_some(
+        boost::asio::buffer(read_buf + bytes_read),
+        boost::bind(handle_read, boost::asio::placeholders::error,
+          boost::asio::placeholders::bytes_transferred, &bytes_read));
+    io_service.run();
+    io_service.reset();
+  }
+
+  BOOST_CHECK(bytes_written == sizeof(write_data));
+  BOOST_CHECK(bytes_read == sizeof(read_data));
+  BOOST_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
+
+  server_socket.close();
+  client_socket.async_read_some(boost::asio::buffer(read_buf), handle_read_eof);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("buffered_write_stream");
+  test->add(BOOST_TEST_CASE(&test_sync_operations));
+  test->add(BOOST_TEST_CASE(&test_async_operations));
+  return test;
+}
diff --git a/test/completion_condition_test.cpp b/test/completion_condition_test.cpp
new file mode 100644
index 0000000000..86178c4f90
--- /dev/null
+++ b/test/completion_condition_test.cpp
@@ -0,0 +1,25 @@
+//
+// completion_condition_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/completion_condition.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("completion_condition");
+  return test;
+}
diff --git a/test/datagram_socket_service_test.cpp b/test/datagram_socket_service_test.cpp
new file mode 100644
index 0000000000..67ad079a6a
--- /dev/null
+++ b/test/datagram_socket_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// datagram_socket_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/datagram_socket_service.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("datagram_socket_service");
+  return test;
+}
diff --git a/test/deadline_timer_service_test.cpp b/test/deadline_timer_service_test.cpp
new file mode 100644
index 0000000000..bb5486bde6
--- /dev/null
+++ b/test/deadline_timer_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// deadline_timer_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/deadline_timer_service.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("deadline_timer_service");
+  return test;
+}
diff --git a/test/deadline_timer_test.cpp b/test/deadline_timer_test.cpp
new file mode 100644
index 0000000000..2cbdd3f216
--- /dev/null
+++ b/test/deadline_timer_test.cpp
@@ -0,0 +1,186 @@
+//
+// deadline_timer_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/deadline_timer.hpp>
+
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+using namespace boost::posix_time;
+
+void increment(int* count)
+{
+  ++(*count);
+}
+
+void decrement_to_zero(boost::asio::deadline_timer* t, int* count)
+{
+  if (*count > 0)
+  {
+    --(*count);
+
+    int before_value = *count;
+
+    t->expires_at(t->expires_at() + seconds(1));
+    t->async_wait(boost::bind(decrement_to_zero, t, count));
+
+    // Completion cannot nest, so count value should remain unchanged.
+    BOOST_CHECK(*count == before_value);
+  }
+}
+
+void increment_if_not_cancelled(int* count, const boost::asio::error& e)
+{
+  if (!e)
+    ++(*count);
+}
+
+void cancel_timer(boost::asio::deadline_timer* t)
+{
+  std::size_t num_cancelled = t->cancel();
+  BOOST_CHECK(num_cancelled == 1);
+}
+
+ptime now()
+{
+  return microsec_clock::universal_time();
+}
+
+void deadline_timer_test()
+{
+  boost::asio::io_service ios;
+  int count = 0;
+
+  ptime start = now();
+
+  boost::asio::deadline_timer t1(ios, seconds(1));
+  t1.wait();
+
+  // The timer must block until after its expiry time.
+  ptime end = now();
+  ptime expected_end = start + seconds(1);
+  BOOST_CHECK(expected_end < end || expected_end == end);
+
+  start = now();
+
+  boost::asio::deadline_timer t2(ios, seconds(1) + microseconds(500000));
+  t2.wait();
+
+  // The timer must block until after its expiry time.
+  end = now();
+  expected_end = start + seconds(1) + microseconds(500000);
+  BOOST_CHECK(expected_end < end || expected_end == end);
+
+  t2.expires_at(t2.expires_at() + seconds(1));
+  t2.wait();
+
+  // The timer must block until after its expiry time.
+  end = now();
+  expected_end += seconds(1);
+  BOOST_CHECK(expected_end < end || expected_end == end);
+
+  start = now();
+
+  t2.expires_from_now(seconds(1) + microseconds(200000));
+  t2.wait();
+
+  // The timer must block until after its expiry time.
+  end = now();
+  expected_end = start + seconds(1) + microseconds(200000);
+  BOOST_CHECK(expected_end < end || expected_end == end);
+
+  start = now();
+
+  boost::asio::deadline_timer t3(ios, seconds(5));
+  t3.async_wait(boost::bind(increment, &count));
+
+  // No completions can be delivered until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.run();
+
+  // The run() call will not return until all operations have finished, and
+  // this should not be until after the timer's expiry time.
+  BOOST_CHECK(count == 1);
+  end = now();
+  expected_end = start + seconds(1);
+  BOOST_CHECK(expected_end < end || expected_end == end);
+
+  count = 3;
+  start = now();
+
+  boost::asio::deadline_timer t4(ios, seconds(1));
+  t4.async_wait(boost::bind(decrement_to_zero, &t4, &count));
+
+  // No completions can be delivered until run() is called.
+  BOOST_CHECK(count == 3);
+
+  ios.reset();
+  ios.run();
+
+  // The run() call will not return until all operations have finished, and
+  // this should not be until after the timer's final expiry time.
+  BOOST_CHECK(count == 0);
+  end = now();
+  expected_end = start + seconds(3);
+  BOOST_CHECK(expected_end < end || expected_end == end);
+
+  count = 0;
+  start = now();
+
+  boost::asio::deadline_timer t5(ios, seconds(10));
+  t5.async_wait(boost::bind(increment_if_not_cancelled, &count,
+        boost::asio::placeholders::error));
+  boost::asio::deadline_timer t6(ios, seconds(1));
+  t6.async_wait(boost::bind(cancel_timer, &t5));
+
+  // No completions can be delivered until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.reset();
+  ios.run();
+
+  // The timer should have been cancelled, so count should not have changed.
+  // The total run time should not have been much more than 1 second (and
+  // certainly far less than 10 seconds).
+  BOOST_CHECK(count == 0);
+  end = now();
+  expected_end = start + seconds(2);
+  BOOST_CHECK(end < expected_end);
+
+  // Wait on the timer again without cancelling it. This time the asynchronous
+  // wait should run to completion and increment the counter.
+  t5.async_wait(boost::bind(increment_if_not_cancelled, &count,
+        boost::asio::placeholders::error));
+
+  ios.reset();
+  ios.run();
+
+  // The timer should not have been cancelled, so count should have changed.
+  // The total time since the timer was created should be more than 10 seconds.
+  BOOST_CHECK(count == 1);
+  end = now();
+  expected_end = start + seconds(10);
+  BOOST_CHECK(expected_end < end);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("deadline_timer");
+  test->add(BOOST_TEST_CASE(&deadline_timer_test));
+  return test;
+}
diff --git a/test/error_handler_test.cpp b/test/error_handler_test.cpp
new file mode 100644
index 0000000000..508a0b21aa
--- /dev/null
+++ b/test/error_handler_test.cpp
@@ -0,0 +1,67 @@
+//
+// error_handler_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/error_handler.hpp>
+
+#include <sstream>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+using namespace boost::asio;
+
+void error_handler_test()
+{
+  io_service ios;
+
+  ip::tcp::socket s(ios);
+  ip::tcp::endpoint endpoint(ip::tcp::v4(), 321);
+
+  error expected_err;
+  s.connect(endpoint, assign_error(expected_err));
+  s.close();
+
+  try
+  {
+    s.close();
+    s.connect(endpoint, throw_error());
+    BOOST_CHECK(0);
+  }
+  catch (error&)
+  {
+  }
+
+  try
+  {
+    s.close();
+    s.connect(endpoint, ignore_error());
+  }
+  catch (error&)
+  {
+    BOOST_CHECK(0);
+  }
+
+  s.close();
+  error err;
+  s.connect(endpoint, assign_error(err));
+  BOOST_CHECK(err == expected_err);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("error_handler");
+  test->add(BOOST_TEST_CASE(&error_handler_test));
+  return test;
+}
diff --git a/test/error_test.cpp b/test/error_test.cpp
new file mode 100644
index 0000000000..bc5fdcb5e0
--- /dev/null
+++ b/test/error_test.cpp
@@ -0,0 +1,92 @@
+//
+// error_test.cpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/error.hpp>
+
+#include <sstream>
+#include "unit_test.hpp"
+
+void test_error_code(int code)
+{
+  boost::asio::error error(code);
+  BOOST_CHECK(code == error.code());
+  BOOST_CHECK(error.what() != 0);
+
+  BOOST_CHECK(code == 0 || error);
+  BOOST_CHECK(code == 0 || !!error);
+
+  boost::asio::error error2(error);
+  BOOST_CHECK(error == error2);
+  BOOST_CHECK(!(error != error2));
+
+  boost::asio::error error3;
+  error3 = error;
+  BOOST_CHECK(error == error3);
+  BOOST_CHECK(!(error != error3));
+
+  std::ostringstream os;
+  os << error;
+  BOOST_CHECK(os.str() == error.what());
+}
+
+void error_test()
+{
+  test_error_code(boost::asio::error::access_denied);
+  test_error_code(boost::asio::error::address_family_not_supported);
+  test_error_code(boost::asio::error::address_in_use);
+  test_error_code(boost::asio::error::already_connected);
+  test_error_code(boost::asio::error::already_started);
+  test_error_code(boost::asio::error::connection_aborted);
+  test_error_code(boost::asio::error::connection_refused);
+  test_error_code(boost::asio::error::connection_reset);
+  test_error_code(boost::asio::error::bad_descriptor);
+  test_error_code(boost::asio::error::eof);
+  test_error_code(boost::asio::error::fault);
+  test_error_code(boost::asio::error::host_not_found);
+  test_error_code(boost::asio::error::host_not_found_try_again);
+  test_error_code(boost::asio::error::host_unreachable);
+  test_error_code(boost::asio::error::in_progress);
+  test_error_code(boost::asio::error::interrupted);
+  test_error_code(boost::asio::error::invalid_argument);
+  test_error_code(boost::asio::error::message_size);
+  test_error_code(boost::asio::error::network_down);
+  test_error_code(boost::asio::error::network_reset);
+  test_error_code(boost::asio::error::network_unreachable);
+  test_error_code(boost::asio::error::no_descriptors);
+  test_error_code(boost::asio::error::no_buffer_space);
+  test_error_code(boost::asio::error::no_data);
+  test_error_code(boost::asio::error::no_memory);
+  test_error_code(boost::asio::error::no_permission);
+  test_error_code(boost::asio::error::no_protocol_option);
+  test_error_code(boost::asio::error::no_recovery);
+  test_error_code(boost::asio::error::not_connected);
+  test_error_code(boost::asio::error::not_socket);
+  test_error_code(boost::asio::error::not_supported);
+  test_error_code(boost::asio::error::operation_aborted);
+  test_error_code(boost::asio::error::service_not_found);
+  test_error_code(boost::asio::error::shut_down);
+  test_error_code(boost::asio::error::success);
+  test_error_code(boost::asio::error::timed_out);
+  test_error_code(boost::asio::error::try_again);
+  test_error_code(boost::asio::error::would_block);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("error");
+  test->add(BOOST_TEST_CASE(&error_test));
+  return test;
+}
diff --git a/test/io_service_test.cpp b/test/io_service_test.cpp
new file mode 100644
index 0000000000..f5dcdb5482
--- /dev/null
+++ b/test/io_service_test.cpp
@@ -0,0 +1,237 @@
+//
+// io_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/io_service.hpp>
+
+#include <sstream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include "unit_test.hpp"
+
+using namespace boost::asio;
+
+void increment(int* count)
+{
+  ++(*count);
+}
+
+void decrement_to_zero(io_service* ios, int* count)
+{
+  if (*count > 0)
+  {
+    --(*count);
+
+    int before_value = *count;
+    ios->post(boost::bind(decrement_to_zero, ios, count));
+
+    // Handler execution cannot nest, so count value should remain unchanged.
+    BOOST_CHECK(*count == before_value);
+  }
+}
+
+void nested_decrement_to_zero(io_service* ios, int* count)
+{
+  if (*count > 0)
+  {
+    --(*count);
+
+    ios->dispatch(boost::bind(nested_decrement_to_zero, ios, count));
+
+    // Handler execution is nested, so count value should now be zero.
+    BOOST_CHECK(*count == 0);
+  }
+}
+
+void sleep_increment(io_service* ios, int* count)
+{
+  deadline_timer t(*ios, boost::posix_time::seconds(2));
+  t.wait();
+
+  if (++(*count) < 3)
+    ios->post(boost::bind(sleep_increment, ios, count));
+}
+
+void start_sleep_increments(io_service* ios, int* count)
+{
+  // Give all threads a chance to start.
+  deadline_timer t(*ios, boost::posix_time::seconds(2));
+  t.wait();
+
+  // Start the first of three increments.
+  ios->post(boost::bind(sleep_increment, ios, count));
+}
+
+void throw_exception()
+{
+  throw 1;
+}
+
+void io_service_test()
+{
+  io_service ios;
+  int count = 0;
+
+  ios.post(boost::bind(increment, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 1);
+
+  count = 0;
+  ios.reset();
+  ios.post(boost::bind(increment, &count));
+  ios.post(boost::bind(increment, &count));
+  ios.post(boost::bind(increment, &count));
+  ios.post(boost::bind(increment, &count));
+  ios.post(boost::bind(increment, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 5);
+
+  count = 0;
+  ios.reset();
+  io_service::work* w = new io_service::work(ios);
+  ios.post(boost::bind(&io_service::interrupt, &ios));
+  ios.run();
+
+  // The only operation executed should have been to interrupt run().
+  BOOST_CHECK(count == 0);
+
+  ios.reset();
+  ios.post(boost::bind(increment, &count));
+  delete w;
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 1);
+
+  count = 10;
+  ios.reset();
+  ios.post(boost::bind(decrement_to_zero, &ios, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 10);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 0);
+
+  count = 10;
+  ios.reset();
+  ios.post(boost::bind(nested_decrement_to_zero, &ios, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 10);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 0);
+
+  count = 10;
+  ios.reset();
+  ios.dispatch(boost::bind(nested_decrement_to_zero, &ios, &count));
+
+  // No handlers can be called until run() is called, even though nested
+  // delivery was specifically allowed in the previous call.
+  BOOST_CHECK(count == 10);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 0);
+
+  count = 0;
+  int count2 = 0;
+  ios.reset();
+  ios.post(boost::bind(start_sleep_increments, &ios, &count));
+  ios.post(boost::bind(start_sleep_increments, &ios, &count2));
+  boost::thread thread1(boost::bind(&io_service::run, &ios));
+  boost::thread thread2(boost::bind(&io_service::run, &ios));
+  thread1.join();
+  thread2.join();
+
+  // The run() calls will not return until all work has finished.
+  BOOST_CHECK(count == 3);
+  BOOST_CHECK(count2 == 3);
+
+  count = 10;
+  io_service ios2;
+  ios.dispatch(ios2.wrap(boost::bind(decrement_to_zero, &ios2, &count)));
+  ios.reset();
+  ios.run();
+
+  // No decrement_to_zero handlers can be called until run() is called on the
+  // second io_service object.
+  BOOST_CHECK(count == 10);
+
+  ios2.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 0);
+
+  count = 0;
+  int exception_count = 0;
+  ios.reset();
+  ios.post(throw_exception);
+  ios.post(boost::bind(increment, &count));
+  ios.post(boost::bind(increment, &count));
+  ios.post(throw_exception);
+  ios.post(boost::bind(increment, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+  BOOST_CHECK(exception_count == 0);
+
+  for (;;)
+  {
+    try
+    {
+      ios.run();
+      break;
+    }
+    catch (int)
+    {
+      ++exception_count;
+    }
+  }
+
+  // The run() calls will not return until all work has finished.
+  BOOST_CHECK(count == 3);
+  BOOST_CHECK(exception_count == 2);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("io_service");
+  test->add(BOOST_TEST_CASE(&io_service_test));
+  return test;
+}
diff --git a/test/ip/address_test.cpp b/test/ip/address_test.cpp
new file mode 100644
index 0000000000..a07a26a2f1
--- /dev/null
+++ b/test/ip/address_test.cpp
@@ -0,0 +1,25 @@
+//
+// address_test.cpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/address.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/address");
+  return test;
+}
diff --git a/test/ip/address_v4_test.cpp b/test/ip/address_v4_test.cpp
new file mode 100644
index 0000000000..ca4b014c9d
--- /dev/null
+++ b/test/ip/address_v4_test.cpp
@@ -0,0 +1,25 @@
+//
+// address_v4_test.cpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/address_v4.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/address_v4");
+  return test;
+}
diff --git a/test/ip/address_v6_test.cpp b/test/ip/address_v6_test.cpp
new file mode 100644
index 0000000000..fbbf7b32c8
--- /dev/null
+++ b/test/ip/address_v6_test.cpp
@@ -0,0 +1,25 @@
+//
+// address_v6_test.cpp
+// ~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/address_v6.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/address_v6");
+  return test;
+}
diff --git a/test/ip/basic_endpoint_test.cpp b/test/ip/basic_endpoint_test.cpp
new file mode 100644
index 0000000000..0dc4c6a8a3
--- /dev/null
+++ b/test/ip/basic_endpoint_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_endpoint_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/basic_endpoint.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/basic_endpoint");
+  return test;
+}
diff --git a/test/ip/basic_resolver_entry_test.cpp b/test/ip/basic_resolver_entry_test.cpp
new file mode 100644
index 0000000000..f6edf3c57f
--- /dev/null
+++ b/test/ip/basic_resolver_entry_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_resolver_entry_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/basic_resolver_entry.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/basic_resolver_entry");
+  return test;
+}
diff --git a/test/ip/basic_resolver_iterator_test.cpp b/test/ip/basic_resolver_iterator_test.cpp
new file mode 100644
index 0000000000..8a240258fb
--- /dev/null
+++ b/test/ip/basic_resolver_iterator_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_resolver_iterator_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/basic_resolver_iterator");
+  return test;
+}
diff --git a/test/ip/basic_resolver_query_test.cpp b/test/ip/basic_resolver_query_test.cpp
new file mode 100644
index 0000000000..b143b58cdc
--- /dev/null
+++ b/test/ip/basic_resolver_query_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_resolver_query_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/basic_resolver_query.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/basic_resolver_query");
+  return test;
+}
diff --git a/test/ip/host_name_test.cpp b/test/ip/host_name_test.cpp
new file mode 100644
index 0000000000..279a3f5c53
--- /dev/null
+++ b/test/ip/host_name_test.cpp
@@ -0,0 +1,54 @@
+//
+// host_name_test.cpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/host_name.hpp>
+
+#include <boost/asio.hpp>
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// ip_host_name_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all host_name functions compile and link
+// correctly. Runtime failures are ignored.
+
+namespace ip_host_name_compile {
+
+using namespace boost::asio;
+
+void test()
+{
+  try
+  {
+    std::string host_name = ip::host_name();
+    std::string host_name2 = ip::host_name(boost::asio::ignore_error());
+  }
+  catch (std::exception&)
+  {
+  }
+}
+
+} // namespace ip_host_name_compile
+
+//------------------------------------------------------------------------------
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/host_name");
+  test->add(BOOST_TEST_CASE(&ip_host_name_compile::test));
+  return test;
+}
diff --git a/test/ip/multicast_test.cpp b/test/ip/multicast_test.cpp
new file mode 100644
index 0000000000..e087ad1639
--- /dev/null
+++ b/test/ip/multicast_test.cpp
@@ -0,0 +1,25 @@
+//
+// multicast_test.cpp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/multicast.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/multicast");
+  return test;
+}
diff --git a/test/ip/resolver_query_base_test.cpp b/test/ip/resolver_query_base_test.cpp
new file mode 100644
index 0000000000..c1e234cae0
--- /dev/null
+++ b/test/ip/resolver_query_base_test.cpp
@@ -0,0 +1,25 @@
+//
+// resolver_query_base_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/resolver_query_base.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/resolver_query_base");
+  return test;
+}
diff --git a/test/ip/tcp_test.cpp b/test/ip/tcp_test.cpp
new file mode 100644
index 0000000000..d8e82f0a62
--- /dev/null
+++ b/test/ip/tcp_test.cpp
@@ -0,0 +1,272 @@
+//
+// tcp_test.cpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/tcp.hpp>
+
+#include <boost/bind.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// ip_tcp_socket_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// ip::tcp::socket compile and link correctly. Runtime failures are ignored.
+
+namespace ip_tcp_socket_compile {
+
+using namespace boost::asio;
+
+void error_handler(const error&)
+{
+}
+
+void connect_handler(const error&)
+{
+}
+
+void send_handler(const error&, std::size_t)
+{
+}
+
+void receive_handler(const error&, std::size_t)
+{
+}
+
+void write_some_handler(const error&, std::size_t)
+{
+}
+
+void read_some_handler(const error&, std::size_t)
+{
+}
+
+void test()
+{
+  try
+  {
+    io_service ios;
+    char mutable_char_buffer[128] = "";
+    const char const_char_buffer[128] = "";
+    socket_base::message_flags in_flags = 0;
+    socket_base::keep_alive socket_option;
+    socket_base::bytes_readable io_control_command;
+
+    // basic_stream_socket constructors.
+
+    ip::tcp::socket socket1(ios);
+    ip::tcp::socket socket2(ios, ip::tcp::v4());
+    ip::tcp::socket socket3(ios, ip::tcp::v6());
+    ip::tcp::socket socket4(ios, ip::tcp::endpoint(ip::tcp::v4(), 0));
+    ip::tcp::socket socket5(ios, ip::tcp::endpoint(ip::tcp::v6(), 0));
+    int native_socket1 = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    ip::tcp::socket socket6(ios, ip::tcp::v4(), native_socket1);
+
+    // basic_io_object functions.
+
+    io_service& ios_ref = socket1.io_service();
+    (void)ios_ref;
+
+    // basic_socket functions.
+
+    ip::tcp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
+    (void)lowest_layer;
+
+    socket1.open(ip::tcp::v4());
+    socket1.open(ip::tcp::v6());
+    socket1.open(ip::tcp::v4(), error_handler);
+    socket1.open(ip::tcp::v6(), error_handler);
+
+    int native_socket2 = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    socket1.assign(ip::tcp::v4(), native_socket2);
+    int native_socket3 = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    socket1.assign(ip::tcp::v4(), native_socket3, error_handler);
+
+    socket1.close();
+    socket1.close(error_handler);
+
+    ip::tcp::socket::native_type native_socket4 = socket1.native();
+    (void)native_socket4;
+
+    socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0));
+    socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0));
+    socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), error_handler);
+    socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), error_handler);
+
+    socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0));
+    socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0));
+    socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0), error_handler);
+    socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0), error_handler);
+
+    socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), connect_handler);
+    socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), connect_handler);
+
+    socket1.set_option(socket_option);
+    socket1.set_option(socket_option, error_handler);
+
+    socket1.get_option(socket_option);
+    socket1.get_option(socket_option, error_handler);
+
+    socket1.io_control(io_control_command);
+    socket1.io_control(io_control_command, error_handler);
+
+    ip::tcp::endpoint endpoint1 = socket1.local_endpoint();
+    ip::tcp::endpoint endpoint2 = socket1.local_endpoint(error_handler);
+
+    ip::tcp::endpoint endpoint3 = socket1.remote_endpoint();
+    ip::tcp::endpoint endpoint4 = socket1.remote_endpoint(error_handler);
+
+    socket1.shutdown(socket_base::shutdown_both);
+    socket1.shutdown(socket_base::shutdown_both, error_handler);
+
+    // basic_stream_socket functions.
+
+    socket1.send(buffer(mutable_char_buffer));
+    socket1.send(buffer(const_char_buffer));
+    socket1.send(buffer(mutable_char_buffer), in_flags);
+    socket1.send(buffer(const_char_buffer), in_flags);
+    socket1.send(buffer(mutable_char_buffer), in_flags, error_handler);
+    socket1.send(buffer(const_char_buffer), in_flags, error_handler);
+
+    socket1.async_send(buffer(mutable_char_buffer), send_handler);
+    socket1.async_send(buffer(const_char_buffer), send_handler);
+    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
+    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
+
+    socket1.receive(buffer(mutable_char_buffer));
+    socket1.receive(buffer(mutable_char_buffer), in_flags);
+    socket1.receive(buffer(mutable_char_buffer), in_flags, error_handler);
+
+    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
+    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
+        receive_handler);
+
+    socket1.write_some(buffer(mutable_char_buffer));
+    socket1.write_some(buffer(const_char_buffer));
+    socket1.write_some(buffer(mutable_char_buffer), error_handler);
+    socket1.write_some(buffer(const_char_buffer), error_handler);
+
+    socket1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
+    socket1.async_write_some(buffer(const_char_buffer), write_some_handler);
+
+    socket1.read_some(buffer(mutable_char_buffer));
+    socket1.read_some(buffer(mutable_char_buffer), error_handler);
+
+    socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
+
+    socket1.peek(buffer(mutable_char_buffer));
+    socket1.peek(buffer(mutable_char_buffer), error_handler);
+
+    std::size_t in_avail1 = socket1.in_avail();
+    (void)in_avail1;
+    std::size_t in_avail2 = socket1.in_avail(error_handler);
+    (void)in_avail2;
+  }
+  catch (std::exception&)
+  {
+  }
+}
+
+} // namespace ip_tcp_socket_compile
+
+//------------------------------------------------------------------------------
+
+// ip_tcp_acceptor_runtime test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks the runtime operation of the ip::tcp::acceptor
+// class.
+
+namespace ip_tcp_acceptor_runtime {
+
+using namespace boost::asio;
+
+void handle_accept(const error& err)
+{
+  BOOST_CHECK(!err);
+}
+
+void handle_connect(const error& err)
+{
+  BOOST_CHECK(!err);
+}
+
+void test()
+{
+  io_service ios;
+
+  ip::tcp::acceptor acceptor(ios, ip::tcp::endpoint(ip::tcp::v4(), 0));
+  ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
+  server_endpoint.address(ip::address_v4::loopback());
+
+  ip::tcp::socket client_side_socket(ios);
+  ip::tcp::socket server_side_socket(ios);
+
+  client_side_socket.connect(server_endpoint);
+  acceptor.accept(server_side_socket);
+
+  client_side_socket.close();
+  server_side_socket.close();
+
+  client_side_socket.connect(server_endpoint);
+  ip::tcp::endpoint client_endpoint;
+  acceptor.accept_endpoint(server_side_socket, client_endpoint);
+
+  ip::tcp::endpoint client_side_local_endpoint
+    = client_side_socket.local_endpoint();
+  BOOST_CHECK(client_side_local_endpoint.port() == client_endpoint.port());
+
+  ip::tcp::endpoint server_side_remote_endpoint
+    = server_side_socket.remote_endpoint();
+  BOOST_CHECK(server_side_remote_endpoint.port() == client_endpoint.port());
+
+  client_side_socket.close();
+  server_side_socket.close();
+
+  acceptor.async_accept(server_side_socket, handle_accept);
+  client_side_socket.async_connect(server_endpoint, handle_connect);
+
+  ios.run();
+
+  client_side_socket.close();
+  server_side_socket.close();
+
+  acceptor.async_accept_endpoint(server_side_socket, client_endpoint,
+      handle_accept);
+  client_side_socket.async_connect(server_endpoint, handle_connect);
+
+  ios.reset();
+  ios.run();
+
+  client_side_local_endpoint = client_side_socket.local_endpoint();
+  BOOST_CHECK(client_side_local_endpoint.port() == client_endpoint.port());
+
+  server_side_remote_endpoint = server_side_socket.remote_endpoint();
+  BOOST_CHECK(server_side_remote_endpoint.port() == client_endpoint.port());
+}
+
+} // namespace ip_tcp_acceptor_runtime
+
+//------------------------------------------------------------------------------
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/tcp");
+  test->add(BOOST_TEST_CASE(&ip_tcp_socket_compile::test));
+  test->add(BOOST_TEST_CASE(&ip_tcp_acceptor_runtime::test));
+  return test;
+}
diff --git a/test/ip/udp_test.cpp b/test/ip/udp_test.cpp
new file mode 100644
index 0000000000..d13ab40ed5
--- /dev/null
+++ b/test/ip/udp_test.cpp
@@ -0,0 +1,280 @@
+//
+// udp_test.cpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ip/udp.hpp>
+
+#include <boost/bind.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "../unit_test.hpp"
+
+//------------------------------------------------------------------------------
+
+// ip_udp_socket_compile test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks that all public member functions on the class
+// ip::udp::socket compile and link correctly. Runtime failures are ignored.
+
+namespace ip_udp_socket_compile {
+
+using namespace boost::asio;
+
+void error_handler(const error&)
+{
+}
+
+void connect_handler(const error&)
+{
+}
+
+void send_handler(const error&, std::size_t)
+{
+}
+
+void receive_handler(const error&, std::size_t)
+{
+}
+
+void test()
+{
+  try
+  {
+    io_service ios;
+    char mutable_char_buffer[128] = "";
+    const char const_char_buffer[128] = "";
+    socket_base::message_flags in_flags = 0;
+    socket_base::keep_alive socket_option;
+    socket_base::bytes_readable io_control_command;
+
+    // basic_datagram_socket constructors.
+
+    ip::udp::socket socket1(ios);
+    ip::udp::socket socket2(ios, ip::udp::v4());
+    ip::udp::socket socket3(ios, ip::udp::v6());
+    ip::udp::socket socket4(ios, ip::udp::endpoint(ip::udp::v4(), 0));
+    ip::udp::socket socket5(ios, ip::udp::endpoint(ip::udp::v6(), 0));
+    int native_socket1 = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    ip::udp::socket socket6(ios, ip::udp::v4(), native_socket1);
+
+    // basic_io_object functions.
+
+    io_service& ios_ref = socket1.io_service();
+    (void)ios_ref;
+
+    // basic_socket functions.
+
+    ip::udp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
+    (void)lowest_layer;
+
+    socket1.open(ip::udp::v4());
+    socket1.open(ip::udp::v6());
+    socket1.open(ip::udp::v4(), error_handler);
+    socket1.open(ip::udp::v6(), error_handler);
+
+    int native_socket2 = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    socket1.assign(ip::udp::v4(), native_socket2);
+    int native_socket3 = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    socket1.assign(ip::udp::v4(), native_socket3, error_handler);
+
+    socket1.close();
+    socket1.close(error_handler);
+
+    ip::udp::socket::native_type native_socket4 = socket1.native();
+    (void)native_socket4;
+
+    socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0));
+    socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0));
+    socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0), error_handler);
+    socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0), error_handler);
+
+    socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0));
+    socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0));
+    socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0), error_handler);
+    socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0), error_handler);
+
+    socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), connect_handler);
+    socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), connect_handler);
+
+    socket1.set_option(socket_option);
+    socket1.set_option(socket_option, error_handler);
+
+    socket1.get_option(socket_option);
+    socket1.get_option(socket_option, error_handler);
+
+    socket1.io_control(io_control_command);
+    socket1.io_control(io_control_command, error_handler);
+
+    ip::udp::endpoint endpoint1 = socket1.local_endpoint();
+    ip::udp::endpoint endpoint2 = socket1.local_endpoint(error_handler);
+
+    ip::udp::endpoint endpoint3 = socket1.remote_endpoint();
+    ip::udp::endpoint endpoint4 = socket1.remote_endpoint(error_handler);
+
+    socket1.shutdown(socket_base::shutdown_both);
+    socket1.shutdown(socket_base::shutdown_both, error_handler);
+
+    // basic_datagram_socket functions.
+
+    socket1.send(buffer(mutable_char_buffer));
+    socket1.send(buffer(const_char_buffer));
+    socket1.send(buffer(mutable_char_buffer), in_flags);
+    socket1.send(buffer(const_char_buffer), in_flags);
+    socket1.send(buffer(mutable_char_buffer), in_flags, error_handler);
+    socket1.send(buffer(const_char_buffer), in_flags, error_handler);
+
+    socket1.async_send(buffer(mutable_char_buffer), send_handler);
+    socket1.async_send(buffer(const_char_buffer), send_handler);
+    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
+    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
+
+    socket1.send_to(buffer(mutable_char_buffer), ip::udp::endpoint(ip::udp::v4(), 0));
+    socket1.send_to(buffer(mutable_char_buffer), ip::udp::endpoint(ip::udp::v6(), 0));
+    socket1.send_to(buffer(const_char_buffer), ip::udp::endpoint(ip::udp::v4(), 0));
+    socket1.send_to(buffer(const_char_buffer), ip::udp::endpoint(ip::udp::v6(), 0));
+    socket1.send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
+    socket1.send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
+    socket1.send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
+    socket1.send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
+    socket1.send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, error_handler);
+    socket1.send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, error_handler);
+    socket1.send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, error_handler);
+    socket1.send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, error_handler);
+
+    socket1.async_send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), send_handler);
+    socket1.async_send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), send_handler);
+    socket1.async_send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), send_handler);
+    socket1.async_send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), send_handler);
+    socket1.async_send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler);
+    socket1.async_send_to(buffer(mutable_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler);
+    socket1.async_send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler);
+    socket1.async_send_to(buffer(const_char_buffer),
+        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler);
+
+    socket1.receive(buffer(mutable_char_buffer));
+    socket1.receive(buffer(mutable_char_buffer), in_flags);
+    socket1.receive(buffer(mutable_char_buffer), in_flags, error_handler);
+
+    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
+    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
+        receive_handler);
+
+    ip::udp::endpoint endpoint;
+    socket1.receive_from(buffer(mutable_char_buffer), endpoint);
+    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
+    socket1.receive_from(buffer(mutable_char_buffer),
+        endpoint, in_flags, error_handler);
+
+    socket1.async_receive_from(buffer(mutable_char_buffer),
+        endpoint, receive_handler);
+    socket1.async_receive_from(buffer(mutable_char_buffer),
+        endpoint, in_flags, receive_handler);
+  }
+  catch (std::exception&)
+  {
+  }
+}
+
+} // namespace ip_udp_socket_compile
+
+//------------------------------------------------------------------------------
+
+// ip_udp_socket_runtime test
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+// The following test checks the runtime operation of the ip::udp::socket class.
+
+namespace ip_udp_socket_runtime {
+
+using namespace boost::asio;
+
+void handle_send(size_t expected_bytes_sent, const error& err,
+    size_t bytes_sent)
+{
+  BOOST_CHECK(!err);
+  BOOST_CHECK(expected_bytes_sent == bytes_sent);
+}
+
+void handle_recv(size_t expected_bytes_recvd, const error& err,
+    size_t bytes_recvd)
+{
+  BOOST_CHECK(!err);
+  BOOST_CHECK(expected_bytes_recvd == bytes_recvd);
+}
+
+void test()
+{
+  using namespace std; // For memcmp and memset.
+
+  io_service ios;
+
+  ip::udp::socket s1(ios, ip::udp::endpoint(ip::udp::v4(), 0));
+  ip::udp::endpoint target_endpoint = s1.local_endpoint();
+  target_endpoint.address(ip::address_v4::loopback());
+
+  ip::udp::socket s2(ios);
+  s2.open(ip::udp::v4());
+  s2.bind(ip::udp::endpoint(ip::udp::v4(), 0));
+  char send_msg[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  s2.send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint);
+
+  char recv_msg[sizeof(send_msg)];
+  ip::udp::endpoint sender_endpoint;
+  size_t bytes_recvd = s1.receive_from(buffer(recv_msg, sizeof(recv_msg)),
+      sender_endpoint);
+
+  BOOST_CHECK(bytes_recvd == sizeof(send_msg));
+  BOOST_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
+
+  memset(recv_msg, 0, sizeof(recv_msg));
+
+  target_endpoint = sender_endpoint;
+  s1.async_send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint,
+      boost::bind(handle_send, sizeof(send_msg),
+        placeholders::error, placeholders::bytes_transferred));
+  s2.async_receive_from(buffer(recv_msg, sizeof(recv_msg)), sender_endpoint,
+      boost::bind(handle_recv, sizeof(recv_msg),
+        placeholders::error, placeholders::bytes_transferred));
+
+  ios.run();
+
+  BOOST_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
+}
+
+} // namespace ip_udp_socket_runtime
+
+//------------------------------------------------------------------------------
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ip/udp");
+  test->add(BOOST_TEST_CASE(&ip_udp_socket_compile::test));
+  test->add(BOOST_TEST_CASE(&ip_udp_socket_runtime::test));
+  return test;
+}
diff --git a/test/is_read_buffered_test.cpp b/test/is_read_buffered_test.cpp
new file mode 100644
index 0000000000..8382a6d0e0
--- /dev/null
+++ b/test/is_read_buffered_test.cpp
@@ -0,0 +1,126 @@
+//
+// is_read_buffered_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/is_read_buffered.hpp>
+
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+using namespace std; // For memcmp, memcpy and memset.
+
+class test_stream
+  : private boost::noncopyable
+{
+public:
+  typedef boost::asio::io_service io_service_type;
+
+  typedef boost::asio::error error_type;
+
+  typedef test_stream lowest_layer_type;
+
+  test_stream(boost::asio::io_service& io_service)
+    : io_service_(io_service)
+  {
+  }
+
+  io_service_type& io_service()
+  {
+    return io_service_;
+  }
+
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  template <typename Const_Buffers>
+  size_t write(const Const_Buffers&)
+  {
+    return 0;
+  }
+
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t write(const Const_Buffers&, Error_Handler)
+  {
+    return 0;
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  void async_write(const Const_Buffers&, Handler handler)
+  {
+    boost::asio::error error;
+    io_service_.post(boost::asio::detail::bind_handler(handler, error, 0));
+  }
+
+  template <typename Mutable_Buffers>
+  size_t read(const Mutable_Buffers&)
+  {
+    return 0;
+  }
+
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t read(const Mutable_Buffers&, Error_Handler error_handler)
+  {
+    return 0;
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  void async_read(const Mutable_Buffers&, Handler handler)
+  {
+    boost::asio::error error;
+    io_service_.post(boost::asio::detail::bind_handler(handler, error, 0));
+  }
+
+private:
+  io_service_type& io_service_;
+};
+
+void is_read_buffered_test()
+{
+  BOOST_CHECK(!boost::asio::is_read_buffered<
+      boost::asio::ip::tcp::socket>::value);
+
+  BOOST_CHECK(!!boost::asio::is_read_buffered<
+      boost::asio::buffered_read_stream<
+        boost::asio::ip::tcp::socket> >::value);
+
+  BOOST_CHECK(!boost::asio::is_read_buffered<
+      boost::asio::buffered_write_stream<
+        boost::asio::ip::tcp::socket> >::value);
+
+  BOOST_CHECK(!!boost::asio::is_read_buffered<
+      boost::asio::buffered_stream<boost::asio::ip::tcp::socket> >::value);
+
+  BOOST_CHECK(!boost::asio::is_read_buffered<test_stream>::value);
+
+  BOOST_CHECK(!!boost::asio::is_read_buffered<
+      boost::asio::buffered_read_stream<test_stream> >::value);
+
+  BOOST_CHECK(!boost::asio::is_read_buffered<
+      boost::asio::buffered_write_stream<test_stream> >::value);
+
+  BOOST_CHECK(!!boost::asio::is_read_buffered<
+      boost::asio::buffered_stream<test_stream> >::value);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("is_read_buffered");
+  test->add(BOOST_TEST_CASE(&is_read_buffered_test));
+  return test;
+}
diff --git a/test/is_write_buffered_test.cpp b/test/is_write_buffered_test.cpp
new file mode 100644
index 0000000000..9c88d86e65
--- /dev/null
+++ b/test/is_write_buffered_test.cpp
@@ -0,0 +1,126 @@
+//
+// is_write_buffered_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/is_write_buffered.hpp>
+
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+using namespace std; // For memcmp, memcpy and memset.
+
+class test_stream
+  : private boost::noncopyable
+{
+public:
+  typedef boost::asio::io_service io_service_type;
+
+  typedef boost::asio::error error_type;
+
+  typedef test_stream lowest_layer_type;
+
+  test_stream(boost::asio::io_service& io_service)
+    : io_service_(io_service)
+  {
+  }
+
+  io_service_type& io_service()
+  {
+    return io_service_;
+  }
+
+  lowest_layer_type& lowest_layer()
+  {
+    return *this;
+  }
+
+  template <typename Const_Buffers>
+  size_t write(const Const_Buffers&)
+  {
+    return 0;
+  }
+
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t write(const Const_Buffers&, Error_Handler)
+  {
+    return 0;
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  void async_write(const Const_Buffers&, Handler handler)
+  {
+    boost::asio::error error;
+    io_service_.post(boost::asio::detail::bind_handler(handler, error, 0));
+  }
+
+  template <typename Mutable_Buffers>
+  size_t read(const Mutable_Buffers&)
+  {
+    return 0;
+  }
+
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t read(const Mutable_Buffers&, Error_Handler error_handler)
+  {
+    return 0;
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  void async_read(const Mutable_Buffers&, Handler handler)
+  {
+    boost::asio::error error;
+    io_service_.post(boost::asio::detail::bind_handler(handler, error, 0));
+  }
+
+private:
+  io_service_type& io_service_;
+};
+
+void is_write_buffered_test()
+{
+  BOOST_CHECK(!boost::asio::is_write_buffered<
+      boost::asio::ip::tcp::socket>::value);
+
+  BOOST_CHECK(!boost::asio::is_write_buffered<
+      boost::asio::buffered_read_stream<
+        boost::asio::ip::tcp::socket> >::value);
+
+  BOOST_CHECK(!!boost::asio::is_write_buffered<
+      boost::asio::buffered_write_stream<
+        boost::asio::ip::tcp::socket> >::value);
+
+  BOOST_CHECK(!!boost::asio::is_write_buffered<
+      boost::asio::buffered_stream<boost::asio::ip::tcp::socket> >::value);
+
+  BOOST_CHECK(!boost::asio::is_write_buffered<test_stream>::value);
+
+  BOOST_CHECK(!boost::asio::is_write_buffered<
+      boost::asio::buffered_read_stream<test_stream> >::value);
+
+  BOOST_CHECK(!!boost::asio::is_write_buffered<
+      boost::asio::buffered_write_stream<test_stream> >::value);
+
+  BOOST_CHECK(!!boost::asio::is_write_buffered<
+      boost::asio::buffered_stream<test_stream> >::value);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("is_write_buffered");
+  test->add(BOOST_TEST_CASE(&is_write_buffered_test));
+  return test;
+}
diff --git a/test/placeholders_test.cpp b/test/placeholders_test.cpp
new file mode 100644
index 0000000000..22c4cc4fec
--- /dev/null
+++ b/test/placeholders_test.cpp
@@ -0,0 +1,25 @@
+//
+// placeholders_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/placeholders.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("placeholders");
+  return test;
+}
diff --git a/test/read_test.cpp b/test/read_test.cpp
new file mode 100644
index 0000000000..1997ccfae9
--- /dev/null
+++ b/test/read_test.cpp
@@ -0,0 +1,631 @@
+//
+// read_test.cpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/read.hpp>
+
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+using namespace std; // For memcmp, memcpy and memset.
+
+class test_stream
+  : private boost::noncopyable
+{
+public:
+  typedef boost::asio::io_service io_service_type;
+  typedef boost::asio::error error_type;
+
+  test_stream(boost::asio::io_service& io_service)
+    : io_service_(io_service),
+      length_(0),
+      position_(0),
+      next_read_length_(0)
+  {
+  }
+
+  io_service_type& io_service()
+  {
+    return io_service_;
+  }
+
+  void reset(const void* data, size_t length)
+  {
+    BOOST_CHECK(length <= max_length);
+
+    memcpy(data_, data, length);
+    length_ = length;
+    position_ = 0;
+    next_read_length_ = length;
+  }
+
+  void next_read_length(size_t length)
+  {
+    next_read_length_ = length;
+  }
+
+  template <typename Const_Buffers>
+  bool check(const Const_Buffers& buffers, size_t length)
+  {
+    if (length != position_)
+      return false;
+
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    size_t checked_length = 0;
+    for (; iter != end && checked_length < length; ++iter)
+    {
+      size_t buffer_length = boost::asio::buffer_size(*iter);
+      if (buffer_length > length - checked_length)
+        buffer_length = length - checked_length;
+      if (memcmp(data_ + checked_length,
+            boost::asio::buffer_cast<const void*>(*iter), buffer_length) != 0)
+        return false;
+      checked_length += buffer_length;
+    }
+
+    return true;
+  }
+
+  template <typename Mutable_Buffers>
+  size_t read_some(const Mutable_Buffers& buffers)
+  {
+    size_t total_length = 0;
+
+    typename Mutable_Buffers::const_iterator iter = buffers.begin();
+    typename Mutable_Buffers::const_iterator end = buffers.end();
+    for (; iter != end && total_length < next_read_length_; ++iter)
+    {
+      size_t length = boost::asio::buffer_size(*iter);
+      if (length > length_ - position_)
+        length = length_ - position_;
+
+      if (length > next_read_length_ - total_length)
+        length = next_read_length_ - total_length;
+
+      memcpy(boost::asio::buffer_cast<void*>(*iter), data_ + position_, length);
+      position_ += length;
+      total_length += length;
+    }
+
+    return total_length;
+  }
+
+  template <typename Mutable_Buffers, typename Error_Handler>
+  size_t read_some(const Mutable_Buffers& buffers, Error_Handler)
+  {
+    return read_some(buffers);
+  }
+
+  template <typename Mutable_Buffers, typename Handler>
+  void async_read_some(const Mutable_Buffers& buffers, Handler handler)
+  {
+    size_t bytes_transferred = read_some(buffers);
+    boost::asio::error error;
+    io_service_.post(
+        boost::asio::detail::bind_handler(handler, error, bytes_transferred));
+  }
+
+private:
+  io_service_type& io_service_;
+  enum { max_length = 8192 };
+  char data_[max_length];
+  size_t length_;
+  size_t position_;
+  size_t next_read_length_;
+};
+
+static const char read_data[]
+  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+void test_2_arg_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffer_container_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  size_t bytes_transferred = boost::asio::read(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+}
+
+void test_3_arg_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffer_container_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  size_t bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+}
+
+void test_4_arg_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffer_container_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  boost::asio::error error;
+  size_t bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_all(), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(1), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(10), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(read_data));
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+  BOOST_CHECK(!error);
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::read(s, buffers,
+      boost::asio::transfer_at_least(42), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+  BOOST_CHECK(!error);
+}
+
+void async_read_handler(const boost::asio::error& e, size_t bytes_transferred,
+    size_t expected_bytes_transferred, bool* called)
+{
+  *called = true;
+  BOOST_CHECK(!e);
+  BOOST_CHECK(bytes_transferred == expected_bytes_transferred);
+}
+
+void test_3_arg_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffer_container_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bool called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers,
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+}
+
+void test_4_arg_async_read()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  char read_buf[sizeof(read_data)];
+  boost::asio::mutable_buffer_container_1 buffers
+    = boost::asio::buffer(read_buf, sizeof(read_buf));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  bool called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset(read_data, sizeof(read_data));
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(read_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(read_data)));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(1);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        42, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset(read_data, sizeof(read_data));
+  s.next_read_length(10);
+  memset(read_buf, 0, sizeof(read_buf));
+  called = false;
+  boost::asio::async_read(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_read_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        50, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 50));
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("read");
+  test->add(BOOST_TEST_CASE(&test_2_arg_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_read));
+  test->add(BOOST_TEST_CASE(&test_3_arg_async_read));
+  test->add(BOOST_TEST_CASE(&test_4_arg_async_read));
+  return test;
+}
diff --git a/test/resolver_service_test.cpp b/test/resolver_service_test.cpp
new file mode 100644
index 0000000000..ce5133d64e
--- /dev/null
+++ b/test/resolver_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// resolver_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/resolver_service.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("resolver_service");
+  return test;
+}
diff --git a/test/socket_acceptor_service_test.cpp b/test/socket_acceptor_service_test.cpp
new file mode 100644
index 0000000000..2b2438af19
--- /dev/null
+++ b/test/socket_acceptor_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// socket_acceptor_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/socket_acceptor_service.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("socket_acceptor_service");
+  return test;
+}
diff --git a/test/socket_base_test.cpp b/test/socket_base_test.cpp
new file mode 100644
index 0000000000..25e7e26e6a
--- /dev/null
+++ b/test/socket_base_test.cpp
@@ -0,0 +1,25 @@
+//
+// socket_base_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/socket_base.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("socket_base");
+  return test;
+}
diff --git a/test/ssl/Jamfile b/test/ssl/Jamfile
new file mode 100644
index 0000000000..22c346d361
--- /dev/null
+++ b/test/ssl/Jamfile
@@ -0,0 +1,37 @@
+subproject libs/asio/test/ssl ;
+
+# bring in the rules for testing
+import testing ;
+
+project boost : $(BOOST_ROOT) ;
+
+if $(UNIX)
+{
+  switch $(JAMUNAME)
+  {
+  case SunOS* :
+    {
+      SOCKET_LIBS = <find-library>socket <find-library>nsl ;
+    }
+  }
+}
+
+template unit_test
+  : <lib>@boost/libs/thread/build/boost_thread
+  : <include>../../../..
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <find-library>ssl
+    <find-library>crypto
+    <mingw><*><find-library>ws2_32
+    <mingw><*><find-library>mswsock
+    $(SOCKET_LIBS)
+  ;
+
+run basic_context_test.cpp <template>unit_test ;
+run context_base_test.cpp <template>unit_test ;
+run context_service_test.cpp <template>unit_test ;
+run context_test.cpp <template>unit_test ;
+run stream_base_test.cpp <template>unit_test ;
+run stream_service_test.cpp <template>unit_test ;
+run stream_test.cpp <template>unit_test ;
diff --git a/test/ssl/Jamfile.v2 b/test/ssl/Jamfile.v2
new file mode 100644
index 0000000000..10c4ec8c3a
--- /dev/null
+++ b/test/ssl/Jamfile.v2
@@ -0,0 +1,51 @@
+import os ;
+import feature ;
+
+lib ssl ;
+lib crypto ;
+
+if [ os.name ] = SOLARIS
+{
+  lib socket ;
+  lib nsl ;
+}
+else if [ os.name ] = NT
+{
+  lib ws2_32 ;
+  lib mswsock ;
+}
+
+local USE_SELECT =
+  <define>BOOST_ASIO_DISABLE_EPOLL
+  <define>BOOST_ASIO_DISABLE_KQUEUE
+  <define>BOOST_ASIO_DISABLE_IOCP
+  ;
+
+project
+  : requirements
+    <library>/boost/date_time//boost_date_time
+    <library>/boost/thread//boost_thread
+    <define>BOOST_ALL_NO_LIB=1
+    <threading>multi
+    <os>SOLARIS:<library>socket
+    <os>SOLARIS:<library>nsl
+    <os>NT<toolset>gcc:<library>ws2_32
+    <os>NT<toolset>gcc:<library>mswsock
+  ;
+
+test-suite "asio-ssl" :
+  [ compile basic_context_test.cpp ]
+  [ compile basic_context_test.cpp : $(USE_SELECT) : basic_context_test_select ]
+  [ compile context_base_test.cpp ]
+  [ compile context_base_test.cpp : $(USE_SELECT) : context_base_test_select ]
+  [ compile context_service_test.cpp ]
+  [ compile context_service_test.cpp : $(USE_SELECT) : context_service_test_select ]
+  [ compile context_test.cpp ]
+  [ compile context_test.cpp : $(USE_SELECT) : context_test_select ]
+  [ compile stream_base_test.cpp ]
+  [ compile stream_base_test.cpp : $(USE_SELECT) : stream_base_test_select ]
+  [ compile stream_service_test.cpp ]
+  [ compile stream_service_test.cpp : $(USE_SELECT) : stream_service_test_select ]
+  [ compile stream_test.cpp ]
+  [ compile stream_test.cpp : $(USE_SELECT) : stream_test_select ]
+  ;
diff --git a/test/ssl/basic_context_test.cpp b/test/ssl/basic_context_test.cpp
new file mode 100644
index 0000000000..d225f38087
--- /dev/null
+++ b/test/ssl/basic_context_test.cpp
@@ -0,0 +1,25 @@
+//
+// basic_context_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/basic_context.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/basic_context");
+  return test;
+}
diff --git a/test/ssl/context_base_test.cpp b/test/ssl/context_base_test.cpp
new file mode 100644
index 0000000000..2bb3fbda51
--- /dev/null
+++ b/test/ssl/context_base_test.cpp
@@ -0,0 +1,25 @@
+//
+// context_base_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/context_base.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/context_base");
+  return test;
+}
diff --git a/test/ssl/context_service_test.cpp b/test/ssl/context_service_test.cpp
new file mode 100644
index 0000000000..082a240de2
--- /dev/null
+++ b/test/ssl/context_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// context_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/context_service.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/context_service");
+  return test;
+}
diff --git a/test/ssl/context_test.cpp b/test/ssl/context_test.cpp
new file mode 100644
index 0000000000..6c50bc8508
--- /dev/null
+++ b/test/ssl/context_test.cpp
@@ -0,0 +1,25 @@
+//
+// context_test.cpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/context.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/context");
+  return test;
+}
diff --git a/test/ssl/stream_base_test.cpp b/test/ssl/stream_base_test.cpp
new file mode 100644
index 0000000000..bc2588af91
--- /dev/null
+++ b/test/ssl/stream_base_test.cpp
@@ -0,0 +1,25 @@
+//
+// stream_base_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/stream_base.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/stream_base");
+  return test;
+}
diff --git a/test/ssl/stream_service_test.cpp b/test/ssl/stream_service_test.cpp
new file mode 100644
index 0000000000..dcb20c184a
--- /dev/null
+++ b/test/ssl/stream_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// stream_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/stream_service.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/stream_service");
+  return test;
+}
diff --git a/test/ssl/stream_test.cpp b/test/ssl/stream_test.cpp
new file mode 100644
index 0000000000..fb0b289002
--- /dev/null
+++ b/test/ssl/stream_test.cpp
@@ -0,0 +1,25 @@
+//
+// stream_test.cpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/ssl/stream.hpp>
+
+#include "../unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("ssl/stream");
+  return test;
+}
diff --git a/test/strand_service_test.cpp b/test/strand_service_test.cpp
new file mode 100644
index 0000000000..66ddb616af
--- /dev/null
+++ b/test/strand_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// strand_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/strand_service.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("strand_service");
+  return test;
+}
diff --git a/test/strand_test.cpp b/test/strand_test.cpp
new file mode 100644
index 0000000000..5016e6dd97
--- /dev/null
+++ b/test/strand_test.cpp
@@ -0,0 +1,166 @@
+//
+// strand_test.cpp
+// ~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/strand.hpp>
+
+#include <sstream>
+#include <boost/bind.hpp>
+#include <boost/asio.hpp>
+#include <boost/thread.hpp>
+#include "unit_test.hpp"
+
+using namespace boost::asio;
+
+void increment(int* count)
+{
+  ++(*count);
+}
+
+void increment_without_lock(strand* s, int* count)
+{
+  int original_count = *count;
+
+  s->dispatch(boost::bind(increment, count));
+
+  // No other functions are currently executing through the locking dispatcher,
+  // so the previous call to dispatch should have successfully nested.
+  BOOST_CHECK(*count == original_count + 1);
+}
+
+void increment_with_lock(strand* s, int* count)
+{
+  int original_count = *count;
+
+  s->dispatch(boost::bind(increment, count));
+
+  // The current function already holds the strand's lock, so the
+  // previous call to dispatch should not have nested.
+  BOOST_CHECK(*count == original_count);
+}
+
+void sleep_increment(io_service* ios, int* count)
+{
+  deadline_timer t(*ios, boost::posix_time::seconds(2));
+  t.wait();
+
+  ++(*count);
+}
+
+void start_sleep_increments(io_service* ios, strand* s, int* count)
+{
+  // Give all threads a chance to start.
+  deadline_timer t(*ios, boost::posix_time::seconds(2));
+  t.wait();
+
+  // Start three increments.
+  s->post(boost::bind(sleep_increment, ios, count));
+  s->post(boost::bind(sleep_increment, ios, count));
+  s->post(boost::bind(sleep_increment, ios, count));
+}
+
+void throw_exception()
+{
+  throw 1;
+}
+
+void strand_test()
+{
+  io_service ios;
+  strand s(ios);
+  int count = 0;
+
+  ios.post(boost::bind(increment_without_lock, &s, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 1);
+
+  count = 0;
+  ios.reset();
+  s.post(boost::bind(increment_with_lock, &s, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+
+  ios.run();
+
+  // The run() call will not return until all work has finished.
+  BOOST_CHECK(count == 1);
+
+  count = 0;
+  ios.reset();
+  ios.post(boost::bind(start_sleep_increments, &ios, &s, &count));
+  boost::thread thread1(boost::bind(&io_service::run, &ios));
+  boost::thread thread2(boost::bind(&io_service::run, &ios));
+
+  // Check all events run one after another even though there are two threads.
+  deadline_timer timer1(ios, boost::posix_time::seconds(3));
+  timer1.wait();
+  BOOST_CHECK(count == 0);
+  timer1.expires_at(timer1.expires_at() + boost::posix_time::seconds(2));
+  timer1.wait();
+  BOOST_CHECK(count == 1);
+  timer1.expires_at(timer1.expires_at() + boost::posix_time::seconds(2));
+  timer1.wait();
+  BOOST_CHECK(count == 2);
+
+  thread1.join();
+  thread2.join();
+
+  // The run() calls will not return until all work has finished.
+  BOOST_CHECK(count == 3);
+
+  count = 0;
+  int exception_count = 0;
+  ios.reset();
+  s.post(throw_exception);
+  s.post(boost::bind(increment, &count));
+  s.post(boost::bind(increment, &count));
+  s.post(throw_exception);
+  s.post(boost::bind(increment, &count));
+
+  // No handlers can be called until run() is called.
+  BOOST_CHECK(count == 0);
+  BOOST_CHECK(exception_count == 0);
+
+  for (;;)
+  {
+    try
+    {
+      ios.run();
+      break;
+    }
+    catch (int)
+    {
+      ++exception_count;
+    }
+  }
+
+  // The run() calls will not return until all work has finished.
+  BOOST_CHECK(count == 3);
+  BOOST_CHECK(exception_count == 2);
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("strand");
+  test->add(BOOST_TEST_CASE(&strand_test));
+  return test;
+}
diff --git a/test/stream_socket_service_test.cpp b/test/stream_socket_service_test.cpp
new file mode 100644
index 0000000000..54e9b563c8
--- /dev/null
+++ b/test/stream_socket_service_test.cpp
@@ -0,0 +1,25 @@
+//
+// stream_socket_service_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/stream_socket_service.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("stream_socket_service");
+  return test;
+}
diff --git a/test/time_traits_test.cpp b/test/time_traits_test.cpp
new file mode 100644
index 0000000000..369b892a90
--- /dev/null
+++ b/test/time_traits_test.cpp
@@ -0,0 +1,25 @@
+//
+// time_traits_test.cpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/time_traits.hpp>
+
+#include "unit_test.hpp"
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("time_traits");
+  return test;
+}
diff --git a/test/unit_test.hpp b/test/unit_test.hpp
new file mode 100644
index 0000000000..7931b9806c
--- /dev/null
+++ b/test/unit_test.hpp
@@ -0,0 +1,40 @@
+//
+// unit_test.hpp
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the 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 UNIT_TEST_HPP
+#define UNIT_TEST_HPP
+
+#include <boost/config.hpp>
+
+#if defined(__BORLANDC__)
+
+// Prevent use of intrinsic for strcmp.
+# include <cstring>
+# undef strcmp
+ 
+// Suppress error about condition always being true.
+# pragma option -w-ccc
+
+#endif // defined(__BORLANDC__)
+
+#if defined(BOOST_MSVC)
+# pragma warning (push)
+# pragma warning (disable:4244)
+#endif // defined(BOOST_MSVC)
+
+#include <boost/test/unit_test.hpp>
+#include <boost/test/included/unit_test_framework.hpp>
+using boost::unit_test::test_suite;
+
+#if defined(BOOST_MSVC)
+# pragma warning (pop)
+#endif // defined(BOOST_MSVC)
+
+#endif // UNIT_TEST_HPP
diff --git a/test/write_test.cpp b/test/write_test.cpp
new file mode 100644
index 0000000000..e0e75fb555
--- /dev/null
+++ b/test/write_test.cpp
@@ -0,0 +1,586 @@
+//
+// write_test.cpp
+// ~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2006 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Disable autolinking for unit tests.
+#if !defined(BOOST_ALL_NO_LIB)
+#define BOOST_ALL_NO_LIB 1
+#endif // !defined(BOOST_ALL_NO_LIB)
+
+// Test that header file is self-contained.
+#include <boost/asio/write.hpp>
+
+#include <boost/bind.hpp>
+#include <boost/noncopyable.hpp>
+#include <cstring>
+#include <boost/asio.hpp>
+#include "unit_test.hpp"
+
+using namespace std; // For memcmp, memcpy and memset.
+
+class test_stream
+  : private boost::noncopyable
+{
+public:
+  typedef boost::asio::io_service io_service_type;
+  typedef boost::asio::error error_type;
+
+  test_stream(boost::asio::io_service& io_service)
+    : io_service_(io_service),
+      length_(max_length),
+      position_(0),
+      next_write_length_(max_length)
+  {
+    memset(data_, 0, max_length);
+  }
+
+  io_service_type& io_service()
+  {
+    return io_service_;
+  }
+
+  void reset(size_t length = max_length)
+  {
+    BOOST_CHECK(length <= max_length);
+
+    memset(data_, 0, max_length);
+    length_ = length;
+    position_ = 0;
+    next_write_length_ = length;
+  }
+
+  void next_write_length(size_t length)
+  {
+    next_write_length_ = length;
+  }
+
+  template <typename Const_Buffers>
+  bool check(const Const_Buffers& buffers, size_t length)
+  {
+    if (length != position_)
+      return false;
+
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    size_t checked_length = 0;
+    for (; iter != end && checked_length < length; ++iter)
+    {
+      size_t buffer_length = boost::asio::buffer_size(*iter);
+      if (buffer_length > length - checked_length)
+        buffer_length = length - checked_length;
+      if (memcmp(data_ + checked_length,
+            boost::asio::buffer_cast<const void*>(*iter), buffer_length) != 0)
+        return false;
+      checked_length += buffer_length;
+    }
+
+    return true;
+  }
+
+  template <typename Const_Buffers>
+  size_t write_some(const Const_Buffers& buffers)
+  {
+    size_t total_length = 0;
+
+    typename Const_Buffers::const_iterator iter = buffers.begin();
+    typename Const_Buffers::const_iterator end = buffers.end();
+    for (; iter != end && total_length < next_write_length_; ++iter)
+    {
+      size_t length = boost::asio::buffer_size(*iter);
+      if (length > length_ - position_)
+        length = length_ - position_;
+
+      if (length > next_write_length_ - total_length)
+        length = next_write_length_ - total_length;
+
+      memcpy(data_ + position_,
+          boost::asio::buffer_cast<const void*>(*iter), length);
+      position_ += length;
+      total_length += length;
+    }
+
+    return total_length;
+  }
+
+  template <typename Const_Buffers, typename Error_Handler>
+  size_t write_some(const Const_Buffers& buffers, Error_Handler)
+  {
+    return write_some(buffers);
+  }
+
+  template <typename Const_Buffers, typename Handler>
+  void async_write_some(const Const_Buffers& buffers, Handler handler)
+  {
+    size_t bytes_transferred = write_some(buffers);
+    boost::asio::error error;
+    io_service_.post(
+        boost::asio::detail::bind_handler(handler, error, bytes_transferred));
+  }
+
+private:
+  io_service_type& io_service_;
+  enum { max_length = 8192 };
+  char data_[max_length];
+  size_t length_;
+  size_t position_;
+  size_t next_write_length_;
+};
+
+static const char write_data[]
+  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+void test_2_arg_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffer_container_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  size_t bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers);
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+}
+
+void test_3_arg_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffer_container_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  size_t bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all());
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset();
+  s.next_write_length(10);
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+}
+
+void test_4_arg_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffer_container_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  boost::asio::error error;
+  size_t bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_all(), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 1);
+  BOOST_CHECK(s.check(buffers, 1));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(1), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(10), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 10);
+  BOOST_CHECK(s.check(buffers, 10));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == sizeof(write_data));
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(1);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 42);
+  BOOST_CHECK(s.check(buffers, 42));
+  BOOST_CHECK(!error);
+
+  s.reset();
+  s.next_write_length(10);
+  error = boost::asio::error();
+  bytes_transferred = boost::asio::write(s, buffers,
+      boost::asio::transfer_at_least(42), boost::asio::assign_error(error));
+  BOOST_CHECK(bytes_transferred == 50);
+  BOOST_CHECK(s.check(buffers, 50));
+  BOOST_CHECK(!error);
+}
+
+void async_write_handler(const boost::asio::error& e, size_t bytes_transferred,
+    size_t expected_bytes_transferred, bool* called)
+{
+  *called = true;
+  BOOST_CHECK(!e);
+  BOOST_CHECK(bytes_transferred == expected_bytes_transferred);
+}
+
+void test_3_arg_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffer_container_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers,
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+}
+
+void test_4_arg_async_write()
+{
+  boost::asio::io_service ios;
+  test_stream s(ios);
+  boost::asio::const_buffer_container_1 buffers
+    = boost::asio::buffer(write_data, sizeof(write_data));
+
+  s.reset();
+  bool called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_all(),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        1, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 1));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(1),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(10),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        10, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 10));
+
+  s.reset();
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        sizeof(write_data), &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, sizeof(write_data)));
+
+  s.reset();
+  s.next_write_length(1);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        42, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 42));
+
+  s.reset();
+  s.next_write_length(10);
+  called = false;
+  boost::asio::async_write(s, buffers, boost::asio::transfer_at_least(42),
+      boost::bind(async_write_handler,
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred,
+        50, &called));
+  ios.reset();
+  ios.run();
+  BOOST_CHECK(called);
+  BOOST_CHECK(s.check(buffers, 50));
+}
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  test_suite* test = BOOST_TEST_SUITE("write");
+  test->add(BOOST_TEST_CASE(&test_2_arg_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_write));
+  test->add(BOOST_TEST_CASE(&test_3_arg_async_write));
+  test->add(BOOST_TEST_CASE(&test_4_arg_async_write));
+  return test;
+}