rottenwheel/monero
1
0
Fork 0
mirror of https://codeberg.org/anoncontributorxmr/monero.git synced 2024-11-23 03:13:28 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

moved non-critical warnings and errors to log level 1

Browse Source
This commit is contained in:
fluffypony 2014-09-09 11:32:00 +02:00
parent 4290c78160
commit cf5a8b1d6c
12 changed files with 108 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contrib/epee/include/misc_log_ex.h
View File

@ -1385,6 +1385,7 @@ POP_WARNINGS
#define LOG_PRINT_MAGENTA(mess, level) LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_magenta) #define LOG_PRINT_MAGENTA(mess, level) LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, level, epee::log_space::console_color_magenta)
#define LOG_PRINT_RED_L0(mess) LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, LOG_LEVEL_0, epee::log_space::console_color_red) #define LOG_PRINT_RED_L0(mess) LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, LOG_LEVEL_0, epee::log_space::console_color_red)
#define LOG_PRINT_RED_L1(mess) LOG_PRINT_COLOR2(LOG_DEFAULT_TARGET, mess, LOG_LEVEL_1, epee::log_space::console_color_red)
#define LOG_PRINT_L0(mess) LOG_PRINT(mess, LOG_LEVEL_0) #define LOG_PRINT_L0(mess) LOG_PRINT(mess, LOG_LEVEL_0)
#define LOG_PRINT_L1(mess) LOG_PRINT(mess, LOG_LEVEL_1) #define LOG_PRINT_L1(mess) LOG_PRINT(mess, LOG_LEVEL_1)

2
contrib/epee/include/net/abstract_tcp_server2.inl
View File

@ -376,7 +376,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
if (e) if (e)
{ {
LOG_PRINT_L0("[sock " << socket_.native_handle() << "] Some problems at write: " << e.message() << ':' << e.value()); LOG_PRINT_L1("[sock " << socket_.native_handle() << "] Some problems at write: " << e.message() << ':' << e.value());
shutdown(); shutdown();
return; return;
} }

2
contrib/epee/include/net/abstract_tcp_server_cp.inl
View File

@ -602,4 +602,4 @@ bool cp_server_impl<TProtocol>::is_stop_signal()
} }
//------------------------------------------------------------- //-------------------------------------------------------------
} }
} }

6
contrib/epee/include/net/levin_client.inl
View File

@ -95,7 +95,7 @@ int levin_client_impl::invoke(int command, const std::string& in_buff, std::stri
if(head.m_signature!=LEVIN_SIGNATURE) if(head.m_signature!=LEVIN_SIGNATURE)
{ {
LOG_PRINT_L0("Signature missmatch in response"); LOG_PRINT_L1("Signature missmatch in response");
return -1; return -1;
} }
@ -156,7 +156,7 @@ inline
if(head.m_signature!=LEVIN_SIGNATURE) if(head.m_signature!=LEVIN_SIGNATURE)
{ {
LOG_PRINT_L0("Signature missmatch in response"); LOG_PRINT_L1("Signature missmatch in response");
return -1; return -1;
} }
@ -191,4 +191,4 @@ inline
} }
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------

6
contrib/epee/include/net/net_parse_helpers.h
View File

@ -103,7 +103,7 @@ namespace net_utils
boost::smatch result; boost::smatch result;
if(!boost::regex_search(uri, result, rexp_match_uri, boost::match_default) && result[0].matched) if(!boost::regex_search(uri, result, rexp_match_uri, boost::match_default) && result[0].matched)
{ {
LOG_PRINT_L0("[PARSE URI] regex not matched for uri: " << uri); LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << uri);
content.m_path = uri; content.m_path = uri;
return true; return true;
} }
@ -139,7 +139,7 @@ namespace net_utils
boost::smatch result; boost::smatch result;
if(!boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched) if(!boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched)
{ {
LOG_PRINT_L0("[PARSE URI] regex not matched for uri: " << rexp_match_uri); LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
//content.m_path = uri; //content.m_path = uri;
return true; return true;
} }
@ -165,4 +165,4 @@ namespace net_utils
} }
} }
} }

2
contrib/epee/include/net/net_utils_base.h
View File

@ -143,7 +143,7 @@ namespace net_utils
#define LOG_PRINT_CC_YELLOW(ct, message, log_level) LOG_PRINT_YELLOW("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level) #define LOG_PRINT_CC_YELLOW(ct, message, log_level) LOG_PRINT_YELLOW("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
#define LOG_PRINT_CC_CYAN(ct, message, log_level) LOG_PRINT_CYAN("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level) #define LOG_PRINT_CC_CYAN(ct, message, log_level) LOG_PRINT_CYAN("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
#define LOG_PRINT_CC_MAGENTA(ct, message, log_level) LOG_PRINT_MAGENTA("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level) #define LOG_PRINT_CC_MAGENTA(ct, message, log_level) LOG_PRINT_MAGENTA("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, log_level)
#define LOG_ERROR_CC(ct, message) LOG_ERROR("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message) #define LOG_ERROR_CC(ct, message) LOG_PRINT_RED("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message, LOG_LEVEL_1)
#define LOG_PRINT_CC_L0(ct, message) LOG_PRINT_L0("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message) #define LOG_PRINT_CC_L0(ct, message) LOG_PRINT_L0("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)
#define LOG_PRINT_CC_L1(ct, message) LOG_PRINT_L1("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message) #define LOG_PRINT_CC_L1(ct, message) LOG_PRINT_L1("[" << epee::net_utils::print_connection_context_short(ct) << "]" << message)

98
src/cryptonote_core/blockchain_storage.cpp
View File

@ -403,17 +403,17 @@ bool blockchain_storage::rollback_blockchain_switching(std::list<block>& origina
for(size_t i = m_blocks.size()-1; i >=rollback_height; i--) for(size_t i = m_blocks.size()-1; i >=rollback_height; i--)
{ {
bool r = pop_block_from_blockchain(); bool r = pop_block_from_blockchain();
CHECK_AND_ASSERT_MES(r, false, "PANIC!!! failed to remove block while chain switching during the rollback!"); CHECK_AND_ASSERT_MES(r, false, "PANIC! failed to remove block while chain switching during the rollback!");
} }
//return back original chain //return back original chain
BOOST_FOREACH(auto& bl, original_chain) BOOST_FOREACH(auto& bl, original_chain)
{ {
block_verification_context bvc = boost::value_initialized<block_verification_context>(); block_verification_context bvc = boost::value_initialized<block_verification_context>();
bool r = handle_block_to_main_chain(bl, bvc); bool r = handle_block_to_main_chain(bl, bvc);
CHECK_AND_ASSERT_MES(r && bvc.m_added_to_main_chain, false, "PANIC!!! failed to add (again) block while chain switching during the rollback!"); CHECK_AND_ASSERT_MES(r && bvc.m_added_to_main_chain, false, "PANIC! failed to add (again) block while chain switching during the rollback!");
} }
LOG_PRINT_L0("Rollback success."); LOG_PRINT_L1("Rollback success.");
return true; return true;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
@ -443,10 +443,10 @@ bool blockchain_storage::switch_to_alternative_blockchain(std::list<blocks_ext_b
bool r = handle_block_to_main_chain(ch_ent->second.bl, bvc); bool r = handle_block_to_main_chain(ch_ent->second.bl, bvc);
if(!r || !bvc.m_added_to_main_chain) if(!r || !bvc.m_added_to_main_chain)
{ {
LOG_PRINT_L0("Failed to switch to alternative blockchain"); LOG_PRINT_L1("Failed to switch to alternative blockchain");
rollback_blockchain_switching(disconnected_chain, split_height); rollback_blockchain_switching(disconnected_chain, split_height);
add_block_as_invalid(ch_ent->second, get_block_hash(ch_ent->second.bl)); add_block_as_invalid(ch_ent->second, get_block_hash(ch_ent->second.bl));
LOG_PRINT_L0("The block was inserted as invalid while connecting new alternative chain, block_id: " << get_block_hash(ch_ent->second.bl)); LOG_PRINT_L1("The block was inserted as invalid while connecting new alternative chain, block_id: " << get_block_hash(ch_ent->second.bl));
m_alternative_chains.erase(ch_ent); m_alternative_chains.erase(ch_ent);
for(auto alt_ch_to_orph_iter = ++alt_ch_iter; alt_ch_to_orph_iter != alt_chain.end(); alt_ch_to_orph_iter++) for(auto alt_ch_to_orph_iter = ++alt_ch_iter; alt_ch_to_orph_iter != alt_chain.end(); alt_ch_to_orph_iter++)
@ -536,17 +536,17 @@ bool blockchain_storage::prevalidate_miner_transaction(const block& b, uint64_t
CHECK_AND_ASSERT_MES(b.miner_tx.vin[0].type() == typeid(txin_gen), false, "coinbase transaction in the block has the wrong type"); CHECK_AND_ASSERT_MES(b.miner_tx.vin[0].type() == typeid(txin_gen), false, "coinbase transaction in the block has the wrong type");
if(boost::get<txin_gen>(b.miner_tx.vin[0]).height != height) if(boost::get<txin_gen>(b.miner_tx.vin[0]).height != height)
{ {
LOG_PRINT_RED_L0("The miner transaction in block has invalid height: " << boost::get<txin_gen>(b.miner_tx.vin[0]).height << ", expected: " << height); LOG_PRINT_RED_L1("The miner transaction in block has invalid height: " << boost::get<txin_gen>(b.miner_tx.vin[0]).height << ", expected: " << height);
return false; return false;
} }
CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, CHECK_AND_ASSERT_MES(b.miner_tx.unlock_time == height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW,
false, false,
"coinbase transaction transaction have wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW); "coinbase transaction transaction has the wrong unlock time=" << b.miner_tx.unlock_time << ", expected " << height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW);
//check outs overflow //check outs overflow
if(!check_outs_overflow(b.miner_tx)) if(!check_outs_overflow(b.miner_tx))
{ {
LOG_PRINT_RED_L0("miner transaction have money overflow in block " << get_block_hash(b)); LOG_PRINT_RED_L1("miner transaction has money overflow in block " << get_block_hash(b));
return false; return false;
} }
@ -563,7 +563,7 @@ bool blockchain_storage::validate_miner_transaction(const block& b, size_t cumul
std::vector<size_t> last_blocks_sizes; std::vector<size_t> last_blocks_sizes;
get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW); get_last_n_blocks_sizes(last_blocks_sizes, CRYPTONOTE_REWARD_BLOCKS_WINDOW);
if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward)) { if (!get_block_reward(epee::misc_utils::median(last_blocks_sizes), cumulative_block_size, already_generated_coins, base_reward)) {
LOG_PRINT_L0("block size " << cumulative_block_size << " is bigger than allowed for this blockchain"); LOG_PRINT_L1("block size " << cumulative_block_size << " is bigger than allowed for this blockchain");
return false; return false;
} }
if(base_reward + fee < money_in_use) if(base_reward + fee < money_in_use)
@ -706,7 +706,7 @@ bool blockchain_storage::create_block_template(block& b, const account_public_ad
b.miner_tx.extra.resize(b.miner_tx.extra.size() - 1); b.miner_tx.extra.resize(b.miner_tx.extra.size() - 1);
if (cumulative_size != txs_size + get_object_blobsize(b.miner_tx)) { if (cumulative_size != txs_size + get_object_blobsize(b.miner_tx)) {
//fuck, not lucky, -1 makes varint-counter size smaller, in that case we continue to grow with cumulative_size //fuck, not lucky, -1 makes varint-counter size smaller, in that case we continue to grow with cumulative_size
LOG_PRINT_RED("Miner tx creation have no luck with delta_extra size = " << delta << " and " << delta - 1 , LOG_LEVEL_2); LOG_PRINT_RED("Miner tx creation has no luck with delta_extra size = " << delta << " and " << delta - 1 , LOG_LEVEL_2);
cumulative_size += delta - 1; cumulative_size += delta - 1;
continue; continue;
} }
@ -751,13 +751,13 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
uint64_t block_height = get_block_height(b); uint64_t block_height = get_block_height(b);
if(0 == block_height) if(0 == block_height)
{ {
LOG_ERROR("Block with id: " << epee::string_tools::pod_to_hex(id) << " (as alternative) have wrong miner transaction"); LOG_ERROR("Block with id: " << epee::string_tools::pod_to_hex(id) << " (as alternative) has wrong miner transaction");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
} }
if (!m_checkpoints.is_alternative_block_allowed(get_current_blockchain_height(), block_height)) if (!m_checkpoints.is_alternative_block_allowed(get_current_blockchain_height(), block_height))
{ {
LOG_PRINT_RED_L0("Block with id: " << id LOG_PRINT_RED_L1("Block with id: " << id
<< ENDL << " can't be accepted for alternative chain, block height: " << block_height << ENDL << " can't be accepted for alternative chain, block height: " << block_height
<< ENDL << " blockchain height: " << get_current_blockchain_height()); << ENDL << " blockchain height: " << get_current_blockchain_height());
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
@ -789,7 +789,7 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
CHECK_AND_ASSERT_MES(m_blocks.size() > alt_chain.front()->second.height, false, "main blockchain wrong height"); CHECK_AND_ASSERT_MES(m_blocks.size() > alt_chain.front()->second.height, false, "main blockchain wrong height");
crypto::hash h = null_hash; crypto::hash h = null_hash;
get_block_hash(m_blocks[alt_chain.front()->second.height - 1].bl, h); get_block_hash(m_blocks[alt_chain.front()->second.height - 1].bl, h);
CHECK_AND_ASSERT_MES(h == alt_chain.front()->second.bl.prev_id, false, "alternative chain have wrong connection to main chain"); CHECK_AND_ASSERT_MES(h == alt_chain.front()->second.bl.prev_id, false, "alternative chain has wrong connection to main chain");
complete_timestamps_vector(alt_chain.front()->second.height - 1, timestamps); complete_timestamps_vector(alt_chain.front()->second.height - 1, timestamps);
}else }else
{ {
@ -799,8 +799,8 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
//check timestamp correct //check timestamp correct
if(!check_block_timestamp(timestamps, b)) if(!check_block_timestamp(timestamps, b))
{ {
LOG_PRINT_RED_L0("Block with id: " << id LOG_PRINT_RED_L1("Block with id: " << id
<< ENDL << " for alternative chain, have invalid timestamp: " << b.timestamp); << ENDL << " for alternative chain, has invalid timestamp: " << b.timestamp);
//add_block_as_invalid(b, id);//do not add blocks to invalid storage before proof of work check was passed //add_block_as_invalid(b, id);//do not add blocks to invalid storage before proof of work check was passed
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
@ -826,8 +826,8 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
get_block_longhash(bei.bl, proof_of_work, bei.height); get_block_longhash(bei.bl, proof_of_work, bei.height);
if(!check_hash(proof_of_work, current_diff)) if(!check_hash(proof_of_work, current_diff))
{ {
LOG_PRINT_RED_L0("Block with id: " << id LOG_PRINT_RED_L1("Block with id: " << id
<< ENDL << " for alternative chain, have not enough proof of work: " << proof_of_work << ENDL << " for alternative chain, does not have enough proof of work: " << proof_of_work
<< ENDL << " expected difficulty: " << current_diff); << ENDL << " expected difficulty: " << current_diff);
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
@ -835,8 +835,8 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
if(!prevalidate_miner_transaction(b, bei.height)) if(!prevalidate_miner_transaction(b, bei.height))
{ {
LOG_PRINT_RED_L0("Block with id: " << epee::string_tools::pod_to_hex(id) LOG_PRINT_RED_L1("Block with id: " << epee::string_tools::pod_to_hex(id)
<< " (as alternative) have wrong miner transaction."); << " (as alternative) has incorrect miner transaction.");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
@ -883,7 +883,7 @@ bool blockchain_storage::handle_alternative_block(const block& b, const crypto::
{ {
//block orphaned //block orphaned
bvc.m_marked_as_orphaned = true; bvc.m_marked_as_orphaned = true;
LOG_PRINT_RED_L0("Block recognized as orphaned and rejected, id = " << id); LOG_PRINT_RED_L1("Block recognized as orphaned and rejected, id = " << id);
} }
return true; return true;
@ -899,7 +899,7 @@ bool blockchain_storage::get_blocks(uint64_t start_offset, size_t count, std::li
blocks.push_back(m_blocks[i].bl); blocks.push_back(m_blocks[i].bl);
std::list<crypto::hash> missed_ids; std::list<crypto::hash> missed_ids;
get_transactions(m_blocks[i].bl.tx_hashes, txs, missed_ids); get_transactions(m_blocks[i].bl.tx_hashes, txs, missed_ids);
CHECK_AND_ASSERT_MES(!missed_ids.size(), false, "have missed transactions in own block in main blockchain"); CHECK_AND_ASSERT_MES(!missed_ids.size(), false, "has missed transactions in own block in main blockchain");
} }
return true; return true;
@ -928,7 +928,7 @@ bool blockchain_storage::handle_get_objects(NOTIFY_REQUEST_GET_OBJECTS::request&
std::list<crypto::hash> missed_tx_id; std::list<crypto::hash> missed_tx_id;
std::list<transaction> txs; std::list<transaction> txs;
get_transactions(bl.tx_hashes, txs, rsp.missed_ids); get_transactions(bl.tx_hashes, txs, rsp.missed_ids);
CHECK_AND_ASSERT_MES(!missed_tx_id.size(), false, "Internal error: have missed missed_tx_id.size()=" << missed_tx_id.size() CHECK_AND_ASSERT_MES(!missed_tx_id.size(), false, "Internal error: has missed missed_tx_id.size()=" << missed_tx_id.size()
<< ENDL << "for block id = " << get_block_hash(bl)); << ENDL << "for block id = " << get_block_hash(bl));
rsp.blocks.push_back(block_complete_entry()); rsp.blocks.push_back(block_complete_entry());
block_complete_entry& e = rsp.blocks.back(); block_complete_entry& e = rsp.blocks.back();
@ -1110,7 +1110,7 @@ void blockchain_storage::print_blockchain(uint64_t start_index, uint64_t end_ind
CRITICAL_REGION_LOCAL(m_blockchain_lock); CRITICAL_REGION_LOCAL(m_blockchain_lock);
if(start_index >=m_blocks.size()) if(start_index >=m_blocks.size())
{ {
LOG_PRINT_L0("Wrong starter index set: " << start_index << ", expected max index " << m_blocks.size()-1); LOG_PRINT_L1("Wrong starter index set: " << start_index << ", expected max index " << m_blocks.size()-1);
return; return;
} }
@ -1205,7 +1205,7 @@ bool blockchain_storage::add_block_as_invalid(const block_extended_info& bei, co
CRITICAL_REGION_LOCAL(m_blockchain_lock); CRITICAL_REGION_LOCAL(m_blockchain_lock);
auto i_res = m_invalid_blocks.insert(std::map<crypto::hash, block_extended_info>::value_type(h, bei)); auto i_res = m_invalid_blocks.insert(std::map<crypto::hash, block_extended_info>::value_type(h, bei));
CHECK_AND_ASSERT_MES(i_res.second, false, "at insertion invalid by tx returned status existed"); CHECK_AND_ASSERT_MES(i_res.second, false, "at insertion invalid by tx returned status existed");
LOG_PRINT_L0("BLOCK ADDED AS INVALID: " << h << ENDL << ", prev_id=" << bei.bl.prev_id << ", m_invalid_blocks count=" << m_invalid_blocks.size()); LOG_PRINT_L1("BLOCK ADDED AS INVALID: " << h << ENDL << ", prev_id=" << bei.bl.prev_id << ", m_invalid_blocks count=" << m_invalid_blocks.size());
return true; return true;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
@ -1306,7 +1306,7 @@ bool blockchain_storage::add_transaction_from_block(const transaction& tx, const
if(!r.second) if(!r.second)
{ {
//double spend detected //double spend detected
LOG_PRINT_L0("tx with id: " << m_tx_id << " in block id: " << m_bl_id << " have input marked as spent with key image: " << ki << ", block declined"); LOG_PRINT_L1("tx with id: " << m_tx_id << " in block id: " << m_bl_id << " has input marked as spent with key image: " << ki << ", block declined");
return false; return false;
} }
return true; return true;
@ -1332,7 +1332,7 @@ bool blockchain_storage::add_transaction_from_block(const transaction& tx, const
auto i_r = m_transactions.insert(std::pair<crypto::hash, transaction_chain_entry>(tx_id, ch_e)); auto i_r = m_transactions.insert(std::pair<crypto::hash, transaction_chain_entry>(tx_id, ch_e));
if(!i_r.second) if(!i_r.second)
{ {
LOG_PRINT_L0("tx with id: " << tx_id << " in block id: " << bl_id << " already in blockchain"); LOG_PRINT_L1("tx with id: " << tx_id << " in block id: " << bl_id << " already in blockchain");
return false; return false;
} }
bool r = push_transaction_to_global_outs_index(tx, tx_id, i_r.first->second.m_global_output_indexes); bool r = push_transaction_to_global_outs_index(tx, tx_id, i_r.first->second.m_global_output_indexes);
@ -1349,7 +1349,7 @@ bool blockchain_storage::get_tx_outputs_gindexs(const crypto::hash& tx_id, std::
auto it = m_transactions.find(tx_id); auto it = m_transactions.find(tx_id);
if(it == m_transactions.end()) if(it == m_transactions.end())
{ {
LOG_PRINT_RED_L0("warning: get_tx_outputs_gindexs failed to find transaction with id = " << tx_id); LOG_PRINT_RED_L1("warning: get_tx_outputs_gindexs failed to find transaction with id = " << tx_id);
return false; return false;
} }
@ -1407,7 +1407,7 @@ bool blockchain_storage::check_tx_inputs(const transaction& tx, const crypto::ha
CHECK_AND_ASSERT_MES(sig_index < tx.signatures.size(), false, "wrong transaction: not signature entry for input with index= " << sig_index); CHECK_AND_ASSERT_MES(sig_index < tx.signatures.size(), false, "wrong transaction: not signature entry for input with index= " << sig_index);
if(!check_tx_input(in_to_key, tx_prefix_hash, tx.signatures[sig_index], pmax_used_block_height)) if(!check_tx_input(in_to_key, tx_prefix_hash, tx.signatures[sig_index], pmax_used_block_height))
{ {
LOG_PRINT_L0("Failed to check ring signature for tx " << get_transaction_hash(tx)); LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx));
return false; return false;
} }
@ -1453,13 +1453,13 @@ bool blockchain_storage::check_tx_input(const txin_to_key& txin, const crypto::h
//check tx unlock time //check tx unlock time
if(!m_bch.is_tx_spendtime_unlocked(tx.unlock_time)) if(!m_bch.is_tx_spendtime_unlocked(tx.unlock_time))
{ {
LOG_PRINT_L0("One of outputs for one of inputs have wrong tx.unlock_time = " << tx.unlock_time); LOG_PRINT_L1("One of outputs for one of inputs has wrong tx.unlock_time = " << tx.unlock_time);
return false; return false;
} }
if(out.target.type() != typeid(txout_to_key)) if(out.target.type() != typeid(txout_to_key))
{ {
LOG_PRINT_L0("Output have wrong type id, which=" << out.target.which()); LOG_PRINT_L1("Output has wrong type id, which=" << out.target.which());
return false; return false;
} }
@ -1473,13 +1473,13 @@ bool blockchain_storage::check_tx_input(const txin_to_key& txin, const crypto::h
outputs_visitor vi(output_keys, *this); outputs_visitor vi(output_keys, *this);
if(!scan_outputkeys_for_indexes(txin, vi, pmax_related_block_height)) if(!scan_outputkeys_for_indexes(txin, vi, pmax_related_block_height))
{ {
LOG_PRINT_L0("Failed to get output keys for tx with amount = " << print_money(txin.amount) << " and count indexes " << txin.key_offsets.size()); LOG_PRINT_L1("Failed to get output keys for tx with amount = " << print_money(txin.amount) << " and count indexes " << txin.key_offsets.size());
return false; return false;
} }
if(txin.key_offsets.size() != output_keys.size()) if(txin.key_offsets.size() != output_keys.size())
{ {
LOG_PRINT_L0("Output keys for tx with amount = " << txin.amount << " and count indexes " << txin.key_offsets.size() << " returned wrong keys count " << output_keys.size()); LOG_PRINT_L1("Output keys for tx with amount = " << txin.amount << " and count indexes " << txin.key_offsets.size() << " returned wrong keys count " << output_keys.size());
return false; return false;
} }
CHECK_AND_ASSERT_MES(sig.size() == output_keys.size(), false, "internal error: tx signatures count=" << sig.size() << " mismatch with outputs keys count for inputs=" << output_keys.size()); CHECK_AND_ASSERT_MES(sig.size() == output_keys.size(), false, "internal error: tx signatures count=" << sig.size() << " mismatch with outputs keys count for inputs=" << output_keys.size());
@ -1498,7 +1498,7 @@ bool blockchain_storage::check_block_timestamp_main(const block& b)
{ {
if(b.timestamp > get_adjusted_time() + CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT) if(b.timestamp > get_adjusted_time() + CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT)
{ {
LOG_PRINT_L0("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than adjusted time + 2 hours"); LOG_PRINT_L1("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", bigger than adjusted time + 2 hours");
return false; return false;
} }
@ -1519,7 +1519,7 @@ bool blockchain_storage::check_block_timestamp(std::vector<uint64_t> timestamps,
if(b.timestamp < median_ts) if(b.timestamp < median_ts)
{ {
LOG_PRINT_L0("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW << " blocks, " << median_ts); LOG_PRINT_L1("Timestamp of block with id: " << get_block_hash(b) << ", " << b.timestamp << ", less than median of last " << BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW << " blocks, " << median_ts);
return false; return false;
} }
@ -1532,16 +1532,16 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
CRITICAL_REGION_LOCAL(m_blockchain_lock); CRITICAL_REGION_LOCAL(m_blockchain_lock);
if(bl.prev_id != get_tail_id()) if(bl.prev_id != get_tail_id())
{ {
LOG_PRINT_L0("Block with id: " << id << ENDL LOG_PRINT_L1("Block with id: " << id << ENDL
<< "have wrong prev_id: " << bl.prev_id << ENDL << "has wrong prev_id: " << bl.prev_id << ENDL
<< "expected: " << get_tail_id()); << "expected: " << get_tail_id());
return false; return false;
} }
if(!check_block_timestamp_main(bl)) if(!check_block_timestamp_main(bl))
{ {
LOG_PRINT_L0("Block with id: " << id << ENDL LOG_PRINT_L1("Block with id: " << id << ENDL
<< "have invalid timestamp: " << bl.timestamp); << "has invalid timestamp: " << bl.timestamp);
//add_block_as_invalid(bl, id);//do not add blocks to invalid storage befor proof of work check was passed //add_block_as_invalid(bl, id);//do not add blocks to invalid storage befor proof of work check was passed
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
@ -1565,9 +1565,9 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
if(!check_hash(proof_of_work, current_diffic)) if(!check_hash(proof_of_work, current_diffic))
{ {
LOG_PRINT_L0("Block with id: " << id << ENDL LOG_PRINT_L1("Block with id: " << id << ENDL
<< "have not enough proof of work: " << proof_of_work << ENDL << "does not have enough proof of work: " << proof_of_work << ENDL
<< "nexpected difficulty: " << current_diffic ); << "unexpected difficulty: " << current_diffic );
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
} }
@ -1588,7 +1588,7 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
if(!prevalidate_miner_transaction(bl, m_blocks.size())) if(!prevalidate_miner_transaction(bl, m_blocks.size()))
{ {
LOG_PRINT_L0("Block with id: " << id LOG_PRINT_L1("Block with id: " << id
<< " failed to pass prevalidation"); << " failed to pass prevalidation");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
@ -1598,7 +1598,7 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
//process transactions //process transactions
if(!add_transaction_from_block(bl.miner_tx, get_transaction_hash(bl.miner_tx), id, get_current_blockchain_height())) if(!add_transaction_from_block(bl.miner_tx, get_transaction_hash(bl.miner_tx), id, get_current_blockchain_height()))
{ {
LOG_PRINT_L0("Block with id: " << id << " failed to add transaction to blockchain storage"); LOG_PRINT_L1("Block with id: " << id << " failed to add transaction to blockchain storage");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
} }
@ -1611,7 +1611,7 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
uint64_t fee = 0; uint64_t fee = 0;
if(!m_tx_pool.take_tx(tx_id, tx, blob_size, fee)) if(!m_tx_pool.take_tx(tx_id, tx, blob_size, fee))
{ {
LOG_PRINT_L0("Block with id: " << id << "have at least one unknown transaction with id: " << tx_id); LOG_PRINT_L1("Block with id: " << id << "has at least one unknown transaction with id: " << tx_id);
purge_block_data_from_blockchain(bl, tx_processed_count); purge_block_data_from_blockchain(bl, tx_processed_count);
//add_block_as_invalid(bl, id); //add_block_as_invalid(bl, id);
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
@ -1619,20 +1619,20 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
} }
if(!check_tx_inputs(tx)) if(!check_tx_inputs(tx))
{ {
LOG_PRINT_L0("Block with id: " << id << "have at least one transaction (id: " << tx_id << ") with wrong inputs."); LOG_PRINT_L1("Block with id: " << id << "has at least one transaction (id: " << tx_id << ") with wrong inputs.");
cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc); cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc);
bool add_res = m_tx_pool.add_tx(tx, tvc, true); bool add_res = m_tx_pool.add_tx(tx, tvc, true);
CHECK_AND_ASSERT_MES2(add_res, "handle_block_to_main_chain: failed to add transaction back to transaction pool"); CHECK_AND_ASSERT_MES2(add_res, "handle_block_to_main_chain: failed to add transaction back to transaction pool");
purge_block_data_from_blockchain(bl, tx_processed_count); purge_block_data_from_blockchain(bl, tx_processed_count);
add_block_as_invalid(bl, id); add_block_as_invalid(bl, id);
LOG_PRINT_L0("Block with id " << id << " added as invalid becouse of wrong inputs in transactions"); LOG_PRINT_L1("Block with id " << id << " added as invalid becouse of wrong inputs in transactions");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
} }
if(!add_transaction_from_block(tx, tx_id, id, get_current_blockchain_height())) if(!add_transaction_from_block(tx, tx_id, id, get_current_blockchain_height()))
{ {
LOG_PRINT_L0("Block with id: " << id << " failed to add transaction to blockchain storage"); LOG_PRINT_L1("Block with id: " << id << " failed to add transaction to blockchain storage");
cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc); cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc);
bool add_res = m_tx_pool.add_tx(tx, tvc, true); bool add_res = m_tx_pool.add_tx(tx, tvc, true);
CHECK_AND_ASSERT_MES2(add_res, "handle_block_to_main_chain: failed to add transaction back to transaction pool"); CHECK_AND_ASSERT_MES2(add_res, "handle_block_to_main_chain: failed to add transaction back to transaction pool");
@ -1648,8 +1648,8 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
uint64_t already_generated_coins = m_blocks.size() ? m_blocks.back().already_generated_coins:0; uint64_t already_generated_coins = m_blocks.size() ? m_blocks.back().already_generated_coins:0;
if(!validate_miner_transaction(bl, cumulative_block_size, fee_summary, base_reward, already_generated_coins)) if(!validate_miner_transaction(bl, cumulative_block_size, fee_summary, base_reward, already_generated_coins))
{ {
LOG_PRINT_L0("Block with id: " << id LOG_PRINT_L1("Block with id: " << id
<< " have wrong miner transaction"); << " has incorrect miner transaction");
purge_block_data_from_blockchain(bl, tx_processed_count); purge_block_data_from_blockchain(bl, tx_processed_count);
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;

34
src/cryptonote_core/cryptonote_core.cpp
View File

@ -159,7 +159,7 @@ namespace cryptonote
if(tx_blob.size() > get_max_tx_size()) if(tx_blob.size() > get_max_tx_size())
{ {
LOG_PRINT_L0("WRONG TRANSACTION BLOB, too big size " << tx_blob.size() << ", rejected"); LOG_PRINT_L1("WRONG TRANSACTION BLOB, too big size " << tx_blob.size() << ", rejected");
tvc.m_verifivation_failed = true; tvc.m_verifivation_failed = true;
return false; return false;
} }
@ -170,7 +170,7 @@ namespace cryptonote
if(!parse_tx_from_blob(tx, tx_hash, tx_prefixt_hash, tx_blob)) if(!parse_tx_from_blob(tx, tx_hash, tx_prefixt_hash, tx_blob))
{ {
LOG_PRINT_L0("WRONG TRANSACTION BLOB, Failed to parse, rejected"); LOG_PRINT_L1("WRONG TRANSACTION BLOB, Failed to parse, rejected");
tvc.m_verifivation_failed = true; tvc.m_verifivation_failed = true;
return false; return false;
} }
@ -178,23 +178,23 @@ namespace cryptonote
if(!check_tx_syntax(tx)) if(!check_tx_syntax(tx))
{ {
LOG_PRINT_L0("WRONG TRANSACTION BLOB, Failed to check tx " << tx_hash << " syntax, rejected"); LOG_PRINT_L1("WRONG TRANSACTION BLOB, Failed to check tx " << tx_hash << " syntax, rejected");
tvc.m_verifivation_failed = true; tvc.m_verifivation_failed = true;
return false; return false;
} }
if(!check_tx_semantic(tx, keeped_by_block)) if(!check_tx_semantic(tx, keeped_by_block))
{ {
LOG_PRINT_L0("WRONG TRANSACTION BLOB, Failed to check tx " << tx_hash << " semantic, rejected"); LOG_PRINT_L1("WRONG TRANSACTION BLOB, Failed to check tx " << tx_hash << " semantic, rejected");
tvc.m_verifivation_failed = true; tvc.m_verifivation_failed = true;
return false; return false;
} }
bool r = add_new_tx(tx, tx_hash, tx_prefixt_hash, tx_blob.size(), tvc, keeped_by_block); bool r = add_new_tx(tx, tx_hash, tx_prefixt_hash, tx_blob.size(), tvc, keeped_by_block);
if(tvc.m_verifivation_failed) if(tvc.m_verifivation_failed)
{LOG_PRINT_RED_L0("Transaction verification failed: " << tx_hash);} {LOG_PRINT_RED_L1("Transaction verification failed: " << tx_hash);}
else if(tvc.m_verifivation_impossible) else if(tvc.m_verifivation_impossible)
{LOG_PRINT_RED_L0("Transaction verification impossible: " << tx_hash);} {LOG_PRINT_RED_L1("Transaction verification impossible: " << tx_hash);}
if(tvc.m_added_to_pool) if(tvc.m_added_to_pool)
LOG_PRINT_L1("tx added: " << tx_hash); LOG_PRINT_L1("tx added: " << tx_hash);
@ -216,25 +216,25 @@ namespace cryptonote
{ {
if(!tx.vin.size()) if(!tx.vin.size())
{ {
LOG_PRINT_RED_L0("tx with empty inputs, rejected for tx id= " << get_transaction_hash(tx)); LOG_PRINT_RED_L1("tx with empty inputs, rejected for tx id= " << get_transaction_hash(tx));
return false; return false;
} }
if(!check_inputs_types_supported(tx)) if(!check_inputs_types_supported(tx))
{ {
LOG_PRINT_RED_L0("unsupported input types for tx id= " << get_transaction_hash(tx)); LOG_PRINT_RED_L1("unsupported input types for tx id= " << get_transaction_hash(tx));
return false; return false;
} }
if(!check_outs_valid(tx)) if(!check_outs_valid(tx))
{ {
LOG_PRINT_RED_L0("tx with invalid outputs, rejected for tx id= " << get_transaction_hash(tx)); LOG_PRINT_RED_L1("tx with invalid outputs, rejected for tx id= " << get_transaction_hash(tx));
return false; return false;
} }
if(!check_money_overflow(tx)) if(!check_money_overflow(tx))
{ {
LOG_PRINT_RED_L0("tx have money overflow, rejected for tx id= " << get_transaction_hash(tx)); LOG_PRINT_RED_L1("tx has money overflow, rejected for tx id= " << get_transaction_hash(tx));
return false; return false;
} }
@ -244,20 +244,20 @@ namespace cryptonote
if(amount_in <= amount_out) if(amount_in <= amount_out)
{ {
LOG_PRINT_RED_L0("tx with wrong amounts: ins " << amount_in << ", outs " << amount_out << ", rejected for tx id= " << get_transaction_hash(tx)); LOG_PRINT_RED_L1("tx with wrong amounts: ins " << amount_in << ", outs " << amount_out << ", rejected for tx id= " << get_transaction_hash(tx));
return false; return false;
} }
if(!keeped_by_block && get_object_blobsize(tx) >= m_blockchain_storage.get_current_comulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE) if(!keeped_by_block && get_object_blobsize(tx) >= m_blockchain_storage.get_current_comulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE)
{ {
LOG_PRINT_RED_L0("tx have to big size " << get_object_blobsize(tx) << ", expected not bigger than " << m_blockchain_storage.get_current_comulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE); LOG_PRINT_RED_L1("tx is too large " << get_object_blobsize(tx) << ", expected not bigger than " << m_blockchain_storage.get_current_comulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
return false; return false;
} }
//check if tx use different key images //check if tx use different key images
if(!check_tx_inputs_keyimages_diff(tx)) if(!check_tx_inputs_keyimages_diff(tx))
{ {
LOG_PRINT_RED_L0("tx have to big size " << get_object_blobsize(tx) << ", expected not bigger than " << m_blockchain_storage.get_current_comulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE); LOG_PRINT_RED_L1("tx is too large " << get_object_blobsize(tx) << ", expected not bigger than " << m_blockchain_storage.get_current_comulative_blocksize_limit() - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE);
return false; return false;
} }
@ -385,7 +385,7 @@ namespace cryptonote
m_blockchain_storage.get_transactions(b.tx_hashes, txs, missed_txs); m_blockchain_storage.get_transactions(b.tx_hashes, txs, missed_txs);
if(missed_txs.size() && m_blockchain_storage.get_block_id_by_height(get_block_height(b)) != get_block_hash(b)) if(missed_txs.size() && m_blockchain_storage.get_block_id_by_height(get_block_height(b)) != get_block_hash(b))
{ {
LOG_PRINT_L0("Block found but, seems that reorganize just happened after that, do not relay this block"); LOG_PRINT_L1("Block found but, seems that reorganize just happened after that, do not relay this block");
return true; return true;
} }
CHECK_AND_ASSERT_MES(txs.size() == b.tx_hashes.size() && !missed_txs.size(), false, "cant find some transactions in found block:" << get_block_hash(b) << " txs.size()=" << txs.size() CHECK_AND_ASSERT_MES(txs.size() == b.tx_hashes.size() && !missed_txs.size(), false, "cant find some transactions in found block:" << get_block_hash(b) << " txs.size()=" << txs.size()
@ -420,7 +420,7 @@ namespace cryptonote
bvc = boost::value_initialized<block_verification_context>(); bvc = boost::value_initialized<block_verification_context>();
if(block_blob.size() > get_max_block_size()) if(block_blob.size() > get_max_block_size())
{ {
LOG_PRINT_L0("WRONG BLOCK BLOB, too big size " << block_blob.size() << ", rejected"); LOG_PRINT_L1("WRONG BLOCK BLOB, too big size " << block_blob.size() << ", rejected");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
} }
@ -428,7 +428,7 @@ namespace cryptonote
block b = AUTO_VAL_INIT(b); block b = AUTO_VAL_INIT(b);
if(!parse_and_validate_block_from_blob(block_blob, b)) if(!parse_and_validate_block_from_blob(block_blob, b))
{ {
LOG_PRINT_L0("Failed to parse and validate new block"); LOG_PRINT_L1("Failed to parse and validate new block");
bvc.m_verifivation_failed = true; bvc.m_verifivation_failed = true;
return false; return false;
} }
@ -444,7 +444,7 @@ namespace cryptonote
{ {
if(block_blob.size() > get_max_block_size()) if(block_blob.size() > get_max_block_size())
{ {
LOG_PRINT_L0("WRONG BLOCK BLOB, too big size " << block_blob.size() << ", rejected"); LOG_PRINT_L1("WRONG BLOCK BLOB, too big size " << block_blob.size() << ", rejected");
return false; return false;
} }
return true; return true;

12
src/cryptonote_core/tx_pool.cpp
View File

@ -80,7 +80,7 @@ namespace cryptonote
if(outputs_amount >= inputs_amount) if(outputs_amount >= inputs_amount)
{ {
LOG_PRINT_L0("transaction use more money then it has: use " << print_money(outputs_amount) << ", have " << print_money(inputs_amount)); LOG_PRINT_L1("transaction use more money then it has: use " << print_money(outputs_amount) << ", have " << print_money(inputs_amount));
tvc.m_verifivation_failed = true; tvc.m_verifivation_failed = true;
return false; return false;
} }
@ -134,7 +134,7 @@ namespace cryptonote
tvc.m_added_to_pool = true; tvc.m_added_to_pool = true;
}else }else
{ {
LOG_PRINT_L0("tx used wrong inputs, rejected"); LOG_PRINT_L1("tx used wrong inputs, rejected");
tvc.m_verifivation_failed = true; tvc.m_verifivation_failed = true;
return false; return false;
} }
@ -242,7 +242,7 @@ namespace cryptonote
if((tx_age > CRYPTONOTE_MEMPOOL_TX_LIVETIME && !it->second.kept_by_block) || if((tx_age > CRYPTONOTE_MEMPOOL_TX_LIVETIME && !it->second.kept_by_block) ||
(tx_age > CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME && it->second.kept_by_block) ) (tx_age > CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME && it->second.kept_by_block) )
{ {
LOG_PRINT_L0("Tx " << it->first << " removed from tx pool due to outdated, age: " << tx_age ); LOG_PRINT_L1("Tx " << it->first << " removed from tx pool due to outdated, age: " << tx_age );
m_transactions.erase(it++); m_transactions.erase(it++);
}else }else
++it; ++it;
@ -476,7 +476,7 @@ namespace cryptonote
for (auto it = m_transactions.begin(); it != m_transactions.end(); ) { for (auto it = m_transactions.begin(); it != m_transactions.end(); ) {
auto it2 = it++; auto it2 = it++;
if (it2->second.blob_size >= TRANSACTION_SIZE_LIMIT) { if (it2->second.blob_size >= TRANSACTION_SIZE_LIMIT) {
LOG_PRINT_L0("Transaction " << get_transaction_hash(it2->second.tx) << " is too big (" << it2->second.blob_size << " bytes), removing it from pool"); LOG_PRINT_L1("Transaction " << get_transaction_hash(it2->second.tx) << " is too big (" << it2->second.blob_size << " bytes), removing it from pool");
remove_transaction_keyimages(it2->second.tx); remove_transaction_keyimages(it2->second.tx);
m_transactions.erase(it2); m_transactions.erase(it2);
} }
@ -491,7 +491,7 @@ namespace cryptonote
{ {
if (!tools::create_directories_if_necessary(m_config_folder)) if (!tools::create_directories_if_necessary(m_config_folder))
{ {
LOG_PRINT_L0("Failed to create data directory: " << m_config_folder); LOG_PRINT_L1("Failed to create data directory: " << m_config_folder);
return false; return false;
} }
@ -499,7 +499,7 @@ namespace cryptonote
bool res = tools::serialize_obj_to_file(*this, state_file_path); bool res = tools::serialize_obj_to_file(*this, state_file_path);
if(!res) if(!res)
{ {
LOG_PRINT_L0("Failed to serialize memory pool to file " << state_file_path); LOG_PRINT_L1("Failed to serialize memory pool to file " << state_file_path);
} }
return true; return true;
} }

10
src/cryptonote_protocol/cryptonote_protocol_handler.inl
View File

@ -225,7 +225,7 @@ namespace cryptonote
m_core.handle_incoming_tx(*tx_blob_it, tvc, true); m_core.handle_incoming_tx(*tx_blob_it, tvc, true);
if(tvc.m_verifivation_failed) if(tvc.m_verifivation_failed)
{ {
LOG_PRINT_CCONTEXT_L0("Block verification failed: transaction verification failed, dropping connection"); LOG_PRINT_CCONTEXT_L1("Block verification failed: transaction verification failed, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }
@ -238,7 +238,7 @@ namespace cryptonote
m_core.resume_mine(); m_core.resume_mine();
if(bvc.m_verifivation_failed) if(bvc.m_verifivation_failed)
{ {
LOG_PRINT_CCONTEXT_L0("Block verification failed, dropping connection"); LOG_PRINT_CCONTEXT_L1("Block verification failed, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }
@ -272,7 +272,7 @@ namespace cryptonote
m_core.handle_incoming_tx(*tx_blob_it, tvc, false); m_core.handle_incoming_tx(*tx_blob_it, tvc, false);
if(tvc.m_verifivation_failed) if(tvc.m_verifivation_failed)
{ {
LOG_PRINT_CCONTEXT_L0("Tx verification failed, dropping connection"); LOG_PRINT_CCONTEXT_L1("Tx verification failed, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }
@ -404,13 +404,13 @@ namespace cryptonote
if(bvc.m_verifivation_failed) if(bvc.m_verifivation_failed)
{ {
LOG_PRINT_CCONTEXT_L0("Block verification failed, dropping connection"); LOG_PRINT_CCONTEXT_L1("Block verification failed, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }
if(bvc.m_marked_as_orphaned) if(bvc.m_marked_as_orphaned)
{ {
LOG_PRINT_CCONTEXT_L0("Block received at sync phase was marked as orphaned, dropping connection"); LOG_PRINT_CCONTEXT_L1("Block received at sync phase was marked as orphaned, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }

34
src/daemon/daemon.cpp
View File

@ -169,20 +169,20 @@ int main(int argc, char* argv[])
daemon_cmmands_handler dch(p2psrv); daemon_cmmands_handler dch(p2psrv);
//initialize objects //initialize objects
LOG_PRINT_L0("Initializing p2p server..."); LOG_PRINT_L0("Initializing P2P server...");
res = p2psrv.init(vm); res = p2psrv.init(vm);
CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize p2p server."); CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize P2P server.");
LOG_PRINT_L0("P2p server initialized OK"); LOG_PRINT_L0("P2P server initialized OK");
LOG_PRINT_L0("Initializing cryptonote protocol..."); LOG_PRINT_L0("Initializing protocol...");
res = cprotocol.init(vm); res = cprotocol.init(vm);
CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize cryptonote protocol."); CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize protocol.");
LOG_PRINT_L0("Cryptonote protocol initialized OK"); LOG_PRINT_L0("Protocol initialized OK");
LOG_PRINT_L0("Initializing core rpc server..."); LOG_PRINT_L0("Initializing core RPC server...");
res = rpc_server.init(vm); res = rpc_server.init(vm);
CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize core rpc server."); CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize core RPC server.");
LOG_PRINT_GREEN("Core rpc server initialized OK on port: " << rpc_server.get_binded_port(), LOG_LEVEL_0); LOG_PRINT_GREEN("Core RPC server initialized OK on port: " << rpc_server.get_binded_port(), LOG_LEVEL_0);
//initialize core here //initialize core here
LOG_PRINT_L0("Initializing core..."); LOG_PRINT_L0("Initializing core...");
@ -196,19 +196,19 @@ int main(int argc, char* argv[])
dch.start_handling(); dch.start_handling();
} }
LOG_PRINT_L0("Starting core rpc server..."); LOG_PRINT_L0("Starting core RPC server...");
res = rpc_server.run(2, false); res = rpc_server.run(2, false);
CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize core rpc server."); CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize core RPC server.");
LOG_PRINT_L0("Core rpc server started ok"); LOG_PRINT_L0("Core RPC server started ok");
tools::signal_handler::install([&dch, &p2psrv] { tools::signal_handler::install([&dch, &p2psrv] {
dch.stop_handling(); dch.stop_handling();
p2psrv.send_stop_signal(); p2psrv.send_stop_signal();
}); });
LOG_PRINT_L0("Starting p2p net loop..."); LOG_PRINT_L0("Starting P2P net loop...");
p2psrv.run(); p2psrv.run();
LOG_PRINT_L0("p2p net loop stopped"); LOG_PRINT_L0("P2P net loop stopped");
//stop components //stop components
LOG_PRINT_L0("Stopping core rpc server..."); LOG_PRINT_L0("Stopping core rpc server...");
@ -218,11 +218,11 @@ int main(int argc, char* argv[])
//deinitialize components //deinitialize components
LOG_PRINT_L0("Deinitializing core..."); LOG_PRINT_L0("Deinitializing core...");
ccore.deinit(); ccore.deinit();
LOG_PRINT_L0("Deinitializing rpc server ..."); LOG_PRINT_L0("Deinitializing RPC server ...");
rpc_server.deinit(); rpc_server.deinit();
LOG_PRINT_L0("Deinitializing cryptonote_protocol..."); LOG_PRINT_L0("Deinitializing protocol...");
cprotocol.deinit(); cprotocol.deinit();
LOG_PRINT_L0("Deinitializing p2p..."); LOG_PRINT_L0("Deinitializing P2P...");
p2psrv.deinit(); p2psrv.deinit();

8
src/p2p/net_node.inl
View File

@ -261,7 +261,7 @@ namespace nodetool
CHECK_AND_ASSERT_MES(res, false, "Failed to bind server"); CHECK_AND_ASSERT_MES(res, false, "Failed to bind server");
m_listenning_port = m_net_server.get_binded_port(); m_listenning_port = m_net_server.get_binded_port();
LOG_PRINT_GREEN("Net service binded on " << m_bind_ip << ":" << m_listenning_port, LOG_LEVEL_0); LOG_PRINT_GREEN("Net service bound to " << m_bind_ip << ":" << m_listenning_port, LOG_LEVEL_0);
if(m_external_port) if(m_external_port)
LOG_PRINT_L0("External port defined as " << m_external_port); LOG_PRINT_L0("External port defined as " << m_external_port);
@ -541,7 +541,7 @@ namespace nodetool
#define LOG_PRINT_CC_PRIORITY_NODE(priority, con, msg) \ #define LOG_PRINT_CC_PRIORITY_NODE(priority, con, msg) \
do { \ do { \
if (priority) {\ if (priority) {\
LOG_PRINT_CC_L0(con, msg); \ LOG_PRINT_CC_L1(con, msg); \
} else {\ } else {\
LOG_PRINT_CC_L1(con, msg); \ LOG_PRINT_CC_L1(con, msg); \
} \ } \
@ -780,7 +780,7 @@ namespace nodetool
{ {
if(be.last_seen > local_time) if(be.last_seen > local_time)
{ {
LOG_PRINT_RED_L0("FOUND FUTURE peerlist for entry " << epee::string_tools::get_ip_string_from_int32(be.adr.ip) << ":" << be.adr.port << " last_seen: " << be.last_seen << ", local_time(on remote node):" << local_time); LOG_PRINT_RED_L1("FOUND FUTURE peerlist for entry " << epee::string_tools::get_ip_string_from_int32(be.adr.ip) << ":" << be.adr.port << " last_seen: " << be.last_seen << ", local_time(on remote node):" << local_time);
return false; return false;
} }
be.last_seen += delta; be.last_seen += delta;
@ -1034,7 +1034,7 @@ namespace nodetool
if(arg.node_data.network_id != MONERO_NETWORK) if(arg.node_data.network_id != MONERO_NETWORK)
{ {
LOG_PRINT_CCONTEXT_L0("WRONG NETWORK AGENT CONNECTED! id=" << epee::string_tools::get_str_from_guid_a(arg.node_data.network_id)); LOG_PRINT_CCONTEXT_L1("WRONG NETWORK AGENT CONNECTED! id=" << epee::string_tools::get_str_from_guid_a(arg.node_data.network_id));
drop_connection(context); drop_connection(context);
return 1; return 1;
} }