sysio::http_plugin_impl Class Reference

Inheritance diagram for sysio::http_plugin_impl:

Collaboration diagram for sysio::http_plugin_impl:

Classes
struct	abstract_conn_impl
struct	in_flight

Public Member Functions
	http_plugin_impl ()=default
	http_plugin_impl (const http_plugin_impl &)=delete
	http_plugin_impl (http_plugin_impl &&)=delete
http_plugin_impl &	operator= (const http_plugin_impl &)=delete
http_plugin_impl &	operator= (http_plugin_impl &&)=delete
bool	host_port_is_valid (const std::string &header_host_port, const string &endpoint_local_host_port)
bool	host_is_valid (const std::string &host, const string &endpoint_local_host_port, bool secure)
ssl_context_ptr	on_tls_init (websocketpp::connection_hdl hdl)
template<class T >
bool	allow_host (const typename T::request_type &req, detail::connection_ptr< T > con)
template<typename T >
bool	verify_max_bytes_in_flight (const T &con)
template<typename T >
auto	make_http_response_handler (detail::abstract_conn_ptr abstract_conn_ptr)
template<class T >
void	handle_http_request (detail::connection_ptr< T > con)
template<class T >
void	create_server_for_endpoint (const tcp::endpoint &ep, websocketpp::server< detail::asio_with_stub_log< T > > &ws)
void	add_aliases_for_endpoint (const tcp::endpoint &ep, string host, string port)

Static Public Member Functions
template<class T >
static void	handle_exception (detail::connection_ptr< T > con)
template<typename T >
static detail::abstract_conn_ptr	make_abstract_conn_ptr (detail::connection_ptr< T > conn, http_plugin_impl_ptr impl)
template<typename T >
static auto	make_in_flight (T &&object, http_plugin_impl_ptr impl)
static detail::internal_url_handler	make_app_thread_url_handler (int priority, url_handler next, http_plugin_impl_ptr my)
static detail::internal_url_handler	make_http_thread_url_handler (url_handler next)

Public Attributes
map< string, detail::internal_url_handler >	url_handlers
std::optional< tcp::endpoint >	listen_endpoint
string	access_control_allow_origin
string	access_control_allow_headers
string	access_control_max_age
bool	access_control_allow_credentials = false
size_t	max_body_size {2*1024*1024}
websocket_server_type	server
uint16_t	thread_pool_size = 2
std::optional< sysio::chain::named_thread_pool >	thread_pool
std::atomic< size_t >	bytes_in_flight {0}
size_t	max_bytes_in_flight = 0
fc::microseconds	max_response_time {30*1000}
std::optional< tcp::endpoint >	https_listen_endpoint
string	https_cert_chain
string	https_key
https_ecdh_curve_t	https_ecdh_curve = SECP384R1
websocket_server_tls_type	https_server
std::optional< asio::local::stream_protocol::endpoint >	unix_endpoint
websocket_local_server_type	unix_server
bool	validate_host = true
set< string >	valid_hosts

Detailed Description

Definition at line 179 of file http_plugin.cpp.

Constructor & Destructor Documentation

http_plugin_impl() [1/3]

sysio::http_plugin_impl::http_plugin_impl ( )

default

http_plugin_impl() [2/3]

sysio::http_plugin_impl::http_plugin_impl ( const http_plugin_impl & )

delete

http_plugin_impl() [3/3]

sysio::http_plugin_impl::http_plugin_impl ( http_plugin_impl && )

delete

Member Function Documentation

add_aliases_for_endpoint()

void sysio::http_plugin_impl::add_aliases_for_endpoint ( const tcp::endpoint & ep, string host, string port )

inline

Definition at line 620 of file http_plugin.cpp.

                                                                                          {
            auto resolved_port_str = std::to_string(ep.port());
            valid_hosts.emplace(host + ":" + port);
            valid_hosts.emplace(host + ":" + resolved_port_str);
         }

allow_host()

template<class T >

bool sysio::http_plugin_impl::allow_host ( const typename T::request_type & req, detail::connection_ptr< T > con )

inline

Definition at line 315 of file http_plugin.cpp.

                                                                                         {
            bool is_secure = con->get_uri()->get_secure();
            const auto& local_endpoint = con->get_socket().lowest_layer().local_endpoint();
            auto local_socket_host_port = local_endpoint.address().to_string() + ":" + std::to_string(local_endpoint.port());
 
            const auto& host_str = req.get_header("Host");
            if (host_str.empty() || !host_is_valid(host_str, local_socket_host_port, is_secure)) {
               con->set_status(websocketpp::http::status_code::bad_request);
               return false;
            }
            return true;
         }

Here is the call graph for this function:

create_server_for_endpoint()

template<class T >

void sysio::http_plugin_impl::create_server_for_endpoint ( const tcp::endpoint & ep, websocketpp::server< detail::asio_with_stub_log< T > > & ws )

inline

Definition at line 601 of file http_plugin.cpp.

                                                                                                                    {
            try {
               ws.clear_access_channels(websocketpp::log::alevel::all);
               ws.init_asio( &thread_pool->get_executor() );
               ws.set_reuse_addr(true);
               ws.set_max_http_body_size(max_body_size);
               // captures `this` & ws, my needs to live as long as server is handling requests
               ws.set_http_handler([&](connection_hdl hdl) {
                  handle_http_request<detail::asio_with_stub_log<T>>(ws.get_con_from_hdl(hdl));
               });
            } catch ( const fc::exception& e ){
               fc_elog( logger, "http: ${e}", ("e", e.to_detail_string()) );
            } catch ( const std::exception& e ){
               fc_elog( logger, "http: ${e}", ("e", e.what()) );
            } catch (...) {
               fc_elog( logger, "error thrown from http io service" );
            }
         }

Here is the call graph for this function:

handle_exception()

template<class T >

static void sysio::http_plugin_impl::handle_exception ( detail::connection_ptr< T > con )

inlinestatic

Definition at line 274 of file http_plugin.cpp.

                                                                   {
            string err = "Internal Service error, http: ";
            const auto deadline = fc::time_point::now() + fc::exception::format_time_limit;
            try {
               con->set_status( websocketpp::http::status_code::internal_server_error );
               try {
                  throw;
               } catch (const fc::exception& e) {
                  err += e.to_detail_string();
                  fc_elog( logger, "${e}", ("e", err));
                  error_results results{websocketpp::http::status_code::internal_server_error,
                                        "Internal Service Error", error_results::error_info( e, verbose_http_errors )};
                  con->set_body( fc::json::to_string( results, deadline ));
               } catch (const std::exception& e) {
                  err += e.what();
                  fc_elog( logger, "${e}", ("e", err));
                  error_results results{websocketpp::http::status_code::internal_server_error,
                                        "Internal Service Error",
                                        error_results::error_info( fc::exception( FC_LOG_MESSAGE( error, e.what())),
                                                                   verbose_http_errors )};
                  con->set_body( fc::json::to_string( results, deadline ));
               } catch (...) {
                  err += "Unknown Exception";
                  error_results results{websocketpp::http::status_code::internal_server_error,
                                        "Internal Service Error",
                                        error_results::error_info(
                                              fc::exception( FC_LOG_MESSAGE( error, "Unknown Exception" )),
                                              verbose_http_errors )};
                  con->set_body( fc::json::to_string( results, deadline ));
               }
            } catch (fc::timeout_exception& e) {
               con->set_body( R"xxx({"message": "Internal Server Error"})xxx" );
               fc_elog( logger, "Timeout exception ${te} attempting to handle exception: ${e}", ("te", e.to_detail_string())("e", err) );
            } catch (...) {
               con->set_body( R"xxx({"message": "Internal Server Error"})xxx" );
               fc_elog( logger, "Exception attempting to handle exception: ${e}", ("e", err) );
            }
            con->send_http_response();
         }

Here is the call graph for this function:

Here is the caller graph for this function:

handle_http_request()

template<class T >

void sysio::http_plugin_impl::handle_http_request ( detail::connection_ptr< T > con )

inline

Definition at line 551 of file http_plugin.cpp.

                                                               {
            try {
               auto& req = con->get_request();
 
               if(!allow_host<T>(req, con))
                  return;
 
               if( !access_control_allow_origin.empty()) {
                  con->append_header( "Access-Control-Allow-Origin", access_control_allow_origin );
               }
               if( !access_control_allow_headers.empty()) {
                  con->append_header( "Access-Control-Allow-Headers", access_control_allow_headers );
               }
               if( !access_control_max_age.empty()) {
                  con->append_header( "Access-Control-Max-Age", access_control_max_age );
               }
               if( access_control_allow_credentials ) {
                  con->append_header( "Access-Control-Allow-Credentials", "true" );
               }
 
               if(req.get_method() == "OPTIONS") {
                  con->set_status(websocketpp::http::status_code::ok);
                  return;
               }
 
               con->append_header( "Content-type", "application/json" );
               con->defer_http_response();
 
               auto abstract_conn_ptr = make_abstract_conn_ptr<T>(con, shared_from_this());
               if( !verify_max_bytes_in_flight( con )) return;
 
               std::string resource = con->get_uri()->get_resource();
               auto handler_itr = url_handlers.find( resource );
               if( handler_itr != url_handlers.end()) {
                  std::string body = con->get_request_body();
                  handler_itr->second( abstract_conn_ptr, std::move( resource ), std::move( body ), make_http_response_handler<T>(abstract_conn_ptr) );
               } else {
                  fc_dlog( logger, "404 - not found: ${ep}", ("ep", resource) );
                  error_results results{websocketpp::http::status_code::not_found,
                                        "Not Found", error_results::error_info(fc::exception( FC_LOG_MESSAGE( error, "Unknown Endpoint" )), verbose_http_errors )};
                  con->set_body( fc::json::to_string( results, fc::time_point::now() + max_response_time ));
                  con->set_status( websocketpp::http::status_code::not_found );
                  con->send_http_response();
               }
            } catch( ... ) {
               handle_exception<T>( con );
            }
         }

Here is the call graph for this function:

host_is_valid()

bool sysio::http_plugin_impl::host_is_valid ( const std::string & host, const string & endpoint_local_host_port, bool secure )

inline

ends in :<number> without a preceeding colon which implies ipv6

Definition at line 223 of file http_plugin.cpp.

                                                                                                         {
            if (!validate_host) {
               return true;
            }
 
            // normalise the incoming host so that it always has the explicit port
            static auto has_port_expr = regex("[^:]:[0-9]+$"); 
            if (std::regex_search(host, has_port_expr)) {
               return host_port_is_valid( host, endpoint_local_host_port );
            } else {
               // according to RFC 2732 ipv6 addresses should always be enclosed with brackets so we shouldn't need to special case here
               return host_port_is_valid( host + ":" + std::to_string(secure ? websocketpp::uri_default_secure_port : websocketpp::uri_default_port ), endpoint_local_host_port);
            }
         }

Here is the call graph for this function:

Here is the caller graph for this function:

host_port_is_valid()

bool sysio::http_plugin_impl::host_port_is_valid ( const std::string & header_host_port, const string & endpoint_local_host_port )

inline

Definition at line 219 of file http_plugin.cpp.

                                                                                                              {
            return !validate_host || header_host_port == endpoint_local_host_port || valid_hosts.find(header_host_port) != valid_hosts.end();
         }

Here is the caller graph for this function:

make_abstract_conn_ptr()

template<typename T >

static detail::abstract_conn_ptr sysio::http_plugin_impl::make_abstract_conn_ptr ( detail::connection_ptr< T > conn, http_plugin_impl_ptr impl )

inlinestatic

Helper to construct an abstract_conn_impl for a given connection and instance of http_plugin_impl

Template Parameters

T	- The downstream parameter for the connection_ptr

Parameters

conn	- existing connection_ptr<T>
impl	- the owning http_plugin_impl

Returns

abstract_conn_ptr backed by type specific implementations of the methods

Definition at line 394 of file http_plugin.cpp.

                                                                                                                          {
            return std::make_shared<abstract_conn_impl<T>>(std::move(conn), std::move(impl));
         }

make_app_thread_url_handler()

static detail::internal_url_handler sysio::http_plugin_impl::make_app_thread_url_handler ( int priority, url_handler next, http_plugin_impl_ptr my )

inlinestatic

Make an internal_url_handler that will run the url_handler on the app() thread and then return to the http thread pool for response processing

Precondition

b.size() has been added to bytes_in_flight by caller

Parameters

priority	- priority to post to the app thread at
next	- the next handler for responses
my	- the http_plugin_impl

Returns

the constructed internal_url_handler

Definition at line 478 of file http_plugin.cpp.

                                                                                                                                  {
            auto next_ptr = std::make_shared<url_handler>(std::move(next));
            return [my=std::move(my), priority, next_ptr=std::move(next_ptr)]
                       ( detail::abstract_conn_ptr conn, string r, string b, url_response_callback then ) {
               auto tracked_b = make_in_flight<string>(std::move(b), my);
               if (!conn->verify_max_bytes_in_flight()) {
                  return;
               }
 
               url_response_callback wrapped_then = [tracked_b, then=std::move(then)](int code, fc::variant resp) {
                  then(code, std::move(resp));
               };
 
               // post to the app thread taking shared ownership of next (via std::shared_ptr),
               // sole ownership of the tracked body and the passed in parameters
               app().post( priority, [next_ptr, conn=std::move(conn), r=std::move(r), tracked_b, wrapped_then=std::move(wrapped_then)]() mutable {
                  try {
                     // call the `next` url_handler and wrap the response handler
                     (*next_ptr)( std::move( r ), std::move(*(*tracked_b)), std::move(wrapped_then)) ;
                  } catch( ... ) {
                     conn->handle_exception();
                  }
               } );
            };
         }

Here is the call graph for this function:

make_http_response_handler()

template<typename T >

auto sysio::http_plugin_impl::make_http_response_handler ( detail::abstract_conn_ptr abstract_conn_ptr )

inline

Construct a lambda appropriate for url_response_callback that will JSON-stringify the provided response

Parameters

con	- pointer for the connection this response should be sent to

Returns

lambda suitable for url_response_callback

Definition at line 529 of file http_plugin.cpp.

                                                                                     {
            return [my=shared_from_this(), abstract_conn_ptr]( int code, fc::variant response ) {
               auto tracked_response = make_in_flight(std::move(response), my);
               if (!abstract_conn_ptr->verify_max_bytes_in_flight()) {
                  return;
               }
 
               // post  back to an HTTP thread to to allow the response handler to be called from any thread
               boost::asio::post( my->thread_pool->get_executor(),
                                  [my, abstract_conn_ptr, code, tracked_response=std::move(tracked_response)]() {
                  try {
                     std::string json = fc::json::to_string( *(*tracked_response), fc::time_point::now() + my->max_response_time );
                     auto tracked_json = make_in_flight(std::move(json), my);
                     abstract_conn_ptr->send_response(std::move(*(*tracked_json)), code);
                  } catch( ... ) {
                     abstract_conn_ptr->handle_exception();
                  }
               });
            };
         }

Here is the call graph for this function:

make_http_thread_url_handler()

static detail::internal_url_handler sysio::http_plugin_impl::make_http_thread_url_handler ( url_handler next )

inlinestatic

Make an internal_url_handler that will run the url_handler directly

Precondition

b.size() has been added to bytes_in_flight by caller

Parameters

next	- the next handler for responses

Returns

the constructed internal_url_handler

Definition at line 511 of file http_plugin.cpp.

                                                                                          {
            return [next=std::move(next)]( detail::abstract_conn_ptr conn, string r, string b, url_response_callback then ) {
               try {
                  next(std::move(r), std::move(b), std::move(then));
               } catch( ... ) {
                  conn->handle_exception();
               }
             };
         }

make_in_flight()

template<typename T >

static auto sysio::http_plugin_impl::make_in_flight ( T && object, http_plugin_impl_ptr impl )

inlinestatic

convenient wrapper to make an in_flight<T>

Definition at line 464 of file http_plugin.cpp.

                                                                           {
            return std::make_shared<in_flight<T>>(std::forward<T>(object), std::move(impl));
         }

Here is the caller graph for this function:

on_tls_init()

ssl_context_ptr sysio::http_plugin_impl::on_tls_init ( websocketpp::connection_hdl hdl )

inline

Definition at line 238 of file http_plugin.cpp.

                                                                    {
            ssl_context_ptr ctx = websocketpp::lib::make_shared<websocketpp::lib::asio::ssl::context>(asio::ssl::context::sslv23_server);
 
            try {
               ctx->set_options(asio::ssl::context::default_workarounds |
                                asio::ssl::context::no_sslv2 |
                                asio::ssl::context::no_sslv3 |
                                asio::ssl::context::no_tlsv1 |
                                asio::ssl::context::no_tlsv1_1 |
                                asio::ssl::context::single_dh_use);
 
               ctx->use_certificate_chain_file(https_cert_chain);
               ctx->use_private_key_file(https_key, asio::ssl::context::pem);
 
               //going for the A+! Do a few more things on the native context to get ECDH in use
 
               fc::ec_key ecdh = EC_KEY_new_by_curve_name(https_ecdh_curve == SECP384R1 ? NID_secp384r1 : NID_X9_62_prime256v1);
               if (!ecdh)
                  SYS_THROW(chain::http_exception, "Failed to set NID_secp384r1");
               if(SSL_CTX_set_tmp_ecdh(ctx->native_handle(), (EC_KEY*)ecdh) != 1)
                  SYS_THROW(chain::http_exception, "Failed to set ECDH PFS");
 
               if(SSL_CTX_set_cipher_list(ctx->native_handle(), \
                  "EECDH+ECDSA+AESGCM:EECDH+aRSA+AESGCM:EECDH+ECDSA+SHA384:EECDH+ECDSA+SHA256:AES256:" \
                  "!DHE:!RSA:!AES128:!RC4:!DES:!3DES:!DSS:!SRP:!PSK:!EXP:!MD5:!LOW:!aNULL:!eNULL") != 1)
                  SYS_THROW(chain::http_exception, "Failed to set HTTPS cipher list");
            } catch (const fc::exception& e) {
               fc_elog( logger, "https server initialization error: ${w}", ("w", e.to_detail_string()) );
            } catch(std::exception& e) {
               fc_elog( logger, "https server initialization error: ${w}", ("w", e.what()) );
            }
 
            return ctx;
         }

Here is the call graph for this function:

operator=() [1/2]

http_plugin_impl & sysio::http_plugin_impl::operator= ( const http_plugin_impl & )

delete

operator=() [2/2]

http_plugin_impl & sysio::http_plugin_impl::operator= ( http_plugin_impl && )

delete

verify_max_bytes_in_flight()

template<typename T >

bool sysio::http_plugin_impl::verify_max_bytes_in_flight ( const T & con )

inline

Definition at line 329 of file http_plugin.cpp.

                                                         {
            auto bytes_in_flight_size = bytes_in_flight.load();
            if( bytes_in_flight_size > max_bytes_in_flight ) {
               fc_dlog( logger, "429 - too many bytes in flight: ${bytes}", ("bytes", bytes_in_flight_size) );
               error_results::error_info ei;
               ei.code = websocketpp::http::status_code::too_many_requests;
               ei.name = "Busy";
               ei.what = "Too many bytes in flight: " + std::to_string( bytes_in_flight_size );
               error_results results{websocketpp::http::status_code::too_many_requests, "Busy", ei};
               con->set_body( fc::json::to_string( results, fc::time_point::maximum() ));
               con->set_status( websocketpp::http::status_code::too_many_requests );
               con->send_http_response();
               return false;
            }
 
            return true;
         }

Here is the call graph for this function:

Member Data Documentation

access_control_allow_credentials

bool sysio::http_plugin_impl::access_control_allow_credentials = false

Definition at line 195 of file http_plugin.cpp.

access_control_allow_headers

string sysio::http_plugin_impl::access_control_allow_headers

Definition at line 193 of file http_plugin.cpp.

access_control_allow_origin

string sysio::http_plugin_impl::access_control_allow_origin

Definition at line 192 of file http_plugin.cpp.

access_control_max_age

string sysio::http_plugin_impl::access_control_max_age

Definition at line 194 of file http_plugin.cpp.

bytes_in_flight

std::atomic<size_t> sysio::http_plugin_impl::bytes_in_flight {0}

Definition at line 202 of file http_plugin.cpp.

{0};

https_cert_chain

string sysio::http_plugin_impl::https_cert_chain

Definition at line 207 of file http_plugin.cpp.

https_ecdh_curve

https_ecdh_curve_t sysio::http_plugin_impl::https_ecdh_curve = SECP384R1

Definition at line 209 of file http_plugin.cpp.

https_key

string sysio::http_plugin_impl::https_key

Definition at line 208 of file http_plugin.cpp.

https_listen_endpoint

std::optional<tcp::endpoint> sysio::http_plugin_impl::https_listen_endpoint

Definition at line 206 of file http_plugin.cpp.

https_server

websocket_server_tls_type sysio::http_plugin_impl::https_server

Definition at line 211 of file http_plugin.cpp.

listen_endpoint

std::optional<tcp::endpoint> sysio::http_plugin_impl::listen_endpoint

Definition at line 191 of file http_plugin.cpp.

max_body_size

size_t sysio::http_plugin_impl::max_body_size {2*1024*1024}

Definition at line 196 of file http_plugin.cpp.

{2*1024*1024};

max_bytes_in_flight

size_t sysio::http_plugin_impl::max_bytes_in_flight = 0

Definition at line 203 of file http_plugin.cpp.

max_response_time

fc::microseconds sysio::http_plugin_impl::max_response_time {30*1000}

Definition at line 204 of file http_plugin.cpp.

{30*1000};

server

websocket_server_type sysio::http_plugin_impl::server

Definition at line 198 of file http_plugin.cpp.

thread_pool

std::optional<sysio::chain::named_thread_pool> sysio::http_plugin_impl::thread_pool

Definition at line 201 of file http_plugin.cpp.

thread_pool_size

uint16_t sysio::http_plugin_impl::thread_pool_size = 2

Definition at line 200 of file http_plugin.cpp.

unix_endpoint

std::optional<asio::local::stream_protocol::endpoint> sysio::http_plugin_impl::unix_endpoint

Definition at line 213 of file http_plugin.cpp.

unix_server

websocket_local_server_type sysio::http_plugin_impl::unix_server

Definition at line 214 of file http_plugin.cpp.

url_handlers

map<string,detail::internal_url_handler> sysio::http_plugin_impl::url_handlers

Definition at line 190 of file http_plugin.cpp.

valid_hosts

set<string> sysio::http_plugin_impl::valid_hosts

Definition at line 217 of file http_plugin.cpp.

validate_host

bool sysio::http_plugin_impl::validate_host = true

Definition at line 216 of file http_plugin.cpp.

---

The documentation for this class was generated from the following file:

• plugins/http_plugin/http_plugin.cpp