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

Added .clang-format file and applied style to source files

Browse source
This commit is contained in:
eidheim 2017-06-26 15:19:52 +02:00
commit e50d2fc63a
13 changed files with 2552 additions and 2538 deletions
Download patch file Download diff file Expand all files Collapse all files

9
.clang-format Normal file
View file

@ -0,0 +1,9 @@
IndentWidth: 2
AccessModifierOffset: -2
UseTab: Never
ColumnLimit: 0
MaxEmptyLinesToKeep: 2
SpaceBeforeParens: Never
BreakBeforeBraces: Custom
BraceWrapping: {BeforeElse: true, BeforeCatch: true}
NamespaceIndentation: All

290
client_http.hpp
View file

@ -2,9 +2,9 @@
#define CLIENT_HTTP_HPP
#include "utility.hpp"
#include <vector>
#include <random>
#include <mutex>
#include <random>
#include <vector>
#ifdef USE_STANDALONE_ASIO
#include <asio.hpp>
@ -13,8 +13,8 @@ namespace SimpleWeb {
using errc = std::errc;
using system_error = std::system_error;
namespace make_error_code = std;
using string_view = const std::string&; // TODO c++17: use std::string_view
}
using string_view = const std::string &; // TODO c++17: use std::string_view
} // namespace SimpleWeb
#else
#include <boost/asio.hpp>
#include <boost/utility/string_ref.hpp>
@ -25,7 +25,7 @@ namespace SimpleWeb {
using system_error = boost::system::system_error;
namespace make_error_code = boost::system::errc;
using string_view = boost::string_ref;
}
} // namespace SimpleWeb
#endif
namespace SimpleWeb {
@ -37,6 +37,7 @@ namespace SimpleWeb {
public:
class Content : public std::istream {
friend class ClientBase<socket_type>;
public:
size_t size() {
return streambuf.size();
@ -47,14 +48,16 @@ namespace SimpleWeb {
ss << rdbuf();
return ss.str();
}
private:
asio::streambuf &streambuf;
Content(asio::streambuf &streambuf): std::istream(&streambuf), streambuf(streambuf) {}
Content(asio::streambuf &streambuf) : std::istream(&streambuf), streambuf(streambuf) {}
};
class Response {
friend class ClientBase<socket_type>;
friend class Client<socket_type>;
public:
std::string http_version, status_code;
@ -65,18 +68,20 @@ namespace SimpleWeb {
private:
asio::streambuf content_buffer;
Response(): content(content_buffer) {}
Response() : content(content_buffer) {}
};
class Config {
friend class ClientBase<socket_type>;
private:
Config() {}
public:
/// Set timeout on requests in seconds. Default value: 0 (no timeout).
size_t timeout=0;
size_t timeout = 0;
/// Set connect timeout in seconds. Default value: 0 (Config::timeout is then used instead).
size_t timeout_connect=0;
size_t timeout_connect = 0;
/// Set proxy server (server:port)
std::string proxy_server;
};
@ -84,13 +89,13 @@ namespace SimpleWeb {
protected:
class Connection {
public:
Connection(const std::string &host, unsigned short port, const Config &config, std::unique_ptr<socket_type> &&socket) :
host(host), port(port), config(config), socket(std::move(socket)) {
Connection(const std::string &host, unsigned short port, const Config &config, std::unique_ptr<socket_type> &&socket)
: host(host), port(port), config(config), socket(std::move(socket)) {
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)));
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 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)));
}
}
@ -99,21 +104,21 @@ namespace SimpleWeb {
Config config;
std::unique_ptr<socket_type> socket;
bool in_use=false;
bool reconnecting=false;
bool in_use = false;
bool reconnecting = false;
std::unique_ptr<asio::ip::tcp::resolver::query> query;
};
class Session {
public:
Session(const std::shared_ptr<asio::io_service> &io_service, const std::shared_ptr<Connection> &connection, std::unique_ptr<asio::streambuf> &&request_buffer) :
io_service(io_service), connection(connection), request_buffer(std::move(request_buffer)), response(new Response()) {}
Session(const std::shared_ptr<asio::io_service> &io_service, const std::shared_ptr<Connection> &connection, std::unique_ptr<asio::streambuf> &&request_buffer)
: io_service(io_service), connection(connection), request_buffer(std::move(request_buffer)), response(new Response()) {}
std::shared_ptr<asio::io_service> io_service;
std::shared_ptr<Connection> connection;
std::unique_ptr<asio::streambuf> request_buffer;
std::shared_ptr<Response> response;
std::function<void(const error_code&)> callback;
std::function<void(const error_code &)> callback;
};
public:
@ -128,10 +133,11 @@ namespace SimpleWeb {
/// Convenience function to perform synchronous request. The io_service is run within this function.
/// If reusing the io_service for other tasks, please use the asynchronous request functions instead.
std::shared_ptr<Response> request(const std::string& method, const std::string& path=std::string("/"), string_view content="", const CaseInsensitiveMultimap& header=CaseInsensitiveMultimap()) {
std::shared_ptr<Response> request(const std::string &method, const std::string &path = std::string("/"),
string_view content = "", const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
std::shared_ptr<Response> response;
request(method, path, content, header, [&response](std::shared_ptr<Response> response_, const error_code &ec) {
response=response_;
response = response_;
if(ec)
throw system_error(ec);
});
@ -144,10 +150,11 @@ namespace SimpleWeb {
/// Convenience function to perform synchronous request. The io_service is run within this function.
/// If reusing the io_service for other tasks, please use the asynchronous request functions instead.
std::shared_ptr<Response> request(const std::string& method, const std::string& path, std::istream& content, const CaseInsensitiveMultimap& header=CaseInsensitiveMultimap()) {
std::shared_ptr<Response> request(const std::string &method, const std::string &path, std::istream &content,
const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
std::shared_ptr<Response> response;
request(method, path, content, header, [&response](std::shared_ptr<Response> response_, const error_code &ec) {
response=response_;
response = response_;
if(ec)
throw system_error(ec);
});
@ -159,28 +166,28 @@ namespace SimpleWeb {
}
/// Asynchronous request where setting and/or running Client's io_service is required.
void request(const std::string &method, const std::string &path, string_view content, const CaseInsensitiveMultimap& header,
std::function<void(std::shared_ptr<Response>, const error_code&)> &&request_callback_) {
auto session=std::make_shared<Session>(io_service, get_connection(), create_request_header(method, path, header));
auto connection=session->connection;
auto response=session->response;
auto request_callback=std::make_shared<std::function<void(std::shared_ptr<Response>, const error_code&)>>(std::move(request_callback_));
auto connections=this->connections;
auto connections_mutex=this->connections_mutex;
session->callback=[connection, response, request_callback, connections, connections_mutex](const error_code &ec) {
void request(const std::string &method, const std::string &path, string_view content, const CaseInsensitiveMultimap &header,
std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback_) {
auto session = std::make_shared<Session>(io_service, get_connection(), create_request_header(method, path, header));
auto connection = session->connection;
auto response = session->response;
auto request_callback = std::make_shared<std::function<void(std::shared_ptr<Response>, const error_code &)>>(std::move(request_callback_));
auto connections = this->connections;
auto connections_mutex = this->connections_mutex;
session->callback = [connection, response, request_callback, connections, connections_mutex](const error_code &ec) {
{
std::lock_guard<std::mutex> lock(*connections_mutex);
connection->in_use=false;
connection->in_use = false;
// Remove unused connections, but keep one open for HTTP persistent connection:
size_t unused_connections=0;
for(auto it=connections->begin();it!=connections->end();) {
size_t unused_connections = 0;
for(auto it = connections->begin(); it != connections->end();) {
if((*it)->in_use)
++it;
else {
++unused_connections;
if(unused_connections>1)
it=connections->erase(it);
if(unused_connections > 1)
it = connections->erase(it);
else
++it;
}
@ -192,53 +199,54 @@ namespace SimpleWeb {
};
std::ostream write_stream(session->request_buffer.get());
if(content.size()>0)
if(content.size() > 0)
write_stream << "Content-Length: " << content.size() << "\r\n";
write_stream << "\r\n" << content;
write_stream << "\r\n"
<< content;
Client<socket_type>::connect(session);
}
/// Asynchronous request where setting and/or running Client's io_service is required.
void request(const std::string &method, const std::string &path, string_view content,
std::function<void(std::shared_ptr<Response>, const error_code&)> &&request_callback) {
std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
request(method, path, content, CaseInsensitiveMultimap(), std::move(request_callback));
}
/// Asynchronous request where setting and/or running Client's io_service is required.
void request(const std::string &method, const std::string &path,
std::function<void(std::shared_ptr<Response>, const error_code&)> &&request_callback) {
std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
request(method, path, std::string(), CaseInsensitiveMultimap(), std::move(request_callback));
}
/// Asynchronous request where setting and/or running Client's io_service is required.
void request(const std::string &method, std::function<void(std::shared_ptr<Response>, const error_code&)> &&request_callback) {
void request(const std::string &method, std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
request(method, std::string("/"), std::string(), CaseInsensitiveMultimap(), std::move(request_callback));
}
/// Asynchronous request where setting and/or running Client's io_service is required.
void request(const std::string &method, const std::string &path, std::istream& content, const CaseInsensitiveMultimap& header,
std::function<void(std::shared_ptr<Response>, const error_code&)> &&request_callback_) {
auto session=std::make_shared<Session>(io_service, get_connection(), create_request_header(method, path, header));
auto connection=session->connection;
auto response=session->response;
auto request_callback=std::make_shared<std::function<void(std::shared_ptr<Response>, const error_code&)>>(std::move(request_callback_));
auto connections=this->connections;
auto connections_mutex=this->connections_mutex;
session->callback=[connection, response, request_callback, connections, connections_mutex](const error_code &ec) {
void request(const std::string &method, const std::string &path, std::istream &content, const CaseInsensitiveMultimap &header,
std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback_) {
auto session = std::make_shared<Session>(io_service, get_connection(), create_request_header(method, path, header));
auto connection = session->connection;
auto response = session->response;
auto request_callback = std::make_shared<std::function<void(std::shared_ptr<Response>, const error_code &)>>(std::move(request_callback_));
auto connections = this->connections;
auto connections_mutex = this->connections_mutex;
session->callback = [connection, response, request_callback, connections, connections_mutex](const error_code &ec) {
{
std::lock_guard<std::mutex> lock(*connections_mutex);
connection->in_use=false;
connection->in_use = false;
// Remove unused connections, but keep one open for HTTP persistent connection:
size_t unused_connections=0;
for(auto it=connections->begin();it!=connections->end();) {
size_t unused_connections = 0;
for(auto it = connections->begin(); it != connections->end();) {
if((*it)->in_use)
++it;
else {
++unused_connections;
if(unused_connections>1)
it=connections->erase(it);
if(unused_connections > 1)
it = connections->erase(it);
else
++it;
}
@ -250,21 +258,21 @@ namespace SimpleWeb {
};
content.seekg(0, std::ios::end);
auto content_length=content.tellg();
auto content_length = content.tellg();
content.seekg(0, std::ios::beg);
std::ostream write_stream(session->request_buffer.get());
if(content_length>0)
if(content_length > 0)
write_stream << "Content-Length: " << content_length << "\r\n";
write_stream << "\r\n";
if(content_length>0)
if(content_length > 0)
write_stream << content.rdbuf();
Client<socket_type>::connect(session);
}
/// Asynchronous request where setting and/or running Client's io_service is required.
void request(const std::string &method, const std::string &path, std::istream& content,
std::function<void(std::shared_ptr<Response>, const error_code&)> &&request_callback) {
void request(const std::string &method, const std::string &path, std::istream &content,
std::function<void(std::shared_ptr<Response>, const error_code &)> &&request_callback) {
request(method, path, content, CaseInsensitiveMultimap(), std::move(request_callback));
}
@ -275,71 +283,72 @@ namespace SimpleWeb {
std::shared_ptr<std::vector<std::shared_ptr<Connection>>> connections;
std::shared_ptr<std::mutex> connections_mutex;
ClientBase(const std::string& host_port, unsigned short default_port) : io_service(new asio::io_service()), connections(new std::vector<std::shared_ptr<Connection>>()), connections_mutex(new std::mutex()) {
auto parsed_host_port=parse_host_port(host_port, default_port);
host=parsed_host_port.first;
port=parsed_host_port.second;
ClientBase(const std::string &host_port, unsigned short default_port)
: io_service(new asio::io_service()), connections(new std::vector<std::shared_ptr<Connection>>()), connections_mutex(new std::mutex()) {
auto parsed_host_port = parse_host_port(host_port, default_port);
host = parsed_host_port.first;
port = parsed_host_port.second;
}
std::shared_ptr<Connection> get_connection() {
std::shared_ptr<Connection> connection;
std::lock_guard<std::mutex> lock(*connections_mutex);
for(auto it=connections->begin();it!=connections->end();++it) {
for(auto it = connections->begin(); it != connections->end(); ++it) {
if(!(*it)->in_use && !connection) {
connection=*it;
connection = *it;
break;
}
}
if(!connection) {
connection=create_connection();
connection = create_connection();
connections->emplace_back(connection);
}
connection->reconnecting=false;
connection->in_use=true;
connection->reconnecting = false;
connection->in_use = true;
return connection;
}
virtual std::shared_ptr<Connection> create_connection()=0;
virtual std::shared_ptr<Connection> create_connection() = 0;
std::unique_ptr<asio::streambuf> create_request_header(const std::string& method, const std::string& path, const CaseInsensitiveMultimap& header) const {
auto corrected_path=path;
if(corrected_path=="")
corrected_path="/";
std::unique_ptr<asio::streambuf> create_request_header(const std::string &method, const std::string &path, const CaseInsensitiveMultimap &header) const {
auto corrected_path = path;
if(corrected_path == "")
corrected_path = "/";
if(!config.proxy_server.empty() && std::is_same<socket_type, asio::ip::tcp::socket>::value)
corrected_path="http://"+host+':'+std::to_string(port)+corrected_path;
corrected_path = "http://" + host + ':' + std::to_string(port) + corrected_path;
std::unique_ptr<asio::streambuf> request_buffer(new asio::streambuf());
std::ostream write_stream(request_buffer.get());
write_stream << method << " " << corrected_path << " HTTP/1.1\r\n";
write_stream << "Host: " << host << "\r\n";
for(auto& h: header)
for(auto &h : header)
write_stream << h.first << ": " << h.second << "\r\n";
return request_buffer;
}
static std::pair<std::string, unsigned short> parse_host_port(const std::string &host_port, unsigned short default_port) {
std::pair<std::string, unsigned short> parsed_host_port;
size_t host_end=host_port.find(':');
if(host_end==std::string::npos) {
parsed_host_port.first=host_port;
parsed_host_port.second=default_port;
size_t host_end = host_port.find(':');
if(host_end == std::string::npos) {
parsed_host_port.first = host_port;
parsed_host_port.second = default_port;
}
else {
parsed_host_port.first=host_port.substr(0, host_end);
parsed_host_port.second=static_cast<unsigned short>(stoul(host_port.substr(host_end+1)));
parsed_host_port.first = host_port.substr(0, host_end);
parsed_host_port.second = static_cast<unsigned short>(stoul(host_port.substr(host_end + 1)));
}
return parsed_host_port;
}
static std::shared_ptr<asio::deadline_timer> get_timeout_timer(const std::shared_ptr<Session> &session, size_t timeout=0) {
if(timeout==0)
timeout=session->connection->config.timeout;
if(timeout==0)
static std::shared_ptr<asio::deadline_timer> get_timeout_timer(const std::shared_ptr<Session> &session, size_t timeout = 0) {
if(timeout == 0)
timeout = session->connection->config.timeout;
if(timeout == 0)
return nullptr;
auto timer=std::make_shared<asio::deadline_timer>(*session->io_service);
auto timer = std::make_shared<asio::deadline_timer>(*session->io_service);
timer->expires_from_now(boost::posix_time::seconds(timeout));
timer->async_wait([session](const error_code& ec) {
timer->async_wait([session](const error_code &ec) {
if(!ec)
close(session);
});
@ -349,22 +358,22 @@ namespace SimpleWeb {
static void parse_response_header(const std::shared_ptr<Response> &response) {
std::string line;
getline(response->content, line);
size_t version_end=line.find(' ');
if(version_end!=std::string::npos) {
if(5<line.size())
response->http_version=line.substr(5, version_end-5);
if((version_end+1)<line.size())
response->status_code=line.substr(version_end+1, line.size()-(version_end+1)-1);
size_t version_end = line.find(' ');
if(version_end != std::string::npos) {
if(5 < line.size())
response->http_version = line.substr(5, version_end - 5);
if((version_end + 1) < line.size())
response->status_code = line.substr(version_end + 1, line.size() - (version_end + 1) - 1);
getline(response->content, line);
size_t param_end;
while((param_end=line.find(':'))!=std::string::npos) {
size_t value_start=param_end+1;
if((value_start)<line.size()) {
if(line[value_start]==' ')
while((param_end = line.find(':')) != std::string::npos) {
size_t value_start = param_end + 1;
if((value_start) < line.size()) {
if(line[value_start] == ' ')
value_start++;
if(value_start<line.size())
response->header.insert(std::make_pair(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1)));
if(value_start < line.size())
response->header.insert(std::make_pair(line.substr(0, param_end), line.substr(value_start, line.size() - value_start - 1)));
}
getline(response->content, line);
@ -373,7 +382,7 @@ namespace SimpleWeb {
}
static void write(const std::shared_ptr<Session> &session) {
auto timer=get_timeout_timer(session);
auto timer = get_timeout_timer(session);
asio::async_write(*session->connection->socket, session->request_buffer->data(), [session, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
@ -387,25 +396,23 @@ namespace SimpleWeb {
}
static void read(const std::shared_ptr<Session> &session) {
auto timer=get_timeout_timer(session);
asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n\r\n",
[session, timer](const error_code& ec, size_t bytes_transferred) {
auto timer = get_timeout_timer(session);
asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n\r\n", [session, timer](const error_code &ec, size_t bytes_transferred) {
if(timer)
timer->cancel();
if(!ec) {
session->connection->reconnecting=false;
session->connection->reconnecting = false;
size_t num_additional_bytes=session->response->content_buffer.size()-bytes_transferred;
size_t num_additional_bytes = session->response->content_buffer.size() - bytes_transferred;
parse_response_header(session->response);
auto header_it=session->response->header.find("Content-Length");
if(header_it!=session->response->header.end()) {
auto content_length=stoull(header_it->second);
if(content_length>num_additional_bytes) {
auto timer=get_timeout_timer(session);
asio::async_read(*session->connection->socket, session->response->content_buffer, asio::transfer_exactly(content_length-num_additional_bytes),
[session, timer](const error_code& ec, size_t /*bytes_transferred*/) {
auto header_it = session->response->header.find("Content-Length");
if(header_it != session->response->header.end()) {
auto content_length = stoull(header_it->second);
if(content_length > num_additional_bytes) {
auto timer = get_timeout_timer(session);
asio::async_read(*session->connection->socket, session->response->content_buffer, asio::transfer_exactly(content_length - num_additional_bytes), [session, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec)
@ -419,20 +426,20 @@ namespace SimpleWeb {
else
session->callback(ec);
}
else if((header_it=session->response->header.find("Transfer-Encoding"))!=session->response->header.end() && header_it->second=="chunked") {
auto tmp_streambuf=std::make_shared<asio::streambuf>();
else if((header_it = session->response->header.find("Transfer-Encoding")) != session->response->header.end() && header_it->second == "chunked") {
auto tmp_streambuf = std::make_shared<asio::streambuf>();
read_chunked(session, tmp_streambuf);
}
else if(session->response->http_version<"1.1" || ((header_it=session->response->header.find("Session"))!=session->response->header.end() && header_it->second=="close")) {
auto timer=get_timeout_timer(session);
asio::async_read(*session->connection->socket, session->response->content_buffer, [session, timer](const error_code& ec, size_t /*bytes_transferred*/) {
else if(session->response->http_version < "1.1" || ((header_it = session->response->header.find("Session")) != session->response->header.end() && header_it->second == "close")) {
auto timer = get_timeout_timer(session);
asio::async_read(*session->connection->socket, session->response->content_buffer, [session, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec)
session->callback(ec);
else {
close(session);
if(ec==asio::error::eof) {
if(ec == asio::error::eof) {
error_code ec;
session->callback(ec);
}
@ -446,7 +453,7 @@ namespace SimpleWeb {
}
else {
if(!session->connection->reconnecting) {
session->connection->reconnecting=true;
session->connection->reconnecting = true;
close(session);
Client<socket_type>::connect(session);
}
@ -459,22 +466,22 @@ namespace SimpleWeb {
}
static void read_chunked(const std::shared_ptr<Session> &session, const std::shared_ptr<asio::streambuf> &tmp_streambuf) {
auto timer=get_timeout_timer(session);
asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n", [session, tmp_streambuf, timer](const error_code& ec, size_t bytes_transferred) {
auto timer = get_timeout_timer(session);
asio::async_read_until(*session->connection->socket, session->response->content_buffer, "\r\n", [session, tmp_streambuf, timer](const error_code &ec, size_t bytes_transferred) {
if(timer)
timer->cancel();
if(!ec) {
std::string line;
getline(session->response->content, line);
bytes_transferred-=line.size()+1;
bytes_transferred -= line.size() + 1;
line.pop_back();
std::streamsize length=stol(line, 0, 16);
std::streamsize length = stol(line, 0, 16);
auto num_additional_bytes=static_cast<std::streamsize>(session->response->content_buffer.size()-bytes_transferred);
auto num_additional_bytes = static_cast<std::streamsize>(session->response->content_buffer.size() - bytes_transferred);
auto post_process=[session, tmp_streambuf, length] {
auto post_process = [session, tmp_streambuf, length] {
std::ostream tmp_stream(tmp_streambuf.get());
if(length>0) {
if(length > 0) {
std::vector<char> buffer(static_cast<size_t>(length));
session->response->content.read(&buffer[0], length);
tmp_stream.write(&buffer[0], length);
@ -484,7 +491,7 @@ namespace SimpleWeb {
session->response->content.get();
session->response->content.get();
if(length>0)
if(length > 0)
read_chunked(session, tmp_streambuf);
else {
std::ostream response_stream(&session->response->content_buffer);
@ -494,10 +501,9 @@ namespace SimpleWeb {
}
};
if((2+length)>num_additional_bytes) {
auto timer=get_timeout_timer(session);
asio::async_read(*session->connection->socket, session->response->content_buffer, asio::transfer_exactly(2+length-num_additional_bytes),
[session, post_process, timer](const error_code& ec, size_t /*bytes_transferred*/) {
if((2 + length) > num_additional_bytes) {
auto timer = get_timeout_timer(session);
asio::async_read(*session->connection->socket, session->response->content_buffer, asio::transfer_exactly(2 + length - num_additional_bytes), [session, post_process, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec)
@ -525,17 +531,17 @@ namespace SimpleWeb {
}
};
template<class socket_type>
template <class socket_type>
class Client : public ClientBase<socket_type> {};
typedef asio::ip::tcp::socket HTTP;
template<>
template <>
class Client<HTTP> : public ClientBase<HTTP> {
public:
friend ClientBase<HTTP>;
Client(const std::string& server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {}
Client(const std::string &server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {}
protected:
std::shared_ptr<Connection> create_connection() override {
@ -544,14 +550,14 @@ namespace SimpleWeb {
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);
auto timer=get_timeout_timer(session, session->connection->config.timeout_connect);
resolver->async_resolve(*session->connection->query, [session, timer, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator it){
auto resolver = std::make_shared<asio::ip::tcp::resolver>(*session->io_service);
auto timer = get_timeout_timer(session, session->connection->config.timeout_connect);
resolver->async_resolve(*session->connection->query, [session, timer, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator it) {
if(timer)
timer->cancel();
if(!ec) {
auto timer=get_timeout_timer(session, session->connection->config.timeout_connect);
asio::async_connect(*session->connection->socket, it, [session, timer, resolver](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, it, [session, timer, resolver](const error_code &ec, asio::ip::tcp::resolver::iterator /*it*/) {
if(timer)
timer->cancel();
if(!ec) {
@ -575,6 +581,6 @@ namespace SimpleWeb {
write(session);
}
};
}
} // namespace SimpleWeb
#endif /* CLIENT_HTTP_HPP */

44
client_https.hpp
View file

@ -12,16 +12,15 @@
namespace SimpleWeb {
typedef asio::ssl::stream<asio::ip::tcp::socket> HTTPS;
template<>
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()) :
ClientBase<HTTPS>::ClientBase(server_port_path, 443), context(asio::ssl::context::tlsv12) {
if(cert_file.size()>0 && private_key_file.size()>0) {
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())
: ClientBase<HTTPS>::ClientBase(server_port_path, 443), context(asio::ssl::context::tlsv12) {
if(cert_file.size() > 0 && private_key_file.size() > 0) {
context.use_certificate_chain_file(cert_file);
context.use_private_key_file(private_key_file, asio::ssl::context::pem);
}
@ -29,12 +28,12 @@ namespace SimpleWeb {
if(verify_certificate)
context.set_verify_callback(asio::ssl::rfc2818_verification(host));
if(verify_file.size()>0)
if(verify_file.size() > 0)
context.load_verify_file(verify_file);
else
context.set_default_verify_paths();
if(verify_file.size()>0 || verify_certificate)
if(verify_file.size() > 0 || verify_certificate)
context.set_verify_mode(asio::ssl::verify_peer);
else
context.set_verify_mode(asio::ssl::verify_none);
@ -49,11 +48,11 @@ namespace SimpleWeb {
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){
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(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*/){
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) {
@ -61,23 +60,24 @@ namespace SimpleWeb {
session->connection->socket->lowest_layer().set_option(option);
if(!session->connection->config.proxy_server.empty()) {
auto write_buffer=std::make_shared<asio::streambuf>();
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);
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*/) {
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) {
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));
}
@ -116,8 +116,8 @@ namespace SimpleWeb {
}
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) {
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)
@ -129,6 +129,6 @@ namespace SimpleWeb {
});
}
};
}
} // namespace SimpleWeb
#endif /* CLIENT_HTTPS_HPP */

115
crypto.hpp
View file

@ -1,29 +1,30 @@
#ifndef SIMPLE_WEB_CRYPTO_HPP
#define SIMPLE_WEB_CRYPTO_HPP
#include <string>
#include <cmath>
#include <sstream>
#include <iomanip>
#include <istream>
#include <sstream>
#include <string>
#include <vector>
//Moving these to a seperate namespace for minimal global namespace cluttering does not work with clang++
#include <openssl/evp.h>
#include <openssl/buffer.h>
#include <openssl/sha.h>
#include <openssl/evp.h>
#include <openssl/md5.h>
#include <openssl/sha.h>
namespace SimpleWeb {
//TODO 2017: remove workaround for MSVS 2012
#if _MSC_VER == 1700 //MSVS 2012 has no definition for round()
//TODO 2017: remove workaround for MSVS 2012
#if _MSC_VER == 1700 //MSVS 2012 has no definition for round()
inline double round(double x) { //custom definition of round() for positive numbers
return floor(x + 0.5);
}
#endif
#endif
class Crypto {
const static size_t buffer_size=131072;
const static size_t buffer_size = 131072;
public:
class Base64 {
public:
@ -31,7 +32,7 @@ namespace SimpleWeb {
std::string base64;
BIO *bio, *b64;
BUF_MEM *bptr=BUF_MEM_new();
BUF_MEM *bptr = BUF_MEM_new();
b64 = BIO_new(BIO_f_base64());
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
@ -40,19 +41,19 @@ namespace SimpleWeb {
BIO_set_mem_buf(b64, bptr, BIO_CLOSE);
//Write directly to base64-buffer to avoid copy
int base64_length=static_cast<int>(round(4*ceil((double)ascii.size()/3.0)));
int base64_length = static_cast<int>(round(4 * ceil((double)ascii.size() / 3.0)));
base64.resize(base64_length);
bptr->length=0;
bptr->max=base64_length+1;
bptr->data=(char*)&base64[0];
bptr->length = 0;
bptr->max = base64_length + 1;
bptr->data = (char *)&base64[0];
BIO_write(b64, &ascii[0], static_cast<int>(ascii.size()));
BIO_flush(b64);
//To keep &base64[0] through BIO_free_all(b64)
bptr->length=0;
bptr->max=0;
bptr->data=nullptr;
bptr->length = 0;
bptr->max = 0;
bptr->data = nullptr;
BIO_free_all(b64);
@ -63,12 +64,12 @@ namespace SimpleWeb {
std::string ascii;
//Resize ascii, however, the size is a up to two bytes too large.
ascii.resize((6*base64.size())/8);
ascii.resize((6 * base64.size()) / 8);
BIO *b64, *bio;
b64 = BIO_new(BIO_f_base64());
BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
bio = BIO_new_mem_buf((char*)&base64[0], static_cast<int>(base64.size()));
bio = BIO_new_mem_buf((char *)&base64[0], static_cast<int>(base64.size()));
bio = BIO_push(b64, bio);
int decoded_length = BIO_read(bio, &ascii[0], static_cast<int>(ascii.size()));
@ -84,123 +85,123 @@ namespace SimpleWeb {
static std::string to_hex_string(const std::string &input) {
std::stringstream hex_stream;
hex_stream << std::hex << std::internal << std::setfill('0');
for (auto &byte : input)
for(auto &byte : input)
hex_stream << std::setw(2) << static_cast<int>(static_cast<unsigned char>(byte));
return hex_stream.str();
}
static std::string md5(const std::string &input, size_t iterations=1) {
static std::string md5(const std::string &input, size_t iterations = 1) {
std::string hash;
hash.resize(128 / 8);
MD5(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
MD5(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
for (size_t c = 1; c < iterations; ++c)
MD5(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
MD5(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string md5(std::istream &stream, size_t iterations=1) {
static std::string md5(std::istream &stream, size_t iterations = 1) {
MD5_CTX context;
MD5_Init(&context);
std::streamsize read_length;
std::vector<char> buffer(buffer_size);
while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
MD5_Update(&context, buffer.data(), read_length);
std::string hash;
hash.resize(128 / 8);
MD5_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
MD5_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
for (size_t c = 1; c < iterations; ++c)
MD5(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
MD5(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string sha1(const std::string &input, size_t iterations=1) {
static std::string sha1(const std::string &input, size_t iterations = 1) {
std::string hash;
hash.resize(160 / 8);
SHA1(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
SHA1(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
for (size_t c = 1; c < iterations; ++c)
SHA1(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
SHA1(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string sha1(std::istream &stream, size_t iterations=1) {
static std::string sha1(std::istream &stream, size_t iterations = 1) {
SHA_CTX context;
SHA1_Init(&context);
std::streamsize read_length;
std::vector<char> buffer(buffer_size);
while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
SHA1_Update(&context, buffer.data(), read_length);
std::string hash;
hash.resize(160 / 8);
SHA1_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
SHA1_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
for (size_t c = 1; c < iterations; ++c)
SHA1(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
SHA1(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string sha256(const std::string &input, size_t iterations=1) {
static std::string sha256(const std::string &input, size_t iterations = 1) {
std::string hash;
hash.resize(256 / 8);
SHA256(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
SHA256(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
for (size_t c = 1; c < iterations; ++c)
SHA256(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
SHA256(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string sha256(std::istream &stream, size_t iterations=1) {
static std::string sha256(std::istream &stream, size_t iterations = 1) {
SHA256_CTX context;
SHA256_Init(&context);
std::streamsize read_length;
std::vector<char> buffer(buffer_size);
while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
SHA256_Update(&context, buffer.data(), read_length);
std::string hash;
hash.resize(256 / 8);
SHA256_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
SHA256_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
for (size_t c = 1; c < iterations; ++c)
SHA256(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
SHA256(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string sha512(const std::string &input, size_t iterations=1) {
static std::string sha512(const std::string &input, size_t iterations = 1) {
std::string hash;
hash.resize(512 / 8);
SHA512(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
SHA512(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
for (size_t c = 1; c < iterations; ++c)
SHA512(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
SHA512(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
static std::string sha512(std::istream &stream, size_t iterations=1) {
static std::string sha512(std::istream &stream, size_t iterations = 1) {
SHA512_CTX context;
SHA512_Init(&context);
std::streamsize read_length;
std::vector<char> buffer(buffer_size);
while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
SHA512_Update(&context, buffer.data(), read_length);
std::string hash;
hash.resize(512 / 8);
SHA512_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
SHA512_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
for (size_t c = 1; c < iterations; ++c)
SHA512(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
for(size_t c = 1; c < iterations; ++c)
SHA512(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
return hash;
}
@ -210,8 +211,8 @@ namespace SimpleWeb {
std::string key;
key.resize(key_size);
PKCS5_PBKDF2_HMAC_SHA1(password.c_str(), password.size(),
reinterpret_cast<const unsigned char*>(salt.c_str()), salt.size(), iterations,
key_size, reinterpret_cast<unsigned char*>(&key[0]));
reinterpret_cast<const unsigned char *>(salt.c_str()), salt.size(), iterations,
key_size, reinterpret_cast<unsigned char *>(&key[0]));
return key;
}
};

118
http_examples.cpp
View file

@ -1,16 +1,16 @@
#include "server_http.hpp"
#include "client_http.hpp"
#include "server_http.hpp"
//Added for the json-example
#define BOOST_SPIRIT_THREADSAFE
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
//Added for the default_resource example
#include <fstream>
#include <boost/filesystem.hpp>
#include <vector>
#include <algorithm>
#include <boost/filesystem.hpp>
#include <fstream>
#include <vector>
#ifdef HAVE_OPENSSL
#include "crypto.hpp"
#endif
@ -23,27 +23,27 @@ typedef SimpleWeb::Server<SimpleWeb::HTTP> HttpServer;
typedef SimpleWeb::Client<SimpleWeb::HTTP> HttpClient;
//Added for the default_resource example
void default_resource_send(const HttpServer &server, const shared_ptr<HttpServer::Response> &response,
const shared_ptr<ifstream> &ifs);
void default_resource_send(const HttpServer &server, const shared_ptr<HttpServer::Response> &response, const shared_ptr<ifstream> &ifs);
int main() {
//HTTP-server at port 8080 using 1 thread
//Unless you do more heavy non-threaded processing in the resources,
//1 thread is usually faster than several threads
HttpServer server;
server.config.port=8080;
server.config.port = 8080;
//Add resources using path-regex and method-string, and an anonymous function
//POST-example for the path /string, responds the posted string
server.resource["^/string$"]["POST"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.resource["^/string$"]["POST"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
//Retrieve string:
auto content=request->content.string();
auto content = request->content.string();
//request->content.string() is a convenience function for:
//stringstream ss;
//ss << request->content.rdbuf();
//auto content=ss.str();
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n" << content;
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n"
<< content;
// Alternatively, use one of the convenience functions, for instance:
@ -58,12 +58,12 @@ int main() {
// "lastName": "Smith",
// "age": 25
//}
server.resource["^/json$"]["POST"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.resource["^/json$"]["POST"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
try {
ptree pt;
read_json(request->content, pt);
auto name=pt.get<string>("firstName")+" "+pt.get<string>("lastName");
auto name = pt.get<string>("firstName") + " " + pt.get<string>("lastName");
*response << "HTTP/1.1 200 OK\r\n"
<< "Content-Type: application/json\r\n"
@ -71,7 +71,8 @@ int main() {
<< name;
}
catch(const exception &e) {
*response << "HTTP/1.1 400 Bad Request\r\nContent-Length: " << strlen(e.what()) << "\r\n\r\n" << e.what();
*response << "HTTP/1.1 400 Bad Request\r\nContent-Length: " << strlen(e.what()) << "\r\n\r\n"
<< e.what();
}
@ -90,17 +91,18 @@ int main() {
//GET-example for the path /info
//Responds with request-information
server.resource["^/info$"]["GET"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.resource["^/info$"]["GET"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
stringstream stream;
stream << "<h1>Request from " << request->remote_endpoint_address << " (" << request->remote_endpoint_port << ")</h1>";
stream << request->method << " " << request->path << " HTTP/" << request->http_version << "<br>";
for(auto &header: request->header)
for(auto &header : request->header)
stream << header.first << ": " << header.second << "<br>";
//find length of content_stream (length received using content_stream.tellp())
stream.seekp(0, ios::end);
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << stream.tellp() << "\r\n\r\n" << stream.rdbuf();
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << stream.tellp() << "\r\n\r\n"
<< stream.rdbuf();
// Alternatively, using a convenience function:
@ -114,9 +116,10 @@ int main() {
//GET-example for the path /match/[number], responds with the matched string in path (number)
//For instance a request GET /match/123 will receive: 123
server.resource["^/match/([0-9]+)$"]["GET"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
string number=request->path_match[1];
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << number.length() << "\r\n\r\n" << number;
server.resource["^/match/([0-9]+)$"]["GET"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
string number = request->path_match[1];
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << number.length() << "\r\n\r\n"
<< number;
// Alternatively, using a convenience function:
@ -124,7 +127,7 @@ int main() {
};
//Get example simulating heavy work in a separate thread
server.resource["^/work$"]["GET"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> /*request*/) {
server.resource["^/work$"]["GET"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> /*request*/) {
thread work_thread([response] {
this_thread::sleep_for(chrono::seconds(5));
response->write("Work done");
@ -136,47 +139,47 @@ int main() {
//Will respond with content in the web/-directory, and its subdirectories.
//Default file: index.html
//Can for instance be used to retrieve an HTML 5 client that uses REST-resources on this server
server.default_resource["GET"]=[&server](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.default_resource["GET"] = [&server](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
try {
auto web_root_path=boost::filesystem::canonical("web");
auto path=boost::filesystem::canonical(web_root_path/request->path);
auto web_root_path = boost::filesystem::canonical("web");
auto path = boost::filesystem::canonical(web_root_path / request->path);
//Check if path is within web_root_path
if(distance(web_root_path.begin(), web_root_path.end())>distance(path.begin(), path.end()) ||
if(distance(web_root_path.begin(), web_root_path.end()) > distance(path.begin(), path.end()) ||
!equal(web_root_path.begin(), web_root_path.end(), path.begin()))
throw invalid_argument("path must be within root path");
if(boost::filesystem::is_directory(path))
path/="index.html";
path /= "index.html";
SimpleWeb::CaseInsensitiveMultimap header;
// Uncomment the following line to enable Cache-Control
// header.emplace("Cache-Control", "max-age=86400");
// Uncomment the following line to enable Cache-Control
// header.emplace("Cache-Control", "max-age=86400");
#ifdef HAVE_OPENSSL
// Uncomment the following lines to enable ETag
// {
// ifstream ifs(path.string(), ifstream::in | ios::binary);
// if(ifs) {
// auto hash=SimpleWeb::Crypto::to_hex_string(SimpleWeb::Crypto::md5(ifs));
// header.emplace("ETag", "\""+hash+"\"");
// auto it=request->header.find("If-None-Match");
// if(it!=request->header.end()) {
// if(!it->second.empty() && it->second.compare(1, hash.size(), hash)==0) {
// response->write(SimpleWeb::StatusCode::redirection_not_modified, header);
// return;
// }
// }
// }
// else
// throw invalid_argument("could not read file");
// }
// Uncomment the following lines to enable ETag
// {
// ifstream ifs(path.string(), ifstream::in | ios::binary);
// if(ifs) {
// auto hash = SimpleWeb::Crypto::to_hex_string(SimpleWeb::Crypto::md5(ifs));
// header.emplace("ETag", "\"" + hash + "\"");
// auto it = request->header.find("If-None-Match");
// if(it != request->header.end()) {
// if(!it->second.empty() && it->second.compare(1, hash.size(), hash) == 0) {
// response->write(SimpleWeb::StatusCode::redirection_not_modified, header);
// return;
// }
// }
// }
// else
// throw invalid_argument("could not read file");
// }
#endif
auto ifs=make_shared<ifstream>();
auto ifs = make_shared<ifstream>();
ifs->open(path.string(), ifstream::in | ios::binary | ios::ate);
if(*ifs) {
auto length=ifs->tellg();
auto length = ifs->tellg();
ifs->seekg(0, ios::beg);
header.emplace("Content-Length", to_string(length));
@ -187,15 +190,15 @@ int main() {
throw invalid_argument("could not read file");
}
catch(const exception &e) {
response->write(SimpleWeb::StatusCode::client_error_bad_request, "Could not open path "+request->path+": "+e.what());
response->write(SimpleWeb::StatusCode::client_error_bad_request, "Could not open path " + request->path + ": " + e.what());
}
};
server.on_error=[](std::shared_ptr<HttpServer::Request> /*request*/, const SimpleWeb::error_code &/*ec*/) {
server.on_error = [](std::shared_ptr<HttpServer::Request> /*request*/, const SimpleWeb::error_code & /*ec*/) {
// handle errors here
};
thread server_thread([&server](){
thread server_thread([&server]() {
//Start server
server.start();
});
@ -207,11 +210,11 @@ int main() {
HttpClient client("localhost:8080");
// synchronous request examples
auto r1=client.request("GET", "/match/123");
auto r1 = client.request("GET", "/match/123");
cout << r1->content.rdbuf() << endl; // Alternatively, use the convenience function r1->content.string()
string json_string="{\"firstName\": \"John\",\"lastName\": \"Smith\",\"age\": 25}";
auto r2=client.request("POST", "/string", json_string);
string json_string = "{\"firstName\": \"John\",\"lastName\": \"Smith\",\"age\": 25}";
auto r2 = client.request("POST", "/string", json_string);
cout << r2->content.rdbuf() << endl;
// asynchronous request example
@ -223,18 +226,15 @@ int main() {
client.io_service->run();
server_thread.join();
return 0;
}
void default_resource_send(const HttpServer &server, const shared_ptr<HttpServer::Response> &response,
const shared_ptr<ifstream> &ifs) {
void default_resource_send(const HttpServer &server, const shared_ptr<HttpServer::Response> &response, const shared_ptr<ifstream> &ifs) {
//read and send 128 KB at a time
static vector<char> buffer(131072); // Safe when server is running on one thread
streamsize read_length;
if((read_length=ifs->read(&buffer[0], buffer.size()).gcount())>0) {
if((read_length = ifs->read(&buffer[0], buffer.size()).gcount()) > 0) {
response->write(&buffer[0], read_length);
if(read_length==static_cast<streamsize>(buffer.size())) {
if(read_length == static_cast<streamsize>(buffer.size())) {
server.send(response, [&server, response, ifs](const SimpleWeb::error_code &ec) {
if(!ec)
default_resource_send(server, response, ifs);

120
https_examples.cpp
View file

@ -1,17 +1,17 @@
#include "server_https.hpp"
#include "client_https.hpp"
#include "server_https.hpp"
//Added for the json-example
#define BOOST_SPIRIT_THREADSAFE
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
//Added for the default_resource example
#include <fstream>
#include <boost/filesystem.hpp>
#include <vector>
#include <algorithm>
#include "crypto.hpp"
#include <algorithm>
#include <boost/filesystem.hpp>
#include <fstream>
#include <vector>
using namespace std;
//Added for the json-example:
@ -21,27 +21,27 @@ typedef SimpleWeb::Server<SimpleWeb::HTTPS> HttpsServer;
typedef SimpleWeb::Client<SimpleWeb::HTTPS> HttpsClient;
//Added for the default_resource example
void default_resource_send(const HttpsServer &server, const shared_ptr<HttpsServer::Response> &response,
const shared_ptr<ifstream> &ifs);
void default_resource_send(const HttpsServer &server, const shared_ptr<HttpsServer::Response> &response, const shared_ptr<ifstream> &ifs);
int main() {
//HTTPS-server at port 8080 using 1 thread
//Unless you do more heavy non-threaded processing in the resources,
//1 thread is usually faster than several threads
HttpsServer server("server.crt", "server.key");
server.config.port=8080;
server.config.port = 8080;
//Add resources using path-regex and method-string, and an anonymous function
//POST-example for the path /string, responds the posted string
server.resource["^/string$"]["POST"]=[](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
server.resource["^/string$"]["POST"] = [](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
//Retrieve string:
auto content=request->content.string();
auto content = request->content.string();
//request->content.string() is a convenience function for:
//stringstream ss;
//ss << request->content.rdbuf();
//auto content=ss.str();
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n" << content;
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n"
<< content;
// Alternatively, use one of the convenience functions, for instance:
@ -56,12 +56,12 @@ int main() {
// "lastName": "Smith",
// "age": 25
//}
server.resource["^/json$"]["POST"]=[](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
server.resource["^/json$"]["POST"] = [](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
try {
ptree pt;
read_json(request->content, pt);
auto name=pt.get<string>("firstName")+" "+pt.get<string>("lastName");
auto name = pt.get<string>("firstName") + " " + pt.get<string>("lastName");
*response << "HTTP/1.1 200 OK\r\n"
<< "Content-Type: application/json\r\n"
@ -69,7 +69,8 @@ int main() {
<< name;
}
catch(const exception &e) {
*response << "HTTP/1.1 400 Bad Request\r\nContent-Length: " << strlen(e.what()) << "\r\n\r\n" << e.what();
*response << "HTTP/1.1 400 Bad Request\r\nContent-Length: " << strlen(e.what()) << "\r\n\r\n"
<< e.what();
}
@ -88,17 +89,18 @@ int main() {
//GET-example for the path /info
//Responds with request-information
server.resource["^/info$"]["GET"]=[](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
server.resource["^/info$"]["GET"] = [](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
stringstream stream;
stream << "<h1>Request from " << request->remote_endpoint_address << " (" << request->remote_endpoint_port << ")</h1>";
stream << request->method << " " << request->path << " HTTP/" << request->http_version << "<br>";
for(auto &header: request->header)
for(auto &header : request->header)
stream << header.first << ": " << header.second << "<br>";
//find length of content_stream (length received using content_stream.tellp())
stream.seekp(0, ios::end);
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << stream.tellp() << "\r\n\r\n" << stream.rdbuf();
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << stream.tellp() << "\r\n\r\n"
<< stream.rdbuf();
// Alternatively, using a convenience function:
@ -112,9 +114,10 @@ int main() {
//GET-example for the path /match/[number], responds with the matched string in path (number)
//For instance a request GET /match/123 will receive: 123
server.resource["^/match/([0-9]+)$"]["GET"]=[](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
string number=request->path_match[1];
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << number.length() << "\r\n\r\n" << number;
server.resource["^/match/([0-9]+)$"]["GET"] = [](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
string number = request->path_match[1];
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << number.length() << "\r\n\r\n"
<< number;
// Alternatively, using a convenience function:
@ -122,7 +125,7 @@ int main() {
};
//Get example simulating heavy work in a separate thread
server.resource["^/work$"]["GET"]=[](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> /*request*/) {
server.resource["^/work$"]["GET"] = [](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> /*request*/) {
thread work_thread([response] {
this_thread::sleep_for(chrono::seconds(5));
response->write("Work done");
@ -134,47 +137,47 @@ int main() {
//Will respond with content in the web/-directory, and its subdirectories.
//Default file: index.html
//Can for instance be used to retrieve an HTML 5 client that uses REST-resources on this server
server.default_resource["GET"]=[&server](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
server.default_resource["GET"] = [&server](shared_ptr<HttpsServer::Response> response, shared_ptr<HttpsServer::Request> request) {
try {
auto web_root_path=boost::filesystem::canonical("web");
auto path=boost::filesystem::canonical(web_root_path/request->path);
auto web_root_path = boost::filesystem::canonical("web");
auto path = boost::filesystem::canonical(web_root_path / request->path);
//Check if path is within web_root_path
if(distance(web_root_path.begin(), web_root_path.end())>distance(path.begin(), path.end()) ||
if(distance(web_root_path.begin(), web_root_path.end()) > distance(path.begin(), path.end()) ||
!equal(web_root_path.begin(), web_root_path.end(), path.begin()))
throw invalid_argument("path must be within root path");
if(boost::filesystem::is_directory(path))
path/="index.html";
path /= "index.html";
SimpleWeb::CaseInsensitiveMultimap header;
// Uncomment the following line to enable Cache-Control
// header.emplace("Cache-Control", "max-age=86400");
// Uncomment the following line to enable Cache-Control
// header.emplace("Cache-Control", "max-age=86400");
#ifdef HAVE_OPENSSL
// Uncomment the following lines to enable ETag
// {
// ifstream ifs(path.string(), ifstream::in | ios::binary);
// if(ifs) {
// auto hash=SimpleWeb::Crypto::to_hex_string(SimpleWeb::Crypto::md5(ifs));
// header.emplace("ETag", "\""+hash+"\"");
// auto it=request->header.find("If-None-Match");
// if(it!=request->header.end()) {
// if(!it->second.empty() && it->second.compare(1, hash.size(), hash)==0) {
// response->write(SimpleWeb::StatusCode::redirection_not_modified, header);
// return;
// }
// }
// }
// else
// throw invalid_argument("could not read file");
// }
// Uncomment the following lines to enable ETag
// {
// ifstream ifs(path.string(), ifstream::in | ios::binary);
// if(ifs) {
// auto hash = SimpleWeb::Crypto::to_hex_string(SimpleWeb::Crypto::md5(ifs));
// header.emplace("ETag", "\"" + hash + "\"");
// auto it = request->header.find("If-None-Match");
// if(it != request->header.end()) {
// if(!it->second.empty() && it->second.compare(1, hash.size(), hash) == 0) {
// response->write(SimpleWeb::StatusCode::redirection_not_modified, header);
// return;
// }
// }
// }
// else
// throw invalid_argument("could not read file");
// }
#endif
auto ifs=make_shared<ifstream>();
auto ifs = make_shared<ifstream>();
ifs->open(path.string(), ifstream::in | ios::binary | ios::ate);
if(*ifs) {
auto length=ifs->tellg();
auto length = ifs->tellg();
ifs->seekg(0, ios::beg);
header.emplace("Content-Length", to_string(length));
@ -185,15 +188,15 @@ int main() {
throw invalid_argument("could not read file");
}
catch(const exception &e) {
response->write(SimpleWeb::StatusCode::client_error_bad_request, "Could not open path "+request->path+": "+e.what());
response->write(SimpleWeb::StatusCode::client_error_bad_request, "Could not open path " + request->path + ": " + e.what());
}
};
server.on_error=[](std::shared_ptr<HttpsServer::Request> /*request*/, const SimpleWeb::error_code &/*ec*/) {
server.on_error = [](std::shared_ptr<HttpsServer::Request> /*request*/, const SimpleWeb::error_code & /*ec*/) {
// handle errors here
};
thread server_thread([&server](){
thread server_thread([&server]() {
//Start server
server.start();
});
@ -206,11 +209,11 @@ int main() {
HttpsClient client("localhost:8080", false);
// synchronous request examples
auto r1=client.request("GET", "/match/123");
auto r1 = client.request("GET", "/match/123");
cout << r1->content.rdbuf() << endl; // Alternatively, use the convenience function r1->content.string()
string json_string="{\"firstName\": \"John\",\"lastName\": \"Smith\",\"age\": 25}";
auto r2=client.request("POST", "/string", json_string);
string json_string = "{\"firstName\": \"John\",\"lastName\": \"Smith\",\"age\": 25}";
auto r2 = client.request("POST", "/string", json_string);
cout << r2->content.rdbuf() << endl;
// asynchronous request example
@ -222,18 +225,15 @@ int main() {
client.io_service->run();
server_thread.join();
return 0;
}
void default_resource_send(const HttpsServer &server, const shared_ptr<HttpsServer::Response> &response,
const shared_ptr<ifstream> &ifs) {
void default_resource_send(const HttpsServer &server, const shared_ptr<HttpsServer::Response> &response, const shared_ptr<ifstream> &ifs) {
//read and send 128 KB at a time
static vector<char> buffer(131072); // Safe when server is running on one thread
streamsize read_length;
if((read_length=ifs->read(&buffer[0], buffer.size()).gcount())>0) {
if((read_length = ifs->read(&buffer[0], buffer.size()).gcount()) > 0) {
response->write(&buffer[0], read_length);
if(read_length==static_cast<streamsize>(buffer.size())) {
if(read_length == static_cast<streamsize>(buffer.size())) {
server.send(response, [&server, response, ifs](const SimpleWeb::error_code &ec) {
if(!ec)
default_resource_send(server, response, ifs);

213
server_http.hpp
View file

@ -2,11 +2,11 @@
#define SERVER_HTTP_HPP
#include "utility.hpp"
#include <map>
#include <thread>
#include <functional>
#include <iostream>
#include <map>
#include <sstream>
#include <thread>
#ifdef USE_STANDALONE_ASIO
#include <asio.hpp>
@ -14,7 +14,7 @@ namespace SimpleWeb {
using error_code = std::error_code;
using errc = std::errc;
namespace make_error_code = std;
}
} // namespace SimpleWeb
#else
#include <boost/asio.hpp>
namespace SimpleWeb {
@ -22,7 +22,7 @@ namespace SimpleWeb {
using error_code = boost::system::error_code;
namespace errc = boost::system::errc;
namespace make_error_code = boost::system::errc;
}
} // namespace SimpleWeb
#endif
// Late 2017 TODO: remove the following checks and always use std::regex
@ -54,17 +54,17 @@ namespace SimpleWeb {
std::shared_ptr<socket_type> socket;
Response(const std::shared_ptr<socket_type> &socket): std::ostream(&streambuf), socket(socket) {}
Response(const std::shared_ptr<socket_type> &socket) : std::ostream(&streambuf), socket(socket) {}
template<class size_type>
template <class size_type>
void write_header(const CaseInsensitiveMultimap &header, size_type size) {
bool content_length_written=false;
bool chunked_transfer_encoding=false;
for(auto &field: header) {
bool content_length_written = false;
bool chunked_transfer_encoding = false;
for(auto &field : header) {
if(!content_length_written && case_insensitive_equal(field.first, "content-length"))
content_length_written=true;
content_length_written = true;
else if(!chunked_transfer_encoding && case_insensitive_equal(field.first, "transfer-encoding") && case_insensitive_equal(field.second, "chunked"))
chunked_transfer_encoding=true;
chunked_transfer_encoding = true;
*this << field.first << ": " << field.second << "\r\n";
}
@ -73,6 +73,7 @@ namespace SimpleWeb {
else
*this << "\r\n";
}
public:
size_t size() {
return streambuf.size();
@ -84,13 +85,13 @@ namespace SimpleWeb {
}
/// Convenience function for writing status line, potential header fields, and empty content
void write(StatusCode status_code=StatusCode::success_ok, const CaseInsensitiveMultimap &header=CaseInsensitiveMultimap()) {
void write(StatusCode status_code = StatusCode::success_ok, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
*this << "HTTP/1.1 " << SimpleWeb::status_code(status_code) << "\r\n";
write_header(header, 0);
}
/// Convenience function for writing status line, header fields, and content
void write(StatusCode status_code, const std::string &content, const CaseInsensitiveMultimap &header=CaseInsensitiveMultimap()) {
void write(StatusCode status_code, const std::string &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
*this << "HTTP/1.1 " << SimpleWeb::status_code(status_code) << "\r\n";
write_header(header, content.size());
if(!content.empty())
@ -98,10 +99,10 @@ namespace SimpleWeb {
}
/// Convenience function for writing status line, header fields, and content
void write(StatusCode status_code, std::istream &content, const CaseInsensitiveMultimap &header=CaseInsensitiveMultimap()) {
void write(StatusCode status_code, std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
*this << "HTTP/1.1 " << SimpleWeb::status_code(status_code) << "\r\n";
content.seekg(0, std::ios::end);
auto size=content.tellg();
auto size = content.tellg();
content.seekg(0, std::ios::beg);
write_header(header, size);
if(size)
@ -109,12 +110,12 @@ namespace SimpleWeb {
}
/// Convenience function for writing success status line, header fields, and content
void write(const std::string &content, const CaseInsensitiveMultimap &header=CaseInsensitiveMultimap()) {
void write(const std::string &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
write(StatusCode::success_ok, content, header);
}
/// Convenience function for writing success status line, header fields, and content
void write(std::istream &content, const CaseInsensitiveMultimap &header=CaseInsensitiveMultimap()) {
void write(std::istream &content, const CaseInsensitiveMultimap &header = CaseInsensitiveMultimap()) {
write(StatusCode::success_ok, content, header);
}
@ -132,6 +133,7 @@ namespace SimpleWeb {
class Content : public std::istream {
friend class ServerBase<socket_type>;
public:
size_t size() {
return streambuf.size();
@ -142,14 +144,16 @@ namespace SimpleWeb {
ss << rdbuf();
return ss.str();
}
private:
asio::streambuf &streambuf;
Content(asio::streambuf &streambuf): std::istream(&streambuf), streambuf(streambuf) {}
Content(asio::streambuf &streambuf) : std::istream(&streambuf), streambuf(streambuf) {}
};
class Request {
friend class ServerBase<socket_type>;
friend class Server<socket_type>;
public:
std::string method, path, http_version;
@ -165,19 +169,20 @@ namespace SimpleWeb {
/// Returns query keys with percent-decoded values.
CaseInsensitiveMultimap parse_query_string() {
auto pos = path.find('?');
if (pos != std::string::npos && pos + 1 < path.size())
if(pos != std::string::npos && pos + 1 < path.size())
return SimpleWeb::QueryString::parse(path.substr(pos + 1));
else
return CaseInsensitiveMultimap();
}
private:
Request(const socket_type &socket): content(streambuf) {
Request(const socket_type &socket) : content(streambuf) {
try {
remote_endpoint_address=socket.lowest_layer().remote_endpoint().address().to_string();
remote_endpoint_port=socket.lowest_layer().remote_endpoint().port();
remote_endpoint_address = socket.lowest_layer().remote_endpoint().address().to_string();
remote_endpoint_port = socket.lowest_layer().remote_endpoint().port();
}
catch(...) {
}
catch(...) {}
}
asio::streambuf streambuf;
@ -186,21 +191,22 @@ namespace SimpleWeb {
class Config {
friend class ServerBase<socket_type>;
Config(unsigned short port): port(port) {}
Config(unsigned short port) : port(port) {}
public:
/// Port number to use. Defaults to 80 for HTTP and 443 for HTTPS.
unsigned short port;
/// Number of threads that the server will use when start() is called. Defaults to 1 thread.
size_t thread_pool_size=1;
size_t thread_pool_size = 1;
/// Timeout on request handling. Defaults to 5 seconds.
size_t timeout_request=5;
size_t timeout_request = 5;
/// Timeout on content handling. Defaults to 300 seconds.
size_t timeout_content=300;
size_t timeout_content = 300;
/// IPv4 address in dotted decimal form or IPv6 address in hexadecimal notation.
/// If empty, the address will be any address.
std::string address;
/// Set to false to avoid binding the socket to an address that is already in use. Defaults to true.
bool reuse_address=true;
bool reuse_address = true;
};
///Set before calling start().
Config config;
@ -208,40 +214,40 @@ namespace SimpleWeb {
private:
class regex_orderable : public regex::regex {
std::string str;
public:
regex_orderable(const char *regex_cstr) : regex::regex(regex_cstr), str(regex_cstr) {}
regex_orderable(const std::string &regex_str) : regex::regex(regex_str), str(regex_str) {}
bool operator<(const regex_orderable &rhs) const {
return str<rhs.str;
return str < rhs.str;
}
};
public:
/// Warning: do not add or remove resources after start() is called
std::map<regex_orderable, std::map<std::string,
std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)> > > resource;
std::map<regex_orderable, std::map<std::string, std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)>>> resource;
std::map<std::string,
std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)> > default_resource;
std::map<std::string, std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)>> default_resource;
std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Request>, const error_code&)> on_error;
std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Request>, const error_code &)> on_error;
std::function<void(std::shared_ptr<socket_type> socket, std::shared_ptr<typename ServerBase<socket_type>::Request>)> on_upgrade;
virtual void start() {
if(!io_service)
io_service=std::make_shared<asio::io_service>();
io_service = std::make_shared<asio::io_service>();
if(io_service->stopped())
io_service->reset();
asio::ip::tcp::endpoint endpoint;
if(config.address.size()>0)
endpoint=asio::ip::tcp::endpoint(asio::ip::address::from_string(config.address), config.port);
if(config.address.size() > 0)
endpoint = asio::ip::tcp::endpoint(asio::ip::address::from_string(config.address), config.port);
else
endpoint=asio::ip::tcp::endpoint(asio::ip::tcp::v4(), config.port);
endpoint = asio::ip::tcp::endpoint(asio::ip::tcp::v4(), config.port);
if(!acceptor)
acceptor=std::unique_ptr<asio::ip::tcp::acceptor>(new asio::ip::tcp::acceptor(*io_service));
acceptor = std::unique_ptr<asio::ip::tcp::acceptor>(new asio::ip::tcp::acceptor(*io_service));
acceptor->open(endpoint.protocol());
acceptor->set_option(asio::socket_base::reuse_address(config.reuse_address));
acceptor->bind(endpoint);
@ -251,31 +257,31 @@ namespace SimpleWeb {
//If thread_pool_size>1, start m_io_service.run() in (thread_pool_size-1) threads for thread-pooling
threads.clear();
for(size_t c=1;c<config.thread_pool_size;c++) {
for(size_t c = 1; c < config.thread_pool_size; c++) {
threads.emplace_back([this]() {
io_service->run();
});
}
//Main thread
if(config.thread_pool_size>0)
if(config.thread_pool_size > 0)
io_service->run();
//Wait for the rest of the threads, if any, to finish as well
for(auto& t: threads) {
for(auto &t : threads) {
t.join();
}
}
void stop() {
acceptor->close();
if(config.thread_pool_size>0)
if(config.thread_pool_size > 0)
io_service->stop();
}
///Use this function if you need to recursively send parts of a longer message
void send(const std::shared_ptr<Response> &response, const std::function<void(const error_code&)>& callback=nullptr) const {
asio::async_write(*response->socket, response->streambuf, [this, response, callback](const error_code& ec, size_t /*bytes_transferred*/) {
void send(const std::shared_ptr<Response> &response, const std::function<void(const error_code &)> &callback = nullptr) const {
asio::async_write(*response->socket, response->streambuf, [this, response, callback](const error_code &ec, size_t /*bytes_transferred*/) {
if(callback)
callback(ec);
});
@ -284,21 +290,22 @@ namespace SimpleWeb {
/// If you have your own asio::io_service, store its pointer here before running start().
/// You might also want to set config.thread_pool_size to 0.
std::shared_ptr<asio::io_service> io_service;
protected:
std::unique_ptr<asio::ip::tcp::acceptor> acceptor;
std::vector<std::thread> threads;
ServerBase(unsigned short port) : config(port) {}
virtual void accept()=0;
virtual void accept() = 0;
std::shared_ptr<asio::deadline_timer> get_timeout_timer(const std::shared_ptr<socket_type> &socket, long seconds) {
if(seconds==0)
if(seconds == 0)
return nullptr;
auto timer=std::make_shared<asio::deadline_timer>(*io_service);
auto timer = std::make_shared<asio::deadline_timer>(*io_service);
timer->expires_from_now(boost::posix_time::seconds(seconds));
timer->async_wait([socket](const error_code& ec){
timer->async_wait([socket](const error_code &ec) {
if(!ec) {
error_code ec;
socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);
@ -314,10 +321,9 @@ namespace SimpleWeb {
std::shared_ptr<Request> request(new Request(*socket));
//Set timeout on the following asio::async-read or write function
auto timer=this->get_timeout_timer(socket, config.timeout_request);
auto timer = this->get_timeout_timer(socket, config.timeout_request);
asio::async_read_until(*socket, request->streambuf, "\r\n\r\n",
[this, socket, request, timer](const error_code& ec, size_t bytes_transferred) {
asio::async_read_until(*socket, request->streambuf, "\r\n\r\n", [this, socket, request, timer](const error_code &ec, size_t bytes_transferred) {
if(timer)
timer->cancel();
if(!ec) {
@ -325,30 +331,27 @@ namespace SimpleWeb {
//"After a successful async_read_until operation, the streambuf may contain additional data beyond the delimiter"
//The chosen solution is to extract lines from the stream directly when parsing the header. What is left of the
//streambuf (maybe some bytes of the content) is appended to in the async_read-function below (for retrieving content).
size_t num_additional_bytes=request->streambuf.size()-bytes_transferred;
size_t num_additional_bytes = request->streambuf.size() - bytes_transferred;
if(!this->parse_request(request))
return;
//If content, read that as well
auto it=request->header.find("Content-Length");
if(it!=request->header.end()) {
auto it = request->header.find("Content-Length");
if(it != request->header.end()) {
unsigned long long content_length;
try {
content_length=stoull(it->second);
content_length = stoull(it->second);
}
catch(const std::exception &e) {
if(on_error)
on_error(request, make_error_code::make_error_code(errc::protocol_error));
return;
}
if(content_length>num_additional_bytes) {
if(content_length > num_additional_bytes) {
//Set timeout on the following asio::async-read or write function
auto timer=this->get_timeout_timer(socket, config.timeout_content);
asio::async_read(*socket, request->streambuf,
asio::transfer_exactly(content_length-num_additional_bytes),
[this, socket, request, timer]
(const error_code& ec, size_t /*bytes_transferred*/) {
auto timer = this->get_timeout_timer(socket, config.timeout_content);
asio::async_read(*socket, request->streambuf, asio::transfer_exactly(content_length - num_additional_bytes), [this, socket, request, timer](const error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec)
@ -372,30 +375,30 @@ namespace SimpleWeb {
std::string line;
getline(request->content, line);
size_t method_end;
if((method_end=line.find(' '))!=std::string::npos) {
if((method_end = line.find(' ')) != std::string::npos) {
size_t path_end;
if((path_end=line.find(' ', method_end+1))!=std::string::npos) {
request->method=line.substr(0, method_end);
request->path=line.substr(method_end+1, path_end-method_end-1);
if((path_end = line.find(' ', method_end + 1)) != std::string::npos) {
request->method = line.substr(0, method_end);
request->path = line.substr(method_end + 1, path_end - method_end - 1);
size_t protocol_end;
if((protocol_end=line.find('/', path_end+1))!=std::string::npos) {
if(line.compare(path_end+1, protocol_end-path_end-1, "HTTP")!=0)
if((protocol_end = line.find('/', path_end + 1)) != std::string::npos) {
if(line.compare(path_end + 1, protocol_end - path_end - 1, "HTTP") != 0)
return false;
request->http_version=line.substr(protocol_end+1, line.size()-protocol_end-2);
request->http_version = line.substr(protocol_end + 1, line.size() - protocol_end - 2);
}
else
return false;
getline(request->content, line);
size_t param_end;
while((param_end=line.find(':'))!=std::string::npos) {
size_t value_start=param_end+1;
if((value_start)<line.size()) {
if(line[value_start]==' ')
while((param_end = line.find(':')) != std::string::npos) {
size_t value_start = param_end + 1;
if((value_start) < line.size()) {
if(line[value_start] == ' ')
value_start++;
if(value_start<line.size())
request->header.emplace(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1));
if(value_start < line.size())
request->header.emplace(line.substr(0, param_end), line.substr(value_start, line.size() - value_start - 1));
}
getline(request->content, line);
@ -412,50 +415,50 @@ namespace SimpleWeb {
void find_resource(const std::shared_ptr<socket_type> &socket, const std::shared_ptr<Request> &request) {
//Upgrade connection
if(on_upgrade) {
auto it=request->header.find("Upgrade");
if(it!=request->header.end()) {
auto it = request->header.find("Upgrade");
if(it != request->header.end()) {
on_upgrade(socket, request);
return;
}
}
//Find path- and method-match, and call write_response
for(auto &regex_method: resource) {
auto it=regex_method.second.find(request->method);
if(it!=regex_method.second.end()) {
for(auto &regex_method : resource) {
auto it = regex_method.second.find(request->method);
if(it != regex_method.second.end()) {
regex::smatch sm_res;
if(regex::regex_match(request->path, sm_res, regex_method.first)) {
request->path_match=std::move(sm_res);
request->path_match = std::move(sm_res);
write_response(socket, request, it->second);
return;
}
}
}
auto it=default_resource.find(request->method);
if(it!=default_resource.end()) {
auto it = default_resource.find(request->method);
if(it != default_resource.end()) {
write_response(socket, request, it->second);
}
}
void write_response(const std::shared_ptr<socket_type> &socket, const std::shared_ptr<Request> &request,
std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>,
std::shared_ptr<typename ServerBase<socket_type>::Request>)>& resource_function) {
std::function<void(std::shared_ptr<typename ServerBase<socket_type>::Response>, std::shared_ptr<typename ServerBase<socket_type>::Request>)> &resource_function) {
//Set timeout on the following asio::async-read or write function
auto timer=this->get_timeout_timer(socket, config.timeout_content);
auto timer = this->get_timeout_timer(socket, config.timeout_content);
auto response=std::shared_ptr<Response>(new Response(socket), [this, request, timer](Response *response_ptr) {
auto response=std::shared_ptr<Response>(response_ptr);
this->send(response, [this, response, request, timer](const error_code& ec) {
auto response = std::shared_ptr<Response>(new Response(socket), [this, request, timer](Response *response_ptr) {
auto response = std::shared_ptr<Response>(response_ptr);
this->send(response, [this, response, request, timer](const error_code &ec) {
if(timer)
timer->cancel();
if(!ec) {
if (response->close_connection_after_response)
if(response->close_connection_after_response)
return;
auto range=request->header.equal_range("Connection");
for(auto it=range.first;it!=range.second;it++) {
auto range = request->header.equal_range("Connection");
for(auto it = range.first; it != range.second; it++) {
if(case_insensitive_equal(it->second, "close")) {
return;
} else if (case_insensitive_equal(it->second, "keep-alive")) {
}
else if(case_insensitive_equal(it->second, "keep-alive")) {
this->read_request_and_content(response->socket);
return;
}
@ -479,20 +482,19 @@ namespace SimpleWeb {
}
};
template<class socket_type>
template <class socket_type>
class Server : public ServerBase<socket_type> {};
typedef asio::ip::tcp::socket HTTP;
template<>
template <>
class Server<HTTP> : public ServerBase<HTTP> {
public:
DEPRECATED Server(unsigned short port, size_t thread_pool_size=1, long timeout_request=5, long timeout_content=300) :
Server() {
config.port=port;
config.thread_pool_size=thread_pool_size;
config.timeout_request=timeout_request;
config.timeout_content=timeout_content;
DEPRECATED Server(unsigned short port, size_t thread_pool_size = 1, long timeout_request = 5, long timeout_content = 300) : Server() {
config.port = port;
config.thread_pool_size = thread_pool_size;
config.timeout_request = timeout_request;
config.timeout_content = timeout_content;
}
Server() : ServerBase<HTTP>::ServerBase(80) {}
@ -501,11 +503,11 @@ namespace SimpleWeb {
void accept() {
//Create new socket for this connection
//Shared_ptr is used to pass temporary objects to the asynchronous functions
auto socket=std::make_shared<HTTP>(*io_service);
auto socket = std::make_shared<HTTP>(*io_service);
acceptor->async_accept(*socket, [this, socket](const error_code& ec){
acceptor->async_accept(*socket, [this, socket](const error_code &ec) {
//Immediately start accepting a new connection (if io_service hasn't been stopped)
if (ec != asio::error::operation_aborted)
if(ec != asio::error::operation_aborted)
accept();
if(!ec) {
@ -519,5 +521,6 @@ namespace SimpleWeb {
});
}
};
}
} // namespace SimpleWeb
#endif /* SERVER_HTTP_HPP */

52
server_https.hpp
View file

@ -9,46 +9,45 @@
#include <boost/asio/ssl.hpp>
#endif
#include <openssl/ssl.h>
#include <algorithm>
#include <openssl/ssl.h>
namespace SimpleWeb {
typedef asio::ssl::stream<asio::ip::tcp::socket> HTTPS;
template<>
template <>
class Server<HTTPS> : public ServerBase<HTTPS> {
std::string session_id_context;
bool set_session_id_context=false;
bool set_session_id_context = false;
public:
DEPRECATED Server(unsigned short port, size_t thread_pool_size, const std::string& cert_file, const std::string& private_key_file,
long timeout_request=5, long timeout_content=300,
const std::string& verify_file=std::string()) :
Server(cert_file, private_key_file, verify_file) {
config.port=port;
config.thread_pool_size=thread_pool_size;
config.timeout_request=timeout_request;
config.timeout_content=timeout_content;
DEPRECATED Server(unsigned short port, size_t thread_pool_size, const std::string &cert_file, const std::string &private_key_file,
long timeout_request = 5, long timeout_content = 300, const std::string &verify_file = std::string())
: Server(cert_file, private_key_file, verify_file) {
config.port = port;
config.thread_pool_size = thread_pool_size;
config.timeout_request = timeout_request;
config.timeout_content = timeout_content;
}
Server(const std::string& cert_file, const std::string& private_key_file, const std::string& verify_file=std::string()):
ServerBase<HTTPS>::ServerBase(443), context(asio::ssl::context::tlsv12) {
Server(const std::string &cert_file, const std::string &private_key_file, const std::string &verify_file = std::string())
: ServerBase<HTTPS>::ServerBase(443), context(asio::ssl::context::tlsv12) {
context.use_certificate_chain_file(cert_file);
context.use_private_key_file(private_key_file, asio::ssl::context::pem);
if(verify_file.size()>0) {
if(verify_file.size() > 0) {
context.load_verify_file(verify_file);
context.set_verify_mode(asio::ssl::verify_peer | asio::ssl::verify_fail_if_no_peer_cert |
asio::ssl::verify_client_once);
set_session_id_context=true;
context.set_verify_mode(asio::ssl::verify_peer | asio::ssl::verify_fail_if_no_peer_cert | asio::ssl::verify_client_once);
set_session_id_context = true;
}
}
void start() {
if(set_session_id_context) {
// Creating session_id_context from address:port but reversed due to small SSL_MAX_SSL_SESSION_ID_LENGTH
session_id_context=std::to_string(config.port)+':';
session_id_context = std::to_string(config.port) + ':';
session_id_context.append(config.address.rbegin(), config.address.rend());
SSL_CTX_set_session_id_context(context.native_handle(), reinterpret_cast<const unsigned char*>(session_id_context.data()),
SSL_CTX_set_session_id_context(context.native_handle(), reinterpret_cast<const unsigned char *>(session_id_context.data()),
std::min<size_t>(session_id_context.size(), SSL_MAX_SSL_SESSION_ID_LENGTH));
}
ServerBase::start();
@ -60,11 +59,11 @@ namespace SimpleWeb {
void accept() {
//Create new socket for this connection
//Shared_ptr is used to pass temporary objects to the asynchronous functions
auto socket=std::make_shared<HTTPS>(*io_service, context);
auto socket = std::make_shared<HTTPS>(*io_service, context);
acceptor->async_accept((*socket).lowest_layer(), [this, socket](const error_code& ec) {
acceptor->async_accept((*socket).lowest_layer(), [this, socket](const error_code &ec) {
//Immediately start accepting a new connection (if io_service hasn't been stopped)
if (ec != asio::error::operation_aborted)
if(ec != asio::error::operation_aborted)
accept();
@ -73,9 +72,8 @@ namespace SimpleWeb {
socket->lowest_layer().set_option(option);
//Set timeout on the following asio::ssl::stream::async_handshake
auto timer=get_timeout_timer(socket, config.timeout_request);
socket->async_handshake(asio::ssl::stream_base::server, [this, socket, timer]
(const error_code& ec) {
auto timer = get_timeout_timer(socket, config.timeout_request);
socket->async_handshake(asio::ssl::stream_base::server, [this, socket, timer](const error_code &ec) {
if(timer)
timer->cancel();
if(!ec)
@ -89,8 +87,6 @@ namespace SimpleWeb {
});
}
};
}
} // namespace SimpleWeb
#endif /* SERVER_HTTPS_HPP */

16
status_code.hpp
View file

@ -5,7 +5,7 @@
#include <vector>
namespace SimpleWeb {
enum class StatusCode {
enum class StatusCode {
unknown = 0,
information_continue = 100,
information_switching_protocols,
@ -68,9 +68,9 @@ enum class StatusCode {
server_error_loop_detected,
server_error_not_extended = 510,
server_error_network_authentication_required
};
};
inline const static std::vector<std::pair<StatusCode, std::string>> &status_codes() {
inline const static std::vector<std::pair<StatusCode, std::string>> &status_codes() {
static std::vector<std::pair<StatusCode, std::string>> status_codes = {
{StatusCode::unknown, ""},
{StatusCode::information_continue, "100 Continue"},
@ -135,23 +135,23 @@ inline const static std::vector<std::pair<StatusCode, std::string>> &status_code
{StatusCode::server_error_not_extended, "510 Not Extended"},
{StatusCode::server_error_network_authentication_required, "511 Network Authentication Required"}};
return status_codes;
}
}
inline StatusCode status_code(const std::string &status_code_str) {
inline StatusCode status_code(const std::string &status_code_str) {
for(auto &status_code : status_codes()) {
if(status_code.second == status_code_str)
return status_code.first;
}
return StatusCode::unknown;
}
}
inline const std::string &status_code(StatusCode status_code_enum) {
inline const std::string &status_code(StatusCode status_code_enum) {
for(auto &status_code : status_codes()) {
if(status_code.first == status_code_enum)
return status_code.second;
}
return status_codes()[0].second;
}
}
} // namespace SimpleWeb
#endif // SIMPLE_WEB_SERVER_STATUS_CODE_HPP

43
tests/crypto_test.cpp
View file

@ -1,66 +1,61 @@
#include <vector>
#include <cassert>
#include <vector>
#include "crypto.hpp"
using namespace std;
using namespace SimpleWeb;
const vector<pair<string, string> > base64_string_tests = {
const vector<pair<string, string>> base64_string_tests = {
{"", ""},
{"f" , "Zg=="},
{"f", "Zg=="},
{"fo", "Zm8="},
{"foo", "Zm9v"},
{"foob", "Zm9vYg=="},
{"fooba", "Zm9vYmE="},
{"foobar", "Zm9vYmFy"}
};
{"foobar", "Zm9vYmFy"}};
const vector<pair<string, string> > md5_string_tests = {
const vector<pair<string, string>> md5_string_tests = {
{"", "d41d8cd98f00b204e9800998ecf8427e"},
{"The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6"}
};
{"The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6"}};
const vector<pair<string, string> > sha1_string_tests = {
const vector<pair<string, string>> sha1_string_tests = {
{"", "da39a3ee5e6b4b0d3255bfef95601890afd80709"},
{"The quick brown fox jumps over the lazy dog", "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"}
};
{"The quick brown fox jumps over the lazy dog", "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"}};
const vector<pair<string, string> > sha256_string_tests = {
const vector<pair<string, string>> sha256_string_tests = {
{"", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
{"The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592"}
};
{"The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592"}};
const vector<pair<string, string> > sha512_string_tests = {
const vector<pair<string, string>> sha512_string_tests = {
{"", "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"},
{"The quick brown fox jumps over the lazy dog", "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6"}
};
{"The quick brown fox jumps over the lazy dog", "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6"}};
int main() {
for(auto& string_test: base64_string_tests) {
assert(Crypto::Base64::encode(string_test.first)==string_test.second);
assert(Crypto::Base64::decode(string_test.second)==string_test.first);
for(auto &string_test : base64_string_tests) {
assert(Crypto::Base64::encode(string_test.first) == string_test.second);
assert(Crypto::Base64::decode(string_test.second) == string_test.first);
}
for(auto& string_test: md5_string_tests) {
for(auto &string_test : md5_string_tests) {
assert(Crypto::to_hex_string(Crypto::md5(string_test.first)) == string_test.second);
stringstream ss(string_test.first);
assert(Crypto::to_hex_string(Crypto::md5(ss)) == string_test.second);
}
for(auto& string_test: sha1_string_tests) {
for(auto &string_test : sha1_string_tests) {
assert(Crypto::to_hex_string(Crypto::sha1(string_test.first)) == string_test.second);
stringstream ss(string_test.first);
assert(Crypto::to_hex_string(Crypto::sha1(ss)) == string_test.second);
}
for(auto& string_test: sha256_string_tests) {
for(auto &string_test : sha256_string_tests) {
assert(Crypto::to_hex_string(Crypto::sha256(string_test.first)) == string_test.second);
stringstream ss(string_test.first);
assert(Crypto::to_hex_string(Crypto::sha256(ss)) == string_test.second);
}
for(auto& string_test: sha512_string_tests) {
for(auto &string_test : sha512_string_tests) {
assert(Crypto::to_hex_string(Crypto::sha512(string_test.first)) == string_test.second);
stringstream ss(string_test.first);
assert(Crypto::to_hex_string(Crypto::sha512(ss)) == string_test.second);

156
tests/io_test.cpp
View file

@ -1,5 +1,5 @@
#include "server_http.hpp"
#include "client_http.hpp"
#include "server_http.hpp"
#include <cassert>
@ -10,50 +10,54 @@ typedef SimpleWeb::Client<SimpleWeb::HTTP> HttpClient;
int main() {
HttpServer server;
server.config.port=8080;
server.config.port = 8080;
server.resource["^/string$"]["POST"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
auto content=request->content.string();
server.resource["^/string$"]["POST"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
auto content = request->content.string();
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n" << content;
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n"
<< content;
};
server.resource["^/string2$"]["POST"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.resource["^/string2$"]["POST"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
response->write(request->content.string());
};
server.resource["^/string3$"]["POST"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.resource["^/string3$"]["POST"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
std::stringstream stream;
stream << request->content.rdbuf();
response->write(stream);
};
server.resource["^/string4$"]["POST"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> /*request*/) {
server.resource["^/string4$"]["POST"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> /*request*/) {
response->write(SimpleWeb::StatusCode::client_error_forbidden, {{"Test1", "test2"}, {"tesT3", "test4"}});
};
server.resource["^/info$"]["GET"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
server.resource["^/info$"]["GET"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
stringstream content_stream;
content_stream << request->method << " " << request->path << " " << request->http_version << " ";
content_stream << request->header.find("test parameter")->second;
content_stream.seekp(0, ios::end);
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content_stream.tellp() << "\r\n\r\n" << content_stream.rdbuf();
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content_stream.tellp() << "\r\n\r\n"
<< content_stream.rdbuf();
};
server.resource["^/match/([0-9]+)$"]["GET"]=[&server](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
string number=request->path_match[1];
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << number.length() << "\r\n\r\n" << number;
server.resource["^/match/([0-9]+)$"]["GET"] = [&server](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
string number = request->path_match[1];
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << number.length() << "\r\n\r\n"
<< number;
};
server.resource["^/header$"]["GET"]=[](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
auto content=request->header.find("test1")->second+request->header.find("test2")->second;
server.resource["^/header$"]["GET"] = [](shared_ptr<HttpServer::Response> response, shared_ptr<HttpServer::Request> request) {
auto content = request->header.find("test1")->second + request->header.find("test2")->second;
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n" << content;
*response << "HTTP/1.1 200 OK\r\nContent-Length: " << content.length() << "\r\n\r\n"
<< content;
};
thread server_thread([&server](){
thread server_thread([&server]() {
//Start server
server.start();
});
@ -64,67 +68,67 @@ int main() {
{
stringstream output;
auto r=client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r->status_code)==SimpleWeb::StatusCode::success_ok);
auto r = client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r->status_code) == SimpleWeb::StatusCode::success_ok);
output << r->content.rdbuf();
assert(output.str()=="A string");
assert(output.str() == "A string");
}
{
stringstream output;
auto r=client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r->status_code)==SimpleWeb::StatusCode::success_ok);
assert(r->content.string()=="A string");
auto r = client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r->status_code) == SimpleWeb::StatusCode::success_ok);
assert(r->content.string() == "A string");
}
{
stringstream output;
auto r=client.request("POST", "/string2", "A string");
assert(SimpleWeb::status_code(r->status_code)==SimpleWeb::StatusCode::success_ok);
auto r = client.request("POST", "/string2", "A string");
assert(SimpleWeb::status_code(r->status_code) == SimpleWeb::StatusCode::success_ok);
output << r->content.rdbuf();
assert(output.str()=="A string");
assert(output.str() == "A string");
}
{
stringstream output;
auto r=client.request("POST", "/string3", "A string");
assert(SimpleWeb::status_code(r->status_code)==SimpleWeb::StatusCode::success_ok);
auto r = client.request("POST", "/string3", "A string");
assert(SimpleWeb::status_code(r->status_code) == SimpleWeb::StatusCode::success_ok);
output << r->content.rdbuf();
assert(output.str()=="A string");
assert(output.str() == "A string");
}
{
stringstream output;
auto r=client.request("POST", "/string4", "A string");
assert(SimpleWeb::status_code(r->status_code)==SimpleWeb::StatusCode::client_error_forbidden);
assert(r->header.size()==3);
assert(r->header.find("test1")->second=="test2");
assert(r->header.find("tEst3")->second=="test4");
assert(r->header.find("content-length")->second=="0");
auto r = client.request("POST", "/string4", "A string");
assert(SimpleWeb::status_code(r->status_code) == SimpleWeb::StatusCode::client_error_forbidden);
assert(r->header.size() == 3);
assert(r->header.find("test1")->second == "test2");
assert(r->header.find("tEst3")->second == "test4");
assert(r->header.find("content-length")->second == "0");
output << r->content.rdbuf();
assert(output.str()=="");
assert(output.str() == "");
}
{
stringstream output;
stringstream content("A string");
auto r=client.request("POST", "/string", content);
auto r = client.request("POST", "/string", content);
output << r->content.rdbuf();
assert(output.str()=="A string");
assert(output.str() == "A string");
}
{
stringstream output;
auto r=client.request("GET", "/info", "", {{"Test Parameter", "test value"}});
auto r = client.request("GET", "/info", "", {{"Test Parameter", "test value"}});
output << r->content.rdbuf();
assert(output.str()=="GET /info 1.1 test value");
assert(output.str() == "GET /info 1.1 test value");
}
{
stringstream output;
auto r=client.request("GET", "/match/123");
auto r = client.request("GET", "/match/123");
output << r->content.rdbuf();
assert(output.str()=="123");
assert(output.str() == "123");
}
}
{
@ -135,41 +139,41 @@ int main() {
// test performing the stream version of the request methods first
stringstream output;
stringstream content("A string");
auto r=client.request("POST", "/string", content);
auto r = client.request("POST", "/string", content);
output << r->content.rdbuf();
assert(output.str()=="A string");
assert(client.connections->size()==1);
connection=client.connections->front().get();
assert(output.str() == "A string");
assert(client.connections->size() == 1);
connection = client.connections->front().get();
}
{
stringstream output;
auto r=client.request("POST", "/string", "A string");
auto r = client.request("POST", "/string", "A string");
output << r->content.rdbuf();
assert(output.str()=="A string");
assert(client.connections->size()==1);
assert(connection==client.connections->front().get());
assert(output.str() == "A string");
assert(client.connections->size() == 1);
assert(connection == client.connections->front().get());
}
{
stringstream output;
auto r=client.request("GET", "/header", "", {{"test1", "test"}, {"test2", "ing"}});
auto r = client.request("GET", "/header", "", {{"test1", "test"}, {"test2", "ing"}});
output << r->content.rdbuf();
assert(output.str()=="testing");
assert(client.connections->size()==1);
assert(connection==client.connections->front().get());
assert(output.str() == "testing");
assert(client.connections->size() == 1);
assert(connection == client.connections->front().get());
}
}
{
HttpClient client("localhost:8080");
bool call=false;
bool call = false;
client.request("GET", "/match/123", [&call](shared_ptr<HttpClient::Response> response, const SimpleWeb::error_code &ec) {
assert(!ec);
stringstream output;
output << response->content.rdbuf();
assert(output.str()=="123");
call=true;
assert(output.str() == "123");
call = true;
});
client.io_service->run();
assert(call);
@ -177,37 +181,37 @@ int main() {
{
vector<int> calls(100);
vector<thread> threads;
for(size_t c=0;c<100;++c) {
calls[c]=0;
for(size_t c = 0; c < 100; ++c) {
calls[c] = 0;
threads.emplace_back([c, &client, &calls] {
client.request("GET", "/match/123", [c, &calls](shared_ptr<HttpClient::Response> response, const SimpleWeb::error_code &ec) {
assert(!ec);
stringstream output;
output << response->content.rdbuf();
assert(output.str()=="123");
calls[c]=1;
assert(output.str() == "123");
calls[c] = 1;
});
});
}
for(auto &thread: threads)
for(auto &thread : threads)
thread.join();
assert(client.connections->size()==100);
assert(client.connections->size() == 100);
client.io_service->reset();
client.io_service->run();
assert(client.connections->size()==1);
for(auto call: calls)
assert(client.connections->size() == 1);
for(auto call : calls)
assert(call);
}
}
{
HttpClient client("localhost:8080");
assert(client.connections->size()==0);
for(size_t c=0;c<5000;++c) {
auto r1=client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r1->status_code)==SimpleWeb::StatusCode::success_ok);
assert(r1->content.string()=="A string");
assert(client.connections->size()==1);
assert(client.connections->size() == 0);
for(size_t c = 0; c < 5000; ++c) {
auto r1 = client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r1->status_code) == SimpleWeb::StatusCode::success_ok);
assert(r1->content.string() == "A string");
assert(client.connections->size() == 1);
stringstream content("A string");
auto r2 = client.request("POST", "/string", content);
@ -217,13 +221,13 @@ int main() {
}
}
for(size_t c=0;c<500;++c) {
for(size_t c = 0; c < 500; ++c) {
{
HttpClient client("localhost:8080");
auto r=client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r->status_code)==SimpleWeb::StatusCode::success_ok);
assert(r->content.string()=="A string");
assert(client.connections->size()==1);
auto r = client.request("POST", "/string", "A string");
assert(SimpleWeb::status_code(r->status_code) == SimpleWeb::StatusCode::success_ok);
assert(r->content.string() == "A string");
assert(client.connections->size() == 1);
}
{

118
tests/parse_test.cpp
View file

@ -1,7 +1,7 @@
#include "server_http.hpp"
#include "client_http.hpp"
#include <iostream>
#include "server_http.hpp"
#include <cassert>
#include <iostream>
using namespace std;
using namespace SimpleWeb;
@ -26,47 +26,47 @@ public:
assert(parse_request(request));
assert(request->method=="GET");
assert(request->path=="/test/");
assert(request->http_version=="1.1");
assert(request->method == "GET");
assert(request->path == "/test/");
assert(request->http_version == "1.1");
assert(request->header.size()==4);
auto header_it=request->header.find("TestHeader");
assert(header_it!=request->header.end() && header_it->second=="test");
header_it=request->header.find("TestHeader2");
assert(header_it!=request->header.end() && header_it->second=="test2");
assert(request->header.size() == 4);
auto header_it = request->header.find("TestHeader");
assert(header_it != request->header.end() && header_it->second == "test");
header_it = request->header.find("TestHeader2");
assert(header_it != request->header.end() && header_it->second == "test2");
header_it=request->header.find("testheader");
assert(header_it!=request->header.end() && header_it->second=="test");
header_it=request->header.find("testheader2");
assert(header_it!=request->header.end() && header_it->second=="test2");
header_it = request->header.find("testheader");
assert(header_it != request->header.end() && header_it->second == "test");
header_it = request->header.find("testheader2");
assert(header_it != request->header.end() && header_it->second == "test2");
auto range=request->header.equal_range("testheader3");
auto first=range.first;
auto second=first;
auto range = request->header.equal_range("testheader3");
auto first = range.first;
auto second = first;
++second;
assert(range.first!=request->header.end() && range.second!=request->header.end() &&
((first->second=="test3a" && second->second=="test3b") ||
(first->second=="test3b" && second->second=="test3a")));
assert(range.first != request->header.end() && range.second != request->header.end() &&
((first->second == "test3a" && second->second == "test3b") ||
(first->second == "test3b" && second->second == "test3a")));
}
};
class ClientTest : public ClientBase<HTTP> {
public:
ClientTest(const std::string& server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {}
ClientTest(const std::string &server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {}
std::shared_ptr<Connection> create_connection() override {
return nullptr;
}
void constructor_parse_test1() {
assert(host=="test.org");
assert(port==8080);
assert(host == "test.org");
assert(port == 8080);
}
void constructor_parse_test2() {
assert(host=="test.org");
assert(port==80);
assert(host == "test.org");
assert(port == 80);
}
void parse_response_header_test() {
@ -82,27 +82,27 @@ public:
parse_response_header(response);
assert(response->http_version=="1.1");
assert(response->status_code=="200 OK");
assert(response->http_version == "1.1");
assert(response->status_code == "200 OK");
assert(response->header.size()==4);
auto header_it=response->header.find("TestHeader");
assert(header_it!=response->header.end() && header_it->second=="test");
header_it=response->header.find("TestHeader2");
assert(header_it!=response->header.end() && header_it->second=="test2");
assert(response->header.size() == 4);
auto header_it = response->header.find("TestHeader");
assert(header_it != response->header.end() && header_it->second == "test");
header_it = response->header.find("TestHeader2");
assert(header_it != response->header.end() && header_it->second == "test2");
header_it=response->header.find("testheader");
assert(header_it!=response->header.end() && header_it->second=="test");
header_it=response->header.find("testheader2");
assert(header_it!=response->header.end() && header_it->second=="test2");
header_it = response->header.find("testheader");
assert(header_it != response->header.end() && header_it->second == "test");
header_it = response->header.find("testheader2");
assert(header_it != response->header.end() && header_it->second == "test2");
auto range=response->header.equal_range("testheader3");
auto first=range.first;
auto second=first;
auto range = response->header.equal_range("testheader3");
auto first = range.first;
auto second = first;
++second;
assert(range.first!=response->header.end() && range.second!=response->header.end() &&
((first->second=="test3a" && second->second=="test3b") ||
(first->second=="test3b" && second->second=="test3a")));
assert(range.first != response->header.end() && range.second != response->header.end() &&
((first->second == "test3a" && second->second == "test3b") ||
(first->second == "test3b" && second->second == "test3a")));
}
};
@ -115,27 +115,27 @@ int main() {
assert(equal("tesT", "test"));
assert(!equal("test", "tset"));
CaseInsensitiveHash hash;
assert(hash("Test")==hash("tesT"));
assert(hash("tesT")==hash("test"));
assert(hash("test")!=hash("tset"));
assert(hash("Test") == hash("tesT"));
assert(hash("tesT") == hash("test"));
assert(hash("test") != hash("tset"));
auto percent_decoded="testing æøå !#$&'()*+,/:;=?@[]";
auto percent_encoded="testing+æøå+%21%23%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D";
assert(Percent::encode(percent_decoded)==percent_encoded);
assert(Percent::decode(percent_encoded)==percent_decoded);
assert(Percent::decode(Percent::encode(percent_decoded))==percent_decoded);
auto percent_decoded = "testing æøå !#$&'()*+,/:;=?@[]";
auto percent_encoded = "testing+æøå+%21%23%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D";
assert(Percent::encode(percent_decoded) == percent_encoded);
assert(Percent::decode(percent_encoded) == percent_decoded);
assert(Percent::decode(Percent::encode(percent_decoded)) == percent_decoded);
SimpleWeb::CaseInsensitiveMultimap fields={{"test1", "æøå"}, {"test2", "!#$&'()*+,/:;=?@[]"}};
auto query_string1="test1=æøå&test2=%21%23%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D";
auto query_string2="test2=%21%23%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D&test1=æøå";
auto query_string_result=QueryString::create(fields);
assert(query_string_result==query_string1 || query_string_result==query_string2);
auto fields_result1=QueryString::parse(query_string1);
auto fields_result2=QueryString::parse(query_string2);
assert(fields_result1==fields_result2 && fields_result1==fields);
SimpleWeb::CaseInsensitiveMultimap fields = {{"test1", "æøå"}, {"test2", "!#$&'()*+,/:;=?@[]"}};
auto query_string1 = "test1=æøå&test2=%21%23%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D";
auto query_string2 = "test2=%21%23%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D&test1=æøå";
auto query_string_result = QueryString::create(fields);
assert(query_string_result == query_string1 || query_string_result == query_string2);
auto fields_result1 = QueryString::parse(query_string1);
auto fields_result2 = QueryString::parse(query_string2);
assert(fields_result1 == fields_result2 && fields_result1 == fields);
ServerTest serverTest;
serverTest.io_service=std::make_shared<asio::io_service>();
serverTest.io_service = std::make_shared<asio::io_service>();
serverTest.parse_request_test();

42
utility.hpp
View file

@ -20,21 +20,21 @@
namespace SimpleWeb {
#ifndef CASE_INSENSITIVE_EQUAL_AND_HASH
#define CASE_INSENSITIVE_EQUAL_AND_HASH
inline bool case_insensitive_equal(const std::string &str1, const std::string &str2) {
inline bool case_insensitive_equal(const std::string &str1, const std::string &str2) {
return str1.size() == str2.size() &&
std::equal(str1.begin(), str1.end(), str2.begin(), [](char a, char b) {
return tolower(a) == tolower(b);
});
}
class CaseInsensitiveEqual {
public:
}
class CaseInsensitiveEqual {
public:
bool operator()(const std::string &str1, const std::string &str2) const {
return case_insensitive_equal(str1, str2);
}
};
// Based on https://stackoverflow.com/questions/2590677/how-do-i-combine-hash-values-in-c0x/2595226#2595226
class CaseInsensitiveHash {
public:
};
// Based on https://stackoverflow.com/questions/2590677/how-do-i-combine-hash-values-in-c0x/2595226#2595226
class CaseInsensitiveHash {
public:
size_t operator()(const std::string &str) const {
size_t h = 0;
std::hash<int> hash;
@ -42,14 +42,14 @@ public:
h ^= hash(tolower(c)) + 0x9e3779b9 + (h << 6) + (h >> 2);
return h;
}
};
};
#endif
typedef std::unordered_multimap<std::string, std::string, CaseInsensitiveHash, CaseInsensitiveEqual> CaseInsensitiveMultimap;
typedef std::unordered_multimap<std::string, std::string, CaseInsensitiveHash, CaseInsensitiveEqual> CaseInsensitiveMultimap;
/// Percent encoding and decoding
class Percent {
public:
/// Percent encoding and decoding
class Percent {
public:
/// Returns percent-encoded string
static std::string encode(const std::string &value) {
static auto hex_chars = "0123456789ABCDEF";
@ -90,11 +90,11 @@ public:
return result;
}
};
};
/// Query string creation and parsing
class QueryString {
public:
/// Query string creation and parsing
class QueryString {
public:
/// Returns query string created from given field names and values
static std::string create(const CaseInsensitiveMultimap &fields) {
std::string result;
@ -144,12 +144,12 @@ public:
return result;
}
};
};
/// Returns query keys with percent-decoded values.
DEPRECATED inline CaseInsensitiveMultimap parse_query_string(const std::string &query_string) {
/// Returns query keys with percent-decoded values.
DEPRECATED inline CaseInsensitiveMultimap parse_query_string(const std::string &query_string) {
return QueryString::parse(query_string);
}
}
} // namespace SimpleWeb
#endif // SIMPLE_WEB_SERVER_UTILITY_HPP