std::string websocket_api_connection::on_message(
const std::string& message,
bool send_message /* = true */ )
{
wdump((message));
try
{
auto var = fc::json::from_string(message);
const auto& var_obj = var.get_object();
if( var_obj.contains( "method" ) )
{
auto call = var.as<fc::rpc::request>();
exception_ptr optexcept;
try
{
auto result = _rpc_state.local_call( call.method, call.params );
if( call.id )
{
auto reply = fc::json::to_string( response( *call.id, result ) );
if( send_message )
_connection.send_message( reply );
return reply;
}
}
catch ( const fc::exception& e )
{
if( call.id )
{
optexcept = e.dynamic_copy_exception();
}
}
if( optexcept ) {
auto reply = fc::json::to_string( response( *call.id, error_object{ 1, optexcept->to_detail_string(), fc::variant(*optexcept)} ) );
if( send_message )
_connection.send_message( reply );
return reply;
}
}
else
{
auto reply = var.as<fc::rpc::response>();
_rpc_state.handle_reply( reply );
}
}
catch ( const fc::exception& e )
{
wdump((e.to_detail_string()));
return e.to_detail_string();
}
return string();
}
void http_api_connection::on_request( const fc::http::request& req, const fc::http::server::response& resp )
{
// this must be called by outside HTTP server's on_request method
std::string resp_body;
http::reply::status_code resp_status;
try
{
resp.add_header( "Content-Type", "application/json" );
std::string req_body( req.body.begin(), req.body.end() );
auto var = fc::json::from_string( req_body );
const auto& var_obj = var.get_object();
if( var_obj.contains( "method" ) )
{
auto call = var.as<fc::rpc::request>();
try
{
auto result = _rpc_state.local_call( call.method, call.params );
resp_body = fc::json::to_string( fc::rpc::response( *call.id, result ) );
resp_status = http::reply::OK;
}
catch ( const fc::exception& e )
{
resp_body = fc::json::to_string( fc::rpc::response( *call.id, error_object{ 1, e.to_detail_string(), fc::variant(e)} ) );
resp_status = http::reply::InternalServerError;
}
}
else
{
resp_status = http::reply::BadRequest;
resp_body = "";
}
}
catch ( const fc::exception& e )
{
resp_status = http::reply::InternalServerError;
resp_body = "";
wdump((e.to_detail_string()));
}
try
{
resp.set_status( resp_status );
resp.set_length( resp_body.length() );
resp.write( resp_body.c_str(), resp_body.length() );
}
catch( const fc::exception& e )
{
wdump((e.to_detail_string()));
}
return;
}
void dump_ethernet_raw_packet(uint8 bInput, char* szMessage, uint8 *payload, int32 len)
{
extern int g_modePacketDump;
extern int g_modePacketInfo;
extern uint8_t g_macFilterUse;
extern uint8_t g_macFilter1[6];
extern uint8_t g_macFilter2[6];
if ( g_macFilterUse )
{
if ( memcmp(payload, g_macFilter1, 6)==0 && memcmp(payload+6, g_macFilter1, 6)==0 && memcmp(payload+6, g_macFilter2, 6)==0 && memcmp(payload+6, g_macFilter2, 6)==0 )
{
return;
}
}
if ( g_modePacketDump==1 )
{
ets_uart_printf(szMessage);
ets_uart_printf(" (%d)\r\n", len);
wdump(payload, len);
}
if ( g_modePacketInfo==1 )
{
void packet_handler(uint32_t packet_length, const uint8_t *packet);
packet_handler(len, payload);
}
}
void rpc_client_impl::connect_to(const fc::ip::endpoint& remote_endpoint,
const bts::blockchain::public_key_type& remote_public_key)
{
fc::buffered_istream_ptr buffered_istream;
fc::buffered_ostream_ptr buffered_ostream;
if( remote_public_key != bts::blockchain::public_key_type() )
{
net::stcp_socket_ptr socket = std::make_shared<bts::net::stcp_socket>();
try
{
socket->connect_to(remote_endpoint);
}
catch ( const fc::exception& e )
{
elog( "fatal: error opening RPC socket to endpoint ${endpoint}: ${e}", ("endpoint", remote_endpoint)("e", e.to_detail_string() ) );
throw;
}
std::vector<char> packed_signature(80, ' ');
FC_ASSERT( socket->readsome(packed_signature.data(), packed_signature.size()) == 80, "Unexpected number of bytes read from RPC socket" );
fc::ecc::compact_signature signature;
signature = fc::raw::unpack<fc::ecc::compact_signature>(packed_signature);
wdump((signature));
FC_ASSERT(blockchain::public_key_type(fc::ecc::public_key(signature, fc::digest(socket->get_shared_secret())))
== remote_public_key,
"Unable to establish secure connection with server.");
buffered_istream = std::make_shared<fc::buffered_istream>(socket);
buffered_ostream = std::make_shared<utilities::padding_ostream<>>(socket);
} else {
fc::tcp_socket_ptr socket = std::make_shared<fc::tcp_socket>();
try
{
socket->connect_to(remote_endpoint);
}
catch ( const fc::exception& e )
{
elog( "fatal: error opening RPC socket to endpoint ${endpoint}: ${e}", ("endpoint", remote_endpoint)("e", e.to_detail_string() ) );
throw;
}
buffered_istream = std::make_shared<fc::buffered_istream>(socket);
buffered_ostream = std::make_shared<fc::buffered_ostream>(socket);
}
_json_connection = std::make_shared<fc::rpc::json_connection>(std::move(buffered_istream),
std::move(buffered_ostream));
_json_exec_loop_complete = fc::async([=](){ _json_connection->exec(); }, "json exec loop");
}
void dynamic_global_property_object::update_virtual_net_bandwidth( const chain_config& cfg ) {
if( average_block_size.average()> (cfg.target_block_size * config::rate_limiting_precision) ) {
virtual_net_bandwidth *= 99;
virtual_net_bandwidth /= 100;
wlog( "reducing virtual net bandwidth by 1%, ${vnb}", ("vnb", virtual_net_bandwidth) );
wdump((average_block_size.average())(cfg.target_block_size*config::rate_limiting_precision));
} else {
virtual_net_bandwidth *= 1000;
virtual_net_bandwidth /= 999;
// ilog( "increasing virtual net bandwidth by .1%, ${vnb}", ("vnb", virtual_net_bandwidth) );
}
auto min = (cfg.max_block_size * config::blocksize_average_window_ms) / config::block_interval_ms;
if( virtual_net_bandwidth < min ) virtual_net_bandwidth = min;
if( virtual_net_bandwidth > min * 1000 ) virtual_net_bandwidth = min * 1000;
}
int main( int argc, char** argv )
{
try {
auto InB1 = fc::sha256::hash("InB1");
auto InB2 = fc::sha256::hash("InB2");
auto OutB1 = fc::sha256::hash("OutB1");
auto InC1 = fc::ecc::blind(InB1,25);
auto InC2 = fc::ecc::blind(InB2,75);
auto OutC1 = fc::ecc::blind(OutB1,40);
auto OutB2 = fc::ecc::blind_sum( {InB1,InB2,OutB1}, 2 );
auto OutC2 = fc::ecc::blind( OutB2, 60 );
FC_ASSERT( fc::ecc::verify_sum( {InC1,InC2}, {OutC1,OutC2}, 0 ) );
auto nonce = fc::sha256::hash("nonce");
auto proof = fc::ecc::range_proof_sign( 0, OutC1, OutB1, nonce, 0, 0, 40 );
wdump( (proof.size()));
auto result = fc::ecc::range_get_info( proof );
wdump((result));
FC_ASSERT( result.max_value >= 60 );
FC_ASSERT( result.min_value >= 0 );
auto B1 = fc::sha256::hash("B1");
auto B2 = fc::sha256::hash("B2");
auto b3 = fc::sha256::hash("b3");
auto B4 = fc::sha256::hash("B4");
auto C1 = fc::ecc::blind( B1, 1 );
auto C2 = fc::ecc::blind( B2, 2 );
auto c3 = fc::ecc::blind( b3, 3 );
auto C4 = fc::ecc::blind( B4, -1 );
auto B3 = fc::ecc::blind_sum( {B1,B2}, 2 );
auto C3 = fc::ecc::blind( B3, 3 );
auto B2m1 = fc::ecc::blind_sum( {B2,B1}, 1 );
auto C2m1 = fc::ecc::blind( B2m1, 1 );
FC_ASSERT( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
{
auto B1 = fc::sha256::hash("B1");
auto B2 = fc::sha256::hash("B2");
auto B3 = fc::sha256::hash("B3");
//secp256k1_scalar_get_b32((unsigned char*)&B1, (const secp256k1_scalar_t*)&B2);
//B1 = fc::variant("b2e5da56ef9f2a34d3e22fd12634bc99261e95c87b9960bf94ed3d27b30").as<fc::sha256>();
auto C1 = fc::ecc::blind( B1, INT64_MAX );
auto C2 = fc::ecc::blind( B1, 0 );
auto C3 = fc::ecc::blind( B1, 1 );
FC_ASSERT( fc::ecc::verify_sum( {C2}, {C3}, -1 ) );
FC_ASSERT( fc::ecc::verify_sum( {C1}, {C1}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C2}, {C2}, 0 ) );
FC_ASSERT( fc::ecc::verify_sum( {C3}, {C2}, 1 ) );
FC_ASSERT( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
FC_ASSERT( fc::ecc::verify_sum( {C2}, {C1}, -INT64_MAX ) );
}
}
catch ( const fc::exception& e )
{
edump((e.to_detail_string()));
}
return 0;
}
