mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
add lightweight block propagation ("fluffy blocks")
Added a new command to the P2P protocol definitions to allow querying for support flags. Implemented handling of new support flags command in net_node. Changed for_each callback template to include support flags. Updated print_connections command to show peer support flags. Added p2p constant for signaling fluffy block support. Added get_pool_transaction function to cryptnote_core. Added new commands to cryptonote protocol for relaying fluffy blocks. Implemented handling of fluffy block command in cryptonote protocol. Enabled fluffy block support in node initial configuration. Implemented get_testnet function in cryptonote_core. Made it so that fluffy blocks only run on testnet.
This commit is contained in:
Dion Ahmetaj
parent
d51f1af75f
commit
d61bd8187e
11 changed files with 492 additions and 11 deletions
|
|
@ -111,6 +111,9 @@
|
|||
#define P2P_IP_FAILS_BEFORE_BLOCK 10
|
||||
#define P2P_IDLE_CONNECTION_KILL_INTERVAL (5*60) //5 minutes
|
||||
|
||||
#define P2P_SUPPORT_FLAG_FLUFFY_BLOCKS 0x01
|
||||
#define P2P_SUPPORT_FLAGS P2P_SUPPORT_FLAG_FLUFFY_BLOCKS
|
||||
|
||||
#define ALLOW_DEBUG_COMMANDS
|
||||
|
||||
#define CRYPTONOTE_NAME "bitmonero"
|
||||
|
|
|
|||
|
|
@ -915,6 +915,11 @@ namespace cryptonote
|
|||
m_mempool.get_transactions(txs);
|
||||
return true;
|
||||
}
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
bool core::get_pool_transaction(const crypto::hash &id, transaction& tx) const
|
||||
{
|
||||
return m_mempool.get_transaction(id, tx);
|
||||
}
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
bool core::get_pool_transactions_and_spent_keys_info(std::vector<tx_info>& tx_infos, std::vector<spent_key_image_info>& key_image_infos) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -379,6 +379,13 @@ namespace cryptonote
|
|||
* @note see tx_memory_pool::get_transactions
|
||||
*/
|
||||
bool get_pool_transactions(std::list<transaction>& txs) const;
|
||||
|
||||
/**
|
||||
* @copydoc tx_memory_pool::get_transaction
|
||||
*
|
||||
* @note see tx_memory_pool::get_transaction
|
||||
*/
|
||||
bool get_pool_transaction(const crypto::hash& id, transaction& tx) const;
|
||||
|
||||
/**
|
||||
* @copydoc tx_memory_pool::get_pool_transactions_and_spent_keys_info
|
||||
|
|
@ -611,6 +618,13 @@ namespace cryptonote
|
|||
* @return the number of blocks to sync in one go
|
||||
*/
|
||||
std::pair<uint64_t, uint64_t> get_coinbase_tx_sum(const uint64_t start_offset, const size_t count);
|
||||
|
||||
/**
|
||||
* @brief get whether we're on testnet or not
|
||||
*
|
||||
* @return are we on testnet?
|
||||
*/
|
||||
bool get_testnet() const { return m_testnet; };
|
||||
|
||||
private:
|
||||
|
||||
|
|
|
|||
|
|
@ -69,6 +69,8 @@ namespace cryptonote
|
|||
|
||||
uint64_t avg_upload;
|
||||
uint64_t current_upload;
|
||||
|
||||
uint32_t support_flags;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(incoming)
|
||||
|
|
@ -87,6 +89,7 @@ namespace cryptonote
|
|||
KV_SERIALIZE(current_download)
|
||||
KV_SERIALIZE(avg_upload)
|
||||
KV_SERIALIZE(current_upload)
|
||||
KV_SERIALIZE(support_flags)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
|
||||
|
|
@ -223,5 +226,49 @@ namespace cryptonote
|
|||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
};
|
||||
|
||||
/************************************************************************/
|
||||
/* */
|
||||
/************************************************************************/
|
||||
struct NOTIFY_NEW_FLUFFY_BLOCK
|
||||
{
|
||||
const static int ID = BC_COMMANDS_POOL_BASE + 8;
|
||||
|
||||
struct request
|
||||
{
|
||||
block_complete_entry b;
|
||||
uint64_t current_blockchain_height;
|
||||
uint32_t hop;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(b)
|
||||
KV_SERIALIZE(current_blockchain_height)
|
||||
KV_SERIALIZE(hop)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
};
|
||||
|
||||
/************************************************************************/
|
||||
/* */
|
||||
/************************************************************************/
|
||||
struct NOTIFY_REQUEST_FLUFFY_MISSING_TX
|
||||
{
|
||||
const static int ID = BC_COMMANDS_POOL_BASE + 9;
|
||||
|
||||
struct request
|
||||
{
|
||||
block_complete_entry b;
|
||||
uint64_t current_blockchain_height;
|
||||
std::vector<size_t> missing_tx_indices;
|
||||
uint32_t hop;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(b)
|
||||
KV_SERIALIZE_CONTAINER_POD_AS_BLOB(missing_tx_indices)
|
||||
KV_SERIALIZE(hop)
|
||||
KV_SERIALIZE(current_blockchain_height)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -91,6 +91,8 @@ namespace cryptonote
|
|||
HANDLE_NOTIFY_T2(NOTIFY_RESPONSE_GET_OBJECTS, &cryptonote_protocol_handler::handle_response_get_objects)
|
||||
HANDLE_NOTIFY_T2(NOTIFY_REQUEST_CHAIN, &cryptonote_protocol_handler::handle_request_chain)
|
||||
HANDLE_NOTIFY_T2(NOTIFY_RESPONSE_CHAIN_ENTRY, &cryptonote_protocol_handler::handle_response_chain_entry)
|
||||
HANDLE_NOTIFY_T2(NOTIFY_NEW_FLUFFY_BLOCK, &cryptonote_protocol_handler::handle_notify_new_fluffy_block)
|
||||
HANDLE_NOTIFY_T2(NOTIFY_REQUEST_FLUFFY_MISSING_TX, &cryptonote_protocol_handler::handle_request_fluffy_missing_tx)
|
||||
END_INVOKE_MAP2()
|
||||
|
||||
bool on_idle();
|
||||
|
|
@ -115,8 +117,9 @@ namespace cryptonote
|
|||
int handle_response_get_objects(int command, NOTIFY_RESPONSE_GET_OBJECTS::request& arg, cryptonote_connection_context& context);
|
||||
int handle_request_chain(int command, NOTIFY_REQUEST_CHAIN::request& arg, cryptonote_connection_context& context);
|
||||
int handle_response_chain_entry(int command, NOTIFY_RESPONSE_CHAIN_ENTRY::request& arg, cryptonote_connection_context& context);
|
||||
|
||||
|
||||
int handle_notify_new_fluffy_block(int command, NOTIFY_NEW_FLUFFY_BLOCK::request& arg, cryptonote_connection_context& context);
|
||||
int handle_request_fluffy_missing_tx(int command, NOTIFY_REQUEST_FLUFFY_MISSING_TX::request& arg, cryptonote_connection_context& context);
|
||||
|
||||
//----------------- i_bc_protocol_layout ---------------------------------------
|
||||
virtual bool relay_block(NOTIFY_NEW_BLOCK::request& arg, cryptonote_connection_context& exclude_context);
|
||||
virtual bool relay_transactions(NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& exclude_context);
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@
|
|||
|
||||
#include <boost/interprocess/detail/atomic.hpp>
|
||||
#include <list>
|
||||
#include <unordered_map>
|
||||
|
||||
#include "cryptonote_core/cryptonote_format_utils.h"
|
||||
#include "profile_tools.h"
|
||||
|
|
@ -124,6 +125,7 @@ namespace cryptonote
|
|||
|
||||
ss << std::setw(30) << std::left << "Remote Host"
|
||||
<< std::setw(20) << "Peer id"
|
||||
<< std::setw(20) << "Support Flags"
|
||||
<< std::setw(30) << "Recv/Sent (inactive,sec)"
|
||||
<< std::setw(25) << "State"
|
||||
<< std::setw(20) << "Livetime(sec)"
|
||||
|
|
@ -134,7 +136,7 @@ namespace cryptonote
|
|||
<< ENDL;
|
||||
|
||||
uint32_t ip;
|
||||
m_p2p->for_each_connection([&](const connection_context& cntxt, nodetool::peerid_type peer_id)
|
||||
m_p2p->for_each_connection([&](const connection_context& cntxt, nodetool::peerid_type peer_id, uint32_t support_flags)
|
||||
{
|
||||
bool local_ip = false;
|
||||
ip = ntohl(cntxt.m_remote_ip);
|
||||
|
|
@ -145,6 +147,7 @@ namespace cryptonote
|
|||
ss << std::setw(30) << std::left << std::string(cntxt.m_is_income ? " [INC]":"[OUT]") +
|
||||
epee::string_tools::get_ip_string_from_int32(cntxt.m_remote_ip) + ":" + std::to_string(cntxt.m_remote_port)
|
||||
<< std::setw(20) << std::hex << peer_id
|
||||
<< std::setw(20) << std::hex << support_flags
|
||||
<< std::setw(30) << std::to_string(cntxt.m_recv_cnt)+ "(" + std::to_string(time(NULL) - cntxt.m_last_recv) + ")" + "/" + std::to_string(cntxt.m_send_cnt) + "(" + std::to_string(time(NULL) - cntxt.m_last_send) + ")"
|
||||
<< std::setw(25) << get_protocol_state_string(cntxt.m_state)
|
||||
<< std::setw(20) << std::to_string(time(NULL) - cntxt.m_started)
|
||||
|
|
@ -184,7 +187,7 @@ namespace cryptonote
|
|||
{
|
||||
std::list<connection_info> connections;
|
||||
|
||||
m_p2p->for_each_connection([&](const connection_context& cntxt, nodetool::peerid_type peer_id)
|
||||
m_p2p->for_each_connection([&](const connection_context& cntxt, nodetool::peerid_type peer_id, uint32_t support_flags)
|
||||
{
|
||||
connection_info cnx;
|
||||
auto timestamp = time(NULL);
|
||||
|
|
@ -197,6 +200,8 @@ namespace cryptonote
|
|||
std::stringstream peer_id_str;
|
||||
peer_id_str << std::hex << peer_id;
|
||||
peer_id_str >> cnx.peer_id;
|
||||
|
||||
cnx.support_flags = support_flags;
|
||||
|
||||
cnx.recv_count = cntxt.m_recv_cnt;
|
||||
cnx.recv_idle_time = timestamp - cntxt.m_last_recv;
|
||||
|
|
@ -361,6 +366,312 @@ namespace cryptonote
|
|||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------
|
||||
template<class t_core>
|
||||
int t_cryptonote_protocol_handler<t_core>::handle_notify_new_fluffy_block(int command, NOTIFY_NEW_FLUFFY_BLOCK::request& arg, cryptonote_connection_context& context)
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_FLUFFY_BLOCK (hop " << arg.hop << ")");
|
||||
if(context.m_state != cryptonote_connection_context::state_normal)
|
||||
return 1;
|
||||
|
||||
m_core.pause_mine();
|
||||
|
||||
block new_block;
|
||||
transaction miner_tx;
|
||||
if(parse_and_validate_block_from_blob(arg.b.block, new_block))
|
||||
{
|
||||
// This is a seccond notification, we must have asked for some missing tx
|
||||
if(!context.m_requested_objects.empty())
|
||||
{
|
||||
// What we asked for != to what we received ..
|
||||
if(context.m_requested_objects.size() != arg.b.txs.size())
|
||||
{
|
||||
LOG_ERROR_CCONTEXT
|
||||
(
|
||||
"NOTIFY_NEW_FLUFFY_BLOCK -> request/response mismatch, "
|
||||
<< "block = " << epee::string_tools::pod_to_hex(get_blob_hash(arg.b.block))
|
||||
<< ", requested = " << context.m_requested_objects.size()
|
||||
<< ", received = " << new_block.tx_hashes.size()
|
||||
<< ", dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
std::list<blobdata> have_tx;
|
||||
|
||||
// Instead of requesting missing transactions by hash like BTC,
|
||||
// we do it by index (thanks to a suggestion from moneromooo) because
|
||||
// we're way cooler .. and also because they're smaller than hashes.
|
||||
//
|
||||
// Also, remember to pepper some whitespace changes around to bother
|
||||
// moneromooo ... only because I <3 him.
|
||||
std::vector<size_t> need_tx_indices;
|
||||
|
||||
transaction tx;
|
||||
crypto::hash tx_hash;
|
||||
|
||||
BOOST_FOREACH(auto& tx_blob, arg.b.txs)
|
||||
{
|
||||
if(parse_and_validate_tx_from_blob(tx_blob, tx))
|
||||
{
|
||||
try
|
||||
{
|
||||
if(!get_transaction_hash(tx, tx_hash))
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L1
|
||||
(
|
||||
"NOTIFY_NEW_FLUFFY_BLOCK: get_transaction_hash failed"
|
||||
<< ", dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L1
|
||||
(
|
||||
"NOTIFY_NEW_FLUFFY_BLOCK: get_transaction_hash failed"
|
||||
<< ", exception thrown"
|
||||
<< ", dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// hijacking m_requested objects in connection context to patch up
|
||||
// a possible DOS vector pointed out by @monero-moo where peers keep
|
||||
// sending (0...n-1) transactions.
|
||||
// If requested objects is not empty, then we must have asked for
|
||||
// some missing transacionts, make sure that they're all there.
|
||||
//
|
||||
// Can I safely re-use this field? I think so, but someone check me!
|
||||
if(!context.m_requested_objects.empty())
|
||||
{
|
||||
auto req_tx_it = context.m_requested_objects.find(tx_hash);
|
||||
if(req_tx_it == context.m_requested_objects.end())
|
||||
{
|
||||
LOG_ERROR_CCONTEXT
|
||||
(
|
||||
"Peer sent wrong transaction (NOTIFY_NEW_FLUFFY_BLOCK): "
|
||||
<< "transaction with id = " << tx_hash << " wasn't requested, "
|
||||
<< "dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
|
||||
context.m_requested_objects.erase(req_tx_it);
|
||||
}
|
||||
|
||||
// we might already have the tx that the peer
|
||||
// sent in our pool, so don't verify again..
|
||||
if(!m_core.get_pool_transaction(tx_hash, tx))
|
||||
{
|
||||
cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc);
|
||||
if(!m_core.handle_incoming_tx(tx_blob, tvc, true, true) || tvc.m_verifivation_failed)
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L1("Block verification failed: transaction verification failed, dropping connection");
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
|
||||
//
|
||||
// future todo:
|
||||
// tx should only not be added to pool if verification failed, but
|
||||
// maybe in the future could not be added for other reasons
|
||||
// according to monero-moo so keep track of these separately ..
|
||||
//
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_ERROR_CCONTEXT
|
||||
(
|
||||
"sent wrong tx: failed to parse and validate transaction: \r\n"
|
||||
<< epee::string_tools::buff_to_hex_nodelimer(tx_blob)
|
||||
<< "\r\n dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
// The initial size equality check could have been fooled if the sender
|
||||
// gave us the number of transactions we asked for, but not the right
|
||||
// ones. This check make sure the transactions we asked for were the
|
||||
// ones we received.
|
||||
if(context.m_requested_objects.size())
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_RED
|
||||
(
|
||||
"NOTIFY_NEW_FLUFFY_BLOCK: peer sent the number of transaction requested"
|
||||
<< ", but not the actual transactions requested"
|
||||
<< ", context.m_requested_objects.size() = " << context.m_requested_objects.size()
|
||||
<< ", dropping connection", LOG_LEVEL_0
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
m_core.resume_mine();
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t tx_idx = 0;
|
||||
BOOST_FOREACH(auto& tx_hash, new_block.tx_hashes)
|
||||
{
|
||||
if(m_core.get_pool_transaction(tx_hash, tx))
|
||||
{
|
||||
have_tx.push_back(tx_to_blob(tx));
|
||||
}
|
||||
else
|
||||
{
|
||||
need_tx_indices.push_back(tx_idx);
|
||||
}
|
||||
|
||||
++tx_idx;
|
||||
}
|
||||
|
||||
if(!need_tx_indices.empty()) // drats, we don't have everything..
|
||||
{
|
||||
// request non-mempool txs
|
||||
NOTIFY_REQUEST_FLUFFY_MISSING_TX::request missing_tx_req;
|
||||
missing_tx_req.b = arg.b;
|
||||
missing_tx_req.hop = arg.hop;
|
||||
missing_tx_req.current_blockchain_height = arg.current_blockchain_height;
|
||||
missing_tx_req.missing_tx_indices = std::move(need_tx_indices);
|
||||
|
||||
m_core.resume_mine();
|
||||
post_notify<NOTIFY_REQUEST_FLUFFY_MISSING_TX>(missing_tx_req, context);
|
||||
}
|
||||
else // whoo-hoo we've got em all ..
|
||||
{
|
||||
block_complete_entry b;
|
||||
b.block = arg.b.block;
|
||||
b.txs = have_tx;
|
||||
|
||||
std::list<block_complete_entry> blocks;
|
||||
blocks.push_back(b);
|
||||
m_core.prepare_handle_incoming_blocks(blocks);
|
||||
|
||||
block_verification_context bvc = boost::value_initialized<block_verification_context>();
|
||||
m_core.handle_incoming_block(arg.b.block, bvc); // got block from handle_notify_new_block
|
||||
m_core.cleanup_handle_incoming_blocks(true);
|
||||
m_core.resume_mine();
|
||||
|
||||
if( bvc.m_verifivation_failed )
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L0("Block verification failed, dropping connection");
|
||||
m_p2p->drop_connection(context);
|
||||
return 1;
|
||||
}
|
||||
if( bvc.m_added_to_main_chain )
|
||||
{
|
||||
++arg.hop;
|
||||
//TODO: Add here announce protocol usage
|
||||
NOTIFY_NEW_BLOCK::request reg_arg = AUTO_VAL_INIT(reg_arg);
|
||||
reg_arg.hop = arg.hop;
|
||||
reg_arg.current_blockchain_height = arg.current_blockchain_height;
|
||||
reg_arg.b.block = b.block;
|
||||
relay_block(reg_arg, context);
|
||||
}
|
||||
else if( bvc.m_marked_as_orphaned )
|
||||
{
|
||||
context.m_state = cryptonote_connection_context::state_synchronizing;
|
||||
NOTIFY_REQUEST_CHAIN::request r = boost::value_initialized<NOTIFY_REQUEST_CHAIN::request>();
|
||||
m_core.get_short_chain_history(r.block_ids);
|
||||
LOG_PRINT_CCONTEXT_L2("-->>NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << r.block_ids.size() );
|
||||
post_notify<NOTIFY_REQUEST_CHAIN>(r, context);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_ERROR_CCONTEXT
|
||||
(
|
||||
"sent wrong block: failed to parse and validate block: \r\n"
|
||||
<< epee::string_tools::buff_to_hex_nodelimer(arg.b.block)
|
||||
<< "\r\n dropping connection"
|
||||
);
|
||||
|
||||
m_core.resume_mine();
|
||||
m_p2p->drop_connection(context);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------
|
||||
template<class t_core>
|
||||
int t_cryptonote_protocol_handler<t_core>::handle_request_fluffy_missing_tx(int command, NOTIFY_REQUEST_FLUFFY_MISSING_TX::request& arg, cryptonote_connection_context& context)
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L2("NOTIFY_REQUEST_FLUFFY_MISSING_TX");
|
||||
|
||||
std::list<block> local_blocks;
|
||||
std::list<transaction> local_txs;
|
||||
if(!m_core.get_blocks(arg.current_blockchain_height - 1, 1, local_blocks, local_txs))
|
||||
{
|
||||
|
||||
LOG_ERROR_CCONTEXT
|
||||
(
|
||||
"Failed to handle request NOTIFY_REQUEST_FLUFFY_MISSING_TX"
|
||||
<< ", get_blocks( start_offset = " << (arg.current_blockchain_height - 1) << " ) failed"
|
||||
<< ", dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
return 1;
|
||||
}
|
||||
|
||||
NOTIFY_NEW_FLUFFY_BLOCK::request fluffy_response;
|
||||
fluffy_response.b = arg.b;
|
||||
fluffy_response.current_blockchain_height = m_core.get_current_blockchain_height();
|
||||
fluffy_response.hop = arg.hop;
|
||||
size_t local_txs_count = local_txs.size();
|
||||
BOOST_FOREACH(auto& tx_idx, arg.missing_tx_indices)
|
||||
{
|
||||
if(tx_idx < local_txs_count)
|
||||
{
|
||||
fluffy_response.b.txs.push_back(t_serializable_object_to_blob( *(std::next(local_txs.begin(), tx_idx)) ));
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_ERROR_CCONTEXT
|
||||
(
|
||||
"Failed to handle request NOTIFY_REQUEST_FLUFFY_MISSING_TX"
|
||||
<< ", request is asking for a tx whose index is out of bounds "
|
||||
<< ", tx index = " << tx_idx << ", block_height = " << arg.current_blockchain_height
|
||||
<< ", dropping connection"
|
||||
);
|
||||
|
||||
m_p2p->drop_connection(context);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
LOG_PRINT_CCONTEXT_L2
|
||||
(
|
||||
"-->>NOTIFY_RESPONSE_FLUFFY_MISSING_TX: "
|
||||
<< ", txs.size()=" << fluffy_response.b.txs.size()
|
||||
<< ", rsp.current_blockchain_height=" << fluffy_response.current_blockchain_height
|
||||
);
|
||||
|
||||
post_notify<NOTIFY_NEW_FLUFFY_BLOCK>(fluffy_response, context);
|
||||
return 1;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------
|
||||
template<class t_core>
|
||||
int t_cryptonote_protocol_handler<t_core>::handle_notify_new_transactions(int command, NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& context)
|
||||
{
|
||||
LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_TRANSACTIONS");
|
||||
|
|
@ -774,7 +1085,28 @@ namespace cryptonote
|
|||
template<class t_core>
|
||||
bool t_cryptonote_protocol_handler<t_core>::relay_block(NOTIFY_NEW_BLOCK::request& arg, cryptonote_connection_context& exclude_context)
|
||||
{
|
||||
return relay_post_notify<NOTIFY_NEW_BLOCK>(arg, exclude_context);
|
||||
NOTIFY_NEW_FLUFFY_BLOCK::request fluffy_arg = AUTO_VAL_INIT(fluffy_arg);
|
||||
fluffy_arg.hop = arg.hop;
|
||||
fluffy_arg.current_blockchain_height = arg.current_blockchain_height;
|
||||
std::list<blobdata> fluffy_txs;
|
||||
fluffy_arg.b = arg.b;
|
||||
fluffy_arg.b.txs = fluffy_txs;
|
||||
|
||||
m_p2p->for_each_connection([this, &arg, &fluffy_arg](connection_context& cntxt, nodetool::peerid_type peer_id, uint32_t support_flags)
|
||||
{
|
||||
if(m_core.get_testnet() && support_flags & P2P_SUPPORT_FLAG_FLUFFY_BLOCKS)
|
||||
{
|
||||
LOG_PRINT_YELLOW("PEER SUPPORTS FLUFFY BLOCKS - RELAYING THIN/COMPACT WHATEVER BLOCK", LOG_LEVEL_1);
|
||||
return post_notify<NOTIFY_NEW_FLUFFY_BLOCK>(fluffy_arg, cntxt);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_PRINT_YELLOW("PEER DOESN'T SUPPORT FLUFFY BLOCKS - RELAYING FULL BLOCK", LOG_LEVEL_1);
|
||||
return post_notify<NOTIFY_NEW_BLOCK>(arg, cntxt);
|
||||
}
|
||||
});
|
||||
|
||||
return 1;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------
|
||||
template<class t_core>
|
||||
|
|
|
|||
|
|
@ -404,6 +404,7 @@ bool t_rpc_command_executor::print_connections() {
|
|||
|
||||
tools::msg_writer() << std::setw(30) << std::left << "Remote Host"
|
||||
<< std::setw(20) << "Peer id"
|
||||
<< std::setw(20) << "Support Flags"
|
||||
<< std::setw(30) << "Recv/Sent (inactive,sec)"
|
||||
<< std::setw(25) << "State"
|
||||
<< std::setw(20) << "Livetime(sec)"
|
||||
|
|
@ -422,6 +423,7 @@ bool t_rpc_command_executor::print_connections() {
|
|||
//<< std::setw(30) << std::left << in_out
|
||||
<< std::setw(30) << std::left << address
|
||||
<< std::setw(20) << info.peer_id
|
||||
<< std::setw(20) << info.support_flags
|
||||
<< std::setw(30) << std::to_string(info.recv_count) + "(" + std::to_string(info.recv_idle_time) + ")/" + std::to_string(info.send_count) + "(" + std::to_string(info.send_idle_time) + ")"
|
||||
<< std::setw(25) << info.state
|
||||
<< std::setw(20) << info.live_time
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ namespace nodetool
|
|||
struct p2p_connection_context_t: base_type //t_payload_net_handler::connection_context //public net_utils::connection_context_base
|
||||
{
|
||||
peerid_type peer_id;
|
||||
uint32_t support_flags;
|
||||
};
|
||||
|
||||
template<class t_payload_net_handler>
|
||||
|
|
@ -146,6 +147,7 @@ namespace nodetool
|
|||
HANDLE_INVOKE_T2(COMMAND_REQUEST_NETWORK_STATE, &node_server::handle_get_network_state)
|
||||
HANDLE_INVOKE_T2(COMMAND_REQUEST_PEER_ID, &node_server::handle_get_peer_id)
|
||||
#endif
|
||||
HANDLE_INVOKE_T2(COMMAND_REQUEST_SUPPORT_FLAGS, &node_server::handle_get_support_flags)
|
||||
CHAIN_INVOKE_MAP_TO_OBJ_FORCE_CONTEXT(m_payload_handler, typename t_payload_net_handler::connection_context&)
|
||||
END_INVOKE_MAP2()
|
||||
|
||||
|
|
@ -158,6 +160,7 @@ namespace nodetool
|
|||
int handle_get_network_state(int command, COMMAND_REQUEST_NETWORK_STATE::request& arg, COMMAND_REQUEST_NETWORK_STATE::response& rsp, p2p_connection_context& context);
|
||||
int handle_get_peer_id(int command, COMMAND_REQUEST_PEER_ID::request& arg, COMMAND_REQUEST_PEER_ID::response& rsp, p2p_connection_context& context);
|
||||
#endif
|
||||
int handle_get_support_flags(int command, COMMAND_REQUEST_SUPPORT_FLAGS::request& arg, COMMAND_REQUEST_SUPPORT_FLAGS::response& rsp, p2p_connection_context& context);
|
||||
bool init_config();
|
||||
bool make_default_config();
|
||||
bool store_config();
|
||||
|
|
@ -174,7 +177,7 @@ namespace nodetool
|
|||
virtual bool invoke_notify_to_peer(int command, const std::string& req_buff, const epee::net_utils::connection_context_base& context);
|
||||
virtual bool drop_connection(const epee::net_utils::connection_context_base& context);
|
||||
virtual void request_callback(const epee::net_utils::connection_context_base& context);
|
||||
virtual void for_each_connection(std::function<bool(typename t_payload_net_handler::connection_context&, peerid_type)> f);
|
||||
virtual void for_each_connection(std::function<bool(typename t_payload_net_handler::connection_context&, peerid_type, uint32_t)> f);
|
||||
virtual bool add_ip_fail(uint32_t address);
|
||||
//----------------- i_connection_filter --------------------------------------------------------
|
||||
virtual bool is_remote_ip_allowed(uint32_t adress);
|
||||
|
|
@ -204,6 +207,7 @@ namespace nodetool
|
|||
bool is_addr_connected(const net_address& peer);
|
||||
template<class t_callback>
|
||||
bool try_ping(basic_node_data& node_data, p2p_connection_context& context, t_callback cb);
|
||||
bool try_get_support_flags(const p2p_connection_context& context, std::function<void(p2p_connection_context&, const uint32_t&)> f);
|
||||
bool make_expected_connections_count(bool white_list, size_t expected_connections);
|
||||
void cache_connect_fail_info(const net_address& addr);
|
||||
bool is_addr_recently_failed(const net_address& addr);
|
||||
|
|
@ -240,10 +244,12 @@ namespace nodetool
|
|||
{
|
||||
network_config m_net_config;
|
||||
uint64_t m_peer_id;
|
||||
uint32_t m_support_flags;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(m_net_config)
|
||||
KV_SERIALIZE(m_peer_id)
|
||||
KV_SERIALIZE(m_support_flags)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -158,6 +158,7 @@ namespace nodetool
|
|||
m_config.m_net_config.connection_timeout = P2P_DEFAULT_CONNECTION_TIMEOUT;
|
||||
m_config.m_net_config.ping_connection_timeout = P2P_DEFAULT_PING_CONNECTION_TIMEOUT;
|
||||
m_config.m_net_config.send_peerlist_sz = P2P_DEFAULT_PEERS_IN_HANDSHAKE;
|
||||
m_config.m_support_flags = P2P_SUPPORT_FLAGS;
|
||||
|
||||
m_first_connection_maker_call = true;
|
||||
CATCH_ENTRY_L0("node_server::init_config", false);
|
||||
|
|
@ -165,10 +166,10 @@ namespace nodetool
|
|||
}
|
||||
//-----------------------------------------------------------------------------------
|
||||
template<class t_payload_net_handler>
|
||||
void node_server<t_payload_net_handler>::for_each_connection(std::function<bool(typename t_payload_net_handler::connection_context&, peerid_type)> f)
|
||||
void node_server<t_payload_net_handler>::for_each_connection(std::function<bool(typename t_payload_net_handler::connection_context&, peerid_type, uint32_t)> f)
|
||||
{
|
||||
m_net_server.get_config_object().foreach_connection([&](p2p_connection_context& cntx){
|
||||
return f(cntx, cntx.peer_id);
|
||||
return f(cntx, cntx.peer_id, cntx.support_flags);
|
||||
});
|
||||
}
|
||||
//-----------------------------------------------------------------------------------
|
||||
|
|
@ -730,6 +731,13 @@ namespace nodetool
|
|||
LOG_PRINT_CC_L1(context_, "COMMAND_HANDSHAKE Failed");
|
||||
m_net_server.get_config_object().close(context_.m_connection_id);
|
||||
}
|
||||
else
|
||||
{
|
||||
try_get_support_flags(context_, [](p2p_connection_context& flags_context, const uint32_t& support_flags)
|
||||
{
|
||||
flags_context.support_flags = support_flags;
|
||||
});
|
||||
}
|
||||
|
||||
return hsh_result;
|
||||
}
|
||||
|
|
@ -1219,6 +1227,13 @@ namespace nodetool
|
|||
return 1;
|
||||
}
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------------
|
||||
template<class t_payload_net_handler>
|
||||
int node_server<t_payload_net_handler>::handle_get_support_flags(int command, COMMAND_REQUEST_SUPPORT_FLAGS::request& arg, COMMAND_REQUEST_SUPPORT_FLAGS::response& rsp, p2p_connection_context& context)
|
||||
{
|
||||
rsp.support_flags = m_config.m_support_flags;
|
||||
return 1;
|
||||
}
|
||||
//-----------------------------------------------------------------------------------
|
||||
template<class t_payload_net_handler>
|
||||
void node_server<t_payload_net_handler>::request_callback(const epee::net_utils::connection_context_base& context)
|
||||
|
|
@ -1338,6 +1353,32 @@ namespace nodetool
|
|||
}
|
||||
//-----------------------------------------------------------------------------------
|
||||
template<class t_payload_net_handler>
|
||||
bool node_server<t_payload_net_handler>::try_get_support_flags(const p2p_connection_context& context, std::function<void(p2p_connection_context&, const uint32_t&)> f)
|
||||
{
|
||||
COMMAND_REQUEST_SUPPORT_FLAGS::request support_flags_request;
|
||||
bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_REQUEST_SUPPORT_FLAGS::response>
|
||||
(
|
||||
context.m_connection_id,
|
||||
COMMAND_REQUEST_SUPPORT_FLAGS::ID,
|
||||
support_flags_request,
|
||||
m_net_server.get_config_object(),
|
||||
[=](int code, const typename COMMAND_REQUEST_SUPPORT_FLAGS::response& rsp, p2p_connection_context& context_)
|
||||
{
|
||||
if(code < 0)
|
||||
{
|
||||
LOG_PRINT_CC_RED(context_, "COMMAND_REQUEST_SUPPORT_FLAGS invoke failed. (" << code << ", " << epee::levin::get_err_descr(code) << ")", LOG_LEVEL_1);
|
||||
return;
|
||||
}
|
||||
|
||||
f(context_, rsp.support_flags);
|
||||
},
|
||||
P2P_DEFAULT_HANDSHAKE_INVOKE_TIMEOUT
|
||||
);
|
||||
|
||||
return r;
|
||||
}
|
||||
//-----------------------------------------------------------------------------------
|
||||
template<class t_payload_net_handler>
|
||||
int node_server<t_payload_net_handler>::handle_timed_sync(int command, typename COMMAND_TIMED_SYNC::request& arg, typename COMMAND_TIMED_SYNC::response& rsp, p2p_connection_context& context)
|
||||
{
|
||||
if(!m_payload_handler.process_payload_sync_data(arg.payload_data, context, false))
|
||||
|
|
@ -1394,7 +1435,7 @@ namespace nodetool
|
|||
if(arg.node_data.peer_id != m_config.m_peer_id && arg.node_data.my_port)
|
||||
{
|
||||
peerid_type peer_id_l = arg.node_data.peer_id;
|
||||
uint32_t port_l = arg.node_data.my_port;
|
||||
uint32_t port_l = arg.node_data.my_port;
|
||||
//try ping to be sure that we can add this peer to peer_list
|
||||
try_ping(arg.node_data, context, [peer_id_l, port_l, context, this]()
|
||||
{
|
||||
|
|
@ -1410,6 +1451,11 @@ namespace nodetool
|
|||
LOG_PRINT_CCONTEXT_L2("PING SUCCESS " << epee::string_tools::get_ip_string_from_int32(context.m_remote_ip) << ":" << port_l);
|
||||
});
|
||||
}
|
||||
|
||||
try_get_support_flags(context, [](p2p_connection_context& flags_context, const uint32_t& support_flags)
|
||||
{
|
||||
flags_context.support_flags = support_flags;
|
||||
});
|
||||
|
||||
//fill response
|
||||
m_peerlist.get_peerlist_head(rsp.local_peerlist);
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ namespace nodetool
|
|||
virtual bool drop_connection(const epee::net_utils::connection_context_base& context)=0;
|
||||
virtual void request_callback(const epee::net_utils::connection_context_base& context)=0;
|
||||
virtual uint64_t get_connections_count()=0;
|
||||
virtual void for_each_connection(std::function<bool(t_connection_context&, peerid_type)> f)=0;
|
||||
virtual void for_each_connection(std::function<bool(t_connection_context&, peerid_type, uint32_t)> f)=0;
|
||||
virtual bool block_ip(uint32_t adress, time_t seconds = 0)=0;
|
||||
virtual bool unblock_ip(uint32_t adress)=0;
|
||||
virtual std::map<uint32_t, time_t> get_blocked_ips()=0;
|
||||
|
|
@ -79,7 +79,7 @@ namespace nodetool
|
|||
{
|
||||
|
||||
}
|
||||
virtual void for_each_connection(std::function<bool(t_connection_context&,peerid_type)> f)
|
||||
virtual void for_each_connection(std::function<bool(t_connection_context&,peerid_type,uint32_t)> f)
|
||||
{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -332,6 +332,29 @@ namespace nodetool
|
|||
};
|
||||
};
|
||||
|
||||
/************************************************************************/
|
||||
/* */
|
||||
/************************************************************************/
|
||||
struct COMMAND_REQUEST_SUPPORT_FLAGS
|
||||
{
|
||||
const static int ID = P2P_COMMANDS_POOL_BASE + 7;
|
||||
|
||||
struct request
|
||||
{
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
|
||||
struct response
|
||||
{
|
||||
uint32_t support_flags;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(support_flags)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue