mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-04-25 22:17:45 +00:00
Code Activity

zone and api work a bit better now

Browse source
This commit is contained in:
NotAdam 2018-10-26 22:14:12 +11:00
parent ccb29c88de
commit ddfbeb724f
5 changed files with 419 additions and 408 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
CMakeLists.txt
View file

@ -36,11 +36,11 @@ add_subdirectory( "src/common" )
add_subdirectory( "src/servers" ) add_subdirectory( "src/servers" )
#add_subdirectory( "src/dbm" ) #add_subdirectory( "src/dbm" )
add_subdirectory( "src/tools/exd_common_gen" ) #add_subdirectory( "src/tools/exd_common_gen" )
add_subdirectory( "src/tools/exd_struct_gen" ) #add_subdirectory( "src/tools/exd_struct_gen" )
add_subdirectory( "src/tools/exd_struct_test" ) #add_subdirectory( "src/tools/exd_struct_test" )
add_subdirectory( "src/tools/quest_parser" ) #add_subdirectory( "src/tools/quest_parser" )
add_subdirectory( "src/tools/discovery_parser" ) #add_subdirectory( "src/tools/discovery_parser" )
add_subdirectory( "src/tools/mob_parse" ) #add_subdirectory( "src/tools/mob_parse" )
#add_subdirectory("src/tools/pcb_reader") #add_subdirectory("src/tools/pcb_reader")
#add_subdirectory("src/tools/event_object_parser") #add_subdirectory("src/tools/event_object_parser")

7
src/servers/sapphire_api/main.cpp
View file

@ -487,7 +487,12 @@ void checkSession( shared_ptr< HttpServer::Response > response, shared_ptr< Http
} }
else else
{ {
std::string json_string = "{\"result\":\"" + std::to_string( result ) + "\"}"; std::string json_string = nlohmann::json( {
{ "result", result },
{ "result2", "penis" },
{ "result3", "wtf" }
} ).dump()
;
*response << buildHttpResponse( 200, json_string, JSON ); *response << buildHttpResponse( 200, json_string, JSON );
} }
} }

23
src/servers/sapphire_lobby/RestConnector.cpp
View file

@ -57,7 +57,7 @@ Core::LobbySessionPtr Core::Network::RestConnector::getSession( char* sId )
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {
@ -99,7 +99,7 @@ bool Core::Network::RestConnector::checkNameTaken( std::string name )
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {
@ -133,7 +133,7 @@ uint32_t Core::Network::RestConnector::getNextCharId()
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {
@ -172,7 +172,7 @@ uint64_t Core::Network::RestConnector::getNextContentId()
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {
@ -213,7 +213,7 @@ CharList Core::Network::RestConnector::getCharList( char* sId )
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {
@ -230,10 +230,11 @@ CharList Core::Network::RestConnector::getCharList( char* sId )
{ {
g_log.debug( child["contentId"] ); g_log.debug( child["contentId"] );
//std::string, uint32_t, uint64_t, std::string //std::string, uint32_t, uint64_t, std::string
list.push_back( std::make_tuple( child["name"].get< std::string >() ), list.push_back( { child["name"].get< std::string >(),
child["charId"].get< uint32_t >(), child["charId"].get< uint32_t >(),
child["contentId"].get< uint64_t >(), child["contentId"].get< uint64_t >(),
child["infoJson"].get< std::string >() ); child["infoJson"].get< std::string >()
} );
} }
return list; return list;
@ -266,7 +267,7 @@ bool Core::Network::RestConnector::deleteCharacter( char* sId, std::string name
auto json = nlohmann::json(); auto json = nlohmann::json();
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {
@ -303,7 +304,7 @@ int Core::Network::RestConnector::createCharacter( char* sId, std::string name,
try try
{ {
json.parse( content ); json = json.parse( content );
} }
catch( std::exception& e ) catch( std::exception& e )
{ {

783
src/servers/sapphire_lobby/client_http.hpp
View file

@ -4,414 +4,419 @@
#include <asio.hpp> #include <asio.hpp>
#include <Util/Util.h> #include <Util/Util.h>
#include <unordered_map> #include <unordered_map>
#include <map> #include <map>
#include <random> #include <random>
#include <mutex> #include <mutex>
#include <type_traits> #include <type_traits>
#include <functional>
#ifndef CASE_INSENSITIVE_EQUALS_AND_HASH
#define CASE_INSENSITIVE_EQUALS_AND_HASH
class case_insensitive_equals { class case_insensitive_equals {
public: public:
bool operator()( const std::string &key1, const std::string &key2 ) const { bool operator()(const std::string &key1, const std::string &key2) const {
return Core::Util::toLowerCopy( key1 ) == Core::Util::toLowerCopy( key2 ); return Core::Util::toLowerCopy( key1 ) == Core::Util::toLowerCopy( key2 );
} }
}; };
class case_insensitive_hash { class case_insensitive_hash {
public: public:
size_t operator()( const std::string &key ) const { size_t operator()( const std::string &key ) const
std::size_t seed = 0; {
for( auto &c : key ) std::size_t seed=0;
Core::Util::hashCombine< char >( seed, std::tolower( c ) ); for( auto &c : key )
return seed; Core::Util::hashCombine< char >( seed, std::tolower( c ) );
} return seed;
}
}; };
#endif
namespace SimpleWeb { namespace SimpleWeb {
template <class socket_type> template <class socket_type>
class Client; class Client;
template <class socket_type>
class ClientBase {
public:
virtual ~ClientBase() {}
template <class socket_type> class Response {
class ClientBase { friend class ClientBase<socket_type>;
public: friend class Client<socket_type>;
virtual ~ClientBase() {} public:
std::string http_version, status_code;
class Response { std::istream content;
friend class ClientBase<socket_type>;
friend class Client<socket_type>;
public:
std::string http_version, status_code;
std::istream content; std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header;
private:
asio::streambuf 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;
/// Set proxy server (server:port)
std::string proxy_server;
};
/// Set before calling request
Config config;
std::shared_ptr<Response> request(const std::string& request_type, const std::string& path="/", std::string_view content="",
const std::map<std::string, std::string>& header=std::map<std::string, std::string>()) {
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;
asio::streambuf write_buffer;
std::ostream write_stream(&write_buffer);
write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n";
write_stream << "Host: " << host << "\r\n";
for(auto& h: header) {
write_stream << h.first << ": " << h.second << "\r\n";
}
if(content.size()>0)
write_stream << "Content-Length: " << content.size() << "\r\n";
write_stream << "\r\n";
connect();
auto timer=get_timeout_timer();
asio::async_write(*socket, write_buffer,
[this, &content, timer](const std::error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(!ec) {
if(!content.empty()) {
auto timer=get_timeout_timer();
asio::async_write(*socket, asio::buffer(content.data(), content.size()),
[this, timer](const std::error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(ec) {
std::lock_guard<std::mutex> lock(socket_mutex);
this->socket=nullptr;
throw std::system_error(ec);
}
});
}
}
else {
std::lock_guard<std::mutex> lock(socket_mutex);
socket=nullptr;
throw std::system_error(ec);
}
});
io_service.reset();
io_service.run();
return request_read();
}
std::shared_ptr<Response> request(const std::string& request_type, const std::string& path, std::iostream& content,
const std::map<std::string, std::string>& header=std::map<std::string, std::string>()) {
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;
content.seekp(0, std::ios::end);
auto content_length=content.tellp();
content.seekp(0, std::ios::beg);
asio::streambuf write_buffer;
std::ostream write_stream(&write_buffer);
write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n";
write_stream << "Host: " << host << "\r\n";
for(auto& h: header) {
write_stream << h.first << ": " << h.second << "\r\n";
}
if(content_length>0)
write_stream << "Content-Length: " << content_length << "\r\n";
write_stream << "\r\n";
if(content_length>0)
write_stream << content.rdbuf();
connect();
auto timer=get_timeout_timer();
asio::async_write(*socket, write_buffer,
[this, timer](const std::error_code &ec, size_t /*bytes_transferred*/) {
if(timer)
timer->cancel();
if(ec) {
std::lock_guard<std::mutex> lock(socket_mutex);
socket=nullptr;
throw std::system_error(ec);
}
});
io_service.reset();
io_service.run();
return request_read();
}
void close() {
std::lock_guard<std::mutex> lock(socket_mutex);
if(socket) {
std::error_code ec;
socket->lowest_layer().shutdown(asio::ip::tcp::socket::shutdown_both, ec);
socket->lowest_layer().close();
}
}
protected:
asio::io_service io_service;
asio::ip::tcp::resolver resolver;
std::unique_ptr<socket_type> socket;
std::mutex socket_mutex;
std::string host;
unsigned short port;
ClientBase(const std::string& host_port, unsigned short default_port) : resolver(io_service) {
auto parsed_host_port=parse_host_port(host_port, default_port);
host=parsed_host_port.first;
port=parsed_host_port.second;
}
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;
}
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)));
}
return parsed_host_port;
}
virtual void connect()=0;
std::shared_ptr< asio::basic_waitable_timer< std::chrono::steady_clock > > get_timeout_timer() {
if(config.timeout==0)
return nullptr;
auto timer=std::make_shared< asio::basic_waitable_timer< std::chrono::steady_clock > >(io_service);
timer->expires_from_now( std::chrono::seconds( config.timeout ) );
timer->async_wait([this](const std::error_code& ec) {
if(!ec) {
close();
}
});
return timer;
}
void parse_response_header(const std::shared_ptr<Response> &response) const {
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);
std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header; 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]==' ')
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)));
}
private: getline(response->content, line);
asio::streambuf content_buffer; }
}
Response() : content( &content_buffer ) {} }
};
std::shared_ptr<Response> request_read() {
class Config { std::shared_ptr<Response> response(new Response());
friend class ClientBase<socket_type>;
private: asio::streambuf chunked_streambuf;
Config() {}
public: auto timer=get_timeout_timer();
/// Set timeout on requests in seconds. Default value: 0 (no timeout). asio::async_read_until(*socket, response->content_buffer, "\r\n\r\n",
size_t timeout = 0; [this, &response, &chunked_streambuf, timer](const std::error_code& ec, size_t bytes_transferred) {
/// Set proxy server (server:port) if(timer)
std::string proxy_server; timer->cancel();
}; if(!ec) {
size_t num_additional_bytes=response->content_buffer.size()-bytes_transferred;
/// Set before calling request
Config config; parse_response_header(response);
std::shared_ptr<Response> request( const std::string& request_type, const std::string& path = "/", std::string_view content = "", auto header_it=response->header.find("Content-Length");
const std::map<std::string, std::string>& header = std::map<std::string, std::string>() ) { if(header_it!=response->header.end()) {
auto corrected_path = path; auto content_length=stoull(header_it->second);
if( corrected_path == "" ) if(content_length>num_additional_bytes) {
corrected_path = "/"; auto timer=get_timeout_timer();
if( !config.proxy_server.empty() && std::is_same<socket_type, asio::ip::tcp::socket>::value ) asio::async_read(*socket, response->content_buffer,
corrected_path = "http://" + host + ':' + std::to_string( port ) + corrected_path; asio::transfer_exactly(content_length-num_additional_bytes),
[this, timer](const std::error_code& ec, size_t /*bytes_transferred*/) {
asio::streambuf write_buffer; if(timer)
std::ostream write_stream( &write_buffer ); timer->cancel();
write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n"; if(ec) {
write_stream << "Host: " << host << "\r\n"; std::lock_guard<std::mutex> lock(socket_mutex);
for( auto& h : header ) { this->socket=nullptr;
write_stream << h.first << ": " << h.second << "\r\n"; throw std::system_error(ec);
} }
if( content.size()>0 ) });
write_stream << "Content-Length: " << content.size() << "\r\n"; }
write_stream << "\r\n"; }
else if((header_it=response->header.find("Transfer-Encoding"))!=response->header.end() && header_it->second=="chunked") {
connect(); request_read_chunked(response, chunked_streambuf);
}
auto timer = get_timeout_timer(); }
asio::async_write( *socket, write_buffer, else {
[this, &content, timer]( const std::error_code &ec, size_t /*bytes_transferred*/ ) { std::lock_guard<std::mutex> lock(socket_mutex);
if( timer ) socket=nullptr;
timer->cancel(); throw std::system_error(ec);
if( !ec ) { }
if( !content.empty() ) { });
auto timer = get_timeout_timer(); io_service.reset();
asio::async_write( *socket, asio::buffer( content.data(), content.size() ), io_service.run();
[this, timer]( const std::error_code &ec, size_t /*bytes_transferred*/ ) {
if( timer ) return response;
timer->cancel(); }
if( ec ) {
std::lock_guard<std::mutex> lock( socket_mutex ); void request_read_chunked(const std::shared_ptr<Response> &response, asio::streambuf &streambuf) {
this->socket = nullptr; auto timer=get_timeout_timer();
throw std::system_error( ec ); asio::async_read_until(*socket, response->content_buffer, "\r\n",
} [this, &response, &streambuf, timer](const std::error_code& ec, size_t bytes_transferred) {
} ); if(timer)
} timer->cancel();
} if(!ec) {
else { std::string line;
std::lock_guard<std::mutex> lock( socket_mutex ); getline(response->content, line);
socket = nullptr; bytes_transferred-=line.size()+1;
throw std::system_error( ec ); line.pop_back();
} std::streamsize length=stol(line, 0, 16);
} );
io_service.reset(); auto num_additional_bytes=static_cast<std::streamsize>(response->content_buffer.size()-bytes_transferred);
io_service.run();
auto post_process=[this, &response, &streambuf, length] {
return request_read(); std::ostream stream(&streambuf);
} if(length>0) {
std::vector<char> buffer(static_cast<size_t>(length));
std::shared_ptr<Response> request( const std::string& request_type, const std::string& path, std::iostream& content, response->content.read(&buffer[0], length);
const std::map<std::string, std::string>& header = std::map<std::string, std::string>() ) { stream.write(&buffer[0], length);
auto corrected_path = path; }
if( corrected_path == "" )
corrected_path = "/"; //Remove "\r\n"
if( !config.proxy_server.empty() && std::is_same<socket_type, asio::ip::tcp::socket>::value ) response->content.get();
corrected_path = "http://" + host + ':' + std::to_string( port ) + corrected_path; response->content.get();
content.seekp( 0, std::ios::end ); if(length>0)
auto content_length = content.tellp(); request_read_chunked(response, streambuf);
content.seekp( 0, std::ios::beg ); else {
std::ostream response_stream(&response->content_buffer);
asio::streambuf write_buffer; response_stream << stream.rdbuf();
std::ostream write_stream( &write_buffer ); }
write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n"; };
write_stream << "Host: " << host << "\r\n";
for( auto& h : header ) { if((2+length)>num_additional_bytes) {
write_stream << h.first << ": " << h.second << "\r\n"; auto timer=get_timeout_timer();
} asio::async_read(*socket, response->content_buffer,
if( content_length>0 ) asio::transfer_exactly(2+length-num_additional_bytes),
write_stream << "Content-Length: " << content_length << "\r\n"; [this, post_process, timer](const std::error_code& ec, size_t /*bytes_transferred*/) {
write_stream << "\r\n"; if(timer)
if( content_length>0 ) timer->cancel();
write_stream << content.rdbuf(); if(!ec) {
post_process();
connect(); }
else {
auto timer = get_timeout_timer(); std::lock_guard<std::mutex> lock(socket_mutex);
asio::async_write( *socket, write_buffer, this->socket=nullptr;
[this, timer]( const std::error_code &ec, size_t /*bytes_transferred*/ ) { throw std::system_error(ec);
if( timer ) }
timer->cancel(); });
if( ec ) { }
std::lock_guard<std::mutex> lock( socket_mutex ); else
socket = nullptr; post_process();
throw std::system_error( ec ); }
} else {
} ); std::lock_guard<std::mutex> lock(socket_mutex);
io_service.reset(); socket=nullptr;
io_service.run(); throw std::system_error(ec);
}
return request_read(); });
} }
};
void close() {
std::lock_guard<std::mutex> lock( socket_mutex ); template<class socket_type>
if( socket ) { class Client : public ClientBase<socket_type> {};
std::error_code ec;
socket->lowest_layer().shutdown( asio::ip::tcp::socket::shutdown_both, ec ); typedef asio::ip::tcp::socket HTTP;
socket->lowest_layer().close();
} template<>
} class Client<HTTP> : public ClientBase<HTTP> {
public:
protected: Client(const std::string& server_port_path) : ClientBase<HTTP>::ClientBase(server_port_path, 80) {}
asio::io_service io_service;
asio::ip::tcp::resolver resolver; protected:
void connect() {
std::unique_ptr<socket_type> socket; if(!socket || !socket->is_open()) {
std::mutex socket_mutex; std::unique_ptr<asio::ip::tcp::resolver::query> query;
if(config.proxy_server.empty())
std::string host; query=std::unique_ptr<asio::ip::tcp::resolver::query>(new asio::ip::tcp::resolver::query(host, std::to_string(port)));
unsigned short port; else {
auto proxy_host_port=parse_host_port(config.proxy_server, 8080);
ClientBase( const std::string& host_port, unsigned short default_port ) : resolver( io_service ) { 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 parsed_host_port = parse_host_port( host_port, default_port ); }
host = parsed_host_port.first; resolver.async_resolve(*query, [this](const std::error_code &ec,
port = parsed_host_port.second; asio::ip::tcp::resolver::iterator it){
} if(!ec) {
{
std::pair<std::string, unsigned short> parse_host_port( const std::string &host_port, unsigned short default_port ) { std::lock_guard<std::mutex> lock(socket_mutex);
std::pair<std::string, unsigned short> parsed_host_port; socket=std::unique_ptr<HTTP>(new HTTP(io_service));
size_t host_end = host_port.find( ':' ); }
if( host_end == std::string::npos ) {
parsed_host_port.first = host_port; auto timer=get_timeout_timer();
parsed_host_port.second = default_port; asio::async_connect(*socket, it, [this, timer]
} (const std::error_code &ec, asio::ip::tcp::resolver::iterator /*it*/){
else { if(timer)
parsed_host_port.first = host_port.substr( 0, host_end ); timer->cancel();
parsed_host_port.second = static_cast<unsigned short>( stoul( host_port.substr( host_end + 1 ) ) ); if(!ec) {
} asio::ip::tcp::no_delay option(true);
return parsed_host_port; this->socket->set_option(option);
} }
else {
virtual void connect() = 0; std::lock_guard<std::mutex> lock(socket_mutex);
this->socket=nullptr;
std::shared_ptr< asio::deadline_timer > get_timeout_timer() { throw std::system_error(ec);
if( config.timeout == 0 ) }
return nullptr; });
}
auto timer = std::make_shared< asio::deadline_timer >( io_service ); else {
timer->expires_from_now( std::chrono::seconds( config.timeout ) ); std::lock_guard<std::mutex> lock(socket_mutex);
timer->async_wait( [this]( const std::error_code& ec ) { socket=nullptr;
if( !ec ) { throw std::system_error(ec);
close(); }
} });
} ); io_service.reset();
return timer; io_service.run();
} }
}
void parse_response_header( const std::shared_ptr<Response> &response ) const { };
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 );
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] == ' ' )
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 ) ) );
}
getline( response->content, line );
}
}
}
std::shared_ptr<Response> request_read() {
std::shared_ptr<Response> response( new Response() );
asio::streambuf chunked_streambuf;
auto timer = get_timeout_timer();
asio::async_read_until( *socket, response->content_buffer, "\r\n\r\n",
[this, &response, &chunked_streambuf, timer]( const std::error_code& ec, size_t bytes_transferred ) {
if( timer )
timer->cancel();
if( !ec ) {
size_t num_additional_bytes = response->content_buffer.size() - bytes_transferred;
parse_response_header( response );
auto header_it = response->header.find( "Content-Length" );
if( header_it != response->header.end() ) {
auto content_length = stoull( header_it->second );
if( content_length>num_additional_bytes ) {
auto timer = get_timeout_timer();
asio::async_read( *socket, response->content_buffer,
asio::transfer_exactly( static_cast< size_t >( content_length - num_additional_bytes ) ),
[this, timer]( const std::error_code& ec, size_t /*bytes_transferred*/ ) {
if( timer )
timer->cancel();
if( ec ) {
std::lock_guard<std::mutex> lock( socket_mutex );
this->socket = nullptr;
throw std::system_error( ec );
}
} );
}
}
else if( ( header_it = response->header.find( "Transfer-Encoding" ) ) != response->header.end() && header_it->second == "chunked" ) {
request_read_chunked( response, chunked_streambuf );
}
}
else {
std::lock_guard<std::mutex> lock( socket_mutex );
socket = nullptr;
throw std::system_error( ec );
}
} );
io_service.reset();
io_service.run();
return response;
}
void request_read_chunked( const std::shared_ptr<Response> &response, asio::streambuf &streambuf ) {
auto timer = get_timeout_timer();
asio::async_read_until( *socket, response->content_buffer, "\r\n",
[this, &response, &streambuf, timer]( const std::error_code& ec, size_t bytes_transferred ) {
if( timer )
timer->cancel();
if( !ec ) {
std::string line;
getline( response->content, line );
bytes_transferred -= line.size() + 1;
line.pop_back();
std::streamsize length = stol( line, 0, 16 );
auto num_additional_bytes = response->content_buffer.size() - bytes_transferred;
auto post_process = [this, &response, &streambuf, length] {
std::ostream stream( &streambuf );
if( length>0 ) {
std::vector<char> buffer( static_cast<size_t>( length ) );
response->content.read( &buffer[0], length );
stream.write( &buffer[0], length );
}
//Remove "\r\n"
response->content.get();
response->content.get();
if( length>0 )
request_read_chunked( response, streambuf );
else {
std::ostream response_stream( &response->content_buffer );
response_stream << stream.rdbuf();
}
};
if( ( 2 + length )>num_additional_bytes ) {
auto timer = get_timeout_timer();
asio::async_read( *socket, response->content_buffer,
asio::transfer_exactly( static_cast< size_t >( 2 + length - num_additional_bytes ) ),
[this, post_process, timer]( const std::error_code& ec, size_t /*bytes_transferred*/ ) {
if( timer )
timer->cancel();
if( !ec ) {
post_process();
}
else {
std::lock_guard<std::mutex> lock( socket_mutex );
this->socket = nullptr;
throw std::system_error( ec );
}
} );
}
else
post_process();
}
else {
std::lock_guard<std::mutex> lock( socket_mutex );
socket = nullptr;
throw std::system_error( ec );
}
} );
}
};
template<class socket_type>
class Client : public ClientBase<socket_type> {};
typedef asio::ip::tcp::socket HTTP;
template<>
class Client<HTTP> : public ClientBase<HTTP> {
public:
Client( const std::string& server_port_path ) : ClientBase<HTTP>::ClientBase( server_port_path, 80 ) {}
protected:
void connect() {
if( !socket || !socket->is_open() ) {
std::unique_ptr<asio::ip::tcp::resolver::query> query;
if( config.proxy_server.empty() )
query = std::unique_ptr<asio::ip::tcp::resolver::query>( new asio::ip::tcp::resolver::query( host, std::to_string( port ) ) );
else {
auto proxy_host_port = parse_host_port( config.proxy_server, 8080 );
query = std::unique_ptr<asio::ip::tcp::resolver::query>( new asio::ip::tcp::resolver::query( proxy_host_port.first, std::to_string( proxy_host_port.second ) ) );
}
resolver.async_resolve( *query, [this]( const std::error_code &ec,
asio::ip::tcp::resolver::iterator it ) {
if( !ec ) {
{
std::lock_guard<std::mutex> lock( socket_mutex );
socket = std::unique_ptr<HTTP>( new HTTP( io_service ) );
}
auto timer = get_timeout_timer();
asio::async_connect( *socket, it, [this, timer]
( const std::error_code &ec, asio::ip::tcp::resolver::iterator /*it*/ ) {
if( timer )
timer->cancel();
if( !ec ) {
asio::ip::tcp::no_delay option( true );
this->socket->set_option( option );
}
else {
std::lock_guard<std::mutex> lock( socket_mutex );
this->socket = nullptr;
throw std::system_error( ec );
}
} );
}
else {
std::lock_guard<std::mutex> lock( socket_mutex );
socket = nullptr;
throw std::system_error( ec );
}
} );
io_service.reset();
io_service.run();
}
}
};
} }
#endif /* CLIENT_HTTP_HPP */ #endif /* CLIENT_HTTP_HPP */

2
src/servers/sapphire_zone/Script/ScriptLoader.cpp
View file

@ -162,7 +162,7 @@ bool Core::Scripting::ScriptLoader::isModuleLoaded( std::string name )
for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it ) for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
{ {
if( Util::toLowerCopy( it->second->library_name) == Util::toLowerCopy( name ) ) if( Util::toLowerCopy( it->second->library_name ) == Util::toLowerCopy( name ) )
return true; return true;
} }