void handle_read(const boost::system::error_code &error,
size_t bytes_transferred) {
if (!error) {
std::string query(data_);
std::string *file = new std::string("");
file->append(directory.c_str()).append(strtok((strtok((char *) (query.c_str()), "GET ")),"?="));
FILE*f = fopen("/home/box/output.txt","w");
fwrite(file->c_str(),1,file->size(),f);
fclose(f);
FILE *file_ptr = fopen(file->c_str(), "r");
if (file_ptr != nullptr) {
boost::asio::write(socket_, boost::asio::buffer(found,strlen(found)));
for (int bytes_read = fread(data_, sizeof(char), 1024, file_ptr); bytes_read != 0;
bytes_read = fread(data_, sizeof(char), 1024, file_ptr)) {
std::string deliver(data_);
boost::asio::write(socket_, boost::asio::buffer(deliver.c_str(),bytes_read));
}
} else {
boost::asio::write(socket_, boost::asio::buffer(not_found,strlen(not_found)));
}
socket_.shutdown(boost::asio::socket_base::shutdown_type::shutdown_both);
handle_write();
} else {
delete this;
}
}
void
do_run()
{
try
{
beast::error_code ec;
beast::flat_buffer buffer;
for(;;)
{
http::request_parser<http::string_body> parser;
parser.header_limit(8192);
parser.body_limit(1024 * 1024);
http::read(sock_, buffer, parser, ec);
if(ec == http::error::end_of_stream)
break;
if(ec)
throw beast::system_error{ec};
do_request(parser.get(), ec);
if(ec)
{
if(ec != http::error::end_of_stream)
throw beast::system_error{ec};
break;
}
}
sock_.shutdown(tcp::socket::shutdown_both, ec);
if(ec && ec != boost::asio::error::not_connected)
throw beast::system_error{ec};
}
catch (const std::exception& e)
{
std::cerr << "Exception: " << e.what() << std::endl;
}
}
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();
});
}
static void really_disconnect(tcp::socket& socket, Logger* logger)
{
try {
socket.shutdown(socket_base::shutdown_both);
socket.close();
} catch(const system::system_error& e) {
// This might be totally okay. Depends on the error.
logger->warning(format("Failed to shut down the socket. This shouldn't happen! (%1%)") % e.what());
}
}
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();
});
}
inline bool TCPServerSession::Close()
{
try
{
if (!mSocket.is_open()) return false;
mSocket.shutdown(socket_base::shutdown_both);
mSocket.close();
return true;
}
catch (...)
{
return false;
}
}