void send_bad_response(
http::status status,
std::string const& error)
{
string_response_.emplace(
std::piecewise_construct,
std::make_tuple(),
std::make_tuple(alloc_));
string_response_->result(status);
string_response_->keep_alive(false);
string_response_->set(http::field::server, "Beast");
string_response_->set(http::field::content_type, "text/plain");
string_response_->body() = error;
string_response_->prepare_payload();
string_serializer_.emplace(*string_response_);
http::async_write(
socket_,
*string_serializer_,
[this](boost::beast::error_code ec, std::size_t)
{
socket_.shutdown(tcp::socket::shutdown_send, ec);
string_serializer_.reset();
string_response_.reset();
accept();
});
}
void send_file(boost::beast::string_view target)
{
// Request path must be absolute and not contain "..".
if (target.empty() || target[0] != '/' || target.find("..") != std::string::npos)
{
send_bad_response(
http::status::not_found,
"File not found\r\n");
return;
}
std::string full_path = doc_root_;
full_path.append(
target.data(),
target.size());
http::file_body::value_type file;
boost::beast::error_code ec;
file.open(
full_path.c_str(),
boost::beast::file_mode::read,
ec);
if(ec)
{
send_bad_response(
http::status::not_found,
"File not found\r\n");
return;
}
file_response_.emplace(
std::piecewise_construct,
std::make_tuple(),
std::make_tuple(alloc_));
file_response_->result(http::status::ok);
file_response_->keep_alive(false);
file_response_->set(http::field::server, "Beast");
file_response_->set(http::field::content_type, mime_type(target.to_string()));
file_response_->body() = std::move(file);
file_response_->prepare_payload();
file_serializer_.emplace(*file_response_);
http::async_write(
socket_,
*file_serializer_,
[this](boost::beast::error_code ec, std::size_t)
{
socket_.shutdown(tcp::socket::shutdown_send, ec);
file_serializer_.reset();
file_response_.reset();
accept();
});
}
void read_request()
{
// On each read the parser needs to be destroyed and
// recreated. We store it in a boost::optional to
// achieve that.
//
// Arguments passed to the parser constructor are
// forwarded to the message object. A single argument
// is forwarded to the body constructor.
//
// We construct the dynamic body with a 1MB limit
// to prevent vulnerability to buffer attacks.
//
parser_.emplace(
std::piecewise_construct,
std::make_tuple(),
std::make_tuple(alloc_));
http::async_read(
socket_,
buffer_,
*parser_,
[this](boost::beast::error_code ec, std::size_t)
{
if (ec)
accept();
else
process_request(parser_->get());
});
}
void
do_read()
{
using boost::asio::buffer;
using boost::asio::buffer_copy;
s_.resize(13);
fc_.emplace(n_);
ts_.emplace(ioc_, *fc_, ", world!");
brs_.emplace(*ts_);
brs_->buffer().commit(buffer_copy(
brs_->buffer().prepare(5), buffer("Hello", 5)));
boost::asio::async_read(*brs_,
buffer(&s_[0], s_.size()),
std::bind(
&loop::on_read,
shared_from_this(),
std::placeholders::_1,
std::placeholders::_2));
}