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

Case insensitive header cleanup. Also cleanup and additions to parse_test

Browse source
This commit is contained in:
eidheim 2016-12-31 10:34:03 +01:00
commit 549bc646bb
3 changed files with 98 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

39
client_http.hpp
View file

@ -12,6 +12,26 @@
#include <mutex>
#include <type_traits>
#ifndef CASE_INSENSITIVE_EQUALS_AND_HASH
#define CASE_INSENSITIVE_EQUALS_AND_HASH
//Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
class case_insensitive_equals {
public:
bool operator()(const std::string &key1, const std::string &key2) const {
return boost::algorithm::iequals(key1, key2);
}
};
class case_insensitive_hash {
public:
size_t operator()(const std::string &key) const {
std::size_t seed=0;
for(auto &c: key)
boost::hash_combine(seed, std::tolower(c));
return seed;
}
};
#endif
namespace SimpleWeb {
template <class socket_type>
class Client;
@ -24,29 +44,12 @@ namespace SimpleWeb {
class Response {
friend class ClientBase<socket_type>;
friend class Client<socket_type>;
//Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
class iequal_to {
public:
bool operator()(const std::string &key1, const std::string &key2) const {
return boost::algorithm::iequals(key1, key2);
}
};
class ihash {
public:
size_t operator()(const std::string &key) const {
std::size_t seed=0;
for(auto &c: key)
boost::hash_combine(seed, std::tolower(c));
return seed;
}
};
public:
std::string http_version, status_code;
std::istream content;
std::unordered_multimap<std::string, std::string, ihash, iequal_to> header;
std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header;
private:
boost::asio::streambuf content_buffer;

41
server_http.hpp
View file

@ -11,6 +11,26 @@
#include <iostream>
#include <sstream>
#ifndef CASE_INSENSITIVE_EQUALS_AND_HASH
#define CASE_INSENSITIVE_EQUALS_AND_HASH
//Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
class case_insensitive_equals {
public:
bool operator()(const std::string &key1, const std::string &key2) const {
return boost::algorithm::iequals(key1, key2);
}
};
class case_insensitive_hash {
public:
size_t operator()(const std::string &key) const {
std::size_t seed=0;
for(auto &c: key)
boost::hash_combine(seed, std::tolower(c));
return seed;
}
};
#endif
// Late 2017 TODO: remove the following checks and always use std::regex
#ifdef USE_BOOST_REGEX
#include <boost/regex.hpp>
@ -74,29 +94,12 @@ namespace SimpleWeb {
class Request {
friend class ServerBase<socket_type>;
friend class Server<socket_type>;
//Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
class iequal_to {
public:
bool operator()(const std::string &key1, const std::string &key2) const {
return boost::algorithm::iequals(key1, key2);
}
};
class ihash {
public:
size_t operator()(const std::string &key) const {
std::size_t seed=0;
for(auto &c: key)
boost::hash_combine(seed, std::tolower(c));
return seed;
}
};
public:
std::string method, path, http_version;
Content content;
std::unordered_multimap<std::string, std::string, ihash, iequal_to> header;
std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header;
REGEX_NS::smatch path_match;
@ -338,7 +341,7 @@ namespace SimpleWeb {
if(line[value_start]==' ')
value_start++;
if(value_start<line.size())
request->header.insert(std::make_pair(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1)));
request->header.emplace(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1));
}
getline(request->content, line);

119
tests/parse_test.cpp
View file

@ -1,18 +1,18 @@
#include "server_http.hpp"
#include "client_http.hpp"
#include <iostream>
#include <cassert>
using namespace std;
using namespace SimpleWeb;
class ServerTest : public ServerBase<HTTP> {
public:
ServerTest() :
ServerBase<HTTP>::ServerBase(8080) {}
ServerTest() : ServerBase<HTTP>::ServerBase(8080) {}
void accept() {}
bool parse_request_test() {
void parse_request_test() {
HTTP socket(*io_service);
std::shared_ptr<Request> request(new Request(socket));
@ -20,28 +20,34 @@ public:
stream << "GET /test/ HTTP/1.1\r\n";
stream << "TestHeader: test\r\n";
stream << "TestHeader2:test2\r\n";
stream << "TestHeader3:test3a\r\n";
stream << "TestHeader3:test3b\r\n";
stream << "\r\n";
if(!parse_request(request))
return 0;
assert(parse_request(request));
if(request->method!="GET")
return 0;
if(request->path!="/test/")
return 0;
if(request->http_version!="1.1")
return 0;
assert(request->method=="GET");
assert(request->path=="/test/");
assert(request->http_version=="1.1");
if(request->header.size()!=2)
return 0;
assert(request->header.size()==4);
auto header_it=request->header.find("TestHeader");
if(header_it==request->header.end() || header_it->second!="test")
return 0;
assert(header_it!=request->header.end() && header_it->second=="test");
header_it=request->header.find("TestHeader2");
if(header_it==request->header.end() || header_it->second!="test2")
return 0;
assert(header_it!=request->header.end() && header_it->second=="test2");
return 1;
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;
++second;
assert(range.first!=request->header.end() && range.second!=request->header.end() &&
((first->second=="test3a" && second->second=="test3b") ||
(first->second=="test3b" && second->second=="test3a")));
}
};
@ -51,51 +57,50 @@ public:
void connect() {}
bool constructor_parse_test1() {
if(host!="test.org")
return 0;
if(port!=8080)
return 0;
return 1;
void constructor_parse_test1() {
assert(host=="test.org");
assert(port==8080);
}
bool constructor_parse_test2() {
if(host!="test.org")
return 0;
if(port!=80)
return 0;
return 1;
void constructor_parse_test2() {
assert(host=="test.org");
assert(port==80);
}
bool parse_response_header_test() {
void parse_response_header_test() {
std::shared_ptr<Response> response(new Response());
ostream stream(&response->content_buffer);
stream << "HTTP/1.1 200 OK\r\n";
stream << "TestHeader: test\r\n";
stream << "TestHeader2:test2\r\n";
stream << "TestHeader3:test3a\r\n";
stream << "TestHeader3:test3b\r\n";
stream << "\r\n";
parse_response_header(response);
if(response->http_version!="1.1")
return 0;
if(response->status_code!="200 OK")
return 0;
assert(response->http_version=="1.1");
assert(response->status_code=="200 OK");
if(response->header.size()!=2)
return 0;
assert(response->header.size()==4);
auto header_it=response->header.find("TestHeader");
if(header_it==response->header.end() || header_it->second!="test")
return 0;
assert(header_it!=response->header.end() && header_it->second=="test");
header_it=response->header.find("TestHeader2");
if(header_it==response->header.end() || header_it->second!="test2")
return 0;
assert(header_it!=response->header.end() && header_it->second=="test2");
return 1;
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;
++second;
assert(range.first!=response->header.end() && range.second!=response->header.end() &&
((first->second=="test3a" && second->second=="test3b") ||
(first->second=="test3b" && second->second=="test3a")));
}
};
@ -103,27 +108,13 @@ int main() {
ServerTest serverTest;
serverTest.io_service=std::make_shared<boost::asio::io_service>();
if(!serverTest.parse_request_test()) {
cerr << "FAIL Server::parse_request" << endl;
return 1;
}
serverTest.parse_request_test();
ClientTest clientTest("test.org:8080");
if(!clientTest.constructor_parse_test1()) {
cerr << "FAIL Client::Client" << endl;
return 1;
}
clientTest.constructor_parse_test1();
ClientTest clientTest2("test.org");
if(!clientTest2.constructor_parse_test2()) {
cerr << "FAIL Client::Client" << endl;
return 1;
}
clientTest2.constructor_parse_test2();
if(!clientTest2.parse_response_header_test()) {
cerr << "FAIL Client::parse_response_header" << endl;
return 1;
}
return 0;
}
clientTest2.parse_response_header_test();
}