Subject: [Boost-users] [asio] SSL enabled http server3 example is blocking
From: Jean-Pierre Bergamin (james_at_[hidden])
Date: 2009-03-02 13:24:01
Dear boost-users
I changed the http server3 example (many thready run io_service::run())
to use SSL connections. I now face the problem that the async_accept
handler is only called when no other connections are alive and not
immediately by another thread as with the original non-ssl example.
My modified request_handler simply sleeps for 10 seconds. Now when a
request arrives while another one is being processed (sleeping), it is
only handled after the other one finished. By setting a breakpoint in
server::handle_accept() I can see that this handler for the second
request is only called after the first connection has been
destroyed/closed. This happens on Windows XP.
Do you may have an idea why the accept handler is not called immediately
or where the blocking could happen? I may help if you could test this on
another platform then XP.
To test this, apply the attached patch to the directory
boost_1_38_0/libs/asio/example/http/server3 and copy the *.pem files
from the asio ssl example to the working directory of the server3 example.
Regards
James
PS: I already posted this question to the asio-users list without
gettinga reply. I'm trying my luck now here on the boost list.
diff -ru server3.orig/connection.cpp server3/connection.cpp
--- server3.orig/connection.cpp 2008-03-12 10:12:08.000000000 +0100
+++ server3/connection.cpp 2009-02-17 15:52:12.867198900 +0100
@@ -17,20 +17,20 @@
namespace server3 {
connection::connection(boost::asio::io_service& io_service,
+ boost::asio::ssl::context &context,
request_handler& handler)
: strand_(io_service),
- socket_(io_service),
+ socket_(io_service, context),
request_handler_(handler)
{
}
-boost::asio::ip::tcp::socket& connection::socket()
+connection::socket_type::lowest_layer_type& connection::socket()
{
- return socket_;
+ return socket_.lowest_layer();
}
-void connection::start()
-{
+void connection::handle_handshake(const boost::system::error_code& e) {
socket_.async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection::handle_read, shared_from_this(),
@@ -38,6 +38,14 @@
boost::asio::placeholders::bytes_transferred)));
}
+void connection::start()
+{
+ socket_.async_handshake(boost::asio::ssl::stream_base::server,
+ boost::bind(&connection::handle_handshake, shared_from_this(),
+ boost::asio::placeholders::error)
+ );
+}
+
void connection::handle_read(const boost::system::error_code& e,
std::size_t bytes_transferred)
{
@@ -85,7 +93,7 @@
{
// Initiate graceful connection closure.
boost::system::error_code ignored_ec;
- socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
+ socket_.shutdown(ignored_ec);
}
// No new asynchronous operations are started. This means that all shared_ptr
diff -ru server3.orig/connection.hpp server3/connection.hpp
--- server3.orig/connection.hpp 2008-03-12 10:12:08.000000000 +0100
+++ server3/connection.hpp 2009-02-26 08:51:42.187500000 +0100
@@ -12,6 +12,7 @@
#define HTTP_SERVER3_CONNECTION_HPP
#include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
#include <boost/array.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
@@ -30,17 +31,20 @@
private boost::noncopyable
{
public:
+ typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket_type;
/// Construct a connection with the given io_service.
explicit connection(boost::asio::io_service& io_service,
+ boost::asio::ssl::context &context,
request_handler& handler);
/// Get the socket associated with the connection.
- boost::asio::ip::tcp::socket& socket();
+ socket_type::lowest_layer_type& socket();
/// Start the first asynchronous operation for the connection.
void start();
-
+ ~connection() {}
private:
+ void handle_handshake(const boost::system::error_code& e);
/// Handle completion of a read operation.
void handle_read(const boost::system::error_code& e,
std::size_t bytes_transferred);
@@ -52,7 +56,7 @@
boost::asio::io_service::strand strand_;
/// Socket for the connection.
- boost::asio::ip::tcp::socket socket_;
+ socket_type socket_;
/// The handler used to process the incoming request.
request_handler& request_handler_;
diff -ru server3.orig/reply.cpp server3/reply.cpp
--- server3.orig/reply.cpp 2008-03-12 10:12:08.000000000 +0100
+++ server3/reply.cpp 2009-02-17 15:52:20.804800500 +0100
@@ -119,7 +119,7 @@
namespace stock_replies {
-const char ok[] = "";
+const char ok[] = "ok\r\n";
const char created[] =
"<html>"
"<head><title>Created</title></head>"
diff -ru server3.orig/request_handler.cpp server3/request_handler.cpp
--- server3.orig/request_handler.cpp 2008-03-12 10:12:08.000000000 +0100
+++ server3/request_handler.cpp 2009-02-26 08:23:56.250000000 +0100
@@ -8,6 +8,7 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
+#include <boost/thread.hpp>
#include "request_handler.hpp"
#include <fstream>
#include <sstream>
@@ -27,56 +28,9 @@
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);
+ using namespace boost;
+ this_thread::sleep(posix_time::seconds(10));
+ rep = reply::stock_reply(reply::ok);
}
bool request_handler::url_decode(const std::string& in, std::string& out)
diff -ru server3.orig/server.cpp server3/server.cpp
--- server3.orig/server.cpp 2008-03-12 10:12:08.000000000 +0100
+++ server3/server.cpp 2009-02-17 16:24:16.173066900 +0100
@@ -21,9 +21,23 @@
const std::string& doc_root, std::size_t thread_pool_size)
: thread_pool_size_(thread_pool_size),
acceptor_(io_service_),
- new_connection_(new connection(io_service_, request_handler_)),
+ context_(io_service_, boost::asio::ssl::context::sslv23),
+ new_connection_(new connection(io_service_, context_, request_handler_)),
request_handler_(doc_root)
{
+
+ context_.set_options(
+ boost::asio::ssl::context::default_workarounds
+ | boost::asio::ssl::context::no_sslv2
+ | boost::asio::ssl::context::single_dh_use);
+ context_.set_password_callback(boost::bind<const char*>(&server::get_password, this));
+
+ 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");
+ context_.set_verify_mode(boost::asio::ssl::context::verify_none);
+
+
// 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);
@@ -63,7 +77,7 @@
if (!e)
{
new_connection_->start();
- new_connection_.reset(new connection(io_service_, request_handler_));
+ new_connection_.reset(new connection(io_service_, context_, request_handler_));
acceptor_.async_accept(new_connection_->socket(),
boost::bind(&server::handle_accept, this,
boost::asio::placeholders::error));
diff -ru server3.orig/server.hpp server3/server.hpp
--- server3.orig/server.hpp 2008-03-12 10:12:08.000000000 +0100
+++ server3/server.hpp 2009-02-17 16:02:27.187562100 +0100
@@ -39,6 +39,10 @@
void stop();
private:
+ const char * get_password() const {
+ return "test";
+ }
+
/// Handle completion of an asynchronous accept operation.
void handle_accept(const boost::system::error_code& e);
@@ -51,6 +55,8 @@
/// Acceptor used to listen for incoming connections.
boost::asio::ip::tcp::acceptor acceptor_;
+ boost::asio::ssl::context context_;
+
/// The next connection to be accepted.
connection_ptr new_connection_;