mirror of
https://codeberg.org/anoncontributorxmr/monero.git
synced 2024-11-22 23:42:24 +00:00
Replace tabs with two spaces for consistency with rest of codebase
Remove trailing whitespace in same files.
This commit is contained in:
warptangent
parent
042e85396c
commit
725acc7f17
26 changed files with 1321 additions and 1323 deletions
|
|
@ -46,30 +46,30 @@ function (die msg)
|
||||||
endfunction ()
|
endfunction ()
|
||||||
|
|
||||||
if (NOT ${ARCH} STREQUAL "")
|
if (NOT ${ARCH} STREQUAL "")
|
||||||
string(SUBSTRING ${ARCH} 0 3 IS_ARM)
|
string(SUBSTRING ${ARCH} 0 3 IS_ARM)
|
||||||
string(TOLOWER ${IS_ARM} IS_ARM)
|
string(TOLOWER ${IS_ARM} IS_ARM)
|
||||||
|
|
||||||
if (${IS_ARM} STREQUAL "arm")
|
if (${IS_ARM} STREQUAL "arm")
|
||||||
string(SUBSTRING ${ARCH} 0 5 ARM_TEST)
|
string(SUBSTRING ${ARCH} 0 5 ARM_TEST)
|
||||||
string(TOLOWER ${ARM_TEST} ARM_TEST)
|
string(TOLOWER ${ARM_TEST} ARM_TEST)
|
||||||
|
|
||||||
if (${ARM_TEST} STREQUAL "armv6")
|
if (${ARM_TEST} STREQUAL "armv6")
|
||||||
set(ARM6 1)
|
set(ARM6 1)
|
||||||
else()
|
else()
|
||||||
set(ARM6 0)
|
set(ARM6 0)
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
if (${ARM_TEST} STREQUAL "armv7")
|
if (${ARM_TEST} STREQUAL "armv7")
|
||||||
set(ARM7 1)
|
set(ARM7 1)
|
||||||
else()
|
else()
|
||||||
set(ARM7 0)
|
set(ARM7 0)
|
||||||
endif()
|
endif()
|
||||||
endif()
|
endif()
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
if(WIN32 OR ARM7 OR ARM6)
|
if(WIN32 OR ARM7 OR ARM6)
|
||||||
set(CMAKE_C_FLAGS_RELEASE "-O2 -DNDEBUG")
|
set(CMAKE_C_FLAGS_RELEASE "-O2 -DNDEBUG")
|
||||||
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
|
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
# set this to 0 if per-block checkpoint needs to be disabled
|
# set this to 0 if per-block checkpoint needs to be disabled
|
||||||
|
|
@ -198,23 +198,23 @@ if (DATABASE STREQUAL "lmdb")
|
||||||
# temporarily allow mingw to compile with berkeley_db,
|
# temporarily allow mingw to compile with berkeley_db,
|
||||||
# regardless if building static or not
|
# regardless if building static or not
|
||||||
if(NOT STATIC OR MINGW)
|
if(NOT STATIC OR MINGW)
|
||||||
find_package(BerkeleyDB)
|
find_package(BerkeleyDB)
|
||||||
|
|
||||||
if(NOT BERKELEY_DB_LIBRARIES)
|
if(NOT BERKELEY_DB_LIBRARIES)
|
||||||
message(STATUS "BerkeleyDB not found and has been disabled.")
|
message(STATUS "BerkeleyDB not found and has been disabled.")
|
||||||
else()
|
else()
|
||||||
message(STATUS "Found BerkeleyDB include (db.h) in ${BERKELEY_DB_INCLUDE_DIR}")
|
message(STATUS "Found BerkeleyDB include (db.h) in ${BERKELEY_DB_INCLUDE_DIR}")
|
||||||
if(BERKELEY_DB_LIBRARIES)
|
if(BERKELEY_DB_LIBRARIES)
|
||||||
message(STATUS "Found BerkeleyDB shared library")
|
message(STATUS "Found BerkeleyDB shared library")
|
||||||
set(BDB_STATIC false CACHE BOOL "BDB Static flag")
|
set(BDB_STATIC false CACHE BOOL "BDB Static flag")
|
||||||
set(BDB_INCLUDE ${BERKELEY_DB_INCLUDE_DIR} CACHE STRING "BDB include path")
|
set(BDB_INCLUDE ${BERKELEY_DB_INCLUDE_DIR} CACHE STRING "BDB include path")
|
||||||
set(BDB_LIBRARY ${BERKELEY_DB_LIBRARIES} CACHE STRING "BDB library name")
|
set(BDB_LIBRARY ${BERKELEY_DB_LIBRARIES} CACHE STRING "BDB library name")
|
||||||
set(BDB_LIBRARY_DIRS "" CACHE STRING "BDB Library dirs")
|
set(BDB_LIBRARY_DIRS "" CACHE STRING "BDB Library dirs")
|
||||||
set(BERKELEY_DB 1)
|
set(BERKELEY_DB 1)
|
||||||
else()
|
else()
|
||||||
message(STATUS "Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev or the equivalent")
|
message(STATUS "Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev or the equivalent")
|
||||||
endif()
|
endif()
|
||||||
endif()
|
endif()
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
if (BERKELEY_DB AND (ARCH_WIDTH STREQUAL "32" OR ARM6 OR ARM7))
|
if (BERKELEY_DB AND (ARCH_WIDTH STREQUAL "32" OR ARM6 OR ARM7))
|
||||||
|
|
|
||||||
|
|
@ -105,5 +105,5 @@ add_subdirectory(daemon)
|
||||||
add_subdirectory(blockchain_utilities)
|
add_subdirectory(blockchain_utilities)
|
||||||
|
|
||||||
if(PER_BLOCK_CHECKPOINT)
|
if(PER_BLOCK_CHECKPOINT)
|
||||||
add_subdirectory(blocks)
|
add_subdirectory(blocks)
|
||||||
endif()
|
endif()
|
||||||
|
|
|
||||||
|
|
@ -99,18 +99,18 @@ private:
|
||||||
template <typename T>
|
template <typename T>
|
||||||
class bdb_safe_buffer
|
class bdb_safe_buffer
|
||||||
{
|
{
|
||||||
// limit the number of buffers to 8
|
// limit the number of buffers to 8
|
||||||
const size_t MaxAllowedBuffers = 8;
|
const size_t MaxAllowedBuffers = 8;
|
||||||
public:
|
public:
|
||||||
bdb_safe_buffer(size_t num_buffers, size_t count)
|
bdb_safe_buffer(size_t num_buffers, size_t count)
|
||||||
{
|
{
|
||||||
if(num_buffers > MaxAllowedBuffers)
|
if(num_buffers > MaxAllowedBuffers)
|
||||||
num_buffers = MaxAllowedBuffers;
|
num_buffers = MaxAllowedBuffers;
|
||||||
|
|
||||||
set_count(num_buffers);
|
set_count(num_buffers);
|
||||||
for (size_t i = 0; i < num_buffers; i++)
|
for (size_t i = 0; i < num_buffers; i++)
|
||||||
m_buffers.push_back((T) malloc(sizeof(T) * count));
|
m_buffers.push_back((T) malloc(sizeof(T) * count));
|
||||||
m_buffer_count = count;
|
m_buffer_count = count;
|
||||||
}
|
}
|
||||||
|
|
||||||
~bdb_safe_buffer()
|
~bdb_safe_buffer()
|
||||||
|
|
|
||||||
|
|
@ -139,9 +139,9 @@ typedef std::pair<crypto::hash, uint64_t> tx_out_index;
|
||||||
#pragma pack(push, 1)
|
#pragma pack(push, 1)
|
||||||
struct output_data_t
|
struct output_data_t
|
||||||
{
|
{
|
||||||
crypto::public_key pubkey;
|
crypto::public_key pubkey;
|
||||||
uint64_t unlock_time;
|
uint64_t unlock_time;
|
||||||
uint64_t height;
|
uint64_t height;
|
||||||
};
|
};
|
||||||
#pragma pack(pop)
|
#pragma pack(pop)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -72,19 +72,19 @@ struct lmdb_cur
|
||||||
done = false;
|
done = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
~lmdb_cur()
|
~lmdb_cur()
|
||||||
{
|
{
|
||||||
close();
|
close();
|
||||||
}
|
}
|
||||||
|
|
||||||
operator MDB_cursor*()
|
operator MDB_cursor*()
|
||||||
{
|
{
|
||||||
return m_cur;
|
return m_cur;
|
||||||
}
|
}
|
||||||
operator MDB_cursor**()
|
operator MDB_cursor**()
|
||||||
{
|
{
|
||||||
return &m_cur;
|
return &m_cur;
|
||||||
}
|
}
|
||||||
|
|
||||||
void close()
|
void close()
|
||||||
{
|
{
|
||||||
|
|
@ -103,8 +103,8 @@ private:
|
||||||
template<typename T>
|
template<typename T>
|
||||||
struct MDB_val_copy: public MDB_val
|
struct MDB_val_copy: public MDB_val
|
||||||
{
|
{
|
||||||
MDB_val_copy(const T &t) :
|
MDB_val_copy(const T &t) :
|
||||||
t_copy(t)
|
t_copy(t)
|
||||||
{
|
{
|
||||||
mv_size = sizeof (T);
|
mv_size = sizeof (T);
|
||||||
mv_data = &t_copy;
|
mv_data = &t_copy;
|
||||||
|
|
@ -116,8 +116,8 @@ private:
|
||||||
template<>
|
template<>
|
||||||
struct MDB_val_copy<cryptonote::blobdata>: public MDB_val
|
struct MDB_val_copy<cryptonote::blobdata>: public MDB_val
|
||||||
{
|
{
|
||||||
MDB_val_copy(const cryptonote::blobdata &bd) :
|
MDB_val_copy(const cryptonote::blobdata &bd) :
|
||||||
data(new char[bd.size()])
|
data(new char[bd.size()])
|
||||||
{
|
{
|
||||||
memcpy(data.get(), bd.data(), bd.size());
|
memcpy(data.get(), bd.data(), bd.size());
|
||||||
mv_size = bd.size();
|
mv_size = bd.size();
|
||||||
|
|
@ -130,8 +130,8 @@ private:
|
||||||
template<>
|
template<>
|
||||||
struct MDB_val_copy<const char*>: public MDB_val
|
struct MDB_val_copy<const char*>: public MDB_val
|
||||||
{
|
{
|
||||||
MDB_val_copy(const char *s) :
|
MDB_val_copy(const char *s) :
|
||||||
data(strdup(s))
|
data(strdup(s))
|
||||||
{
|
{
|
||||||
mv_size = strlen(s) + 1; // include the NUL, makes it easier for compares
|
mv_size = strlen(s) + 1; // include the NUL, makes it easier for compares
|
||||||
mv_data = data.get();
|
mv_data = data.get();
|
||||||
|
|
@ -160,16 +160,16 @@ auto compare_uint8 = [](const MDB_val *a, const MDB_val *b)
|
||||||
|
|
||||||
int compare_hash32(const MDB_val *a, const MDB_val *b)
|
int compare_hash32(const MDB_val *a, const MDB_val *b)
|
||||||
{
|
{
|
||||||
uint32_t *va = (uint32_t*) a->mv_data;
|
uint32_t *va = (uint32_t*) a->mv_data;
|
||||||
uint32_t *vb = (uint32_t*) b->mv_data;
|
uint32_t *vb = (uint32_t*) b->mv_data;
|
||||||
for (int n = 7; n >= 0; n--)
|
for (int n = 7; n >= 0; n--)
|
||||||
{
|
{
|
||||||
if (va[n] == vb[n])
|
if (va[n] == vb[n])
|
||||||
continue;
|
continue;
|
||||||
return va[n] < vb[n] ? -1 : 1;
|
return va[n] < vb[n] ? -1 : 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int compare_string(const MDB_val *a, const MDB_val *b)
|
int compare_string(const MDB_val *a, const MDB_val *b)
|
||||||
|
|
@ -313,18 +313,18 @@ void BlockchainLMDB::do_resize(uint64_t increase_size)
|
||||||
// check disk capacity
|
// check disk capacity
|
||||||
try
|
try
|
||||||
{
|
{
|
||||||
boost::filesystem::path path(m_folder);
|
boost::filesystem::path path(m_folder);
|
||||||
boost::filesystem::space_info si = boost::filesystem::space(path);
|
boost::filesystem::space_info si = boost::filesystem::space(path);
|
||||||
if(si.available < add_size)
|
if(si.available < add_size)
|
||||||
{
|
{
|
||||||
LOG_PRINT_RED_L0("!! WARNING: Insufficient free space to extend database !!: " << si.available / 1LL << 20L);
|
LOG_PRINT_RED_L0("!! WARNING: Insufficient free space to extend database !!: " << si.available / 1LL << 20L);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
catch(...)
|
catch(...)
|
||||||
{
|
{
|
||||||
// print something but proceed.
|
// print something but proceed.
|
||||||
LOG_PRINT_YELLOW("Unable to query free disk space.", LOG_LEVEL_0);
|
LOG_PRINT_YELLOW("Unable to query free disk space.", LOG_LEVEL_0);
|
||||||
}
|
}
|
||||||
|
|
||||||
MDB_envinfo mei;
|
MDB_envinfo mei;
|
||||||
|
|
@ -417,7 +417,7 @@ bool BlockchainLMDB::need_resize(uint64_t threshold_size) const
|
||||||
}
|
}
|
||||||
return false;
|
return false;
|
||||||
#else
|
#else
|
||||||
return false;
|
return false;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -505,7 +505,7 @@ uint64_t BlockchainLMDB::get_estimated_batch_size(uint64_t batch_num_blocks) con
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::add_block(const block& blk, const size_t& block_size, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated,
|
void BlockchainLMDB::add_block(const block& blk, const size_t& block_size, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated,
|
||||||
const crypto::hash& blk_hash)
|
const crypto::hash& blk_hash)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
check_open();
|
check_open();
|
||||||
|
|
@ -685,15 +685,15 @@ void BlockchainLMDB::add_output(const crypto::hash& tx_hash, const tx_out& tx_ou
|
||||||
|
|
||||||
if (tx_output.target.type() == typeid(txout_to_key))
|
if (tx_output.target.type() == typeid(txout_to_key))
|
||||||
{
|
{
|
||||||
output_data_t od;
|
output_data_t od;
|
||||||
od.pubkey = boost::get < txout_to_key > (tx_output.target).key;
|
od.pubkey = boost::get < txout_to_key > (tx_output.target).key;
|
||||||
od.unlock_time = unlock_time;
|
od.unlock_time = unlock_time;
|
||||||
od.height = m_height;
|
od.height = m_height;
|
||||||
|
|
||||||
MDB_val_copy<output_data_t> data(od);
|
MDB_val_copy<output_data_t> data(od);
|
||||||
//MDB_val_copy<crypto::public_key> val_pubkey(boost::get<txout_to_key>(tx_output.target).key);
|
//MDB_val_copy<crypto::public_key> val_pubkey(boost::get<txout_to_key>(tx_output.target).key);
|
||||||
if (mdb_put(*m_write_txn, m_output_keys, &k, &data, 0))
|
if (mdb_put(*m_write_txn, m_output_keys, &k, &data, 0))
|
||||||
throw0(DB_ERROR("Failed to add output pubkey to db transaction"));
|
throw0(DB_ERROR("Failed to add output pubkey to db transaction"));
|
||||||
}
|
}
|
||||||
|
|
||||||
m_num_outputs++;
|
m_num_outputs++;
|
||||||
|
|
@ -894,14 +894,14 @@ tx_out BlockchainLMDB::output_from_blob(const blobdata& blob) const
|
||||||
uint64_t BlockchainLMDB::get_output_global_index(const uint64_t& amount, const uint64_t& index)
|
uint64_t BlockchainLMDB::get_output_global_index(const uint64_t& amount, const uint64_t& index)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
std::vector <uint64_t> offsets;
|
std::vector <uint64_t> offsets;
|
||||||
std::vector <uint64_t> global_indices;
|
std::vector <uint64_t> global_indices;
|
||||||
offsets.push_back(index);
|
offsets.push_back(index);
|
||||||
get_output_global_indices(amount, offsets, global_indices);
|
get_output_global_indices(amount, offsets, global_indices);
|
||||||
if (!global_indices.size())
|
if (!global_indices.size())
|
||||||
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
|
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
|
||||||
|
|
||||||
return global_indices[0];
|
return global_indices[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::check_open() const
|
void BlockchainLMDB::check_open() const
|
||||||
|
|
@ -956,7 +956,7 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
|
||||||
|
|
||||||
// check for existing LMDB files in base directory
|
// check for existing LMDB files in base directory
|
||||||
boost::filesystem::path old_files = direc.parent_path();
|
boost::filesystem::path old_files = direc.parent_path();
|
||||||
if (boost::filesystem::exists(old_files / "data.mdb") || boost::filesystem::exists(old_files / "lock.mdb"))
|
if (boost::filesystem::exists(old_files / "data.mdb") || boost::filesystem::exists(old_files / "lock.mdb"))
|
||||||
{
|
{
|
||||||
LOG_PRINT_L0("Found existing LMDB files in " << old_files.string());
|
LOG_PRINT_L0("Found existing LMDB files in " << old_files.string());
|
||||||
LOG_PRINT_L0("Move data.mdb and/or lock.mdb to " << filename << ", or delete them, and then restart");
|
LOG_PRINT_L0("Move data.mdb and/or lock.mdb to " << filename << ", or delete them, and then restart");
|
||||||
|
|
@ -1022,7 +1022,7 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
|
||||||
|
|
||||||
lmdb_db_open(txn, LMDB_OUTPUT_TXS, MDB_INTEGERKEY | MDB_CREATE, m_output_txs, "Failed to open db handle for m_output_txs");
|
lmdb_db_open(txn, LMDB_OUTPUT_TXS, MDB_INTEGERKEY | MDB_CREATE, m_output_txs, "Failed to open db handle for m_output_txs");
|
||||||
lmdb_db_open(txn, LMDB_OUTPUT_INDICES, MDB_INTEGERKEY | MDB_CREATE, m_output_indices, "Failed to open db handle for m_output_indices");
|
lmdb_db_open(txn, LMDB_OUTPUT_INDICES, MDB_INTEGERKEY | MDB_CREATE, m_output_indices, "Failed to open db handle for m_output_indices");
|
||||||
lmdb_db_open(txn, LMDB_OUTPUT_AMOUNTS, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_output_amounts, "Failed to open db handle for m_output_amounts");
|
lmdb_db_open(txn, LMDB_OUTPUT_AMOUNTS, MDB_INTEGERKEY | MDB_DUPSORT | MDB_DUPFIXED | MDB_CREATE, m_output_amounts, "Failed to open db handle for m_output_amounts");
|
||||||
lmdb_db_open(txn, LMDB_OUTPUT_KEYS, MDB_INTEGERKEY | MDB_CREATE, m_output_keys, "Failed to open db handle for m_output_keys");
|
lmdb_db_open(txn, LMDB_OUTPUT_KEYS, MDB_INTEGERKEY | MDB_CREATE, m_output_keys, "Failed to open db handle for m_output_keys");
|
||||||
|
|
||||||
lmdb_db_open(txn, LMDB_SPENT_KEYS, MDB_CREATE, m_spent_keys, "Failed to open db handle for m_spent_keys");
|
lmdb_db_open(txn, LMDB_SPENT_KEYS, MDB_CREATE, m_spent_keys, "Failed to open db handle for m_spent_keys");
|
||||||
|
|
@ -1057,26 +1057,26 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
|
||||||
|
|
||||||
bool compatible = true;
|
bool compatible = true;
|
||||||
|
|
||||||
// ND: This "new" version of the lmdb database is incompatible with
|
// ND: This "new" version of the lmdb database is incompatible with
|
||||||
// the previous version. Ensure that the output_keys database is
|
// the previous version. Ensure that the output_keys database is
|
||||||
// sizeof(output_data_t) in length. Otherwise, inform user and
|
// sizeof(output_data_t) in length. Otherwise, inform user and
|
||||||
// terminate.
|
// terminate.
|
||||||
if(m_height > 0)
|
if(m_height > 0)
|
||||||
{
|
{
|
||||||
MDB_val_copy<uint64_t> k(0);
|
MDB_val_copy<uint64_t> k(0);
|
||||||
MDB_val v;
|
MDB_val v;
|
||||||
auto get_result = mdb_get(txn, m_output_keys, &k, &v);
|
auto get_result = mdb_get(txn, m_output_keys, &k, &v);
|
||||||
if(get_result != MDB_SUCCESS)
|
if(get_result != MDB_SUCCESS)
|
||||||
{
|
{
|
||||||
txn.abort();
|
txn.abort();
|
||||||
m_open = false;
|
m_open = false;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
// LOG_PRINT_L0("Output keys size: " << v.mv_size);
|
// LOG_PRINT_L0("Output keys size: " << v.mv_size);
|
||||||
if(v.mv_size != sizeof(output_data_t))
|
if(v.mv_size != sizeof(output_data_t))
|
||||||
compatible = false;
|
compatible = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
MDB_val_copy<const char*> k("version");
|
MDB_val_copy<const char*> k("version");
|
||||||
MDB_val v;
|
MDB_val v;
|
||||||
|
|
@ -1721,11 +1721,11 @@ output_data_t BlockchainLMDB::get_output_key(const uint64_t &global_index) const
|
||||||
|
|
||||||
output_data_t BlockchainLMDB::get_output_key(const uint64_t& amount, const uint64_t& index)
|
output_data_t BlockchainLMDB::get_output_key(const uint64_t& amount, const uint64_t& index)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
check_open();
|
check_open();
|
||||||
|
|
||||||
uint64_t glob_index = get_output_global_index(amount, index);
|
uint64_t glob_index = get_output_global_index(amount, index);
|
||||||
return get_output_key(glob_index);
|
return get_output_key(glob_index);
|
||||||
}
|
}
|
||||||
|
|
||||||
tx_out_index BlockchainLMDB::get_output_tx_and_index_from_global(const uint64_t& index) const
|
tx_out_index BlockchainLMDB::get_output_tx_and_index_from_global(const uint64_t& index) const
|
||||||
|
|
@ -1760,14 +1760,14 @@ tx_out_index BlockchainLMDB::get_output_tx_and_index_from_global(const uint64_t&
|
||||||
tx_out_index BlockchainLMDB::get_output_tx_and_index(const uint64_t& amount, const uint64_t& index)
|
tx_out_index BlockchainLMDB::get_output_tx_and_index(const uint64_t& amount, const uint64_t& index)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
std::vector < uint64_t > offsets;
|
std::vector < uint64_t > offsets;
|
||||||
std::vector<tx_out_index> indices;
|
std::vector<tx_out_index> indices;
|
||||||
offsets.push_back(index);
|
offsets.push_back(index);
|
||||||
get_output_tx_and_index(amount, offsets, indices);
|
get_output_tx_and_index(amount, offsets, indices);
|
||||||
if (!indices.size())
|
if (!indices.size())
|
||||||
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
|
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
|
||||||
|
|
||||||
return indices[0];
|
return indices[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
std::vector<uint64_t> BlockchainLMDB::get_tx_output_indices(const crypto::hash& h) const
|
std::vector<uint64_t> BlockchainLMDB::get_tx_output_indices(const crypto::hash& h) const
|
||||||
|
|
@ -2152,7 +2152,7 @@ void BlockchainLMDB::set_batch_transactions(bool batch_transactions)
|
||||||
}
|
}
|
||||||
|
|
||||||
uint64_t BlockchainLMDB::add_block(const block& blk, const size_t& block_size, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated,
|
uint64_t BlockchainLMDB::add_block(const block& blk, const size_t& block_size, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated,
|
||||||
const std::vector<transaction>& txs)
|
const std::vector<transaction>& txs)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
check_open();
|
check_open();
|
||||||
|
|
@ -2235,192 +2235,192 @@ void BlockchainLMDB::pop_block(block& blk, std::vector<transaction>& txs)
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::get_output_tx_and_index_from_global(const std::vector<uint64_t> &global_indices,
|
void BlockchainLMDB::get_output_tx_and_index_from_global(const std::vector<uint64_t> &global_indices,
|
||||||
std::vector<tx_out_index> &tx_out_indices) const
|
std::vector<tx_out_index> &tx_out_indices) const
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
check_open();
|
check_open();
|
||||||
tx_out_indices.clear();
|
tx_out_indices.clear();
|
||||||
|
|
||||||
TXN_PREFIX_RDONLY();
|
TXN_PREFIX_RDONLY();
|
||||||
|
|
||||||
for (const uint64_t &index : global_indices)
|
for (const uint64_t &index : global_indices)
|
||||||
{
|
{
|
||||||
MDB_val_copy<uint64_t> k(index);
|
MDB_val_copy<uint64_t> k(index);
|
||||||
MDB_val v;
|
MDB_val v;
|
||||||
|
|
||||||
auto get_result = mdb_get(*txn_ptr, m_output_txs, &k, &v);
|
auto get_result = mdb_get(*txn_ptr, m_output_txs, &k, &v);
|
||||||
if (get_result == MDB_NOTFOUND)
|
if (get_result == MDB_NOTFOUND)
|
||||||
throw1(OUTPUT_DNE("output with given index not in db"));
|
throw1(OUTPUT_DNE("output with given index not in db"));
|
||||||
else if (get_result)
|
else if (get_result)
|
||||||
throw0(DB_ERROR("DB error attempting to fetch output tx hash"));
|
throw0(DB_ERROR("DB error attempting to fetch output tx hash"));
|
||||||
|
|
||||||
crypto::hash tx_hash = *(const crypto::hash*) v.mv_data;
|
crypto::hash tx_hash = *(const crypto::hash*) v.mv_data;
|
||||||
|
|
||||||
get_result = mdb_get(*txn_ptr, m_output_indices, &k, &v);
|
get_result = mdb_get(*txn_ptr, m_output_indices, &k, &v);
|
||||||
if (get_result == MDB_NOTFOUND)
|
if (get_result == MDB_NOTFOUND)
|
||||||
throw1(OUTPUT_DNE("output with given index not in db"));
|
throw1(OUTPUT_DNE("output with given index not in db"));
|
||||||
else if (get_result)
|
else if (get_result)
|
||||||
throw0(DB_ERROR("DB error attempting to fetch output tx index"));
|
throw0(DB_ERROR("DB error attempting to fetch output tx index"));
|
||||||
|
|
||||||
auto result = tx_out_index(tx_hash, *(const uint64_t *) v.mv_data);
|
auto result = tx_out_index(tx_hash, *(const uint64_t *) v.mv_data);
|
||||||
tx_out_indices.push_back(result);
|
tx_out_indices.push_back(result);
|
||||||
}
|
}
|
||||||
|
|
||||||
TXN_POSTFIX_SUCCESS();
|
TXN_POSTFIX_SUCCESS();
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::get_output_global_indices(const uint64_t& amount, const std::vector<uint64_t> &offsets,
|
void BlockchainLMDB::get_output_global_indices(const uint64_t& amount, const std::vector<uint64_t> &offsets,
|
||||||
std::vector<uint64_t> &global_indices)
|
std::vector<uint64_t> &global_indices)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
TIME_MEASURE_START(txx);
|
TIME_MEASURE_START(txx);
|
||||||
check_open();
|
check_open();
|
||||||
global_indices.clear();
|
global_indices.clear();
|
||||||
|
|
||||||
uint64_t max = 0;
|
uint64_t max = 0;
|
||||||
for (const uint64_t &index : offsets)
|
for (const uint64_t &index : offsets)
|
||||||
{
|
{
|
||||||
if (index > max)
|
if (index > max)
|
||||||
max = index;
|
max = index;
|
||||||
}
|
}
|
||||||
|
|
||||||
TXN_PREFIX_RDONLY();
|
TXN_PREFIX_RDONLY();
|
||||||
|
|
||||||
lmdb_cur cur(*txn_ptr, m_output_amounts);
|
lmdb_cur cur(*txn_ptr, m_output_amounts);
|
||||||
|
|
||||||
MDB_val_copy<uint64_t> k(amount);
|
MDB_val_copy<uint64_t> k(amount);
|
||||||
MDB_val v;
|
MDB_val v;
|
||||||
auto result = mdb_cursor_get(cur, &k, &v, MDB_SET);
|
auto result = mdb_cursor_get(cur, &k, &v, MDB_SET);
|
||||||
if (result == MDB_NOTFOUND)
|
if (result == MDB_NOTFOUND)
|
||||||
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
|
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
|
||||||
else if (result)
|
else if (result)
|
||||||
throw0(DB_ERROR("DB error attempting to get an output"));
|
throw0(DB_ERROR("DB error attempting to get an output"));
|
||||||
|
|
||||||
size_t num_elems = 0;
|
size_t num_elems = 0;
|
||||||
mdb_cursor_count(cur, &num_elems);
|
mdb_cursor_count(cur, &num_elems);
|
||||||
if (max <= 1 && num_elems <= max)
|
if (max <= 1 && num_elems <= max)
|
||||||
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but output not found"));
|
throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but output not found"));
|
||||||
|
|
||||||
uint64_t t_dbmul = 0;
|
uint64_t t_dbmul = 0;
|
||||||
uint64_t t_dbscan = 0;
|
uint64_t t_dbscan = 0;
|
||||||
if (max <= 1)
|
if (max <= 1)
|
||||||
{
|
{
|
||||||
for (const uint64_t& index : offsets)
|
for (const uint64_t& index : offsets)
|
||||||
{
|
{
|
||||||
mdb_cursor_get(cur, &k, &v, MDB_FIRST_DUP);
|
mdb_cursor_get(cur, &k, &v, MDB_FIRST_DUP);
|
||||||
for (uint64_t i = 0; i < index; ++i)
|
for (uint64_t i = 0; i < index; ++i)
|
||||||
{
|
{
|
||||||
mdb_cursor_get(cur, &k, &v, MDB_NEXT_DUP);
|
mdb_cursor_get(cur, &k, &v, MDB_NEXT_DUP);
|
||||||
}
|
}
|
||||||
|
|
||||||
mdb_cursor_get(cur, &k, &v, MDB_GET_CURRENT);
|
mdb_cursor_get(cur, &k, &v, MDB_GET_CURRENT);
|
||||||
uint64_t glob_index = *(const uint64_t*) v.mv_data;
|
uint64_t glob_index = *(const uint64_t*) v.mv_data;
|
||||||
LOG_PRINT_L3("Amount: " << amount << " M0->v: " << glob_index);
|
LOG_PRINT_L3("Amount: " << amount << " M0->v: " << glob_index);
|
||||||
global_indices.push_back(glob_index);
|
global_indices.push_back(glob_index);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
uint32_t curcount = 0;
|
uint32_t curcount = 0;
|
||||||
uint32_t blockstart = 0;
|
uint32_t blockstart = 0;
|
||||||
for (const uint64_t& index : offsets)
|
for (const uint64_t& index : offsets)
|
||||||
{
|
{
|
||||||
if (index >= num_elems)
|
if (index >= num_elems)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L1("Index: " << index << " Elems: " << num_elems << " partial results found for get_output_tx_and_index");
|
LOG_PRINT_L1("Index: " << index << " Elems: " << num_elems << " partial results found for get_output_tx_and_index");
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
while (index >= curcount)
|
while (index >= curcount)
|
||||||
{
|
{
|
||||||
TIME_MEASURE_START(db1);
|
TIME_MEASURE_START(db1);
|
||||||
if (mdb_cursor_get(cur, &k, &v, curcount == 0 ? MDB_GET_MULTIPLE : MDB_NEXT_MULTIPLE) != 0)
|
if (mdb_cursor_get(cur, &k, &v, curcount == 0 ? MDB_GET_MULTIPLE : MDB_NEXT_MULTIPLE) != 0)
|
||||||
{
|
{
|
||||||
// allow partial results
|
// allow partial results
|
||||||
result = false;
|
result = false;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
int count = v.mv_size / sizeof(uint64_t);
|
int count = v.mv_size / sizeof(uint64_t);
|
||||||
|
|
||||||
blockstart = curcount;
|
blockstart = curcount;
|
||||||
curcount += count;
|
curcount += count;
|
||||||
TIME_MEASURE_FINISH(db1);
|
TIME_MEASURE_FINISH(db1);
|
||||||
t_dbmul += db1;
|
t_dbmul += db1;
|
||||||
}
|
}
|
||||||
|
|
||||||
LOG_PRINT_L3("Records returned: " << curcount << " Index: " << index);
|
LOG_PRINT_L3("Records returned: " << curcount << " Index: " << index);
|
||||||
TIME_MEASURE_START(db2);
|
TIME_MEASURE_START(db2);
|
||||||
uint64_t actual_index = index - blockstart;
|
uint64_t actual_index = index - blockstart;
|
||||||
uint64_t glob_index = ((const uint64_t*) v.mv_data)[actual_index];
|
uint64_t glob_index = ((const uint64_t*) v.mv_data)[actual_index];
|
||||||
|
|
||||||
LOG_PRINT_L3("Amount: " << amount << " M1->v: " << glob_index);
|
LOG_PRINT_L3("Amount: " << amount << " M1->v: " << glob_index);
|
||||||
global_indices.push_back(glob_index);
|
global_indices.push_back(glob_index);
|
||||||
|
|
||||||
TIME_MEASURE_FINISH(db2);
|
TIME_MEASURE_FINISH(db2);
|
||||||
t_dbscan += db2;
|
t_dbscan += db2;
|
||||||
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
cur.close();
|
cur.close();
|
||||||
TXN_POSTFIX_SUCCESS();
|
TXN_POSTFIX_SUCCESS();
|
||||||
|
|
||||||
TIME_MEASURE_FINISH(txx);
|
TIME_MEASURE_FINISH(txx);
|
||||||
LOG_PRINT_L3("txx: " << txx << " db1: " << t_dbmul << " db2: " << t_dbscan);
|
LOG_PRINT_L3("txx: " << txx << " db1: " << t_dbmul << " db2: " << t_dbscan);
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::get_output_key(const uint64_t &amount, const std::vector<uint64_t> &offsets, std::vector<output_data_t> &outputs)
|
void BlockchainLMDB::get_output_key(const uint64_t &amount, const std::vector<uint64_t> &offsets, std::vector<output_data_t> &outputs)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
TIME_MEASURE_START(db3);
|
TIME_MEASURE_START(db3);
|
||||||
check_open();
|
check_open();
|
||||||
outputs.clear();
|
outputs.clear();
|
||||||
|
|
||||||
std::vector <uint64_t> global_indices;
|
std::vector <uint64_t> global_indices;
|
||||||
get_output_global_indices(amount, offsets, global_indices);
|
get_output_global_indices(amount, offsets, global_indices);
|
||||||
|
|
||||||
if (global_indices.size() > 0)
|
if (global_indices.size() > 0)
|
||||||
{
|
{
|
||||||
TXN_PREFIX_RDONLY();
|
TXN_PREFIX_RDONLY();
|
||||||
|
|
||||||
for (const uint64_t &index : global_indices)
|
for (const uint64_t &index : global_indices)
|
||||||
{
|
{
|
||||||
MDB_val_copy<uint64_t> k(index);
|
MDB_val_copy<uint64_t> k(index);
|
||||||
MDB_val v;
|
MDB_val v;
|
||||||
|
|
||||||
auto get_result = mdb_get(*txn_ptr, m_output_keys, &k, &v);
|
auto get_result = mdb_get(*txn_ptr, m_output_keys, &k, &v);
|
||||||
if (get_result == MDB_NOTFOUND)
|
if (get_result == MDB_NOTFOUND)
|
||||||
throw1(OUTPUT_DNE("Attempting to get output pubkey by global index, but key does not exist"));
|
throw1(OUTPUT_DNE("Attempting to get output pubkey by global index, but key does not exist"));
|
||||||
else if (get_result)
|
else if (get_result)
|
||||||
throw0(DB_ERROR("Error attempting to retrieve an output pubkey from the db"));
|
throw0(DB_ERROR("Error attempting to retrieve an output pubkey from the db"));
|
||||||
|
|
||||||
output_data_t data = *(const output_data_t *) v.mv_data;
|
output_data_t data = *(const output_data_t *) v.mv_data;
|
||||||
outputs.push_back(data);
|
outputs.push_back(data);
|
||||||
}
|
}
|
||||||
|
|
||||||
TXN_POSTFIX_SUCCESS();
|
TXN_POSTFIX_SUCCESS();
|
||||||
}
|
}
|
||||||
|
|
||||||
TIME_MEASURE_FINISH(db3);
|
TIME_MEASURE_FINISH(db3);
|
||||||
LOG_PRINT_L3("db3: " << db3);
|
LOG_PRINT_L3("db3: " << db3);
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices)
|
void BlockchainLMDB::get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
|
||||||
check_open();
|
check_open();
|
||||||
indices.clear();
|
indices.clear();
|
||||||
|
|
||||||
std::vector <uint64_t> global_indices;
|
std::vector <uint64_t> global_indices;
|
||||||
get_output_global_indices(amount, offsets, global_indices);
|
get_output_global_indices(amount, offsets, global_indices);
|
||||||
|
|
||||||
TIME_MEASURE_START(db3);
|
TIME_MEASURE_START(db3);
|
||||||
if(global_indices.size() > 0)
|
if(global_indices.size() > 0)
|
||||||
{
|
{
|
||||||
get_output_tx_and_index_from_global(global_indices, indices);
|
get_output_tx_and_index_from_global(global_indices, indices);
|
||||||
}
|
}
|
||||||
TIME_MEASURE_FINISH(db3);
|
TIME_MEASURE_FINISH(db3);
|
||||||
LOG_PRINT_L3("db3: " << db3);
|
LOG_PRINT_L3("db3: " << db3);
|
||||||
}
|
}
|
||||||
|
|
||||||
void BlockchainLMDB::set_hard_fork_starting_height(uint8_t version, uint64_t height)
|
void BlockchainLMDB::set_hard_fork_starting_height(uint8_t version, uint64_t height)
|
||||||
|
|
|
||||||
|
|
@ -165,7 +165,7 @@ public:
|
||||||
|
|
||||||
virtual tx_out_index get_output_tx_and_index_from_global(const uint64_t& index) const;
|
virtual tx_out_index get_output_tx_and_index_from_global(const uint64_t& index) const;
|
||||||
virtual void get_output_tx_and_index_from_global(const std::vector<uint64_t> &global_indices,
|
virtual void get_output_tx_and_index_from_global(const std::vector<uint64_t> &global_indices,
|
||||||
std::vector<tx_out_index> &tx_out_indices) const;
|
std::vector<tx_out_index> &tx_out_indices) const;
|
||||||
|
|
||||||
virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index);
|
virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index);
|
||||||
virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices);
|
virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices);
|
||||||
|
|
|
||||||
|
|
@ -49,18 +49,18 @@ extern const unsigned char _binary_testnet_blocks_end[];
|
||||||
|
|
||||||
const unsigned char *get_blocks_dat_start(int testnet)
|
const unsigned char *get_blocks_dat_start(int testnet)
|
||||||
{
|
{
|
||||||
if (testnet)
|
if (testnet)
|
||||||
return _binary_testnet_blocks_start;
|
return _binary_testnet_blocks_start;
|
||||||
else
|
else
|
||||||
return _binary_blocks_start;
|
return _binary_blocks_start;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t get_blocks_dat_size(int testnet)
|
size_t get_blocks_dat_size(int testnet)
|
||||||
{
|
{
|
||||||
if (testnet)
|
if (testnet)
|
||||||
return (size_t) (_binary_testnet_blocks_end - _binary_testnet_blocks_start);
|
return (size_t) (_binary_testnet_blocks_end - _binary_testnet_blocks_start);
|
||||||
else
|
else
|
||||||
return (size_t) (_binary_blocks_end - _binary_blocks_start);
|
return (size_t) (_binary_blocks_end - _binary_blocks_start);
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
||||||
|
|
@ -25,11 +25,11 @@ extern "C"
|
||||||
{
|
{
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define TABLE_ALIGN 32
|
#define TABLE_ALIGN 32
|
||||||
#define WPOLY 0x011b
|
#define WPOLY 0x011b
|
||||||
#define N_COLS 4
|
#define N_COLS 4
|
||||||
#define AES_BLOCK_SIZE 16
|
#define AES_BLOCK_SIZE 16
|
||||||
#define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2))
|
#define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2))
|
||||||
|
|
||||||
#if defined(_MSC_VER)
|
#if defined(_MSC_VER)
|
||||||
#define ALIGN __declspec(align(TABLE_ALIGN))
|
#define ALIGN __declspec(align(TABLE_ALIGN))
|
||||||
|
|
@ -61,45 +61,45 @@ extern "C"
|
||||||
#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c))
|
#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c))
|
||||||
|
|
||||||
#define sb_data(w) {\
|
#define sb_data(w) {\
|
||||||
w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\
|
w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\
|
||||||
w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\
|
w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\
|
||||||
w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\
|
w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\
|
||||||
w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\
|
w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\
|
||||||
w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\
|
w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\
|
||||||
w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\
|
w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\
|
||||||
w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\
|
w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\
|
||||||
w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\
|
w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\
|
||||||
w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\
|
w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\
|
||||||
w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\
|
w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\
|
||||||
w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\
|
w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\
|
||||||
w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\
|
w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\
|
||||||
w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\
|
w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\
|
||||||
w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\
|
w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\
|
||||||
w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\
|
w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\
|
||||||
w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\
|
w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\
|
||||||
w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\
|
w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\
|
||||||
w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\
|
w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\
|
||||||
w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\
|
w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\
|
||||||
w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\
|
w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\
|
||||||
w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\
|
w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\
|
||||||
w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\
|
w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\
|
||||||
w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\
|
w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\
|
||||||
w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\
|
w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\
|
||||||
w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\
|
w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\
|
||||||
w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\
|
w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\
|
||||||
w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\
|
w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\
|
||||||
w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\
|
w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\
|
||||||
w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\
|
w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\
|
||||||
w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\
|
w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\
|
||||||
w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\
|
w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\
|
||||||
w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16) }
|
w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16) }
|
||||||
|
|
||||||
#define rc_data(w) {\
|
#define rc_data(w) {\
|
||||||
w(0x01), w(0x02), w(0x04), w(0x08), w(0x10),w(0x20), w(0x40), w(0x80),\
|
w(0x01), w(0x02), w(0x04), w(0x08), w(0x10),w(0x20), w(0x40), w(0x80),\
|
||||||
w(0x1b), w(0x36) }
|
w(0x1b), w(0x36) }
|
||||||
|
|
||||||
#define bytes2word(b0, b1, b2, b3) (((uint32_t)(b3) << 24) | \
|
#define bytes2word(b0, b1, b2, b3) (((uint32_t)(b3) << 24) | \
|
||||||
((uint32_t)(b2) << 16) | ((uint32_t)(b1) << 8) | (b0))
|
((uint32_t)(b2) << 16) | ((uint32_t)(b1) << 8) | (b0))
|
||||||
|
|
||||||
#define h0(x) (x)
|
#define h0(x) (x)
|
||||||
#define w0(p) bytes2word(p, 0, 0, 0)
|
#define w0(p) bytes2word(p, 0, 0, 0)
|
||||||
|
|
@ -133,10 +133,10 @@ extern "C"
|
||||||
#define d_4(t,n,b,e,f,g,h) ALIGN const t n[4][256] = { b(e), b(f), b(g), b(h) }
|
#define d_4(t,n,b,e,f,g,h) ALIGN const t n[4][256] = { b(e), b(f), b(g), b(h) }
|
||||||
|
|
||||||
#define four_tables(x,tab,vf,rf,c) \
|
#define four_tables(x,tab,vf,rf,c) \
|
||||||
(tab[0][bval(vf(x,0,c),rf(0,c))] \
|
(tab[0][bval(vf(x,0,c),rf(0,c))] \
|
||||||
^ tab[1][bval(vf(x,1,c),rf(1,c))] \
|
^ tab[1][bval(vf(x,1,c),rf(1,c))] \
|
||||||
^ tab[2][bval(vf(x,2,c),rf(2,c))] \
|
^ tab[2][bval(vf(x,2,c),rf(2,c))] \
|
||||||
^ tab[3][bval(vf(x,3,c),rf(3,c))])
|
^ tab[3][bval(vf(x,3,c),rf(3,c))])
|
||||||
|
|
||||||
d_4(uint32_t, t_dec(f,n), sb_data, u0, u1, u2, u3);
|
d_4(uint32_t, t_dec(f,n), sb_data, u0, u1, u2, u3);
|
||||||
|
|
||||||
|
|
@ -150,33 +150,33 @@ d_4(uint32_t, t_dec(f,n), sb_data, u0, u1, u2, u3);
|
||||||
|
|
||||||
STATIC INLINE void aesb_single_round(const uint8_t *in, uint8_t *out, uint8_t *expandedKey)
|
STATIC INLINE void aesb_single_round(const uint8_t *in, uint8_t *out, uint8_t *expandedKey)
|
||||||
{
|
{
|
||||||
uint32_t b0[4], b1[4];
|
uint32_t b0[4], b1[4];
|
||||||
const uint32_t *kp = (uint32_t *) expandedKey;
|
const uint32_t *kp = (uint32_t *) expandedKey;
|
||||||
state_in(b0, in);
|
state_in(b0, in);
|
||||||
|
|
||||||
round(fwd_rnd, b1, b0, kp);
|
round(fwd_rnd, b1, b0, kp);
|
||||||
|
|
||||||
state_out(out, b1);
|
state_out(out, b1);
|
||||||
}
|
}
|
||||||
|
|
||||||
STATIC INLINE void aesb_pseudo_round(const uint8_t *in, uint8_t *out, uint8_t *expandedKey)
|
STATIC INLINE void aesb_pseudo_round(const uint8_t *in, uint8_t *out, uint8_t *expandedKey)
|
||||||
{
|
{
|
||||||
uint32_t b0[4], b1[4];
|
uint32_t b0[4], b1[4];
|
||||||
const uint32_t *kp = (uint32_t *) expandedKey;
|
const uint32_t *kp = (uint32_t *) expandedKey;
|
||||||
state_in(b0, in);
|
state_in(b0, in);
|
||||||
|
|
||||||
round(fwd_rnd, b1, b0, kp);
|
round(fwd_rnd, b1, b0, kp);
|
||||||
round(fwd_rnd, b0, b1, kp + 1 * N_COLS);
|
round(fwd_rnd, b0, b1, kp + 1 * N_COLS);
|
||||||
round(fwd_rnd, b1, b0, kp + 2 * N_COLS);
|
round(fwd_rnd, b1, b0, kp + 2 * N_COLS);
|
||||||
round(fwd_rnd, b0, b1, kp + 3 * N_COLS);
|
round(fwd_rnd, b0, b1, kp + 3 * N_COLS);
|
||||||
round(fwd_rnd, b1, b0, kp + 4 * N_COLS);
|
round(fwd_rnd, b1, b0, kp + 4 * N_COLS);
|
||||||
round(fwd_rnd, b0, b1, kp + 5 * N_COLS);
|
round(fwd_rnd, b0, b1, kp + 5 * N_COLS);
|
||||||
round(fwd_rnd, b1, b0, kp + 6 * N_COLS);
|
round(fwd_rnd, b1, b0, kp + 6 * N_COLS);
|
||||||
round(fwd_rnd, b0, b1, kp + 7 * N_COLS);
|
round(fwd_rnd, b0, b1, kp + 7 * N_COLS);
|
||||||
round(fwd_rnd, b1, b0, kp + 8 * N_COLS);
|
round(fwd_rnd, b1, b0, kp + 8 * N_COLS);
|
||||||
round(fwd_rnd, b0, b1, kp + 9 * N_COLS);
|
round(fwd_rnd, b0, b1, kp + 9 * N_COLS);
|
||||||
|
|
||||||
state_out(out, b0);
|
state_out(out, b0);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -104,9 +104,9 @@
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define pre_aes() \
|
#define pre_aes() \
|
||||||
j = state_index(a); \
|
j = state_index(a); \
|
||||||
_c = _mm_load_si128(R128(&hp_state[j])); \
|
_c = _mm_load_si128(R128(&hp_state[j])); \
|
||||||
_a = _mm_load_si128(R128(a)); \
|
_a = _mm_load_si128(R128(a)); \
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* An SSE-optimized implementation of the second half of CryptoNight step 3.
|
* An SSE-optimized implementation of the second half of CryptoNight step 3.
|
||||||
|
|
@ -118,18 +118,18 @@
|
||||||
* This code is based upon an optimized implementation by dga.
|
* This code is based upon an optimized implementation by dga.
|
||||||
*/
|
*/
|
||||||
#define post_aes() \
|
#define post_aes() \
|
||||||
_mm_store_si128(R128(c), _c); \
|
_mm_store_si128(R128(c), _c); \
|
||||||
_b = _mm_xor_si128(_b, _c); \
|
_b = _mm_xor_si128(_b, _c); \
|
||||||
_mm_store_si128(R128(&hp_state[j]), _b); \
|
_mm_store_si128(R128(&hp_state[j]), _b); \
|
||||||
j = state_index(c); \
|
j = state_index(c); \
|
||||||
p = U64(&hp_state[j]); \
|
p = U64(&hp_state[j]); \
|
||||||
b[0] = p[0]; b[1] = p[1]; \
|
b[0] = p[0]; b[1] = p[1]; \
|
||||||
__mul(); \
|
__mul(); \
|
||||||
a[0] += hi; a[1] += lo; \
|
a[0] += hi; a[1] += lo; \
|
||||||
p = U64(&hp_state[j]); \
|
p = U64(&hp_state[j]); \
|
||||||
p[0] = a[0]; p[1] = a[1]; \
|
p[0] = a[0]; p[1] = a[1]; \
|
||||||
a[0] ^= b[0]; a[1] ^= b[1]; \
|
a[0] ^= b[0]; a[1] ^= b[1]; \
|
||||||
_b = _c; \
|
_b = _c; \
|
||||||
|
|
||||||
#if defined(_MSC_VER)
|
#if defined(_MSC_VER)
|
||||||
#define THREADV __declspec(thread)
|
#define THREADV __declspec(thread)
|
||||||
|
|
@ -665,59 +665,59 @@ static void (*const extra_hashes[4])(const void *, size_t, char *) = {
|
||||||
|
|
||||||
STATIC INLINE void ___mul128(uint32_t *a, uint32_t *b, uint32_t *h, uint32_t *l)
|
STATIC INLINE void ___mul128(uint32_t *a, uint32_t *b, uint32_t *h, uint32_t *l)
|
||||||
{
|
{
|
||||||
// ND: 64x64 multiplication for ARM7
|
// ND: 64x64 multiplication for ARM7
|
||||||
__asm__ __volatile__
|
__asm__ __volatile__
|
||||||
(
|
(
|
||||||
// lo hi
|
// lo hi
|
||||||
"umull %[r0], %[r1], %[b], %[d]\n\t" // bd [r0 = bd.lo]
|
"umull %[r0], %[r1], %[b], %[d]\n\t" // bd [r0 = bd.lo]
|
||||||
"umull %[r2], %[r3], %[b], %[c]\n\t" // bc
|
"umull %[r2], %[r3], %[b], %[c]\n\t" // bc
|
||||||
"umull %[b], %[c], %[a], %[c]\n\t" // ac
|
"umull %[b], %[c], %[a], %[c]\n\t" // ac
|
||||||
"adds %[r1], %[r1], %[r2]\n\t" // r1 = bd.hi + bc.lo
|
"adds %[r1], %[r1], %[r2]\n\t" // r1 = bd.hi + bc.lo
|
||||||
"adcs %[r2], %[r3], %[b]\n\t" // r2 = ac.lo + bc.hi + carry
|
"adcs %[r2], %[r3], %[b]\n\t" // r2 = ac.lo + bc.hi + carry
|
||||||
"adc %[r3], %[c], #0\n\t" // r3 = ac.hi + carry
|
"adc %[r3], %[c], #0\n\t" // r3 = ac.hi + carry
|
||||||
"umull %[b], %[a], %[a], %[d]\n\t" // ad
|
"umull %[b], %[a], %[a], %[d]\n\t" // ad
|
||||||
"adds %[r1], %[r1], %[b]\n\t" // r1 = bd.hi + bc.lo + ad.lo
|
"adds %[r1], %[r1], %[b]\n\t" // r1 = bd.hi + bc.lo + ad.lo
|
||||||
"adcs %[r2], %[r2], %[a]\n\t" // r2 = ac.lo + bc.hi + ad.hi + carry
|
"adcs %[r2], %[r2], %[a]\n\t" // r2 = ac.lo + bc.hi + ad.hi + carry
|
||||||
"adc %[r3], %[r3], #0\n\t" // r3 = ac.hi + carry
|
"adc %[r3], %[r3], #0\n\t" // r3 = ac.hi + carry
|
||||||
: [r0]"=&r"(l[0]), [r1]"=&r"(l[1]), [r2]"=&r"(h[0]), [r3]"=&r"(h[1])
|
: [r0]"=&r"(l[0]), [r1]"=&r"(l[1]), [r2]"=&r"(h[0]), [r3]"=&r"(h[1])
|
||||||
: [a]"r"(a[1]), [b]"r"(a[0]), [c]"r"(b[1]), [d]"r"(b[0])
|
: [a]"r"(a[1]), [b]"r"(a[0]), [c]"r"(b[1]), [d]"r"(b[0])
|
||||||
: "cc"
|
: "cc"
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
STATIC INLINE void mul(const uint8_t* a, const uint8_t* b, uint8_t* res)
|
STATIC INLINE void mul(const uint8_t* a, const uint8_t* b, uint8_t* res)
|
||||||
{
|
{
|
||||||
___mul128((uint32_t *) a, (uint32_t *) b, (uint32_t *) (res + 0), (uint32_t *) (res + 8));
|
___mul128((uint32_t *) a, (uint32_t *) b, (uint32_t *) (res + 0), (uint32_t *) (res + 8));
|
||||||
}
|
}
|
||||||
|
|
||||||
STATIC INLINE void sum_half_blocks(uint8_t* a, const uint8_t* b)
|
STATIC INLINE void sum_half_blocks(uint8_t* a, const uint8_t* b)
|
||||||
{
|
{
|
||||||
uint64_t a0, a1, b0, b1;
|
uint64_t a0, a1, b0, b1;
|
||||||
a0 = U64(a)[0];
|
a0 = U64(a)[0];
|
||||||
a1 = U64(a)[1];
|
a1 = U64(a)[1];
|
||||||
b0 = U64(b)[0];
|
b0 = U64(b)[0];
|
||||||
b1 = U64(b)[1];
|
b1 = U64(b)[1];
|
||||||
a0 += b0;
|
a0 += b0;
|
||||||
a1 += b1;
|
a1 += b1;
|
||||||
U64(a)[0] = a0;
|
U64(a)[0] = a0;
|
||||||
U64(a)[1] = a1;
|
U64(a)[1] = a1;
|
||||||
}
|
}
|
||||||
|
|
||||||
STATIC INLINE void swap_blocks(uint8_t *a, uint8_t *b)
|
STATIC INLINE void swap_blocks(uint8_t *a, uint8_t *b)
|
||||||
{
|
{
|
||||||
uint64_t t[2];
|
uint64_t t[2];
|
||||||
U64(t)[0] = U64(a)[0];
|
U64(t)[0] = U64(a)[0];
|
||||||
U64(t)[1] = U64(a)[1];
|
U64(t)[1] = U64(a)[1];
|
||||||
U64(a)[0] = U64(b)[0];
|
U64(a)[0] = U64(b)[0];
|
||||||
U64(a)[1] = U64(b)[1];
|
U64(a)[1] = U64(b)[1];
|
||||||
U64(b)[0] = U64(t)[0];
|
U64(b)[0] = U64(t)[0];
|
||||||
U64(b)[1] = U64(t)[1];
|
U64(b)[1] = U64(t)[1];
|
||||||
}
|
}
|
||||||
|
|
||||||
STATIC INLINE void xor_blocks(uint8_t* a, const uint8_t* b)
|
STATIC INLINE void xor_blocks(uint8_t* a, const uint8_t* b)
|
||||||
{
|
{
|
||||||
U64(a)[0] ^= U64(b)[0];
|
U64(a)[0] ^= U64(b)[0];
|
||||||
U64(a)[1] ^= U64(b)[1];
|
U64(a)[1] ^= U64(b)[1];
|
||||||
}
|
}
|
||||||
|
|
||||||
#pragma pack(push, 1)
|
#pragma pack(push, 1)
|
||||||
|
|
@ -774,25 +774,25 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
|
||||||
|
|
||||||
for(i = 0; i < ITER / 2; i++)
|
for(i = 0; i < ITER / 2; i++)
|
||||||
{
|
{
|
||||||
#define MASK ((uint32_t)(((MEMORY / AES_BLOCK_SIZE) - 1) << 4))
|
#define MASK ((uint32_t)(((MEMORY / AES_BLOCK_SIZE) - 1) << 4))
|
||||||
#define state_index(x) ((*(uint32_t *) x) & MASK)
|
#define state_index(x) ((*(uint32_t *) x) & MASK)
|
||||||
|
|
||||||
// Iteration 1
|
// Iteration 1
|
||||||
p = &long_state[state_index(a)];
|
p = &long_state[state_index(a)];
|
||||||
aesb_single_round(p, p, a);
|
aesb_single_round(p, p, a);
|
||||||
|
|
||||||
xor_blocks(b, p);
|
xor_blocks(b, p);
|
||||||
swap_blocks(b, p);
|
swap_blocks(b, p);
|
||||||
swap_blocks(a, b);
|
swap_blocks(a, b);
|
||||||
|
|
||||||
// Iteration 2
|
// Iteration 2
|
||||||
p = &long_state[state_index(a)];
|
p = &long_state[state_index(a)];
|
||||||
|
|
||||||
mul(a, p, d);
|
mul(a, p, d);
|
||||||
sum_half_blocks(b, d);
|
sum_half_blocks(b, d);
|
||||||
swap_blocks(b, p);
|
swap_blocks(b, p);
|
||||||
xor_blocks(b, p);
|
xor_blocks(b, p);
|
||||||
swap_blocks(a, b);
|
swap_blocks(a, b);
|
||||||
}
|
}
|
||||||
|
|
||||||
memcpy(text, state.init, INIT_SIZE_BYTE);
|
memcpy(text, state.init, INIT_SIZE_BYTE);
|
||||||
|
|
@ -874,13 +874,13 @@ static void copy_block(uint8_t* dst, const uint8_t* src) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static void swap_blocks(uint8_t *a, uint8_t *b){
|
static void swap_blocks(uint8_t *a, uint8_t *b){
|
||||||
uint64_t t[2];
|
uint64_t t[2];
|
||||||
U64(t)[0] = U64(a)[0];
|
U64(t)[0] = U64(a)[0];
|
||||||
U64(t)[1] = U64(a)[1];
|
U64(t)[1] = U64(a)[1];
|
||||||
U64(a)[0] = U64(b)[0];
|
U64(a)[0] = U64(b)[0];
|
||||||
U64(a)[1] = U64(b)[1];
|
U64(a)[1] = U64(b)[1];
|
||||||
U64(b)[0] = U64(t)[0];
|
U64(b)[0] = U64(t)[0];
|
||||||
U64(b)[1] = U64(t)[1];
|
U64(b)[1] = U64(t)[1];
|
||||||
}
|
}
|
||||||
|
|
||||||
static void xor_blocks(uint8_t* a, const uint8_t* b) {
|
static void xor_blocks(uint8_t* a, const uint8_t* b) {
|
||||||
|
|
@ -920,7 +920,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
|
||||||
oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE);
|
oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE);
|
||||||
for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
|
for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
|
||||||
for (j = 0; j < INIT_SIZE_BLK; j++) {
|
for (j = 0; j < INIT_SIZE_BLK; j++) {
|
||||||
aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
|
aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
|
||||||
}
|
}
|
||||||
memcpy(&long_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
|
memcpy(&long_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
|
||||||
}
|
}
|
||||||
|
|
@ -938,7 +938,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
|
||||||
/* Iteration 1 */
|
/* Iteration 1 */
|
||||||
j = e2i(a, MEMORY / AES_BLOCK_SIZE);
|
j = e2i(a, MEMORY / AES_BLOCK_SIZE);
|
||||||
copy_block(c, &long_state[j * AES_BLOCK_SIZE]);
|
copy_block(c, &long_state[j * AES_BLOCK_SIZE]);
|
||||||
aesb_single_round(c, c, a);
|
aesb_single_round(c, c, a);
|
||||||
xor_blocks(b, c);
|
xor_blocks(b, c);
|
||||||
swap_blocks(b, c);
|
swap_blocks(b, c);
|
||||||
copy_block(&long_state[j * AES_BLOCK_SIZE], c);
|
copy_block(&long_state[j * AES_BLOCK_SIZE], c);
|
||||||
|
|
@ -961,7 +961,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
|
||||||
for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
|
for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
|
||||||
for (j = 0; j < INIT_SIZE_BLK; j++) {
|
for (j = 0; j < INIT_SIZE_BLK; j++) {
|
||||||
xor_blocks(&text[j * AES_BLOCK_SIZE], &long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
|
xor_blocks(&text[j * AES_BLOCK_SIZE], &long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
|
||||||
aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
|
aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
memcpy(state.init, text, INIT_SIZE_BYTE);
|
memcpy(state.init, text, INIT_SIZE_BYTE);
|
||||||
|
|
|
||||||
|
|
@ -65,9 +65,9 @@ set(cryptonote_core_private_headers
|
||||||
hardfork.h)
|
hardfork.h)
|
||||||
|
|
||||||
if(PER_BLOCK_CHECKPOINT)
|
if(PER_BLOCK_CHECKPOINT)
|
||||||
set(Blocks "blocks")
|
set(Blocks "blocks")
|
||||||
else()
|
else()
|
||||||
set(Blocks "")
|
set(Blocks "")
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
bitmonero_private_headers(cryptonote_core
|
bitmonero_private_headers(cryptonote_core
|
||||||
|
|
|
||||||
|
|
@ -99,8 +99,8 @@ static const uint64_t testnet_hard_fork_version_1_till = 624633;
|
||||||
|
|
||||||
//------------------------------------------------------------------
|
//------------------------------------------------------------------
|
||||||
Blockchain::Blockchain(tx_memory_pool& tx_pool) :
|
Blockchain::Blockchain(tx_memory_pool& tx_pool) :
|
||||||
m_db(), m_tx_pool(tx_pool), m_timestamps_and_difficulties_height(0), m_current_block_cumul_sz_limit(0), m_is_in_checkpoint_zone(false),
|
m_db(), m_tx_pool(tx_pool), m_timestamps_and_difficulties_height(0), m_current_block_cumul_sz_limit(0), m_is_in_checkpoint_zone(false),
|
||||||
m_is_blockchain_storing(false), m_enforce_dns_checkpoints(false), m_max_prepare_blocks_threads(4), m_db_blocks_per_sync(1), m_db_sync_mode(db_async), m_fast_sync(true)
|
m_is_blockchain_storing(false), m_enforce_dns_checkpoints(false), m_max_prepare_blocks_threads(4), m_db_blocks_per_sync(1), m_db_sync_mode(db_async), m_fast_sync(true)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L3("Blockchain::" << __func__);
|
LOG_PRINT_L3("Blockchain::" << __func__);
|
||||||
}
|
}
|
||||||
|
|
@ -2043,13 +2043,13 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
auto it = m_check_txin_table.find(tx_prefix_hash);
|
auto it = m_check_txin_table.find(tx_prefix_hash);
|
||||||
if(it == m_check_txin_table.end())
|
if(it == m_check_txin_table.end())
|
||||||
{
|
{
|
||||||
m_check_txin_table.emplace(tx_prefix_hash, std::unordered_map<crypto::key_image, bool>());
|
m_check_txin_table.emplace(tx_prefix_hash, std::unordered_map<crypto::key_image, bool>());
|
||||||
it = m_check_txin_table.find(tx_prefix_hash);
|
it = m_check_txin_table.find(tx_prefix_hash);
|
||||||
assert(it != m_check_txin_table.end());
|
assert(it != m_check_txin_table.end());
|
||||||
}
|
}
|
||||||
|
|
||||||
uint64_t t_t1 = 0;
|
uint64_t t_t1 = 0;
|
||||||
std::vector<std::vector<crypto::public_key>> pubkeys(tx.vin.size());
|
std::vector<std::vector<crypto::public_key>> pubkeys(tx.vin.size());
|
||||||
|
|
@ -2062,13 +2062,13 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
|
||||||
boost::thread_group threadpool;
|
boost::thread_group threadpool;
|
||||||
|
|
||||||
std::auto_ptr < boost::asio::io_service::work > work(new boost::asio::io_service::work(ioservice));
|
std::auto_ptr < boost::asio::io_service::work > work(new boost::asio::io_service::work(ioservice));
|
||||||
if(threads > 1)
|
if(threads > 1)
|
||||||
{
|
{
|
||||||
for (int i = 0; i < threads; i++)
|
for (int i = 0; i < threads; i++)
|
||||||
{
|
{
|
||||||
threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &ioservice));
|
threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &ioservice));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#define KILL_IOSERVICE() \
|
#define KILL_IOSERVICE() \
|
||||||
if(threads > 1) \
|
if(threads > 1) \
|
||||||
|
|
@ -2092,19 +2092,19 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
|
||||||
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 defined(CACHE_VIN_RESULTS)
|
#if defined(CACHE_VIN_RESULTS)
|
||||||
auto itk = it->second.find(in_to_key.k_image);
|
auto itk = it->second.find(in_to_key.k_image);
|
||||||
if(itk != it->second.end())
|
if(itk != it->second.end())
|
||||||
{
|
{
|
||||||
if(!itk->second)
|
if(!itk->second)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L1("Failed ring signature for tx " << get_transaction_hash(tx) << " vin key with k_image: " << in_to_key.k_image << " sig_index: " << sig_index);
|
LOG_PRINT_L1("Failed ring signature for tx " << get_transaction_hash(tx) << " vin key with k_image: " << in_to_key.k_image << " sig_index: " << sig_index);
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
// txin has been verified already, skip
|
// txin has been verified already, skip
|
||||||
sig_index++;
|
sig_index++;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// make sure that output being spent matches up correctly with the
|
// make sure that output being spent matches up correctly with the
|
||||||
|
|
@ -2112,15 +2112,15 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
|
||||||
TIME_MEASURE_START(aa);
|
TIME_MEASURE_START(aa);
|
||||||
if (!check_tx_input(in_to_key, tx_prefix_hash, tx.signatures[sig_index], pubkeys[sig_index], pmax_used_block_height))
|
if (!check_tx_input(in_to_key, tx_prefix_hash, tx.signatures[sig_index], pubkeys[sig_index], pmax_used_block_height))
|
||||||
{
|
{
|
||||||
it->second[in_to_key.k_image] = false;
|
it->second[in_to_key.k_image] = false;
|
||||||
LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx) << " vin key with k_image: " << in_to_key.k_image << " sig_index: " << sig_index);
|
LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx) << " vin key with k_image: " << in_to_key.k_image << " sig_index: " << sig_index);
|
||||||
if (pmax_used_block_height) // a default value of NULL is used when called from Blockchain::handle_block_to_main_chain()
|
if (pmax_used_block_height) // a default value of NULL is used when called from Blockchain::handle_block_to_main_chain()
|
||||||
{
|
{
|
||||||
LOG_PRINT_L1(" *pmax_used_block_height: " << *pmax_used_block_height);
|
LOG_PRINT_L1(" *pmax_used_block_height: " << *pmax_used_block_height);
|
||||||
}
|
}
|
||||||
|
|
||||||
KILL_IOSERVICE();
|
KILL_IOSERVICE();
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (threads > 1)
|
if (threads > 1)
|
||||||
|
|
@ -2131,21 +2131,21 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
check_ring_signature(tx_prefix_hash, in_to_key.k_image, pubkeys[sig_index], tx.signatures[sig_index], results[sig_index]);
|
check_ring_signature(tx_prefix_hash, in_to_key.k_image, pubkeys[sig_index], tx.signatures[sig_index], results[sig_index]);
|
||||||
if (!results[sig_index])
|
if (!results[sig_index])
|
||||||
|
{
|
||||||
|
it->second[in_to_key.k_image] = false;
|
||||||
|
LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx) << " vin key with k_image: " << in_to_key.k_image << " sig_index: " << sig_index);
|
||||||
|
|
||||||
|
if (pmax_used_block_height) // a default value of NULL is used when called from Blockchain::handle_block_to_main_chain()
|
||||||
{
|
{
|
||||||
it->second[in_to_key.k_image] = false;
|
LOG_PRINT_L1("*pmax_used_block_height: " << *pmax_used_block_height);
|
||||||
LOG_PRINT_L1("Failed to check ring signature for tx " << get_transaction_hash(tx) << " vin key with k_image: " << in_to_key.k_image << " sig_index: " << sig_index);
|
|
||||||
|
|
||||||
if (pmax_used_block_height) // a default value of NULL is used when called from Blockchain::handle_block_to_main_chain()
|
|
||||||
{
|
|
||||||
LOG_PRINT_L1("*pmax_used_block_height: " << *pmax_used_block_height);
|
|
||||||
}
|
|
||||||
|
|
||||||
KILL_IOSERVICE();
|
|
||||||
return false;
|
|
||||||
}
|
}
|
||||||
it->second[in_to_key.k_image] = true;
|
|
||||||
|
KILL_IOSERVICE();
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
it->second[in_to_key.k_image] = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
sig_index++;
|
sig_index++;
|
||||||
|
|
@ -2155,21 +2155,21 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
|
||||||
|
|
||||||
if (threads > 1)
|
if (threads > 1)
|
||||||
{
|
{
|
||||||
// save results to table, passed or otherwise
|
// save results to table, passed or otherwise
|
||||||
bool failed = false;
|
bool failed = false;
|
||||||
for (size_t i = 0; i < tx.vin.size(); i++)
|
for (size_t i = 0; i < tx.vin.size(); i++)
|
||||||
{
|
{
|
||||||
const txin_to_key& in_to_key = boost::get<txin_to_key>(tx.vin[i]);
|
const txin_to_key& in_to_key = boost::get<txin_to_key>(tx.vin[i]);
|
||||||
it->second[in_to_key.k_image] = results[i];
|
it->second[in_to_key.k_image] = results[i];
|
||||||
if(!failed && !results[i])
|
if(!failed && !results[i])
|
||||||
failed = true;
|
failed = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (failed)
|
if (failed)
|
||||||
{
|
{
|
||||||
LOG_PRINT_L1("Failed to check ring signatures!, t_loop: " << t_t1);
|
LOG_PRINT_L1("Failed to check ring signatures!, t_loop: " << t_t1);
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
LOG_PRINT_L1("t_loop: " << t_t1);
|
LOG_PRINT_L1("t_loop: " << t_t1);
|
||||||
return true;
|
return true;
|
||||||
|
|
@ -3154,9 +3154,9 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
|
||||||
TIME_MEASURE_FINISH(scantable);
|
TIME_MEASURE_FINISH(scantable);
|
||||||
if (total_txs > 0)
|
if (total_txs > 0)
|
||||||
{
|
{
|
||||||
m_fake_scan_time = scantable / total_txs;
|
m_fake_scan_time = scantable / total_txs;
|
||||||
if(m_show_time_stats)
|
if(m_show_time_stats)
|
||||||
LOG_PRINT_L0("Prepare scantable took: " << scantable << " ms");
|
LOG_PRINT_L0("Prepare scantable took: " << scantable << " ms");
|
||||||
}
|
}
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
|
|
|
||||||
|
|
@ -61,9 +61,9 @@ namespace cryptonote
|
||||||
|
|
||||||
enum blockchain_db_sync_mode
|
enum blockchain_db_sync_mode
|
||||||
{
|
{
|
||||||
db_sync,
|
db_sync,
|
||||||
db_async,
|
db_async,
|
||||||
db_nosync
|
db_nosync
|
||||||
};
|
};
|
||||||
|
|
||||||
/************************************************************************/
|
/************************************************************************/
|
||||||
|
|
@ -153,7 +153,7 @@ namespace cryptonote
|
||||||
|
|
||||||
// user options, must be called before calling init()
|
// user options, must be called before calling init()
|
||||||
void set_user_options(uint64_t block_threads, uint64_t blocks_per_sync,
|
void set_user_options(uint64_t block_threads, uint64_t blocks_per_sync,
|
||||||
blockchain_db_sync_mode sync_mode, bool fast_sync);
|
blockchain_db_sync_mode sync_mode, bool fast_sync);
|
||||||
|
|
||||||
void set_show_time_stats(bool stats) { m_show_time_stats = stats; }
|
void set_show_time_stats(bool stats) { m_show_time_stats = stats; }
|
||||||
|
|
||||||
|
|
@ -174,12 +174,12 @@ namespace cryptonote
|
||||||
return *m_db;
|
return *m_db;
|
||||||
}
|
}
|
||||||
|
|
||||||
void output_scan_worker(const uint64_t amount,const std::vector<uint64_t> &offsets,
|
void output_scan_worker(const uint64_t amount,const std::vector<uint64_t> &offsets,
|
||||||
std::vector<output_data_t> &outputs, std::unordered_map<crypto::hash,
|
std::vector<output_data_t> &outputs, std::unordered_map<crypto::hash,
|
||||||
cryptonote::transaction> &txs) const;
|
cryptonote::transaction> &txs) const;
|
||||||
|
|
||||||
void block_longhash_worker(const uint64_t height, const std::vector<block> &blocks,
|
void block_longhash_worker(const uint64_t height, const std::vector<block> &blocks,
|
||||||
std::unordered_map<crypto::hash, crypto::hash> &map) const;
|
std::unordered_map<crypto::hash, crypto::hash> &map) const;
|
||||||
private:
|
private:
|
||||||
typedef std::unordered_map<crypto::hash, size_t> blocks_by_id_index;
|
typedef std::unordered_map<crypto::hash, size_t> blocks_by_id_index;
|
||||||
typedef std::unordered_map<crypto::hash, transaction_chain_entry> transactions_container;
|
typedef std::unordered_map<crypto::hash, transaction_chain_entry> transactions_container;
|
||||||
|
|
@ -209,21 +209,21 @@ namespace cryptonote
|
||||||
std::vector<crypto::hash> m_blocks_hash_check;
|
std::vector<crypto::hash> m_blocks_hash_check;
|
||||||
std::vector<crypto::hash> m_blocks_txs_check;
|
std::vector<crypto::hash> m_blocks_txs_check;
|
||||||
|
|
||||||
blockchain_db_sync_mode m_db_sync_mode;
|
blockchain_db_sync_mode m_db_sync_mode;
|
||||||
bool m_fast_sync;
|
bool m_fast_sync;
|
||||||
bool m_show_time_stats;
|
bool m_show_time_stats;
|
||||||
uint64_t m_db_blocks_per_sync;
|
uint64_t m_db_blocks_per_sync;
|
||||||
uint64_t m_max_prepare_blocks_threads;
|
uint64_t m_max_prepare_blocks_threads;
|
||||||
uint64_t m_fake_pow_calc_time;
|
uint64_t m_fake_pow_calc_time;
|
||||||
uint64_t m_fake_scan_time;
|
uint64_t m_fake_scan_time;
|
||||||
uint64_t m_sync_counter;
|
uint64_t m_sync_counter;
|
||||||
std::vector<uint64_t> m_timestamps;
|
std::vector<uint64_t> m_timestamps;
|
||||||
std::vector<difficulty_type> m_difficulties;
|
std::vector<difficulty_type> m_difficulties;
|
||||||
uint64_t m_timestamps_and_difficulties_height;
|
uint64_t m_timestamps_and_difficulties_height;
|
||||||
|
|
||||||
boost::asio::io_service m_async_service;
|
boost::asio::io_service m_async_service;
|
||||||
boost::thread_group m_async_pool;
|
boost::thread_group m_async_pool;
|
||||||
std::unique_ptr<boost::asio::io_service::work> m_async_work_idle;
|
std::unique_ptr<boost::asio::io_service::work> m_async_work_idle;
|
||||||
|
|
||||||
// all alternative chains
|
// all alternative chains
|
||||||
blocks_ext_by_hash m_alternative_chains; // crypto::hash -> block_extended_info
|
blocks_ext_by_hash m_alternative_chains; // crypto::hash -> block_extended_info
|
||||||
|
|
@ -273,6 +273,6 @@ namespace cryptonote
|
||||||
bool check_for_double_spend(const transaction& tx, key_images_container& keys_this_block) const;
|
bool check_for_double_spend(const transaction& tx, key_images_container& keys_this_block) const;
|
||||||
void get_timestamp_and_difficulty(uint64_t ×tamp, difficulty_type &difficulty, const int offset) const;
|
void get_timestamp_and_difficulty(uint64_t ×tamp, difficulty_type &difficulty, const int offset) const;
|
||||||
void check_ring_signature(const crypto::hash &tx_prefix_hash, const crypto::key_image &key_image,
|
void check_ring_signature(const crypto::hash &tx_prefix_hash, const crypto::key_image &key_image,
|
||||||
const std::vector<crypto::public_key> &pubkeys, const std::vector<crypto::signature> &sig, uint64_t &result);
|
const std::vector<crypto::public_key> &pubkeys, const std::vector<crypto::signature> &sig, uint64_t &result);
|
||||||
};
|
};
|
||||||
} // namespace cryptonote
|
} // namespace cryptonote
|
||||||
|
|
|
||||||
|
|
@ -101,7 +101,7 @@ bool blockchain_storage::init(const std::string& config_folder, bool testnet)
|
||||||
// mainchain
|
// mainchain
|
||||||
for (size_t height=0; height < m_blocks.size(); ++height)
|
for (size_t height=0; height < m_blocks.size(); ++height)
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES((!m_checkpoints.is_in_checkpoint_zone(height)) || m_checkpoints.check_block(height,get_block_hash(m_blocks[height].bl)),false,"checkpoint fail, blockchain.bin invalid");
|
CHECK_AND_ASSERT_MES((!m_checkpoints.is_in_checkpoint_zone(height)) || m_checkpoints.check_block(height,get_block_hash(m_blocks[height].bl)),false,"checkpoint fail, blockchain.bin invalid");
|
||||||
}
|
}
|
||||||
|
|
||||||
// check alt chains
|
// check alt chains
|
||||||
|
|
@ -110,7 +110,7 @@ bool blockchain_storage::init(const std::string& config_folder, bool testnet)
|
||||||
// see issue #118
|
// see issue #118
|
||||||
BOOST_FOREACH(blocks_ext_by_hash::value_type& alt_block, m_alternative_chains)
|
BOOST_FOREACH(blocks_ext_by_hash::value_type& alt_block, m_alternative_chains)
|
||||||
{
|
{
|
||||||
CHECK_AND_ASSERT_MES(m_checkpoints.is_alternative_block_allowed(m_blocks.size()-1,alt_block.second.height),false,"stored alternative block not allowed, blockchain.bin invalid");
|
CHECK_AND_ASSERT_MES(m_checkpoints.is_alternative_block_allowed(m_blocks.size()-1,alt_block.second.height),false,"stored alternative block not allowed, blockchain.bin invalid");
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
@ -1072,13 +1072,13 @@ bool blockchain_storage::get_random_outs_for_amounts(const COMMAND_RPC_GET_RANDO
|
||||||
size_t try_count = 0;
|
size_t try_count = 0;
|
||||||
for(uint64_t j = 0; j != req.outs_count && try_count < up_index_limit;)
|
for(uint64_t j = 0; j != req.outs_count && try_count < up_index_limit;)
|
||||||
{
|
{
|
||||||
// triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
|
// triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
|
||||||
uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
|
uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
|
||||||
double frac = std::sqrt((double)r / ((uint64_t)1 << 53));
|
double frac = std::sqrt((double)r / ((uint64_t)1 << 53));
|
||||||
size_t i = (size_t)(frac*up_index_limit);
|
size_t i = (size_t)(frac*up_index_limit);
|
||||||
// just in case rounding up to 1 occurs after sqrt
|
// just in case rounding up to 1 occurs after sqrt
|
||||||
if (i == up_index_limit)
|
if (i == up_index_limit)
|
||||||
--i;
|
--i;
|
||||||
if(used.count(i))
|
if(used.count(i))
|
||||||
continue;
|
continue;
|
||||||
bool added = add_out_to_get_random_outs(amount_outs, result_outs, amount, i);
|
bool added = add_out_to_get_random_outs(amount_outs, result_outs, amount, i);
|
||||||
|
|
@ -1155,27 +1155,27 @@ uint64_t blockchain_storage::block_difficulty(size_t i) const
|
||||||
//------------------------------------------------------------------
|
//------------------------------------------------------------------
|
||||||
double blockchain_storage::get_avg_block_size( size_t count) const
|
double blockchain_storage::get_avg_block_size( size_t count) const
|
||||||
{
|
{
|
||||||
if (count > get_current_blockchain_height()) return 500;
|
if (count > get_current_blockchain_height()) return 500;
|
||||||
|
|
||||||
double average = 0;
|
double average = 0;
|
||||||
_dbg1_c("net/blksize", "HEIGHT: " << get_current_blockchain_height());
|
_dbg1_c("net/blksize", "HEIGHT: " << get_current_blockchain_height());
|
||||||
_dbg1_c("net/blksize", "BLOCK ID BY HEIGHT: " << get_block_id_by_height(get_current_blockchain_height()) );
|
_dbg1_c("net/blksize", "BLOCK ID BY HEIGHT: " << get_block_id_by_height(get_current_blockchain_height()) );
|
||||||
_dbg1_c("net/blksize", "BLOCK TAIL ID: " << get_tail_id() );
|
_dbg1_c("net/blksize", "BLOCK TAIL ID: " << get_tail_id() );
|
||||||
std::vector<size_t> size_vector;
|
std::vector<size_t> size_vector;
|
||||||
|
|
||||||
get_backward_blocks_sizes(get_current_blockchain_height() - count, size_vector, count);
|
get_backward_blocks_sizes(get_current_blockchain_height() - count, size_vector, count);
|
||||||
|
|
||||||
std::vector<size_t>::iterator it;
|
std::vector<size_t>::iterator it;
|
||||||
it = size_vector.begin();
|
it = size_vector.begin();
|
||||||
while (it != size_vector.end()) {
|
while (it != size_vector.end()) {
|
||||||
average += *it;
|
average += *it;
|
||||||
_dbg2_c("net/blksize", "VECTOR ELEMENT: " << (*it) );
|
_dbg2_c("net/blksize", "VECTOR ELEMENT: " << (*it) );
|
||||||
it++;
|
it++;
|
||||||
}
|
}
|
||||||
average = average / count;
|
average = average / count;
|
||||||
_dbg1_c("net/blksize", "VECTOR SIZE: " << size_vector.size() << " average=" << average);
|
_dbg1_c("net/blksize", "VECTOR SIZE: " << size_vector.size() << " average=" << average);
|
||||||
|
|
||||||
return average;
|
return average;
|
||||||
}
|
}
|
||||||
//------------------------------------------------------------------
|
//------------------------------------------------------------------
|
||||||
void blockchain_storage::print_blockchain(uint64_t start_index, uint64_t end_index) const
|
void blockchain_storage::print_blockchain(uint64_t start_index, uint64_t end_index) const
|
||||||
|
|
@ -1770,7 +1770,7 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
|
||||||
<< "), coinbase_blob_size: " << coinbase_blob_size << ", cumulative size: " << cumulative_block_size
|
<< "), coinbase_blob_size: " << coinbase_blob_size << ", cumulative size: " << cumulative_block_size
|
||||||
<< ", " << block_processing_time << "("<< target_calculating_time << "/" << longhash_calculating_time << ")ms");
|
<< ", " << block_processing_time << "("<< target_calculating_time << "/" << longhash_calculating_time << ")ms");
|
||||||
|
|
||||||
epee::net_utils::data_logger::get_instance().add_data("blockchain_processing_time", block_processing_time);
|
epee::net_utils::data_logger::get_instance().add_data("blockchain_processing_time", block_processing_time);
|
||||||
|
|
||||||
bvc.m_added_to_main_chain = true;
|
bvc.m_added_to_main_chain = true;
|
||||||
/*if(!m_orphanes_reorganize_in_work)
|
/*if(!m_orphanes_reorganize_in_work)
|
||||||
|
|
@ -1837,13 +1837,13 @@ void blockchain_storage::check_against_checkpoints(const checkpoints& points, bo
|
||||||
// if asked to enforce checkpoints, roll back to a couple of blocks before the checkpoint
|
// if asked to enforce checkpoints, roll back to a couple of blocks before the checkpoint
|
||||||
if (enforce)
|
if (enforce)
|
||||||
{
|
{
|
||||||
LOG_ERROR("Local blockchain failed to pass a checkpoint, rolling back!");
|
LOG_ERROR("Local blockchain failed to pass a checkpoint, rolling back!");
|
||||||
std::list<block> empty;
|
std::list<block> empty;
|
||||||
rollback_blockchain_switching(empty, pt.first - 2);
|
rollback_blockchain_switching(empty, pt.first - 2);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
LOG_ERROR("WARNING: local blockchain failed to pass a MoneroPulse checkpoint, and you could be on a fork. You should either sync up from scratch, OR download a fresh blockchain bootstrap, OR enable checkpoint enforcing with the --enforce-dns-checkpointing command-line option");
|
LOG_ERROR("WARNING: local blockchain failed to pass a MoneroPulse checkpoint, and you could be on a fork. You should either sync up from scratch, OR download a fresh blockchain bootstrap, OR enable checkpoint enforcing with the --enforce-dns-checkpointing command-line option");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -46,11 +46,11 @@ namespace
|
||||||
bool ok = false;
|
bool ok = false;
|
||||||
for (const auto& record_in_b : b)
|
for (const auto& record_in_b : b)
|
||||||
{
|
{
|
||||||
if (record_in_a == record_in_b)
|
if (record_in_a == record_in_b)
|
||||||
{
|
{
|
||||||
ok = true;
|
ok = true;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (!ok) return false;
|
if (!ok) return false;
|
||||||
}
|
}
|
||||||
|
|
@ -64,19 +64,19 @@ namespace cryptonote
|
||||||
|
|
||||||
struct t_hashline
|
struct t_hashline
|
||||||
{
|
{
|
||||||
uint64_t height;
|
uint64_t height;
|
||||||
std::string hash;
|
std::string hash;
|
||||||
BEGIN_KV_SERIALIZE_MAP()
|
BEGIN_KV_SERIALIZE_MAP()
|
||||||
KV_SERIALIZE(height)
|
KV_SERIALIZE(height)
|
||||||
KV_SERIALIZE(hash)
|
KV_SERIALIZE(hash)
|
||||||
END_KV_SERIALIZE_MAP()
|
END_KV_SERIALIZE_MAP()
|
||||||
};
|
};
|
||||||
|
|
||||||
struct t_hash_json {
|
struct t_hash_json {
|
||||||
std::vector<t_hashline> hashlines;
|
std::vector<t_hashline> hashlines;
|
||||||
BEGIN_KV_SERIALIZE_MAP()
|
BEGIN_KV_SERIALIZE_MAP()
|
||||||
KV_SERIALIZE(hashlines)
|
KV_SERIALIZE(hashlines)
|
||||||
END_KV_SERIALIZE_MAP()
|
END_KV_SERIALIZE_MAP()
|
||||||
};
|
};
|
||||||
|
|
||||||
bool create_checkpoints(cryptonote::checkpoints& checkpoints)
|
bool create_checkpoints(cryptonote::checkpoints& checkpoints)
|
||||||
|
|
@ -126,11 +126,11 @@ bool load_checkpoints_from_json(cryptonote::checkpoints& checkpoints, std::strin
|
||||||
uint64_t height;
|
uint64_t height;
|
||||||
height = it->height;
|
height = it->height;
|
||||||
if (height <= prev_max_height) {
|
if (height <= prev_max_height) {
|
||||||
LOG_PRINT_L1("ignoring checkpoint height " << height);
|
LOG_PRINT_L1("ignoring checkpoint height " << height);
|
||||||
} else {
|
} else {
|
||||||
std::string blockhash = it->hash;
|
std::string blockhash = it->hash;
|
||||||
LOG_PRINT_L1("Adding checkpoint height " << height << ", hash=" << blockhash);
|
LOG_PRINT_L1("Adding checkpoint height " << height << ", hash=" << blockhash);
|
||||||
ADD_CHECKPOINT(height, blockhash);
|
ADD_CHECKPOINT(height, blockhash);
|
||||||
}
|
}
|
||||||
++it;
|
++it;
|
||||||
}
|
}
|
||||||
|
|
@ -142,15 +142,15 @@ bool load_checkpoints_from_dns(cryptonote::checkpoints& checkpoints, bool testne
|
||||||
{
|
{
|
||||||
// All four MoneroPulse domains have DNSSEC on and valid
|
// All four MoneroPulse domains have DNSSEC on and valid
|
||||||
static const std::vector<std::string> dns_urls = { "checkpoints.moneropulse.se"
|
static const std::vector<std::string> dns_urls = { "checkpoints.moneropulse.se"
|
||||||
, "checkpoints.moneropulse.org"
|
, "checkpoints.moneropulse.org"
|
||||||
, "checkpoints.moneropulse.net"
|
, "checkpoints.moneropulse.net"
|
||||||
, "checkpoints.moneropulse.co"
|
, "checkpoints.moneropulse.co"
|
||||||
};
|
};
|
||||||
|
|
||||||
static const std::vector<std::string> testnet_dns_urls = { "testpoints.moneropulse.se"
|
static const std::vector<std::string> testnet_dns_urls = { "testpoints.moneropulse.se"
|
||||||
, "testpoints.moneropulse.org"
|
, "testpoints.moneropulse.org"
|
||||||
, "testpoints.moneropulse.net"
|
, "testpoints.moneropulse.net"
|
||||||
, "testpoints.moneropulse.co"
|
, "testpoints.moneropulse.co"
|
||||||
};
|
};
|
||||||
|
|
||||||
std::vector<std::vector<std::string> > records;
|
std::vector<std::vector<std::string> > records;
|
||||||
|
|
@ -220,8 +220,8 @@ bool load_checkpoints_from_dns(cryptonote::checkpoints& checkpoints, bool testne
|
||||||
{
|
{
|
||||||
if (dns_records_match(records[i], records[j]))
|
if (dns_records_match(records[i], records[j]))
|
||||||
{
|
{
|
||||||
good_records_index = i;
|
good_records_index = i;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (good_records_index >= 0) break;
|
if (good_records_index >= 0) break;
|
||||||
|
|
@ -246,7 +246,7 @@ bool load_checkpoints_from_dns(cryptonote::checkpoints& checkpoints, bool testne
|
||||||
std::stringstream ss(record.substr(0, pos));
|
std::stringstream ss(record.substr(0, pos));
|
||||||
if (!(ss >> height))
|
if (!(ss >> height))
|
||||||
{
|
{
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
// parse the second part as crypto::hash,
|
// parse the second part as crypto::hash,
|
||||||
|
|
@ -254,7 +254,7 @@ bool load_checkpoints_from_dns(cryptonote::checkpoints& checkpoints, bool testne
|
||||||
std::string hashStr = record.substr(pos + 1);
|
std::string hashStr = record.substr(pos + 1);
|
||||||
if (!epee::string_tools::parse_tpod_from_hex_string(hashStr, hash))
|
if (!epee::string_tools::parse_tpod_from_hex_string(hashStr, hash))
|
||||||
{
|
{
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
ADD_CHECKPOINT(height, hashStr);
|
ADD_CHECKPOINT(height, hashStr);
|
||||||
|
|
|
||||||
|
|
@ -106,8 +106,8 @@ namespace cryptonote {
|
||||||
assert(current_block_size < std::numeric_limits<uint32_t>::max());
|
assert(current_block_size < std::numeric_limits<uint32_t>::max());
|
||||||
|
|
||||||
uint64_t product_hi;
|
uint64_t product_hi;
|
||||||
// BUGFIX: 32-bit saturation bug (e.g. ARM7), the result was being
|
// BUGFIX: 32-bit saturation bug (e.g. ARM7), the result was being
|
||||||
// treated as 32-bit by default.
|
// treated as 32-bit by default.
|
||||||
uint64_t multiplicand = 2 * median_size - current_block_size;
|
uint64_t multiplicand = 2 * median_size - current_block_size;
|
||||||
multiplicand *= current_block_size;
|
multiplicand *= current_block_size;
|
||||||
uint64_t product_lo = mul128(base_reward, multiplicand, &product_hi);
|
uint64_t product_lo = mul128(base_reward, multiplicand, &product_hi);
|
||||||
|
|
|
||||||
|
|
@ -178,7 +178,7 @@ namespace cryptonote
|
||||||
test_drop_download_height(command_line::get_arg(vm, command_line::arg_test_drop_download_height));
|
test_drop_download_height(command_line::get_arg(vm, command_line::arg_test_drop_download_height));
|
||||||
|
|
||||||
if (command_line::get_arg(vm, command_line::arg_test_drop_download) == true)
|
if (command_line::get_arg(vm, command_line::arg_test_drop_download) == true)
|
||||||
test_drop_download();
|
test_drop_download();
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
@ -331,7 +331,7 @@ namespace cryptonote
|
||||||
db->set_auto_remove_logs(auto_remove_logs);
|
db->set_auto_remove_logs(auto_remove_logs);
|
||||||
db->open(filename, db_flags);
|
db->open(filename, db_flags);
|
||||||
if(!db->m_open)
|
if(!db->m_open)
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
catch (const DB_ERROR& e)
|
catch (const DB_ERROR& e)
|
||||||
{
|
{
|
||||||
|
|
@ -374,12 +374,12 @@ namespace cryptonote
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
bool core::deinit()
|
bool core::deinit()
|
||||||
{
|
{
|
||||||
m_miner.stop();
|
m_miner.stop();
|
||||||
m_mempool.deinit();
|
m_mempool.deinit();
|
||||||
if (!m_fast_exit)
|
if (!m_fast_exit)
|
||||||
{
|
{
|
||||||
m_blockchain_storage.deinit();
|
m_blockchain_storage.deinit();
|
||||||
}
|
}
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
|
|
@ -395,28 +395,28 @@ namespace cryptonote
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
void core::test_drop_download()
|
void core::test_drop_download()
|
||||||
{
|
{
|
||||||
m_test_drop_download = false;
|
m_test_drop_download = false;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
void core::test_drop_download_height(uint64_t height)
|
void core::test_drop_download_height(uint64_t height)
|
||||||
{
|
{
|
||||||
m_test_drop_download_height = height;
|
m_test_drop_download_height = height;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
bool core::get_test_drop_download() const
|
bool core::get_test_drop_download() const
|
||||||
{
|
{
|
||||||
return m_test_drop_download;
|
return m_test_drop_download;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
bool core::get_test_drop_download_height() const
|
bool core::get_test_drop_download_height() const
|
||||||
{
|
{
|
||||||
if (m_test_drop_download_height == 0)
|
if (m_test_drop_download_height == 0)
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
if (get_blockchain_storage().get_current_blockchain_height() <= m_test_drop_download_height)
|
if (get_blockchain_storage().get_current_blockchain_height() <= m_test_drop_download_height)
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------------------
|
||||||
bool core::handle_incoming_tx(const blobdata& tx_blob, tx_verification_context& tvc, bool keeped_by_block, bool relayed)
|
bool core::handle_incoming_tx(const blobdata& tx_blob, tx_verification_context& tvc, bool keeped_by_block, bool relayed)
|
||||||
|
|
|
||||||
|
|
@ -175,7 +175,7 @@ namespace cryptonote
|
||||||
|
|
||||||
static std::atomic<bool> m_fast_exit;
|
static std::atomic<bool> m_fast_exit;
|
||||||
bool m_test_drop_download = true;
|
bool m_test_drop_download = true;
|
||||||
uint64_t m_test_drop_download_height = 0;
|
uint64_t m_test_drop_download_height = 0;
|
||||||
|
|
||||||
tx_memory_pool m_mempool;
|
tx_memory_pool m_mempool;
|
||||||
#if BLOCKCHAIN_DB == DB_LMDB
|
#if BLOCKCHAIN_DB == DB_LMDB
|
||||||
|
|
|
||||||
|
|
@ -53,40 +53,40 @@ namespace cryptonote {
|
||||||
#else
|
#else
|
||||||
|
|
||||||
static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high) {
|
static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high) {
|
||||||
// __int128 isn't part of the standard, so the previous function wasn't portable. mul128() in Windows is fine,
|
// __int128 isn't part of the standard, so the previous function wasn't portable. mul128() in Windows is fine,
|
||||||
// but this portable function should be used elsewhere. Credit for this function goes to latexi95.
|
// but this portable function should be used elsewhere. Credit for this function goes to latexi95.
|
||||||
|
|
||||||
uint64_t aLow = a & 0xFFFFFFFF;
|
uint64_t aLow = a & 0xFFFFFFFF;
|
||||||
uint64_t aHigh = a >> 32;
|
uint64_t aHigh = a >> 32;
|
||||||
uint64_t bLow = b & 0xFFFFFFFF;
|
uint64_t bLow = b & 0xFFFFFFFF;
|
||||||
uint64_t bHigh = b >> 32;
|
uint64_t bHigh = b >> 32;
|
||||||
|
|
||||||
uint64_t res = aLow * bLow;
|
uint64_t res = aLow * bLow;
|
||||||
uint64_t lowRes1 = res & 0xFFFFFFFF;
|
uint64_t lowRes1 = res & 0xFFFFFFFF;
|
||||||
uint64_t carry = res >> 32;
|
uint64_t carry = res >> 32;
|
||||||
|
|
||||||
res = aHigh * bLow + carry;
|
res = aHigh * bLow + carry;
|
||||||
uint64_t highResHigh1 = res >> 32;
|
uint64_t highResHigh1 = res >> 32;
|
||||||
uint64_t highResLow1 = res & 0xFFFFFFFF;
|
uint64_t highResLow1 = res & 0xFFFFFFFF;
|
||||||
|
|
||||||
res = aLow * bHigh;
|
res = aLow * bHigh;
|
||||||
uint64_t lowRes2 = res & 0xFFFFFFFF;
|
uint64_t lowRes2 = res & 0xFFFFFFFF;
|
||||||
carry = res >> 32;
|
carry = res >> 32;
|
||||||
|
|
||||||
res = aHigh * bHigh + carry;
|
res = aHigh * bHigh + carry;
|
||||||
uint64_t highResHigh2 = res >> 32;
|
uint64_t highResHigh2 = res >> 32;
|
||||||
uint64_t highResLow2 = res & 0xFFFFFFFF;
|
uint64_t highResLow2 = res & 0xFFFFFFFF;
|
||||||
|
|
||||||
//Addition
|
//Addition
|
||||||
|
|
||||||
uint64_t r = highResLow1 + lowRes2;
|
uint64_t r = highResLow1 + lowRes2;
|
||||||
carry = r >> 32;
|
carry = r >> 32;
|
||||||
low = (r << 32) | lowRes1;
|
low = (r << 32) | lowRes1;
|
||||||
r = highResHigh1 + highResLow2 + carry;
|
r = highResHigh1 + highResLow2 + carry;
|
||||||
uint64_t d3 = r & 0xFFFFFFFF;
|
uint64_t d3 = r & 0xFFFFFFFF;
|
||||||
carry = r >> 32;
|
carry = r >> 32;
|
||||||
r = highResHigh2 + carry;
|
r = highResHigh2 + carry;
|
||||||
high = d3 | (r << 32);
|
high = d3 | (r << 32);
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
||||||
|
|
@ -346,7 +346,7 @@ namespace cryptonote
|
||||||
difficulty_type local_diff = 0;
|
difficulty_type local_diff = 0;
|
||||||
uint32_t local_template_ver = 0;
|
uint32_t local_template_ver = 0;
|
||||||
block b;
|
block b;
|
||||||
slow_hash_allocate_state();
|
slow_hash_allocate_state();
|
||||||
while(!m_stop)
|
while(!m_stop)
|
||||||
{
|
{
|
||||||
if(m_pausers_count)//anti split workaround
|
if(m_pausers_count)//anti split workaround
|
||||||
|
|
@ -357,7 +357,6 @@ namespace cryptonote
|
||||||
|
|
||||||
if(local_template_ver != m_template_no)
|
if(local_template_ver != m_template_no)
|
||||||
{
|
{
|
||||||
|
|
||||||
CRITICAL_REGION_BEGIN(m_template_lock);
|
CRITICAL_REGION_BEGIN(m_template_lock);
|
||||||
b = m_template;
|
b = m_template;
|
||||||
local_diff = m_diffic;
|
local_diff = m_diffic;
|
||||||
|
|
@ -395,7 +394,7 @@ namespace cryptonote
|
||||||
nonce+=m_threads_total;
|
nonce+=m_threads_total;
|
||||||
++m_hashes;
|
++m_hashes;
|
||||||
}
|
}
|
||||||
slow_hash_free_state();
|
slow_hash_free_state();
|
||||||
LOG_PRINT_L0("Miner thread stopped ["<< th_local_index << "]");
|
LOG_PRINT_L0("Miner thread stopped ["<< th_local_index << "]");
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -228,8 +228,8 @@ namespace cryptonote
|
||||||
bool tx_memory_pool::remove_transaction_keyimages(const transaction& tx)
|
bool tx_memory_pool::remove_transaction_keyimages(const transaction& tx)
|
||||||
{
|
{
|
||||||
CRITICAL_REGION_LOCAL(m_transactions_lock);
|
CRITICAL_REGION_LOCAL(m_transactions_lock);
|
||||||
// ND: Speedup
|
// ND: Speedup
|
||||||
// 1. Move transaction hash calcuation outside of loop. ._.
|
// 1. Move transaction hash calcuation outside of loop. ._.
|
||||||
crypto::hash actual_hash = get_transaction_hash(tx);
|
crypto::hash actual_hash = get_transaction_hash(tx);
|
||||||
BOOST_FOREACH(const txin_v& vi, tx.vin)
|
BOOST_FOREACH(const txin_v& vi, tx.vin)
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -139,7 +139,7 @@ namespace cryptonote
|
||||||
};
|
};
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool remove_stuck_transactions();
|
bool remove_stuck_transactions();
|
||||||
bool have_tx_keyimg_as_spent(const crypto::key_image& key_im) const;
|
bool have_tx_keyimg_as_spent(const crypto::key_image& key_im) const;
|
||||||
bool have_tx_keyimges_as_spent(const transaction& tx) const;
|
bool have_tx_keyimges_as_spent(const transaction& tx) const;
|
||||||
bool remove_transaction_keyimages(const transaction& tx);
|
bool remove_transaction_keyimages(const transaction& tx);
|
||||||
|
|
|
||||||
|
|
@ -50,7 +50,7 @@ namespace cryptonote
|
||||||
|
|
||||||
|
|
||||||
// static
|
// static
|
||||||
// template<class t_core> std::ofstream t_cryptonote_protocol_handler<t_core>::m_logreq("logreq.txt"); // static
|
// template<class t_core> std::ofstream t_cryptonote_protocol_handler<t_core>::m_logreq("logreq.txt"); // static
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -119,10 +119,10 @@ namespace cryptonote
|
||||||
std::stringstream ss;
|
std::stringstream ss;
|
||||||
ss.precision(1);
|
ss.precision(1);
|
||||||
|
|
||||||
double down_sum = 0.0;
|
double down_sum = 0.0;
|
||||||
double down_curr_sum = 0.0;
|
double down_curr_sum = 0.0;
|
||||||
double up_sum = 0.0;
|
double up_sum = 0.0;
|
||||||
double up_curr_sum = 0.0;
|
double up_curr_sum = 0.0;
|
||||||
|
|
||||||
ss << std::setw(30) << std::left << "Remote Host"
|
ss << std::setw(30) << std::left << "Remote Host"
|
||||||
<< std::setw(20) << "Peer id"
|
<< std::setw(20) << "Peer id"
|
||||||
|
|
@ -135,15 +135,15 @@ namespace cryptonote
|
||||||
<< std::setw(13) << "Up(now)"
|
<< std::setw(13) << "Up(now)"
|
||||||
<< ENDL;
|
<< ENDL;
|
||||||
|
|
||||||
uint32_t ip;
|
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)
|
||||||
{
|
{
|
||||||
bool local_ip = false;
|
bool local_ip = false;
|
||||||
ip = ntohl(cntxt.m_remote_ip);
|
ip = ntohl(cntxt.m_remote_ip);
|
||||||
// TODO: local ip in calss A, B
|
// TODO: local ip in calss A, B
|
||||||
if (ip > 3232235520 && ip < 3232301055) // 192.168.x.x
|
if (ip > 3232235520 && ip < 3232301055) // 192.168.x.x
|
||||||
local_ip = true;
|
local_ip = true;
|
||||||
auto connection_time = time(NULL) - cntxt.m_started;
|
auto connection_time = time(NULL) - cntxt.m_started;
|
||||||
ss << std::setw(30) << std::left << std::string(cntxt.m_is_income ? " [INC]":"[OUT]") +
|
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)
|
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 << peer_id
|
||||||
|
|
@ -158,25 +158,25 @@ namespace cryptonote
|
||||||
<< std::left << (ip == LOCALHOST_INT ? "[LOCALHOST]" : "") // 127.0.0.1
|
<< std::left << (ip == LOCALHOST_INT ? "[LOCALHOST]" : "") // 127.0.0.1
|
||||||
<< ENDL;
|
<< ENDL;
|
||||||
|
|
||||||
if (connection_time > 1)
|
if (connection_time > 1)
|
||||||
{
|
{
|
||||||
down_sum += (cntxt.m_recv_cnt / connection_time / 1024);
|
down_sum += (cntxt.m_recv_cnt / connection_time / 1024);
|
||||||
up_sum += (cntxt.m_send_cnt / connection_time / 1024);
|
up_sum += (cntxt.m_send_cnt / connection_time / 1024);
|
||||||
}
|
}
|
||||||
|
|
||||||
down_curr_sum += (cntxt.m_current_speed_down / 1024);
|
down_curr_sum += (cntxt.m_current_speed_down / 1024);
|
||||||
up_curr_sum += (cntxt.m_current_speed_up / 1024);
|
up_curr_sum += (cntxt.m_current_speed_up / 1024);
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
});
|
});
|
||||||
ss << ENDL
|
ss << ENDL
|
||||||
<< std::setw(125) << " "
|
<< std::setw(125) << " "
|
||||||
<< std::setw(12) << down_sum
|
<< std::setw(12) << down_sum
|
||||||
<< std::setw(14) << down_curr_sum
|
<< std::setw(14) << down_curr_sum
|
||||||
<< std::setw(10) << up_sum
|
<< std::setw(10) << up_sum
|
||||||
<< std::setw(13) << up_curr_sum
|
<< std::setw(13) << up_curr_sum
|
||||||
<< ENDL;
|
<< ENDL;
|
||||||
LOG_PRINT_L0("Connections: " << ENDL << ss.str());
|
LOG_PRINT_L0("Connections: " << ENDL << ss.str());
|
||||||
}
|
}
|
||||||
//------------------------------------------------------------------------------------------------------------------------
|
//------------------------------------------------------------------------------------------------------------------------
|
||||||
// Returns a list of connection_info objects describing each open p2p connection
|
// Returns a list of connection_info objects describing each open p2p connection
|
||||||
|
|
@ -211,40 +211,40 @@ namespace cryptonote
|
||||||
cnx.live_time = timestamp - cntxt.m_started;
|
cnx.live_time = timestamp - cntxt.m_started;
|
||||||
|
|
||||||
uint32_t ip;
|
uint32_t ip;
|
||||||
ip = ntohl(cntxt.m_remote_ip);
|
ip = ntohl(cntxt.m_remote_ip);
|
||||||
if (ip == LOCALHOST_INT)
|
if (ip == LOCALHOST_INT)
|
||||||
{
|
{
|
||||||
cnx.localhost = true;
|
cnx.localhost = true;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
cnx.localhost = false;
|
cnx.localhost = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ip > 3232235520 && ip < 3232301055) // 192.168.x.x
|
if (ip > 3232235520 && ip < 3232301055) // 192.168.x.x
|
||||||
{
|
{
|
||||||
cnx.local_ip = true;
|
cnx.local_ip = true;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
cnx.local_ip = false;
|
cnx.local_ip = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
auto connection_time = time(NULL) - cntxt.m_started;
|
auto connection_time = time(NULL) - cntxt.m_started;
|
||||||
if (connection_time == 0)
|
if (connection_time == 0)
|
||||||
{
|
{
|
||||||
cnx.avg_download = 0;
|
cnx.avg_download = 0;
|
||||||
cnx.avg_upload = 0;
|
cnx.avg_upload = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
cnx.avg_download = cntxt.m_recv_cnt / connection_time / 1024;
|
cnx.avg_download = cntxt.m_recv_cnt / connection_time / 1024;
|
||||||
cnx.avg_upload = cntxt.m_send_cnt / connection_time / 1024;
|
cnx.avg_upload = cntxt.m_send_cnt / connection_time / 1024;
|
||||||
}
|
}
|
||||||
|
|
||||||
cnx.current_download = cntxt.m_current_speed_down / 1024;
|
cnx.current_download = cntxt.m_current_speed_down / 1024;
|
||||||
cnx.current_upload = cntxt.m_current_speed_up / 1024;
|
cnx.current_upload = cntxt.m_current_speed_up / 1024;
|
||||||
|
|
||||||
connections.push_back(cnx);
|
connections.push_back(cnx);
|
||||||
|
|
||||||
|
|
@ -413,21 +413,21 @@ namespace cryptonote
|
||||||
|
|
||||||
template<class t_core>
|
template<class t_core>
|
||||||
double t_cryptonote_protocol_handler<t_core>::get_avg_block_size() {
|
double t_cryptonote_protocol_handler<t_core>::get_avg_block_size() {
|
||||||
// return m_core.get_blockchain_storage().get_avg_block_size(count); // this does not count too well the actuall network-size of data we need to download
|
// return m_core.get_blockchain_storage().get_avg_block_size(count); // this does not count too well the actuall network-size of data we need to download
|
||||||
|
|
||||||
CRITICAL_REGION_LOCAL(m_buffer_mutex);
|
CRITICAL_REGION_LOCAL(m_buffer_mutex);
|
||||||
double avg = 0;
|
double avg = 0;
|
||||||
if (m_avg_buffer.size() == 0) {
|
if (m_avg_buffer.size() == 0) {
|
||||||
_warn("m_avg_buffer.size() == 0");
|
_warn("m_avg_buffer.size() == 0");
|
||||||
return 500;
|
return 500;
|
||||||
}
|
}
|
||||||
|
|
||||||
const bool dbg_poke_lock = 0; // debug: try to trigger an error by poking around with locks. TODO: configure option
|
const bool dbg_poke_lock = 0; // debug: try to trigger an error by poking around with locks. TODO: configure option
|
||||||
long int dbg_repeat=0;
|
long int dbg_repeat=0;
|
||||||
do {
|
do {
|
||||||
for (auto element : m_avg_buffer) avg += element;
|
for (auto element : m_avg_buffer) avg += element;
|
||||||
} while(dbg_poke_lock && (dbg_repeat++)<100000); // in debug/poke mode, repeat this calculation to trigger hidden locking error if there is one
|
} while(dbg_poke_lock && (dbg_repeat++)<100000); // in debug/poke mode, repeat this calculation to trigger hidden locking error if there is one
|
||||||
return avg / m_avg_buffer.size();
|
return avg / m_avg_buffer.size();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -440,33 +440,33 @@ namespace cryptonote
|
||||||
size_t size = 0;
|
size_t size = 0;
|
||||||
for (auto element : arg.txs) size += element.size();
|
for (auto element : arg.txs) size += element.size();
|
||||||
|
|
||||||
for (auto element : arg.blocks) {
|
for (auto element : arg.blocks) {
|
||||||
size += element.block.size();
|
size += element.block.size();
|
||||||
for (auto tx : element.txs)
|
for (auto tx : element.txs)
|
||||||
size += tx.size();
|
size += tx.size();
|
||||||
}
|
}
|
||||||
|
|
||||||
for (auto element : arg.missed_ids)
|
for (auto element : arg.missed_ids)
|
||||||
size += sizeof(element.data);
|
size += sizeof(element.data);
|
||||||
|
|
||||||
size += sizeof(arg.current_blockchain_height);
|
size += sizeof(arg.current_blockchain_height);
|
||||||
{
|
{
|
||||||
CRITICAL_REGION_LOCAL(m_buffer_mutex);
|
CRITICAL_REGION_LOCAL(m_buffer_mutex);
|
||||||
m_avg_buffer.push_back(size);
|
m_avg_buffer.push_back(size);
|
||||||
|
|
||||||
const bool dbg_poke_lock = 0; // debug: try to trigger an error by poking around with locks. TODO: configure option
|
const bool dbg_poke_lock = 0; // debug: try to trigger an error by poking around with locks. TODO: configure option
|
||||||
long int dbg_repeat=0;
|
long int dbg_repeat=0;
|
||||||
do {
|
do {
|
||||||
m_avg_buffer.push_back(666); // a test value
|
m_avg_buffer.push_back(666); // a test value
|
||||||
m_avg_buffer.erase_end(1);
|
m_avg_buffer.erase_end(1);
|
||||||
} while(dbg_poke_lock && (dbg_repeat++)<100000); // in debug/poke mode, repeat this calculation to trigger hidden locking error if there is one
|
} while(dbg_poke_lock && (dbg_repeat++)<100000); // in debug/poke mode, repeat this calculation to trigger hidden locking error if there is one
|
||||||
}
|
}
|
||||||
/*using namespace boost::chrono;
|
/*using namespace boost::chrono;
|
||||||
auto point = steady_clock::now();
|
auto point = steady_clock::now();
|
||||||
auto time_from_epoh = point.time_since_epoch();
|
auto time_from_epoh = point.time_since_epoch();
|
||||||
auto sec = duration_cast< seconds >( time_from_epoh ).count();*/
|
auto sec = duration_cast< seconds >( time_from_epoh ).count();*/
|
||||||
|
|
||||||
//epee::net_utils::network_throttle_manager::get_global_throttle_inreq().logger_handle_net("log/dr-monero/net/req-all.data", sec, get_avg_block_size());
|
//epee::net_utils::network_throttle_manager::get_global_throttle_inreq().logger_handle_net("log/dr-monero/net/req-all.data", sec, get_avg_block_size());
|
||||||
|
|
||||||
if(context.m_last_response_height > arg.current_blockchain_height)
|
if(context.m_last_response_height > arg.current_blockchain_height)
|
||||||
{
|
{
|
||||||
|
|
@ -540,67 +540,66 @@ namespace cryptonote
|
||||||
|
|
||||||
if (m_core.get_test_drop_download() && m_core.get_test_drop_download_height()) { // DISCARD BLOCKS for testing
|
if (m_core.get_test_drop_download() && m_core.get_test_drop_download_height()) { // DISCARD BLOCKS for testing
|
||||||
|
|
||||||
uint64_t previous_height = m_core.get_current_blockchain_height();
|
uint64_t previous_height = m_core.get_current_blockchain_height();
|
||||||
|
|
||||||
m_core.prepare_handle_incoming_blocks(arg.blocks);
|
m_core.prepare_handle_incoming_blocks(arg.blocks);
|
||||||
BOOST_FOREACH(const block_complete_entry& block_entry, arg.blocks)
|
BOOST_FOREACH(const block_complete_entry& block_entry, arg.blocks)
|
||||||
{
|
{
|
||||||
// process transactions
|
// process transactions
|
||||||
TIME_MEASURE_START(transactions_process_time);
|
TIME_MEASURE_START(transactions_process_time);
|
||||||
BOOST_FOREACH(auto& tx_blob, block_entry.txs)
|
BOOST_FOREACH(auto& tx_blob, block_entry.txs)
|
||||||
{
|
{
|
||||||
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
|
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
|
||||||
m_core.handle_incoming_tx(tx_blob, tvc, true, true);
|
m_core.handle_incoming_tx(tx_blob, tvc, true, true);
|
||||||
if(tvc.m_verifivation_failed)
|
if(tvc.m_verifivation_failed)
|
||||||
{
|
{
|
||||||
LOG_ERROR_CCONTEXT("transaction verification failed on NOTIFY_RESPONSE_GET_OBJECTS, \r\ntx_id = "
|
LOG_ERROR_CCONTEXT("transaction verification failed on NOTIFY_RESPONSE_GET_OBJECTS, \r\ntx_id = "
|
||||||
<< epee::string_tools::pod_to_hex(get_blob_hash(tx_blob)) << ", dropping connection");
|
<< epee::string_tools::pod_to_hex(get_blob_hash(tx_blob)) << ", dropping connection");
|
||||||
m_p2p->drop_connection(context);
|
m_p2p->drop_connection(context);
|
||||||
m_core.cleanup_handle_incoming_blocks();
|
m_core.cleanup_handle_incoming_blocks();
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
TIME_MEASURE_FINISH(transactions_process_time);
|
TIME_MEASURE_FINISH(transactions_process_time);
|
||||||
|
|
||||||
// process block
|
// process block
|
||||||
|
|
||||||
TIME_MEASURE_START(block_process_time);
|
TIME_MEASURE_START(block_process_time);
|
||||||
block_verification_context bvc = boost::value_initialized<block_verification_context>();
|
block_verification_context bvc = boost::value_initialized<block_verification_context>();
|
||||||
|
|
||||||
m_core.handle_incoming_block(block_entry.block, bvc, false); // <--- process block
|
m_core.handle_incoming_block(block_entry.block, bvc, false); // <--- process block
|
||||||
|
|
||||||
if(bvc.m_verifivation_failed)
|
if(bvc.m_verifivation_failed)
|
||||||
{
|
{
|
||||||
LOG_PRINT_CCONTEXT_L1("Block verification failed, dropping connection");
|
LOG_PRINT_CCONTEXT_L1("Block verification failed, dropping connection");
|
||||||
m_p2p->drop_connection(context);
|
m_p2p->drop_connection(context);
|
||||||
m_p2p->add_ip_fail(context.m_remote_ip);
|
m_p2p->add_ip_fail(context.m_remote_ip);
|
||||||
m_core.cleanup_handle_incoming_blocks();
|
m_core.cleanup_handle_incoming_blocks();
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
if(bvc.m_marked_as_orphaned)
|
if(bvc.m_marked_as_orphaned)
|
||||||
{
|
{
|
||||||
LOG_PRINT_CCONTEXT_L1("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);
|
||||||
m_p2p->add_ip_fail(context.m_remote_ip);
|
m_p2p->add_ip_fail(context.m_remote_ip);
|
||||||
m_core.cleanup_handle_incoming_blocks();
|
m_core.cleanup_handle_incoming_blocks();
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
TIME_MEASURE_FINISH(block_process_time);
|
TIME_MEASURE_FINISH(block_process_time);
|
||||||
LOG_PRINT_CCONTEXT_L2("Block process time: " << block_process_time + transactions_process_time << "(" << transactions_process_time << "/" << block_process_time << ")ms");
|
LOG_PRINT_CCONTEXT_L2("Block process time: " << block_process_time + transactions_process_time << "(" << transactions_process_time << "/" << block_process_time << ")ms");
|
||||||
|
|
||||||
epee::net_utils::data_logger::get_instance().add_data("calc_time", block_process_time + transactions_process_time);
|
epee::net_utils::data_logger::get_instance().add_data("calc_time", block_process_time + transactions_process_time);
|
||||||
epee::net_utils::data_logger::get_instance().add_data("block_processing", 1);
|
epee::net_utils::data_logger::get_instance().add_data("block_processing", 1);
|
||||||
|
|
||||||
|
} // each download block
|
||||||
|
m_core.cleanup_handle_incoming_blocks();
|
||||||
|
|
||||||
} // each download block
|
if (m_core.get_current_blockchain_height() > previous_height)
|
||||||
m_core.cleanup_handle_incoming_blocks();
|
{
|
||||||
|
LOG_PRINT_CCONTEXT_YELLOW( "Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height() , LOG_LEVEL_0);
|
||||||
if (m_core.get_current_blockchain_height() > previous_height)
|
}
|
||||||
{
|
} // if not DISCARD BLOCK
|
||||||
LOG_PRINT_CCONTEXT_YELLOW( "Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height() , LOG_LEVEL_0);
|
|
||||||
}
|
|
||||||
} // if not DISCARD BLOCK
|
|
||||||
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
@ -632,14 +631,14 @@ namespace cryptonote
|
||||||
template<class t_core>
|
template<class t_core>
|
||||||
bool t_cryptonote_protocol_handler<t_core>::request_missing_objects(cryptonote_connection_context& context, bool check_having_blocks)
|
bool t_cryptonote_protocol_handler<t_core>::request_missing_objects(cryptonote_connection_context& context, bool check_having_blocks)
|
||||||
{
|
{
|
||||||
//if (!m_one_request == false)
|
//if (!m_one_request == false)
|
||||||
//return true;
|
//return true;
|
||||||
m_one_request = false;
|
m_one_request = false;
|
||||||
// save request size to log (dr monero)
|
// save request size to log (dr monero)
|
||||||
/*using namespace boost::chrono;
|
/*using namespace boost::chrono;
|
||||||
auto point = steady_clock::now();
|
auto point = steady_clock::now();
|
||||||
auto time_from_epoh = point.time_since_epoch();
|
auto time_from_epoh = point.time_since_epoch();
|
||||||
auto sec = duration_cast< seconds >( time_from_epoh ).count();*/
|
auto sec = duration_cast< seconds >( time_from_epoh ).count();*/
|
||||||
|
|
||||||
if(context.m_needed_objects.size())
|
if(context.m_needed_objects.size())
|
||||||
{
|
{
|
||||||
|
|
@ -648,8 +647,8 @@ namespace cryptonote
|
||||||
size_t count = 0;
|
size_t count = 0;
|
||||||
auto it = context.m_needed_objects.begin();
|
auto it = context.m_needed_objects.begin();
|
||||||
|
|
||||||
size_t count_limit = BLOCKS_SYNCHRONIZING_DEFAULT_COUNT;
|
size_t count_limit = BLOCKS_SYNCHRONIZING_DEFAULT_COUNT;
|
||||||
_note_c("net/req-calc" , "Setting count_limit: " << count_limit);
|
_note_c("net/req-calc" , "Setting count_limit: " << count_limit);
|
||||||
while(it != context.m_needed_objects.end() && count < BLOCKS_SYNCHRONIZING_DEFAULT_COUNT)
|
while(it != context.m_needed_objects.end() && count < BLOCKS_SYNCHRONIZING_DEFAULT_COUNT)
|
||||||
{
|
{
|
||||||
if( !(check_having_blocks && m_core.have_block(*it)))
|
if( !(check_having_blocks && m_core.have_block(*it)))
|
||||||
|
|
@ -661,8 +660,8 @@ namespace cryptonote
|
||||||
context.m_needed_objects.erase(it++);
|
context.m_needed_objects.erase(it++);
|
||||||
}
|
}
|
||||||
LOG_PRINT_CCONTEXT_L1("-->>NOTIFY_REQUEST_GET_OBJECTS: blocks.size()=" << req.blocks.size() << ", txs.size()=" << req.txs.size()
|
LOG_PRINT_CCONTEXT_L1("-->>NOTIFY_REQUEST_GET_OBJECTS: blocks.size()=" << req.blocks.size() << ", txs.size()=" << req.txs.size()
|
||||||
<< "requested blocks count=" << count << " / " << count_limit);
|
<< "requested blocks count=" << count << " / " << count_limit);
|
||||||
//epee::net_utils::network_throttle_manager::get_global_throttle_inreq().logger_handle_net("log/dr-monero/net/req-all.data", sec, get_avg_block_size());
|
//epee::net_utils::network_throttle_manager::get_global_throttle_inreq().logger_handle_net("log/dr-monero/net/req-all.data", sec, get_avg_block_size());
|
||||||
|
|
||||||
post_notify<NOTIFY_REQUEST_GET_OBJECTS>(req, context);
|
post_notify<NOTIFY_REQUEST_GET_OBJECTS>(req, context);
|
||||||
}else if(context.m_last_response_height < context.m_remote_blockchain_height-1)
|
}else if(context.m_last_response_height < context.m_remote_blockchain_height-1)
|
||||||
|
|
@ -670,12 +669,12 @@ namespace cryptonote
|
||||||
|
|
||||||
NOTIFY_REQUEST_CHAIN::request r = boost::value_initialized<NOTIFY_REQUEST_CHAIN::request>();
|
NOTIFY_REQUEST_CHAIN::request r = boost::value_initialized<NOTIFY_REQUEST_CHAIN::request>();
|
||||||
m_core.get_short_chain_history(r.block_ids);
|
m_core.get_short_chain_history(r.block_ids);
|
||||||
handler_request_blocks_history( r.block_ids ); // change the limit(?), sleep(?)
|
handler_request_blocks_history( r.block_ids ); // change the limit(?), sleep(?)
|
||||||
|
|
||||||
//std::string blob; // for calculate size of request
|
//std::string blob; // for calculate size of request
|
||||||
//epee::serialization::store_t_to_binary(r, blob);
|
//epee::serialization::store_t_to_binary(r, blob);
|
||||||
//epee::net_utils::network_throttle_manager::get_global_throttle_inreq().logger_handle_net("log/dr-monero/net/req-all.data", sec, get_avg_block_size());
|
//epee::net_utils::network_throttle_manager::get_global_throttle_inreq().logger_handle_net("log/dr-monero/net/req-all.data", sec, get_avg_block_size());
|
||||||
LOG_PRINT_CCONTEXT_L1("r = " << 200);
|
LOG_PRINT_CCONTEXT_L1("r = " << 200);
|
||||||
|
|
||||||
LOG_PRINT_CCONTEXT_L1("-->>NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << r.block_ids.size() );
|
LOG_PRINT_CCONTEXT_L1("-->>NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << r.block_ids.size() );
|
||||||
post_notify<NOTIFY_REQUEST_CHAIN>(r, context);
|
post_notify<NOTIFY_REQUEST_CHAIN>(r, context);
|
||||||
|
|
@ -783,17 +782,17 @@ namespace cryptonote
|
||||||
return relay_post_notify<NOTIFY_NEW_TRANSACTIONS>(arg, exclude_context);
|
return relay_post_notify<NOTIFY_NEW_TRANSACTIONS>(arg, exclude_context);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// @deprecated
|
/// @deprecated
|
||||||
template<class t_core> std::ofstream& t_cryptonote_protocol_handler<t_core>::get_logreq() const {
|
template<class t_core> std::ofstream& t_cryptonote_protocol_handler<t_core>::get_logreq() const {
|
||||||
static std::ofstream * logreq=NULL;
|
static std::ofstream * logreq=NULL;
|
||||||
if (!logreq) {
|
if (!logreq) {
|
||||||
LOG_PRINT_RED("LOG OPENED",LOG_LEVEL_0);
|
LOG_PRINT_RED("LOG OPENED",LOG_LEVEL_0);
|
||||||
logreq = new std::ofstream("logreq.txt"); // leak mem (singleton)
|
logreq = new std::ofstream("logreq.txt"); // leak mem (singleton)
|
||||||
*logreq << "Opened log" << std::endl;
|
*logreq << "Opened log" << std::endl;
|
||||||
}
|
}
|
||||||
LOG_PRINT_YELLOW("LOG USED",LOG_LEVEL_0);
|
LOG_PRINT_YELLOW("LOG USED",LOG_LEVEL_0);
|
||||||
(*logreq) << "log used" << std::endl;
|
(*logreq) << "log used" << std::endl;
|
||||||
return *logreq;
|
return *logreq;
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
|
||||||
|
|
@ -28,12 +28,12 @@
|
||||||
|
|
||||||
set(blocksdat "")
|
set(blocksdat "")
|
||||||
if(PER_BLOCK_CHECKPOINT)
|
if(PER_BLOCK_CHECKPOINT)
|
||||||
if(APPLE)
|
if(APPLE)
|
||||||
add_custom_command(OUTPUT blocksdat.o COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && touch stub.c && ${CMAKE_C_COMPILER} -o stub.o -c stub.c COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && ld -r -sectcreate __DATA __blocks_dat ../blocks/checkpoints.dat -o ${CMAKE_CURRENT_BINARY_DIR}/blocksdat.o stub.o && rm -f stub.*)
|
add_custom_command(OUTPUT blocksdat.o COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && touch stub.c && ${CMAKE_C_COMPILER} -o stub.o -c stub.c COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && ld -r -sectcreate __DATA __blocks_dat ../blocks/checkpoints.dat -o ${CMAKE_CURRENT_BINARY_DIR}/blocksdat.o stub.o && rm -f stub.*)
|
||||||
else()
|
else()
|
||||||
add_custom_command(OUTPUT blocksdat.o COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && cp ../blocks/checkpoints.dat blocks.dat && ld -r -b binary -o ${CMAKE_CURRENT_BINARY_DIR}/blocksdat.o blocks.dat && rm -f blocks.dat)
|
add_custom_command(OUTPUT blocksdat.o COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && cp ../blocks/checkpoints.dat blocks.dat && ld -r -b binary -o ${CMAKE_CURRENT_BINARY_DIR}/blocksdat.o blocks.dat && rm -f blocks.dat)
|
||||||
endif()
|
endif()
|
||||||
set(blocksdat "blocksdat.o")
|
set(blocksdat "blocksdat.o")
|
||||||
endif()
|
endif()
|
||||||
|
|
||||||
set(daemon_sources
|
set(daemon_sources
|
||||||
|
|
|
||||||
|
|
@ -51,8 +51,8 @@ int main(int argc, char const * argv[])
|
||||||
{
|
{
|
||||||
try {
|
try {
|
||||||
|
|
||||||
_note_c("dbg/main", "Begin of main()");
|
_note_c("dbg/main", "Begin of main()");
|
||||||
// TODO parse the debug options like set log level right here at start
|
// TODO parse the debug options like set log level right here at start
|
||||||
|
|
||||||
tools::sanitize_locale();
|
tools::sanitize_locale();
|
||||||
|
|
||||||
|
|
@ -261,7 +261,7 @@ int main(int argc, char const * argv[])
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
_note_c("dbg/main", "Moving from main() into the daemonize now.");
|
_note_c("dbg/main", "Moving from main() into the daemonize now.");
|
||||||
|
|
||||||
return daemonizer::daemonize(argc, argv, daemonize::t_executor{}, vm);
|
return daemonizer::daemonize(argc, argv, daemonize::t_executor{}, vm);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -83,15 +83,15 @@ namespace nodetool
|
||||||
typedef t_payload_net_handler payload_net_handler;
|
typedef t_payload_net_handler payload_net_handler;
|
||||||
|
|
||||||
node_server(t_payload_net_handler& payload_handler)
|
node_server(t_payload_net_handler& payload_handler)
|
||||||
:m_payload_handler(payload_handler),
|
:m_payload_handler(payload_handler),
|
||||||
m_current_number_of_out_peers(0),
|
m_current_number_of_out_peers(0),
|
||||||
m_allow_local_ip(false),
|
m_allow_local_ip(false),
|
||||||
m_hide_my_port(false),
|
m_hide_my_port(false),
|
||||||
m_no_igd(false),
|
m_no_igd(false),
|
||||||
m_offline(false),
|
m_offline(false),
|
||||||
m_save_graph(false),
|
m_save_graph(false),
|
||||||
is_closing(false),
|
is_closing(false),
|
||||||
m_net_server( epee::net_utils::e_connection_type_P2P ) // this is a P2P connection of the main p2p node server, because this is class node_server<>
|
m_net_server( epee::net_utils::e_connection_type_P2P ) // this is a P2P connection of the main p2p node server, because this is class node_server<>
|
||||||
{}
|
{}
|
||||||
virtual ~node_server()
|
virtual ~node_server()
|
||||||
{}
|
{}
|
||||||
|
|
@ -215,20 +215,20 @@ namespace nodetool
|
||||||
template <class Container>
|
template <class Container>
|
||||||
bool parse_peers_and_add_to_container(const boost::program_options::variables_map& vm, const command_line::arg_descriptor<std::vector<std::string> > & arg, Container& container);
|
bool parse_peers_and_add_to_container(const boost::program_options::variables_map& vm, const command_line::arg_descriptor<std::vector<std::string> > & arg, Container& container);
|
||||||
|
|
||||||
bool set_max_out_peers(const boost::program_options::variables_map& vm, int64_t max);
|
bool set_max_out_peers(const boost::program_options::variables_map& vm, int64_t max);
|
||||||
bool set_tos_flag(const boost::program_options::variables_map& vm, int limit);
|
bool set_tos_flag(const boost::program_options::variables_map& vm, int limit);
|
||||||
|
|
||||||
bool set_rate_up_limit(const boost::program_options::variables_map& vm, int64_t limit);
|
bool set_rate_up_limit(const boost::program_options::variables_map& vm, int64_t limit);
|
||||||
bool set_rate_down_limit(const boost::program_options::variables_map& vm, int64_t limit);
|
bool set_rate_down_limit(const boost::program_options::variables_map& vm, int64_t limit);
|
||||||
bool set_rate_limit(const boost::program_options::variables_map& vm, int64_t limit);
|
bool set_rate_limit(const boost::program_options::variables_map& vm, int64_t limit);
|
||||||
|
|
||||||
void kill() { ///< will be called e.g. from deinit()
|
void kill() { ///< will be called e.g. from deinit()
|
||||||
_info("Killing the net_node");
|
_info("Killing the net_node");
|
||||||
is_closing = true;
|
is_closing = true;
|
||||||
if(mPeersLoggerThread != nullptr)
|
if(mPeersLoggerThread != nullptr)
|
||||||
mPeersLoggerThread->join(); // make sure the thread finishes
|
mPeersLoggerThread->join(); // make sure the thread finishes
|
||||||
_info("Joined extra background net_node threads");
|
_info("Joined extra background net_node threads");
|
||||||
}
|
}
|
||||||
|
|
||||||
//debug functions
|
//debug functions
|
||||||
std::string print_connections_container();
|
std::string print_connections_container();
|
||||||
|
|
@ -247,16 +247,16 @@ namespace nodetool
|
||||||
END_KV_SERIALIZE_MAP()
|
END_KV_SERIALIZE_MAP()
|
||||||
};
|
};
|
||||||
|
|
||||||
public:
|
public:
|
||||||
config m_config; // TODO was private, add getters?
|
config m_config; // TODO was private, add getters?
|
||||||
std::atomic<unsigned int> m_current_number_of_out_peers;
|
std::atomic<unsigned int> m_current_number_of_out_peers;
|
||||||
|
|
||||||
void set_save_graph(bool save_graph)
|
void set_save_graph(bool save_graph)
|
||||||
{
|
{
|
||||||
m_save_graph = save_graph;
|
m_save_graph = save_graph;
|
||||||
epee::net_utils::connection_basic::set_save_graph(save_graph);
|
epee::net_utils::connection_basic::set_save_graph(save_graph);
|
||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
std::string m_config_folder;
|
std::string m_config_folder;
|
||||||
|
|
||||||
bool m_have_address;
|
bool m_have_address;
|
||||||
|
|
@ -270,7 +270,7 @@ namespace nodetool
|
||||||
bool m_offline;
|
bool m_offline;
|
||||||
std::atomic<bool> m_save_graph;
|
std::atomic<bool> m_save_graph;
|
||||||
std::atomic<bool> is_closing;
|
std::atomic<bool> is_closing;
|
||||||
std::unique_ptr<std::thread> mPeersLoggerThread;
|
std::unique_ptr<std::thread> mPeersLoggerThread;
|
||||||
//critical_section m_connections_lock;
|
//critical_section m_connections_lock;
|
||||||
//connections_indexed_container m_connections;
|
//connections_indexed_container m_connections;
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -90,16 +90,16 @@ namespace nodetool
|
||||||
const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_seed_node = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"};
|
const command_line::arg_descriptor<std::vector<std::string> > arg_p2p_seed_node = {"seed-node", "Connect to a node to retrieve peer addresses, and disconnect"};
|
||||||
const command_line::arg_descriptor<bool> arg_p2p_hide_my_port = {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true};
|
const command_line::arg_descriptor<bool> arg_p2p_hide_my_port = {"hide-my-port", "Do not announce yourself as peerlist candidate", false, true};
|
||||||
|
|
||||||
const command_line::arg_descriptor<bool> arg_no_igd = {"no-igd", "Disable UPnP port mapping"};
|
const command_line::arg_descriptor<bool> arg_no_igd = {"no-igd", "Disable UPnP port mapping"};
|
||||||
const command_line::arg_descriptor<bool> arg_offline = {"offline", "Do not listen for peers, nor connect to any"};
|
const command_line::arg_descriptor<bool> arg_offline = {"offline", "Do not listen for peers, nor connect to any"};
|
||||||
const command_line::arg_descriptor<int64_t> arg_out_peers = {"out-peers", "set max limit of out peers", -1};
|
const command_line::arg_descriptor<int64_t> arg_out_peers = {"out-peers", "set max limit of out peers", -1};
|
||||||
const command_line::arg_descriptor<int> arg_tos_flag = {"tos-flag", "set TOS flag", -1};
|
const command_line::arg_descriptor<int> arg_tos_flag = {"tos-flag", "set TOS flag", -1};
|
||||||
|
|
||||||
const command_line::arg_descriptor<int64_t> arg_limit_rate_up = {"limit-rate-up", "set limit-rate-up [kB/s]", -1};
|
const command_line::arg_descriptor<int64_t> arg_limit_rate_up = {"limit-rate-up", "set limit-rate-up [kB/s]", -1};
|
||||||
const command_line::arg_descriptor<int64_t> arg_limit_rate_down = {"limit-rate-down", "set limit-rate-down [kB/s]", -1};
|
const command_line::arg_descriptor<int64_t> arg_limit_rate_down = {"limit-rate-down", "set limit-rate-down [kB/s]", -1};
|
||||||
const command_line::arg_descriptor<int64_t> arg_limit_rate = {"limit-rate", "set limit-rate [kB/s]", -1};
|
const command_line::arg_descriptor<int64_t> arg_limit_rate = {"limit-rate", "set limit-rate [kB/s]", -1};
|
||||||
|
|
||||||
const command_line::arg_descriptor<bool> arg_save_graph = {"save-graph", "Save data for dr monero", false};
|
const command_line::arg_descriptor<bool> arg_save_graph = {"save-graph", "Save data for dr monero", false};
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
|
|
@ -268,8 +268,8 @@ namespace nodetool
|
||||||
|
|
||||||
if(command_line::has_arg(vm, arg_save_graph))
|
if(command_line::has_arg(vm, arg_save_graph))
|
||||||
{
|
{
|
||||||
set_save_graph(true);
|
set_save_graph(true);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (command_line::has_arg(vm,arg_p2p_add_exclusive_node))
|
if (command_line::has_arg(vm,arg_p2p_add_exclusive_node))
|
||||||
{
|
{
|
||||||
|
|
@ -293,19 +293,19 @@ namespace nodetool
|
||||||
m_hide_my_port = true;
|
m_hide_my_port = true;
|
||||||
|
|
||||||
if ( !set_max_out_peers(vm, command_line::get_arg(vm, arg_out_peers) ) )
|
if ( !set_max_out_peers(vm, command_line::get_arg(vm, arg_out_peers) ) )
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
if ( !set_tos_flag(vm, command_line::get_arg(vm, arg_tos_flag) ) )
|
if ( !set_tos_flag(vm, command_line::get_arg(vm, arg_tos_flag) ) )
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
if ( !set_rate_up_limit(vm, command_line::get_arg(vm, arg_limit_rate_up) ) )
|
if ( !set_rate_up_limit(vm, command_line::get_arg(vm, arg_limit_rate_up) ) )
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
if ( !set_rate_down_limit(vm, command_line::get_arg(vm, arg_limit_rate_down) ) )
|
if ( !set_rate_down_limit(vm, command_line::get_arg(vm, arg_limit_rate_down) ) )
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
if ( !set_rate_limit(vm, command_line::get_arg(vm, arg_limit_rate) ) )
|
if ( !set_rate_limit(vm, command_line::get_arg(vm, arg_limit_rate) ) )
|
||||||
return false;
|
return false;
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
@ -512,48 +512,48 @@ namespace nodetool
|
||||||
|
|
||||||
// Add UPnP port mapping
|
// Add UPnP port mapping
|
||||||
if(m_no_igd == false) {
|
if(m_no_igd == false) {
|
||||||
LOG_PRINT_L0("Attempting to add IGD port mapping.");
|
LOG_PRINT_L0("Attempting to add IGD port mapping.");
|
||||||
int result;
|
int result;
|
||||||
#if MINIUPNPC_API_VERSION > 13
|
#if MINIUPNPC_API_VERSION > 13
|
||||||
// default according to miniupnpc.h
|
// default according to miniupnpc.h
|
||||||
unsigned char ttl = 2;
|
unsigned char ttl = 2;
|
||||||
UPNPDev* deviceList = upnpDiscover(1000, NULL, NULL, 0, 0, ttl, &result);
|
UPNPDev* deviceList = upnpDiscover(1000, NULL, NULL, 0, 0, ttl, &result);
|
||||||
#else
|
#else
|
||||||
UPNPDev* deviceList = upnpDiscover(1000, NULL, NULL, 0, 0, &result);
|
UPNPDev* deviceList = upnpDiscover(1000, NULL, NULL, 0, 0, &result);
|
||||||
#endif
|
#endif
|
||||||
UPNPUrls urls;
|
UPNPUrls urls;
|
||||||
IGDdatas igdData;
|
IGDdatas igdData;
|
||||||
char lanAddress[64];
|
char lanAddress[64];
|
||||||
result = UPNP_GetValidIGD(deviceList, &urls, &igdData, lanAddress, sizeof lanAddress);
|
result = UPNP_GetValidIGD(deviceList, &urls, &igdData, lanAddress, sizeof lanAddress);
|
||||||
freeUPNPDevlist(deviceList);
|
freeUPNPDevlist(deviceList);
|
||||||
if (result != 0) {
|
if (result != 0) {
|
||||||
if (result == 1) {
|
if (result == 1) {
|
||||||
std::ostringstream portString;
|
std::ostringstream portString;
|
||||||
portString << m_listenning_port;
|
portString << m_listenning_port;
|
||||||
|
|
||||||
// Delete the port mapping before we create it, just in case we have dangling port mapping from the daemon not being shut down correctly
|
// Delete the port mapping before we create it, just in case we have dangling port mapping from the daemon not being shut down correctly
|
||||||
UPNP_DeletePortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), "TCP", 0);
|
UPNP_DeletePortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), "TCP", 0);
|
||||||
|
|
||||||
int portMappingResult;
|
int portMappingResult;
|
||||||
portMappingResult = UPNP_AddPortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), portString.str().c_str(), lanAddress, CRYPTONOTE_NAME, "TCP", 0, "0");
|
portMappingResult = UPNP_AddPortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), portString.str().c_str(), lanAddress, CRYPTONOTE_NAME, "TCP", 0, "0");
|
||||||
if (portMappingResult != 0) {
|
if (portMappingResult != 0) {
|
||||||
LOG_ERROR("UPNP_AddPortMapping failed, error: " << strupnperror(portMappingResult));
|
LOG_ERROR("UPNP_AddPortMapping failed, error: " << strupnperror(portMappingResult));
|
||||||
} else {
|
} else {
|
||||||
LOG_PRINT_GREEN("Added IGD port mapping.", LOG_LEVEL_0);
|
LOG_PRINT_GREEN("Added IGD port mapping.", LOG_LEVEL_0);
|
||||||
}
|
}
|
||||||
} else if (result == 2) {
|
} else if (result == 2) {
|
||||||
LOG_PRINT_L0("IGD was found but reported as not connected.");
|
LOG_PRINT_L0("IGD was found but reported as not connected.");
|
||||||
} else if (result == 3) {
|
} else if (result == 3) {
|
||||||
LOG_PRINT_L0("UPnP device was found but not recoginzed as IGD.");
|
LOG_PRINT_L0("UPnP device was found but not recoginzed as IGD.");
|
||||||
} else {
|
} else {
|
||||||
LOG_ERROR("UPNP_GetValidIGD returned an unknown result code.");
|
LOG_ERROR("UPNP_GetValidIGD returned an unknown result code.");
|
||||||
}
|
}
|
||||||
|
|
||||||
FreeUPNPUrls(&urls);
|
FreeUPNPUrls(&urls);
|
||||||
} else {
|
} else {
|
||||||
LOG_PRINT_L0("No IGD was found.");
|
LOG_PRINT_L0("No IGD was found.");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return res;
|
return res;
|
||||||
}
|
}
|
||||||
//-----------------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------------
|
||||||
|
|
@ -566,29 +566,29 @@ namespace nodetool
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::run()
|
bool node_server<t_payload_net_handler>::run()
|
||||||
{
|
{
|
||||||
// creating thread to log number of connections
|
// creating thread to log number of connections
|
||||||
mPeersLoggerThread.reset(new std::thread([&]()
|
mPeersLoggerThread.reset(new std::thread([&]()
|
||||||
{
|
{
|
||||||
_note("Thread monitor number of peers - start");
|
_note("Thread monitor number of peers - start");
|
||||||
while (!is_closing)
|
while (!is_closing)
|
||||||
{ // main loop of thread
|
{ // main loop of thread
|
||||||
//number_of_peers = m_net_server.get_config_object().get_connections_count();
|
//number_of_peers = m_net_server.get_config_object().get_connections_count();
|
||||||
unsigned int number_of_peers = 0;
|
unsigned int number_of_peers = 0;
|
||||||
m_net_server.get_config_object().foreach_connection([&](const p2p_connection_context& cntxt)
|
m_net_server.get_config_object().foreach_connection([&](const p2p_connection_context& cntxt)
|
||||||
{
|
{
|
||||||
if (!cntxt.m_is_income) ++number_of_peers;
|
if (!cntxt.m_is_income) ++number_of_peers;
|
||||||
return true;
|
return true;
|
||||||
}); // lambda
|
}); // lambda
|
||||||
|
|
||||||
m_current_number_of_out_peers = number_of_peers;
|
m_current_number_of_out_peers = number_of_peers;
|
||||||
if (epee::net_utils::data_logger::is_dying())
|
if (epee::net_utils::data_logger::is_dying())
|
||||||
break;
|
break;
|
||||||
epee::net_utils::data_logger::get_instance().add_data("peers", number_of_peers);
|
epee::net_utils::data_logger::get_instance().add_data("peers", number_of_peers);
|
||||||
|
|
||||||
std::this_thread::sleep_for(std::chrono::seconds(1));
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
||||||
} // main loop of thread
|
} // main loop of thread
|
||||||
_note("Thread monitor number of peers - done");
|
_note("Thread monitor number of peers - done");
|
||||||
})); // lambda
|
})); // lambda
|
||||||
|
|
||||||
//here you can set worker threads count
|
//here you can set worker threads count
|
||||||
int thrds_count = 10;
|
int thrds_count = 10;
|
||||||
|
|
@ -620,7 +620,7 @@ namespace nodetool
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::deinit()
|
bool node_server<t_payload_net_handler>::deinit()
|
||||||
{
|
{
|
||||||
kill();
|
kill();
|
||||||
m_peerlist.deinit();
|
m_peerlist.deinit();
|
||||||
m_net_server.deinit_server();
|
m_net_server.deinit_server();
|
||||||
return store_config();
|
return store_config();
|
||||||
|
|
@ -835,16 +835,16 @@ namespace nodetool
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist, uint64_t last_seen_stamp, bool white)
|
bool node_server<t_payload_net_handler>::try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist, uint64_t last_seen_stamp, bool white)
|
||||||
{
|
{
|
||||||
if (m_current_number_of_out_peers == m_config.m_net_config.connections_count) // out peers limit
|
if (m_current_number_of_out_peers == m_config.m_net_config.connections_count) // out peers limit
|
||||||
{
|
{
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
else if (m_current_number_of_out_peers > m_config.m_net_config.connections_count)
|
else if (m_current_number_of_out_peers > m_config.m_net_config.connections_count)
|
||||||
{
|
{
|
||||||
m_net_server.get_config_object().del_out_connections(1);
|
m_net_server.get_config_object().del_out_connections(1);
|
||||||
m_current_number_of_out_peers --; // atomic variable, update time = 1s
|
m_current_number_of_out_peers --; // atomic variable, update time = 1s
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
LOG_PRINT_L1("Connecting to " << epee::string_tools::get_ip_string_from_int32(na.ip) << ":"
|
LOG_PRINT_L1("Connecting to " << epee::string_tools::get_ip_string_from_int32(na.ip) << ":"
|
||||||
<< epee::string_tools::num_to_string_fast(na.port) << "(white=" << white << ", last_seen: "
|
<< epee::string_tools::num_to_string_fast(na.port) << "(white=" << white << ", last_seen: "
|
||||||
<< (last_seen_stamp ? epee::misc_utils::get_time_interval_string(time(NULL) - last_seen_stamp):"never")
|
<< (last_seen_stamp ? epee::misc_utils::get_time_interval_string(time(NULL) - last_seen_stamp):"never")
|
||||||
|
|
@ -946,12 +946,12 @@ namespace nodetool
|
||||||
|
|
||||||
++try_count;
|
++try_count;
|
||||||
|
|
||||||
_note("Considering connecting (out) to peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip) << ":" << boost::lexical_cast<std::string>(pe.adr.port));
|
_note("Considering connecting (out) to peer: " << pe.id << " " << epee::string_tools::get_ip_string_from_int32(pe.adr.ip) << ":" << boost::lexical_cast<std::string>(pe.adr.port));
|
||||||
|
|
||||||
if(is_peer_used(pe)) {
|
if(is_peer_used(pe)) {
|
||||||
_note("Peer is used");
|
_note("Peer is used");
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
if(!is_remote_ip_allowed(pe.adr.ip))
|
if(!is_remote_ip_allowed(pe.adr.ip))
|
||||||
continue;
|
continue;
|
||||||
|
|
@ -965,9 +965,9 @@ namespace nodetool
|
||||||
<< "] last_seen: " << (pe.last_seen ? epee::misc_utils::get_time_interval_string(time(NULL) - pe.last_seen) : "never"));
|
<< "] last_seen: " << (pe.last_seen ? epee::misc_utils::get_time_interval_string(time(NULL) - pe.last_seen) : "never"));
|
||||||
|
|
||||||
if(!try_to_connect_and_handshake_with_new_peer(pe.adr, false, pe.last_seen, use_white_list)) {
|
if(!try_to_connect_and_handshake_with_new_peer(pe.adr, false, pe.last_seen, use_white_list)) {
|
||||||
_note("Handshake failed");
|
_note("Handshake failed");
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
@ -1518,89 +1518,89 @@ namespace nodetool
|
||||||
|
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::set_max_out_peers(const boost::program_options::variables_map& vm, int64_t max)
|
bool node_server<t_payload_net_handler>::set_max_out_peers(const boost::program_options::variables_map& vm, int64_t max)
|
||||||
{
|
{
|
||||||
if(max == -1) {
|
if(max == -1) {
|
||||||
m_config.m_net_config.connections_count = P2P_DEFAULT_CONNECTIONS_COUNT;
|
m_config.m_net_config.connections_count = P2P_DEFAULT_CONNECTIONS_COUNT;
|
||||||
epee::net_utils::data_logger::get_instance().add_data("peers_limit", m_config.m_net_config.connections_count);
|
epee::net_utils::data_logger::get_instance().add_data("peers_limit", m_config.m_net_config.connections_count);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
epee::net_utils::data_logger::get_instance().add_data("peers_limit", max);
|
epee::net_utils::data_logger::get_instance().add_data("peers_limit", max);
|
||||||
m_config.m_net_config.connections_count = max;
|
m_config.m_net_config.connections_count = max;
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
void node_server<t_payload_net_handler>::delete_connections(size_t count)
|
void node_server<t_payload_net_handler>::delete_connections(size_t count)
|
||||||
{
|
{
|
||||||
m_net_server.get_config_object().del_out_connections(count);
|
m_net_server.get_config_object().del_out_connections(count);
|
||||||
}
|
}
|
||||||
|
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::set_tos_flag(const boost::program_options::variables_map& vm, int flag)
|
bool node_server<t_payload_net_handler>::set_tos_flag(const boost::program_options::variables_map& vm, int flag)
|
||||||
{
|
{
|
||||||
if(flag==-1){
|
if(flag==-1){
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_tos_flag(flag);
|
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_tos_flag(flag);
|
||||||
_dbg1("Set ToS flag " << flag);
|
_dbg1("Set ToS flag " << flag);
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
template<class t_payload_net_handler>
|
|
||||||
bool node_server<t_payload_net_handler>::set_rate_up_limit(const boost::program_options::variables_map& vm, int64_t limit)
|
|
||||||
{
|
|
||||||
this->islimitup=true;
|
|
||||||
|
|
||||||
if (limit==-1) {
|
|
||||||
limit=default_limit_up;
|
|
||||||
this->islimitup=false;
|
|
||||||
}
|
|
||||||
|
|
||||||
limit *= 1024;
|
|
||||||
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_up_limit( limit );
|
|
||||||
LOG_PRINT_L0("Set limit-up to " << limit/1024 << " kB/s");
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::set_rate_down_limit(const boost::program_options::variables_map& vm, int64_t limit)
|
bool node_server<t_payload_net_handler>::set_rate_up_limit(const boost::program_options::variables_map& vm, int64_t limit)
|
||||||
{
|
{
|
||||||
this->islimitdown=true;
|
this->islimitup=true;
|
||||||
if(limit==-1) {
|
|
||||||
limit=default_limit_down;
|
if (limit==-1) {
|
||||||
this->islimitdown=false;
|
limit=default_limit_up;
|
||||||
}
|
this->islimitup=false;
|
||||||
limit *= 1024;
|
}
|
||||||
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_down_limit( limit );
|
|
||||||
LOG_PRINT_L0("Set limit-down to " << limit/1024 << " kB/s");
|
limit *= 1024;
|
||||||
return true;
|
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_up_limit( limit );
|
||||||
}
|
LOG_PRINT_L0("Set limit-up to " << limit/1024 << " kB/s");
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
template<class t_payload_net_handler>
|
template<class t_payload_net_handler>
|
||||||
bool node_server<t_payload_net_handler>::set_rate_limit(const boost::program_options::variables_map& vm, int64_t limit)
|
bool node_server<t_payload_net_handler>::set_rate_down_limit(const boost::program_options::variables_map& vm, int64_t limit)
|
||||||
{
|
{
|
||||||
int64_t limit_up = 0;
|
this->islimitdown=true;
|
||||||
int64_t limit_down = 0;
|
if(limit==-1) {
|
||||||
|
limit=default_limit_down;
|
||||||
|
this->islimitdown=false;
|
||||||
|
}
|
||||||
|
limit *= 1024;
|
||||||
|
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_down_limit( limit );
|
||||||
|
LOG_PRINT_L0("Set limit-down to " << limit/1024 << " kB/s");
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
if(limit == -1)
|
template<class t_payload_net_handler>
|
||||||
{
|
bool node_server<t_payload_net_handler>::set_rate_limit(const boost::program_options::variables_map& vm, int64_t limit)
|
||||||
limit_up = default_limit_up * 1024;
|
{
|
||||||
limit_down = default_limit_down * 1024;
|
int64_t limit_up = 0;
|
||||||
}
|
int64_t limit_down = 0;
|
||||||
else
|
|
||||||
{
|
|
||||||
limit_up = limit * 1024;
|
|
||||||
limit_down = limit * 1024;
|
|
||||||
}
|
|
||||||
if(!this->islimitup) {
|
|
||||||
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_up_limit(limit_up);
|
|
||||||
LOG_PRINT_L0("Set limit-up to " << limit_up/1024 << " kB/s");
|
|
||||||
}
|
|
||||||
if(!this->islimitdown) {
|
|
||||||
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_down_limit(limit_down);
|
|
||||||
LOG_PRINT_L0("Set limit-down to " << limit_down/1024 << " kB/s");
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
if(limit == -1)
|
||||||
}
|
{
|
||||||
|
limit_up = default_limit_up * 1024;
|
||||||
|
limit_down = default_limit_down * 1024;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
limit_up = limit * 1024;
|
||||||
|
limit_down = limit * 1024;
|
||||||
|
}
|
||||||
|
if(!this->islimitup) {
|
||||||
|
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_up_limit(limit_up);
|
||||||
|
LOG_PRINT_L0("Set limit-up to " << limit_up/1024 << " kB/s");
|
||||||
|
}
|
||||||
|
if(!this->islimitdown) {
|
||||||
|
epee::net_utils::connection<epee::levin::async_protocol_handler<p2p_connection_context> >::set_rate_down_limit(limit_down);
|
||||||
|
LOG_PRINT_L0("Set limit-down to " << limit_down/1024 << " kB/s");
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue