jyapayne/Simple-Web-Server
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixes #114: added support for async client requests. Also includes some cleanup, support for parallel requests, and client reconnect

Browse source
This commit is contained in:
eidheim 2017-06-14 15:16:24 +02:00
commit e1aebba344
4 changed files with 471 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

142
client_https.hpp
View file

@ -15,6 +15,8 @@ namespace SimpleWeb {
template<>
class Client<HTTPS> : public ClientBase<HTTPS> {
public:
friend ClientBase<HTTPS>;
Client(const std::string& server_port_path, bool verify_certificate=true,
const std::string& cert_file=std::string(), const std::string& private_key_file=std::string(),
const std::string& verify_file=std::string()) :
@ -36,95 +38,95 @@ namespace SimpleWeb {
context.set_verify_mode(asio::ssl::verify_peer);
else
context.set_verify_mode(asio::ssl::verify_none);
socket=std::unique_ptr<HTTPS>(new HTTPS(*io_service, context));
}
protected:
asio::ssl::context context;
void connect() {
if(!socket->lowest_layer().is_open()) {
std::unique_ptr<asio::ip::tcp::resolver::query> query;
if(config.proxy_server.empty())
query=std::unique_ptr<asio::ip::tcp::resolver::query>(new asio::ip::tcp::resolver::query(host, std::to_string(port)));
else {
auto proxy_host_port=parse_host_port(config.proxy_server, 8080);
query=std::unique_ptr<asio::ip::tcp::resolver::query>(new asio::ip::tcp::resolver::query(proxy_host_port.first, std::to_string(proxy_host_port.second)));
}
auto resolver=std::make_shared<asio::ip::tcp::resolver>(*io_service);
resolver->async_resolve(*query, [this, resolver] (const error_code &ec, asio::ip::tcp::resolver::iterator it){
std::shared_ptr<Connection> create_connection() override {
return std::make_shared<Connection>(host, port, config, std::unique_ptr<HTTPS>(new HTTPS(*io_service, context)));
}
static void connect(const std::shared_ptr<Session> &session) {
if(!session->connection->socket->lowest_layer().is_open()) {
auto resolver=std::make_shared<asio::ip::tcp::resolver>(*session->io_service);
resolver->async_resolve(*session->connection->query, [session, resolver] (const error_code &ec, asio::ip::tcp::resolver::iterator it){
if(!ec) {
auto timer=get_timeout_timer(config.timeout_connect);
asio::async_connect(socket->lowest_layer(), it, [this, resolver, timer] (const error_code &ec, asio::ip::tcp::resolver::iterator /*it*/){
auto timer=get_timeout_timer(session, session->connection->config.timeout_connect);
asio::async_connect(session->connection->socket->lowest_layer(), it, [session, resolver, timer] (const error_code &ec, asio::ip::tcp::resolver::iterator /*it*/){
if(timer)
timer->cancel();
if(!ec) {
asio::ip::tcp::no_delay option(true);
this->socket->lowest_layer().set_option(option);
session->connection->socket->lowest_layer().set_option(option);
if(!session->connection->config.proxy_server.empty()) {
auto write_buffer=std::make_shared<asio::streambuf>();
std::ostream write_stream(write_buffer.get());
auto host_port=session->connection->host+':'+std::to_string(session->connection->port);
write_stream << "CONNECT "+host_port+" HTTP/1.1\r\n" << "Host: " << host_port << "\r\n\r\n";
auto timer=get_timeout_timer(session, session->connection->config.timeout_connect);
asio::async_write(session->connection->socket->next_layer(), *write_buffer, [session, write_buffer, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec) {
std::shared_ptr<Response> response(new Response());
auto timer=get_timeout_timer(session, session->connection->config.timeout_connect);
asio::async_read_until(session->connection->socket->next_layer(), response->content_buffer, "\r\n\r\n", [session, response, timer](const error_code& ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec) {
parse_response_header(response);
if (response->status_code.empty() || response->status_code.compare(0, 3, "200") != 0) {
close(session);
session->callback(make_error_code::make_error_code(errc::permission_denied));
}
else
handshake(session);
}
else {
close(session);
session->callback(ec);
}
});
}
else {
close(session);
session->callback(ec);
}
});
}
else
handshake(session);
}
else {
close();
throw system_error(ec);
close(session);
session->callback(ec);
}
});
}
else {
close();
throw system_error(ec);
close(session);
session->callback(ec);
}
});
io_service->reset();
io_service->run();
if(!config.proxy_server.empty()) {
auto write_buffer=std::make_shared<asio::streambuf>();
std::ostream write_stream(write_buffer.get());
auto host_port=host+':'+std::to_string(port);
write_stream << "CONNECT "+host_port+" HTTP/1.1\r\n" << "Host: " << host_port << "\r\n\r\n";
auto timer=get_timeout_timer();
asio::async_write(socket->next_layer(), *write_buffer, [this, write_buffer, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(ec) {
close();
throw system_error(ec);
}
});
io_service->reset();
io_service->run();
std::shared_ptr<Response> response(new Response());
timer=get_timeout_timer();
asio::async_read_until(socket->next_layer(), response->content_buffer, "\r\n\r\n", [this, response, timer](const error_code& ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(ec) {
close();
throw system_error(ec);
}
});
io_service->reset();
io_service->run();
parse_response_header(response);
if (response->status_code.empty() || response->status_code.compare(0, 3, "200") != 0) {
close();
throw make_error_code::make_error_code(errc::permission_denied);
}
}
auto timer=get_timeout_timer();
this->socket->async_handshake(asio::ssl::stream_base::client, [this, timer](const error_code& ec) {
if(timer)
timer->cancel();
if(ec) {
close();
throw system_error(ec);
}
});
io_service->reset();
io_service->run();
}
else
write(session);
}
static void handshake(const std::shared_ptr<Session> &session) {
auto timer=get_timeout_timer(session, session->connection->config.timeout_connect);
session->connection->socket->async_handshake(asio::ssl::stream_base::client, [session, timer](const error_code& ec) {
if(timer)
timer->cancel();
if(!ec)
write(session);
else {
close(session);
session->callback(ec);
}
});
}
};
}