kumi/danicoin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Replace tabs with two spaces for consistency with rest of codebase

Browse source 
Remove trailing whitespace in same files.
This commit is contained in:
warptangent 2015-12-13 20:54:39 -08:00
parent 042e85396c
commit 725acc7f17
No known key found for this signature in database
GPG key ID: 0E490BEBFBE4E92D
26 changed files with 1321 additions and 1323 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
CMakeLists.txt
View file

@ -1,21 +1,21 @@
# Copyright (c) 2014-2015, The Monero Project # Copyright (c) 2014-2015, The Monero Project
# #
# All rights reserved. # All rights reserved.
# #
# Redistribution and use in source and binary forms, with or without modification, are # Redistribution and use in source and binary forms, with or without modification, are
# permitted provided that the following conditions are met: # permitted provided that the following conditions are met:
# #
# 1. Redistributions of source code must retain the above copyright notice, this list of # 1. Redistributions of source code must retain the above copyright notice, this list of
# conditions and the following disclaimer. # conditions and the following disclaimer.
# #
# 2. Redistributions in binary form must reproduce the above copyright notice, this list # 2. Redistributions in binary form must reproduce the above copyright notice, this list
# of conditions and the following disclaimer in the documentation and/or other # of conditions and the following disclaimer in the documentation and/or other
# materials provided with the distribution. # materials provided with the distribution.
# #
# 3. Neither the name of the copyright holder nor the names of its contributors may be # 3. Neither the name of the copyright holder nor the names of its contributors may be
# used to endorse or promote products derived from this software without specific # used to endorse or promote products derived from this software without specific
# prior written permission. # prior written permission.
# #
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# #
# Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
cmake_minimum_required(VERSION 2.8.7) cmake_minimum_required(VERSION 2.8.7)
@ -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
@ -137,7 +137,7 @@ elseif(CMAKE_SYSTEM_NAME MATCHES "DragonFly.*|FreeBSD")
endif() endif()
# TODO: check bsdi, NetBSD, OpenBSD, to see if they need the same FreeBSD changes # TODO: check bsdi, NetBSD, OpenBSD, to see if they need the same FreeBSD changes
# #
# elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*") # elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*")
# set(NETBSD TRUE) # set(NETBSD TRUE)
# elseif(CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*") # elseif(CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*")
@ -194,27 +194,27 @@ endif()
set(BERKELEY_DB 0) set(BERKELEY_DB 0)
if (DATABASE STREQUAL "lmdb") if (DATABASE STREQUAL "lmdb")
set(BLOCKCHAIN_DB DB_LMDB) set(BLOCKCHAIN_DB DB_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))
@ -234,7 +234,7 @@ endif()
if(BERKELEY_DB) if(BERKELEY_DB)
add_definitions("-DBERKELEY_DB") add_definitions("-DBERKELEY_DB")
endif() endif()
add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}") add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")
if (UNIX AND NOT APPLE) if (UNIX AND NOT APPLE)

16
src/CMakeLists.txt
View file

@ -1,21 +1,21 @@
# Copyright (c) 2014-2015, The Monero Project # Copyright (c) 2014-2015, The Monero Project
# #
# All rights reserved. # All rights reserved.
# #
# Redistribution and use in source and binary forms, with or without modification, are # Redistribution and use in source and binary forms, with or without modification, are
# permitted provided that the following conditions are met: # permitted provided that the following conditions are met:
# #
# 1. Redistributions of source code must retain the above copyright notice, this list of # 1. Redistributions of source code must retain the above copyright notice, this list of
# conditions and the following disclaimer. # conditions and the following disclaimer.
# #
# 2. Redistributions in binary form must reproduce the above copyright notice, this list # 2. Redistributions in binary form must reproduce the above copyright notice, this list
# of conditions and the following disclaimer in the documentation and/or other # of conditions and the following disclaimer in the documentation and/or other
# materials provided with the distribution. # materials provided with the distribution.
# #
# 3. Neither the name of the copyright holder nor the names of its contributors may be # 3. Neither the name of the copyright holder nor the names of its contributors may be
# used to endorse or promote products derived from this software without specific # used to endorse or promote products derived from this software without specific
# prior written permission. # prior written permission.
# #
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# #
# Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
if (WIN32 OR STATIC) if (WIN32 OR STATIC)
@ -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()

28
src/blockchain_db/berkeleydb/db_bdb.h
View file

@ -1,20 +1,20 @@
// Copyright (c) 2014, The Monero Project // Copyright (c) 2014, The Monero Project
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -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()

26
src/blockchain_db/blockchain_db.h
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014, The Monero Project // Copyright (c) 2014, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -85,7 +85,7 @@
* size_t get_block_size(height) * size_t get_block_size(height)
* difficulty get_block_cumulative_difficulty(height) * difficulty get_block_cumulative_difficulty(height)
* uint64_t get_block_already_generated_coins(height) * uint64_t get_block_already_generated_coins(height)
* uint64_t get_block_timestamp(height) * uint64_t get_block_timestamp(height)
* uint64_t get_top_block_timestamp() * uint64_t get_top_block_timestamp()
* hash get_block_hash_from_height(height) * hash get_block_hash_from_height(height)
* blocks get_blocks_range(height1, height2) * blocks get_blocks_range(height1, height2)
@ -139,12 +139,12 @@ 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)
/*********************************** /***********************************
* Exception Definitions * Exception Definitions
***********************************/ ***********************************/
@ -300,7 +300,7 @@ private:
/********************************************************************* /*********************************************************************
* private concrete members * private concrete members
*********************************************************************/ *********************************************************************/
// private version of pop_block, for undoing if an add_block goes tits up // private version of pop_block, for undoing if an add_block goes tits up
void pop_block(); void pop_block();
@ -479,7 +479,7 @@ public:
virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index) = 0; virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index) = 0;
virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices) = 0; virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices) = 0;
virtual void get_output_key(const uint64_t &amount, const std::vector<uint64_t> &offsets, std::vector<output_data_t> &outputs) = 0; virtual void get_output_key(const uint64_t &amount, const std::vector<uint64_t> &offsets, std::vector<output_data_t> &outputs) = 0;
virtual bool can_thread_bulk_indices() const = 0; virtual bool can_thread_bulk_indices() const = 0;
// return a vector of indices corresponding to the global output index for // return a vector of indices corresponding to the global output index for

464
src/blockchain_db/lmdb/db_lmdb.cpp
View file

@ -1,20 +1,20 @@
// Copyright (c) 2014, The Monero Project // Copyright (c) 2014, The Monero Project
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -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++;
@ -891,17 +891,17 @@ tx_out BlockchainLMDB::output_from_blob(const blobdata& blob) const
return o; return o;
} }
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)

12
src/blockchain_db/lmdb/db_lmdb.h
View file

@ -1,20 +1,20 @@
// Copyright (c) 2014, The Monero Project // Copyright (c) 2014, The Monero Project
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -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);

16
src/blocks/blockexports.c
View file

@ -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

132
src/crypto/aesb.c
View file

@ -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);
@ -149,34 +149,34 @@ d_4(uint32_t, t_dec(f,n), sb_data, u0, u1, u2, u3);
#endif #endif
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, b0, b1, kp + 1 * N_COLS);
round(fwd_rnd, b1, b0, kp + 2 * N_COLS);
round(fwd_rnd, b0, b1, kp + 3 * N_COLS);
round(fwd_rnd, b1, b0, kp + 4 * N_COLS);
round(fwd_rnd, b0, b1, kp + 5 * N_COLS);
round(fwd_rnd, b1, b0, kp + 6 * N_COLS);
round(fwd_rnd, b0, b1, kp + 7 * N_COLS);
round(fwd_rnd, b1, b0, kp + 8 * N_COLS);
round(fwd_rnd, b0, b1, kp + 9 * N_COLS);
state_out(out, b0); round(fwd_rnd, b1, b0, kp);
round(fwd_rnd, b0, b1, kp + 1 * N_COLS);
round(fwd_rnd, b1, b0, kp + 2 * N_COLS);
round(fwd_rnd, b0, b1, kp + 3 * N_COLS);
round(fwd_rnd, b1, b0, kp + 4 * N_COLS);
round(fwd_rnd, b0, b1, kp + 5 * N_COLS);
round(fwd_rnd, b1, b0, kp + 6 * N_COLS);
round(fwd_rnd, b0, b1, kp + 7 * N_COLS);
round(fwd_rnd, b1, b0, kp + 8 * N_COLS);
round(fwd_rnd, b0, b1, kp + 9 * N_COLS);
state_out(out, b0);
} }

190
src/crypto/slow-hash.c
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <assert.h> #include <assert.h>
@ -104,33 +104,33 @@
#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.
* After using AES to mix a scratchpad value into _c (done by the caller), * After using AES to mix a scratchpad value into _c (done by the caller),
* this macro xors it with _b and stores the result back to the same index (j) that it * this macro xors it with _b and stores the result back to the same index (j) that it
* loaded the scratchpad value from. It then performs a second random memory * loaded the scratchpad value from. It then performs a second random memory
* read/write from the scratchpad, but this time mixes the values using a 64 * read/write from the scratchpad, but this time mixes the values using a 64
* bit multiply. * bit multiply.
* 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)
#else #else
@ -226,14 +226,14 @@ STATIC INLINE void aes_256_assist2(__m128i* t1, __m128i * t3)
*t3 = _mm_xor_si128(*t3, t2); *t3 = _mm_xor_si128(*t3, t2);
} }
/** /**
* @brief expands 'key' into a form it can be used for AES encryption. * @brief expands 'key' into a form it can be used for AES encryption.
* *
* This is an SSE-optimized implementation of AES key schedule generation. It * This is an SSE-optimized implementation of AES key schedule generation. It
* expands the key into multiple round keys, each of which is used in one round * expands the key into multiple round keys, each of which is used in one round
* of the AES encryption used to fill (and later, extract randomness from) * of the AES encryption used to fill (and later, extract randomness from)
* the large 2MB buffer. Note that CryptoNight does not use a completely * the large 2MB buffer. Note that CryptoNight does not use a completely
* standard AES encryption for its buffer expansion, so do not copy this * standard AES encryption for its buffer expansion, so do not copy this
* function outside of Monero without caution! This version uses the hardware * function outside of Monero without caution! This version uses the hardware
* AESKEYGENASSIST instruction to speed key generation, and thus requires * AESKEYGENASSIST instruction to speed key generation, and thus requires
* CPU AES support. * CPU AES support.
@ -402,7 +402,7 @@ BOOL SetLockPagesPrivilege(HANDLE hProcess, BOOL bEnable)
/** /**
* @brief allocate the 2MB scratch buffer using OS support for huge pages, if available * @brief allocate the 2MB scratch buffer using OS support for huge pages, if available
* *
* This function tries to allocate the 2MB scratch buffer using a single * This function tries to allocate the 2MB scratch buffer using a single
* 2MB "huge page" (instead of the usual 4KB page sizes) to reduce TLB misses * 2MB "huge page" (instead of the usual 4KB page sizes) to reduce TLB misses
* during the random accesses to the scratch buffer. This is one of the * during the random accesses to the scratch buffer. This is one of the
* important speed optimizations needed to make CryptoNight faster. * important speed optimizations needed to make CryptoNight faster.
@ -423,7 +423,7 @@ void slow_hash_allocate_state(void)
#else #else
#if defined(__APPLE__) || defined(__FreeBSD__) #if defined(__APPLE__) || defined(__FreeBSD__)
hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE, hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, 0, 0); MAP_PRIVATE | MAP_ANON, 0, 0);
#else #else
hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE, hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, 0, 0); MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, 0, 0);
@ -562,7 +562,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
*/ */
_b = _mm_load_si128(R128(b)); _b = _mm_load_si128(R128(b));
// Two independent versions, one with AES, one without, to ensure that // Two independent versions, one with AES, one without, to ensure that
// the useAes test is only performed once, not every iteration. // the useAes test is only performed once, not every iteration.
if(useAes) if(useAes)
{ {
@ -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) {
@ -916,11 +916,11 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
memcpy(text, state.init, INIT_SIZE_BYTE); memcpy(text, state.init, INIT_SIZE_BYTE);
memcpy(aes_key, state.hs.b, AES_KEY_SIZE); memcpy(aes_key, state.hs.b, AES_KEY_SIZE);
aes_ctx = (oaes_ctx *) oaes_alloc(); aes_ctx = (oaes_ctx *) oaes_alloc();
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);

6
src/cryptonote_core/CMakeLists.txt
View file

@ -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
@ -86,7 +86,7 @@ target_link_libraries(cryptonote_core
${Boost_PROGRAM_OPTIONS_LIBRARY} ${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SERIALIZATION_LIBRARY} ${Boost_SERIALIZATION_LIBRARY}
LINK_PRIVATE LINK_PRIVATE
${Blocks} ${Blocks}
${Boost_FILESYSTEM_LIBRARY} ${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY} ${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY} ${Boost_THREAD_LIBRARY}

148
src/cryptonote_core/blockchain.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <algorithm> #include <algorithm>
@ -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,14 +2062,14 @@ 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;

64
src/cryptonote_core/blockchain.h
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#pragma once #pragma once
@ -61,11 +61,11 @@ 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,10 +153,10 @@ 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; }
HardFork::State get_hard_fork_state() const; HardFork::State get_hard_fork_state() const;
uint8_t get_current_hard_fork_version() const { return m_hardfork->get_current_version(); } uint8_t get_current_hard_fork_version() const { return m_hardfork->get_current_version(); }
uint8_t get_ideal_hard_fork_version() const { return m_hardfork->get_ideal_version(); } uint8_t get_ideal_hard_fork_version() const { return m_hardfork->get_ideal_version(); }
@ -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;
@ -208,22 +208,22 @@ namespace cryptonote
// SHA-3 hashes for each block and for fast pow checking // SHA-3 hashes for each block and for fast pow checking
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 &timestamp, difficulty_type &difficulty, const int offset) const; void get_timestamp_and_difficulty(uint64_t &timestamp, 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

88
src/cryptonote_core/blockchain_storage.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <algorithm> #include <algorithm>
@ -97,11 +97,11 @@ bool blockchain_storage::init(const std::string& config_folder, bool testnet)
{ {
// checkpoints // checkpoints
// 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
@ -1248,7 +1248,7 @@ bool blockchain_storage::find_blockchain_supplement(const uint64_t req_start_blo
{ {
CRITICAL_REGION_LOCAL(m_blockchain_lock); CRITICAL_REGION_LOCAL(m_blockchain_lock);
if(req_start_block > 0) { if(req_start_block > 0) {
start_height = req_start_block; start_height = req_start_block;
} else { } else {
if(!find_blockchain_supplement(qblock_ids, start_height)) if(!find_blockchain_supplement(qblock_ids, start_height))
return false; return false;
@ -1739,9 +1739,9 @@ bool blockchain_storage::handle_block_to_main_chain(const block& bl, const crypt
bei.block_cumulative_size = cumulative_block_size; bei.block_cumulative_size = cumulative_block_size;
bei.cumulative_difficulty = current_diffic; bei.cumulative_difficulty = current_diffic;
// In the "tail" state when the minimum subsidy (implemented in get_block_reward) is in effect, the number of // In the "tail" state when the minimum subsidy (implemented in get_block_reward) is in effect, the number of
// coins will eventually exceed MONEY_SUPPLY and overflow a uint64. To prevent overflow, cap already_generated_coins // coins will eventually exceed MONEY_SUPPLY and overflow a uint64. To prevent overflow, cap already_generated_coins
// at MONEY_SUPPLY. already_generated_coins is only used to compute the block subsidy and MONEY_SUPPLY yields a // at MONEY_SUPPLY. already_generated_coins is only used to compute the block subsidy and MONEY_SUPPLY yields a
// subsidy of 0 under the base formula and therefore the minimum subsidy >0 in the tail state. // subsidy of 0 under the base formula and therefore the minimum subsidy >0 in the tail state.
bei.already_generated_coins = base_reward < (MONEY_SUPPLY-already_generated_coins) ? already_generated_coins + base_reward : MONEY_SUPPLY; bei.already_generated_coins = base_reward < (MONEY_SUPPLY-already_generated_coins) ? already_generated_coins + base_reward : MONEY_SUPPLY;
@ -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");
} }
} }
} }

76
src/cryptonote_core/checkpoints_create.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include "checkpoints_create.h" #include "checkpoints_create.h"
@ -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;
} }
@ -62,25 +62,25 @@ namespace
namespace cryptonote 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)
{ {
ADD_CHECKPOINT(1, "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148"); ADD_CHECKPOINT(1, "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148");
ADD_CHECKPOINT(10, "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381"); ADD_CHECKPOINT(10, "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381");
ADD_CHECKPOINT(100, "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d"); ADD_CHECKPOINT(100, "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d");
@ -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);

18
src/cryptonote_core/cryptonote_basic_impl.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include "include_base_utils.h" #include "include_base_utils.h"
@ -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);

62
src/cryptonote_core/cryptonote_core.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include "include_base_utils.h" #include "include_base_utils.h"
@ -63,7 +63,7 @@ namespace cryptonote
m_blockchain_storage(&m_mempool), m_blockchain_storage(&m_mempool),
#endif #endif
m_miner(this), m_miner(this),
m_miner_address(boost::value_initialized<account_public_address>()), m_miner_address(boost::value_initialized<account_public_address>()),
m_starter_message_showed(false), m_starter_message_showed(false),
m_target_blockchain_height(0), m_target_blockchain_height(0),
m_checkpoints_path(""), m_checkpoints_path(""),
@ -176,10 +176,10 @@ namespace cryptonote
set_enforce_dns_checkpoints(command_line::get_arg(vm, command_line::arg_dns_checkpoints)); set_enforce_dns_checkpoints(command_line::get_arg(vm, command_line::arg_dns_checkpoints));
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)
return true;
return false; if (get_blockchain_storage().get_current_blockchain_height() <= m_test_drop_download_height)
return true;
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)
@ -852,14 +852,14 @@ namespace cryptonote
{ {
if(!m_starter_message_showed) if(!m_starter_message_showed)
{ {
LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL
<< "The daemon will start synchronizing with the network. It may take up to several hours." << ENDL << "The daemon will start synchronizing with the network. It may take up to several hours." << ENDL
<< ENDL << ENDL
<< "You can set the level of process detailization* through \"set_log <level>\" command*, where <level> is between 0 (no details) and 4 (very verbose)." << ENDL << "You can set the level of process detailization* through \"set_log <level>\" command*, where <level> is between 0 (no details) and 4 (very verbose)." << ENDL
<< ENDL << ENDL
<< "Use \"help\" command to see the list of available commands." << ENDL << "Use \"help\" command to see the list of available commands." << ENDL
<< ENDL << ENDL
<< "Note: in case you need to interrupt the process, use \"exit\" command. Otherwise, the current progress won't be saved." << ENDL << "Note: in case you need to interrupt the process, use \"exit\" command. Otherwise, the current progress won't be saved." << ENDL
<< "**********************************************************************"); << "**********************************************************************");
m_starter_message_showed = true; m_starter_message_showed = true;
} }
@ -915,6 +915,6 @@ namespace cryptonote
{ {
raise(SIGTERM); raise(SIGTERM);
} }
std::atomic<bool> core::m_fast_exit(false); std::atomic<bool> core::m_fast_exit(false);
} }

18
src/cryptonote_core/cryptonote_core.h
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#pragma once #pragma once
@ -68,7 +68,7 @@ namespace cryptonote
bool handle_incoming_block(const blobdata& block_blob, block_verification_context& bvc, bool update_miner_blocktemplate = true); bool handle_incoming_block(const blobdata& block_blob, block_verification_context& bvc, bool update_miner_blocktemplate = true);
bool prepare_handle_incoming_blocks(const std::list<block_complete_entry> &blocks); bool prepare_handle_incoming_blocks(const std::list<block_complete_entry> &blocks);
bool cleanup_handle_incoming_blocks(bool force_sync = false); bool cleanup_handle_incoming_blocks(bool force_sync = false);
bool check_incoming_block_size(const blobdata& block_blob) const; bool check_incoming_block_size(const blobdata& block_blob) const;
i_cryptonote_protocol* get_protocol(){return m_pprotocol;} i_cryptonote_protocol* get_protocol(){return m_pprotocol;}
@ -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

80
src/cryptonote_core/difficulty.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <algorithm> #include <algorithm>
@ -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

29
src/cryptonote_core/miner.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <sstream> #include <sstream>
@ -68,9 +68,9 @@ namespace cryptonote
m_thread_index(0), m_thread_index(0),
m_phandler(phandler), m_phandler(phandler),
m_height(0), m_height(0),
m_pausers_count(0), m_pausers_count(0),
m_threads_total(0), m_threads_total(0),
m_starter_nonce(0), m_starter_nonce(0),
m_last_hr_merge_time(0), m_last_hr_merge_time(0),
m_hashes(0), m_hashes(0),
m_do_print_hashrate(false), m_do_print_hashrate(false),
@ -109,7 +109,7 @@ namespace cryptonote
block bl = AUTO_VAL_INIT(bl); block bl = AUTO_VAL_INIT(bl);
difficulty_type di = AUTO_VAL_INIT(di); difficulty_type di = AUTO_VAL_INIT(di);
uint64_t height = AUTO_VAL_INIT(height); uint64_t height = AUTO_VAL_INIT(height);
cryptonote::blobdata extra_nonce; cryptonote::blobdata extra_nonce;
if(m_extra_messages.size() && m_config.current_extra_message_index < m_extra_messages.size()) if(m_extra_messages.size() && m_config.current_extra_message_index < m_extra_messages.size())
{ {
extra_nonce = m_extra_messages[m_config.current_extra_message_index]; extra_nonce = m_extra_messages[m_config.current_extra_message_index];
@ -135,7 +135,7 @@ namespace cryptonote
merge_hr(); merge_hr();
return true; return true;
}); });
return true; return true;
} }
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
@ -227,7 +227,7 @@ namespace cryptonote
uint32_t miner::get_threads_count() const { uint32_t miner::get_threads_count() const {
return m_threads_total; return m_threads_total;
} }
//----------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------
bool miner::start(const account_public_address& adr, size_t threads_count, const boost::thread::attributes& attrs) bool miner::start(const account_public_address& adr, size_t threads_count, const boost::thread::attributes& attrs)
{ {
m_mine_address = adr; m_mine_address = adr;
@ -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;
} }

24
src/cryptonote_core/tx_pool.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <algorithm> #include <algorithm>
@ -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)
{ {
@ -299,7 +299,7 @@ namespace cryptonote
{ {
uint64_t tx_age = time(nullptr) - it->second.receive_time; uint64_t tx_age = time(nullptr) - it->second.receive_time;
if((tx_age > CRYPTONOTE_MEMPOOL_TX_LIVETIME && !it->second.kept_by_block) || if((tx_age > CRYPTONOTE_MEMPOOL_TX_LIVETIME && !it->second.kept_by_block) ||
(tx_age > CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME && it->second.kept_by_block) ) (tx_age > CRYPTONOTE_MEMPOOL_TX_FROM_ALT_BLOCK_LIVETIME && it->second.kept_by_block) )
{ {
LOG_PRINT_L1("Tx " << it->first << " removed from tx pool due to outdated, age: " << tx_age ); LOG_PRINT_L1("Tx " << it->first << " removed from tx pool due to outdated, age: " << tx_age );
@ -574,7 +574,7 @@ namespace cryptonote
// If adding this tx will make the block size // If adding this tx will make the block size
// greater than CRYPTONOTE_GETBLOCKTEMPLATE_MAX // greater than CRYPTONOTE_GETBLOCKTEMPLATE_MAX
// _BLOCK_SIZE bytes, reject the tx; this will // _BLOCK_SIZE bytes, reject the tx; this will
// keep block sizes from becoming too unwieldly // keep block sizes from becoming too unwieldly
// to propagate at 60s block times. // to propagate at 60s block times.
if ( (total_size + tx_it->second.blob_size) > CRYPTONOTE_GETBLOCKTEMPLATE_MAX_BLOCK_SIZE ) if ( (total_size + tx_it->second.blob_size) > CRYPTONOTE_GETBLOCKTEMPLATE_MAX_BLOCK_SIZE )
@ -586,7 +586,7 @@ namespace cryptonote
// If we've exceeded the penalty free size, // If we've exceeded the penalty free size,
// stop including more tx // stop including more tx
if (total_size > median_size) if (total_size > median_size)
break; break;
// Skip transactions that are not ready to be // Skip transactions that are not ready to be
// included into the blockchain or that are // included into the blockchain or that are

16
src/cryptonote_core/tx_pool.h
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#pragma once #pragma once
@ -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);

533
src/cryptonote_protocol/cryptonote_protocol_handler.inl
View file

@ -3,23 +3,23 @@
/// @brief This is the orginal cryptonote protocol network-events handler, modified by us /// @brief This is the orginal cryptonote protocol network-events handler, modified by us
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -29,7 +29,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
// (may contain code and/or modifications by other developers) // (may contain code and/or modifications by other developers)
@ -49,14 +49,14 @@ 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
//----------------------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
t_cryptonote_protocol_handler<t_core>::t_cryptonote_protocol_handler(t_core& rcore, nodetool::i_p2p_endpoint<connection_context>* p_net_layout):m_core(rcore), t_cryptonote_protocol_handler<t_core>::t_cryptonote_protocol_handler(t_core& rcore, nodetool::i_p2p_endpoint<connection_context>* p_net_layout):m_core(rcore),
m_p2p(p_net_layout), m_p2p(p_net_layout),
m_syncronized_connections_count(0), m_syncronized_connections_count(0),
m_synchronized(false) m_synchronized(false)
@ -66,21 +66,21 @@ namespace cryptonote
m_p2p = &m_p2p_stub; m_p2p = &m_p2p_stub;
} }
//----------------------------------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::init(const boost::program_options::variables_map& vm) bool t_cryptonote_protocol_handler<t_core>::init(const boost::program_options::variables_map& vm)
{ {
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::deinit() bool t_cryptonote_protocol_handler<t_core>::deinit()
{ {
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
void t_cryptonote_protocol_handler<t_core>::set_p2p_endpoint(nodetool::i_p2p_endpoint<connection_context>* p2p) void t_cryptonote_protocol_handler<t_core>::set_p2p_endpoint(nodetool::i_p2p_endpoint<connection_context>* p2p)
{ {
if(p2p) if(p2p)
@ -88,8 +88,8 @@ namespace cryptonote
else else
m_p2p = &m_p2p_stub; m_p2p = &m_p2p_stub;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::on_callback(cryptonote_connection_context& context) bool t_cryptonote_protocol_handler<t_core>::on_callback(cryptonote_connection_context& context)
{ {
LOG_PRINT_CCONTEXT_L2("callback fired"); LOG_PRINT_CCONTEXT_L2("callback fired");
@ -107,22 +107,22 @@ namespace cryptonote
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::get_stat_info(core_stat_info& stat_inf) bool t_cryptonote_protocol_handler<t_core>::get_stat_info(core_stat_info& stat_inf)
{ {
return m_core.get_stat_info(stat_inf); return m_core.get_stat_info(stat_inf);
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
void t_cryptonote_protocol_handler<t_core>::log_connections() void t_cryptonote_protocol_handler<t_core>::log_connections()
{ {
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"
@ -131,19 +131,19 @@ namespace cryptonote
<< std::setw(20) << "Livetime(sec)" << std::setw(20) << "Livetime(sec)"
<< std::setw(12) << "Down (kB/s)" << std::setw(12) << "Down (kB/s)"
<< std::setw(14) << "Down(now)" << std::setw(14) << "Down(now)"
<< std::setw(10) << "Up (kB/s)" << std::setw(10) << "Up (kB/s)"
<< 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
@ -157,30 +157,30 @@ namespace cryptonote
<< (local_ip ? "[LAN]" : "") << (local_ip ? "[LAN]" : "")
<< 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
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
std::list<connection_info> t_cryptonote_protocol_handler<t_core>::get_connections() std::list<connection_info> t_cryptonote_protocol_handler<t_core>::get_connections()
{ {
@ -209,43 +209,43 @@ namespace cryptonote
cnx.state = get_protocol_state_string(cntxt.m_state); cnx.state = get_protocol_state_string(cntxt.m_state);
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_upload = cntxt.m_current_speed_up / 1024;
cnx.current_download = cntxt.m_current_speed_down / 1024;
cnx.current_upload = cntxt.m_current_speed_up / 1024;
connections.push_back(cnx); connections.push_back(cnx);
return true; return true;
@ -254,7 +254,7 @@ namespace cryptonote
return connections; return connections;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::process_payload_sync_data(const CORE_SYNC_DATA& hshd, cryptonote_connection_context& context, bool is_inital) bool t_cryptonote_protocol_handler<t_core>::process_payload_sync_data(const CORE_SYNC_DATA& hshd, cryptonote_connection_context& context, bool is_inital)
{ {
if(context.m_state == cryptonote_connection_context::state_befor_handshake && !is_inital) if(context.m_state == cryptonote_connection_context::state_befor_handshake && !is_inital)
@ -263,7 +263,7 @@ namespace cryptonote
if(context.m_state == cryptonote_connection_context::state_synchronizing) if(context.m_state == cryptonote_connection_context::state_synchronizing)
return true; return true;
if(m_core.have_block(hshd.top_id)) if(m_core.have_block(hshd.top_id))
{ {
context.m_state = cryptonote_connection_context::state_normal; context.m_state = cryptonote_connection_context::state_normal;
if(is_inital) if(is_inital)
@ -271,11 +271,11 @@ namespace cryptonote
return true; return true;
} }
/* As I don't know if accessing hshd from core could be a good practice, /* As I don't know if accessing hshd from core could be a good practice,
I prefer pushing target height to the core at the same time it is pushed to the user. I prefer pushing target height to the core at the same time it is pushed to the user.
Nz. */ Nz. */
m_core.set_target_blockchain_height(static_cast<int64_t>(hshd.current_height)); m_core.set_target_blockchain_height(static_cast<int64_t>(hshd.current_height));
int64_t diff = static_cast<int64_t>(hshd.current_height) - static_cast<int64_t>(m_core.get_current_blockchain_height()); int64_t diff = static_cast<int64_t>(hshd.current_height) - static_cast<int64_t>(m_core.get_current_blockchain_height());
LOG_PRINT_CCONTEXT_YELLOW("Sync data returned unknown top block: " << m_core.get_current_blockchain_height() << " -> " << hshd.current_height LOG_PRINT_CCONTEXT_YELLOW("Sync data returned unknown top block: " << m_core.get_current_blockchain_height() << " -> " << hshd.current_height
<< " [" << std::abs(diff) << " blocks (" << diff / (24 * 60 * 60 / DIFFICULTY_TARGET) << " days) " << " [" << std::abs(diff) << " blocks (" << diff / (24 * 60 * 60 / DIFFICULTY_TARGET) << " days) "
@ -290,16 +290,16 @@ namespace cryptonote
m_p2p->request_callback(context); m_p2p->request_callback(context);
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::get_payload_sync_data(CORE_SYNC_DATA& hshd) bool t_cryptonote_protocol_handler<t_core>::get_payload_sync_data(CORE_SYNC_DATA& hshd)
{ {
m_core.get_blockchain_top(hshd.current_height, hshd.top_id); m_core.get_blockchain_top(hshd.current_height, hshd.top_id);
hshd.current_height +=1; hshd.current_height +=1;
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::get_payload_sync_data(blobdata& data) bool t_cryptonote_protocol_handler<t_core>::get_payload_sync_data(blobdata& data)
{ {
CORE_SYNC_DATA hsd = boost::value_initialized<CORE_SYNC_DATA>(); CORE_SYNC_DATA hsd = boost::value_initialized<CORE_SYNC_DATA>();
@ -307,8 +307,8 @@ namespace cryptonote
epee::serialization::store_t_to_binary(hsd, data); epee::serialization::store_t_to_binary(hsd, data);
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
int t_cryptonote_protocol_handler<t_core>::handle_notify_new_block(int command, NOTIFY_NEW_BLOCK::request& arg, cryptonote_connection_context& context) int t_cryptonote_protocol_handler<t_core>::handle_notify_new_block(int command, NOTIFY_NEW_BLOCK::request& arg, cryptonote_connection_context& context)
{ {
LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_BLOCK (hop " << arg.hop << ")"); LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_BLOCK (hop " << arg.hop << ")");
@ -333,7 +333,7 @@ namespace cryptonote
} }
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(arg.b.block, bvc); // got block from handle_notify_new_block m_core.handle_incoming_block(arg.b.block, bvc); // got block from handle_notify_new_block
m_core.cleanup_handle_incoming_blocks(true); m_core.cleanup_handle_incoming_blocks(true);
m_core.resume_mine(); m_core.resume_mine();
if(bvc.m_verifivation_failed) if(bvc.m_verifivation_failed)
@ -355,11 +355,11 @@ namespace cryptonote
LOG_PRINT_CCONTEXT_L2("-->>NOTIFY_REQUEST_CHAIN: m_block_ids.size()=" << r.block_ids.size() ); LOG_PRINT_CCONTEXT_L2("-->>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);
} }
return 1; return 1;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
int t_cryptonote_protocol_handler<t_core>::handle_notify_new_transactions(int command, NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& context) int t_cryptonote_protocol_handler<t_core>::handle_notify_new_transactions(int command, NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& context)
{ {
LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_TRANSACTIONS"); LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_TRANSACTIONS");
@ -391,7 +391,7 @@ namespace cryptonote
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
int t_cryptonote_protocol_handler<t_core>::handle_request_get_objects(int command, NOTIFY_REQUEST_GET_OBJECTS::request& arg, cryptonote_connection_context& context) int t_cryptonote_protocol_handler<t_core>::handle_request_get_objects(int command, NOTIFY_REQUEST_GET_OBJECTS::request& arg, cryptonote_connection_context& context)
{ {
LOG_PRINT_CCONTEXT_L2("NOTIFY_REQUEST_GET_OBJECTS"); LOG_PRINT_CCONTEXT_L2("NOTIFY_REQUEST_GET_OBJECTS");
@ -401,7 +401,7 @@ namespace cryptonote
LOG_ERROR_CCONTEXT("failed to handle request NOTIFY_REQUEST_GET_OBJECTS, dropping connection"); LOG_ERROR_CCONTEXT("failed to handle request NOTIFY_REQUEST_GET_OBJECTS, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
} }
LOG_PRINT_CCONTEXT_L2("-->>NOTIFY_RESPONSE_GET_OBJECTS: blocks.size()=" << rsp.blocks.size() << ", txs.size()=" << rsp.txs.size() LOG_PRINT_CCONTEXT_L2("-->>NOTIFY_RESPONSE_GET_OBJECTS: blocks.size()=" << rsp.blocks.size() << ", txs.size()=" << rsp.txs.size()
<< ", rsp.m_current_blockchain_height=" << rsp.current_blockchain_height << ", missed_ids.size()=" << rsp.missed_ids.size()); << ", rsp.m_current_blockchain_height=" << rsp.current_blockchain_height << ", missed_ids.size()=" << rsp.missed_ids.size());
post_notify<NOTIFY_RESPONSE_GET_OBJECTS>(rsp, context); post_notify<NOTIFY_RESPONSE_GET_OBJECTS>(rsp, context);
//handler_response_blocks_now(sizeof(rsp)); // XXX //handler_response_blocks_now(sizeof(rsp)); // XXX
@ -410,67 +410,67 @@ 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();
} }
template<class t_core> template<class t_core>
int t_cryptonote_protocol_handler<t_core>::handle_response_get_objects(int command, NOTIFY_RESPONSE_GET_OBJECTS::request& arg, cryptonote_connection_context& context) int t_cryptonote_protocol_handler<t_core>::handle_response_get_objects(int command, NOTIFY_RESPONSE_GET_OBJECTS::request& arg, cryptonote_connection_context& context)
{ {
LOG_PRINT_CCONTEXT_L2("NOTIFY_RESPONSE_GET_OBJECTS"); LOG_PRINT_CCONTEXT_L2("NOTIFY_RESPONSE_GET_OBJECTS");
// calculate size of request - mainly for logging/debug // calculate size of request - mainly for logging/debug
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) {
size += element.block.size();
for (auto tx : element.txs)
size += tx.size();
}
for (auto element : arg.missed_ids)
size += sizeof(element.data);
size += sizeof(arg.current_blockchain_height);
{
CRITICAL_REGION_LOCAL(m_buffer_mutex);
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 for (auto element : arg.blocks) {
long int dbg_repeat=0; size += element.block.size();
do { for (auto tx : element.txs)
m_avg_buffer.push_back(666); // a test value size += tx.size();
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
} for (auto element : arg.missed_ids)
/*using namespace boost::chrono; size += sizeof(element.data);
auto point = steady_clock::now();
auto time_from_epoh = point.time_since_epoch(); size += sizeof(arg.current_blockchain_height);
auto sec = duration_cast< seconds >( time_from_epoh ).count();*/ {
CRITICAL_REGION_LOCAL(m_buffer_mutex);
//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()); 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
long int dbg_repeat=0;
do {
m_avg_buffer.push_back(666); // a test value
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
}
/*using namespace boost::chrono;
auto point = steady_clock::now();
auto time_from_epoh = point.time_since_epoch();
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());
if(context.m_last_response_height > arg.current_blockchain_height) if(context.m_last_response_height > arg.current_blockchain_height)
{ {
LOG_ERROR_CCONTEXT("sent wrong NOTIFY_HAVE_OBJECTS: arg.m_current_blockchain_height=" << arg.current_blockchain_height LOG_ERROR_CCONTEXT("sent wrong NOTIFY_HAVE_OBJECTS: arg.m_current_blockchain_height=" << arg.current_blockchain_height
<< " < m_last_response_height=" << context.m_last_response_height << ", dropping connection"); << " < m_last_response_height=" << context.m_last_response_height << ", dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
@ -485,14 +485,14 @@ namespace cryptonote
block b; block b;
if(!parse_and_validate_block_from_blob(block_entry.block, b)) if(!parse_and_validate_block_from_blob(block_entry.block, b))
{ {
LOG_ERROR_CCONTEXT("sent wrong block: failed to parse and validate block: \r\n" LOG_ERROR_CCONTEXT("sent wrong block: failed to parse and validate block: \r\n"
<< epee::string_tools::buff_to_hex_nodelimer(block_entry.block) << "\r\n dropping connection"); << epee::string_tools::buff_to_hex_nodelimer(block_entry.block) << "\r\n dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }
//to avoid concurrency in core between connections, suspend connections which delivered block later then first one //to avoid concurrency in core between connections, suspend connections which delivered block later then first one
if(count == 2) if(count == 2)
{ {
if(m_core.have_block(get_block_hash(b))) if(m_core.have_block(get_block_hash(b)))
{ {
context.m_state = cryptonote_connection_context::state_idle; context.m_state = cryptonote_connection_context::state_idle;
@ -502,18 +502,18 @@ namespace cryptonote
return 1; return 1;
} }
} }
auto req_it = context.m_requested_objects.find(get_block_hash(b)); auto req_it = context.m_requested_objects.find(get_block_hash(b));
if(req_it == context.m_requested_objects.end()) if(req_it == context.m_requested_objects.end())
{ {
LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block)) LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block))
<< " wasn't requested, dropping connection"); << " wasn't requested, dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
} }
if(b.tx_hashes.size() != block_entry.txs.size()) if(b.tx_hashes.size() != block_entry.txs.size())
{ {
LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block)) LOG_ERROR_CCONTEXT("sent wrong NOTIFY_RESPONSE_GET_OBJECTS: block with id=" << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block))
<< ", tx_hashes.size()=" << b.tx_hashes.size() << " mismatch with block_complete_entry.m_txs.size()=" << block_entry.txs.size() << ", dropping connection"); << ", tx_hashes.size()=" << b.tx_hashes.size() << " mismatch with block_complete_entry.m_txs.size()=" << block_entry.txs.size() << ", dropping connection");
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
@ -524,7 +524,7 @@ namespace cryptonote
if(context.m_requested_objects.size()) if(context.m_requested_objects.size())
{ {
LOG_PRINT_CCONTEXT_RED("returned not all requested objects (context.m_requested_objects.size()=" LOG_PRINT_CCONTEXT_RED("returned not all requested objects (context.m_requested_objects.size()="
<< context.m_requested_objects.size() << "), dropping connection", LOG_LEVEL_0); << context.m_requested_objects.size() << "), dropping connection", LOG_LEVEL_0);
m_p2p->drop_connection(context); m_p2p->drop_connection(context);
return 1; return 1;
@ -537,78 +537,77 @@ namespace cryptonote
boost::bind(&t_core::resume_mine, &m_core)); boost::bind(&t_core::resume_mine, &m_core));
LOG_PRINT_CCONTEXT_YELLOW( "Got NEW BLOCKS inside of " << __FUNCTION__ << ": size: " << arg.blocks.size() , LOG_LEVEL_1); LOG_PRINT_CCONTEXT_YELLOW( "Got NEW BLOCKS inside of " << __FUNCTION__ << ": size: " << arg.blocks.size() , LOG_LEVEL_1);
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();
m_core.prepare_handle_incoming_blocks(arg.blocks); uint64_t previous_height = m_core.get_current_blockchain_height();
BOOST_FOREACH(const block_complete_entry& block_entry, arg.blocks)
{
// process transactions
TIME_MEASURE_START(transactions_process_time);
BOOST_FOREACH(auto& tx_blob, block_entry.txs)
{
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
m_core.handle_incoming_tx(tx_blob, tvc, true, true);
if(tvc.m_verifivation_failed)
{
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");
m_p2p->drop_connection(context);
m_core.cleanup_handle_incoming_blocks();
return 1;
}
}
TIME_MEASURE_FINISH(transactions_process_time);
// process block m_core.prepare_handle_incoming_blocks(arg.blocks);
BOOST_FOREACH(const block_complete_entry& block_entry, arg.blocks)
TIME_MEASURE_START(block_process_time); {
block_verification_context bvc = boost::value_initialized<block_verification_context>(); // process transactions
TIME_MEASURE_START(transactions_process_time);
m_core.handle_incoming_block(block_entry.block, bvc, false); // <--- process block BOOST_FOREACH(auto& tx_blob, block_entry.txs)
{
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
m_core.handle_incoming_tx(tx_blob, tvc, true, true);
if(tvc.m_verifivation_failed)
{
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");
m_p2p->drop_connection(context);
m_core.cleanup_handle_incoming_blocks();
return 1;
}
}
TIME_MEASURE_FINISH(transactions_process_time);
if(bvc.m_verifivation_failed) // process block
{
LOG_PRINT_CCONTEXT_L1("Block verification failed, dropping connection");
m_p2p->drop_connection(context);
m_p2p->add_ip_fail(context.m_remote_ip);
m_core.cleanup_handle_incoming_blocks();
return 1;
}
if(bvc.m_marked_as_orphaned)
{
LOG_PRINT_CCONTEXT_L1("Block received at sync phase was marked as orphaned, dropping connection");
m_p2p->drop_connection(context);
m_p2p->add_ip_fail(context.m_remote_ip);
m_core.cleanup_handle_incoming_blocks();
return 1;
}
TIME_MEASURE_FINISH(block_process_time); TIME_MEASURE_START(block_process_time);
LOG_PRINT_CCONTEXT_L2("Block process time: " << block_process_time + transactions_process_time << "(" << transactions_process_time << "/" << block_process_time << ")ms"); block_verification_context bvc = boost::value_initialized<block_verification_context>();
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);
m_core.handle_incoming_block(block_entry.block, bvc, false); // <--- process block
} // each download block
m_core.cleanup_handle_incoming_blocks(); if(bvc.m_verifivation_failed)
{
LOG_PRINT_CCONTEXT_L1("Block verification failed, dropping connection");
m_p2p->drop_connection(context);
m_p2p->add_ip_fail(context.m_remote_ip);
m_core.cleanup_handle_incoming_blocks();
return 1;
}
if(bvc.m_marked_as_orphaned)
{
LOG_PRINT_CCONTEXT_L1("Block received at sync phase was marked as orphaned, dropping connection");
m_p2p->drop_connection(context);
m_p2p->add_ip_fail(context.m_remote_ip);
m_core.cleanup_handle_incoming_blocks();
return 1;
}
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");
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);
} // each download block
m_core.cleanup_handle_incoming_blocks();
if (m_core.get_current_blockchain_height() > previous_height)
{
LOG_PRINT_CCONTEXT_YELLOW( "Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height() , LOG_LEVEL_0);
}
} // if not DISCARD BLOCK
if (m_core.get_current_blockchain_height() > previous_height)
{
LOG_PRINT_CCONTEXT_YELLOW( "Synced " << m_core.get_current_blockchain_height() << "/" << m_core.get_target_blockchain_height() , LOG_LEVEL_0);
}
} // if not DISCARD BLOCK
} }
request_missing_objects(context, true); request_missing_objects(context, true);
return 1; return 1;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::on_idle() bool t_cryptonote_protocol_handler<t_core>::on_idle()
{ {
return m_core.on_idle(); return m_core.on_idle();
@ -629,18 +628,18 @@ namespace cryptonote
return 1; return 1;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
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())
{ {
//we know objects that we need, request this objects //we know objects that we need, request this objects
@ -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,35 +660,35 @@ 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)
{//we have to fetch more objects ids, request blockchain entry {//we have to fetch more objects ids, request blockchain entry
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);
}else }else
{ {
CHECK_AND_ASSERT_MES(context.m_last_response_height == context.m_remote_blockchain_height-1 CHECK_AND_ASSERT_MES(context.m_last_response_height == context.m_remote_blockchain_height-1
&& !context.m_needed_objects.size() && !context.m_needed_objects.size()
&& !context.m_requested_objects.size(), false, "request_missing_blocks final condition failed!" && !context.m_requested_objects.size(), false, "request_missing_blocks final condition failed!"
<< "\r\nm_last_response_height=" << context.m_last_response_height << "\r\nm_last_response_height=" << context.m_last_response_height
<< "\r\nm_remote_blockchain_height=" << context.m_remote_blockchain_height << "\r\nm_remote_blockchain_height=" << context.m_remote_blockchain_height
<< "\r\nm_needed_objects.size()=" << context.m_needed_objects.size() << "\r\nm_needed_objects.size()=" << context.m_needed_objects.size()
<< "\r\nm_requested_objects.size()=" << context.m_requested_objects.size() << "\r\nm_requested_objects.size()=" << context.m_requested_objects.size()
<< "\r\non connection [" << epee::net_utils::print_connection_context_short(context)<< "]"); << "\r\non connection [" << epee::net_utils::print_connection_context_short(context)<< "]");
context.m_state = cryptonote_connection_context::state_normal; context.m_state = cryptonote_connection_context::state_normal;
LOG_PRINT_CCONTEXT_GREEN(" SYNCHRONIZED OK", LOG_LEVEL_0); LOG_PRINT_CCONTEXT_GREEN(" SYNCHRONIZED OK", LOG_LEVEL_0);
on_connection_synchronized(); on_connection_synchronized();
@ -697,16 +696,16 @@ namespace cryptonote
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::on_connection_synchronized() bool t_cryptonote_protocol_handler<t_core>::on_connection_synchronized()
{ {
bool val_expected = false; bool val_expected = false;
if(m_synchronized.compare_exchange_strong(val_expected, true)) if(m_synchronized.compare_exchange_strong(val_expected, true))
{ {
LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL LOG_PRINT_L0(ENDL << "**********************************************************************" << ENDL
<< "You are now synchronized with the network. You may now start simplewallet." << ENDL << "You are now synchronized with the network. You may now start simplewallet." << ENDL
<< ENDL << ENDL
<< "Please note, that the blockchain will be saved only after you quit the daemon with \"exit\" command or if you use \"save\" command." << ENDL << "Please note, that the blockchain will be saved only after you quit the daemon with \"exit\" command or if you use \"save\" command." << ENDL
<< "Otherwise, you will possibly need to synchronize the blockchain again." << ENDL << "Otherwise, you will possibly need to synchronize the blockchain again." << ENDL
<< ENDL << ENDL
<< "Use \"help\" command to see the list of available commands." << ENDL << "Use \"help\" command to see the list of available commands." << ENDL
@ -716,7 +715,7 @@ namespace cryptonote
return true; return true;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
size_t t_cryptonote_protocol_handler<t_core>::get_synchronizing_connections_count() size_t t_cryptonote_protocol_handler<t_core>::get_synchronizing_connections_count()
{ {
size_t count = 0; size_t count = 0;
@ -728,12 +727,12 @@ namespace cryptonote
return count; return count;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
int t_cryptonote_protocol_handler<t_core>::handle_response_chain_entry(int command, NOTIFY_RESPONSE_CHAIN_ENTRY::request& arg, cryptonote_connection_context& context) int t_cryptonote_protocol_handler<t_core>::handle_response_chain_entry(int command, NOTIFY_RESPONSE_CHAIN_ENTRY::request& arg, cryptonote_connection_context& context)
{ {
LOG_PRINT_CCONTEXT_L2("NOTIFY_RESPONSE_CHAIN_ENTRY: m_block_ids.size()=" << arg.m_block_ids.size() LOG_PRINT_CCONTEXT_L2("NOTIFY_RESPONSE_CHAIN_ENTRY: m_block_ids.size()=" << arg.m_block_ids.size()
<< ", m_start_height=" << arg.start_height << ", m_total_height=" << arg.total_height); << ", m_start_height=" << arg.start_height << ", m_total_height=" << arg.total_height);
if(!arg.m_block_ids.size()) if(!arg.m_block_ids.size())
{ {
LOG_ERROR_CCONTEXT("sent empty m_block_ids, dropping connection"); LOG_ERROR_CCONTEXT("sent empty m_block_ids, dropping connection");
@ -750,7 +749,7 @@ namespace cryptonote
m_p2p->add_ip_fail(context.m_remote_ip); m_p2p->add_ip_fail(context.m_remote_ip);
return 1; return 1;
} }
context.m_remote_blockchain_height = arg.total_height; context.m_remote_blockchain_height = arg.total_height;
context.m_last_response_height = arg.start_height + arg.m_block_ids.size()-1; context.m_last_response_height = arg.start_height + arg.m_block_ids.size()-1;
if(context.m_last_response_height > context.m_remote_blockchain_height) if(context.m_last_response_height > context.m_remote_blockchain_height)
@ -771,29 +770,29 @@ namespace cryptonote
return 1; return 1;
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::relay_block(NOTIFY_NEW_BLOCK::request& arg, cryptonote_connection_context& exclude_context) bool t_cryptonote_protocol_handler<t_core>::relay_block(NOTIFY_NEW_BLOCK::request& arg, cryptonote_connection_context& exclude_context)
{ {
return relay_post_notify<NOTIFY_NEW_BLOCK>(arg, exclude_context); return relay_post_notify<NOTIFY_NEW_BLOCK>(arg, exclude_context);
} }
//------------------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------------------
template<class t_core> template<class t_core>
bool t_cryptonote_protocol_handler<t_core>::relay_transactions(NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& exclude_context) bool t_cryptonote_protocol_handler<t_core>::relay_transactions(NOTIFY_NEW_TRANSACTIONS::request& arg, cryptonote_connection_context& exclude_context)
{ {
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

12
src/daemon/CMakeLists.txt
View file

@ -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

22
src/daemon/main.cpp
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -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();
@ -77,7 +77,7 @@ int main(int argc, char const * argv[])
command_line::add_arg(visible_options, daemon_args::arg_config_file, default_conf.string()); command_line::add_arg(visible_options, daemon_args::arg_config_file, default_conf.string());
command_line::add_arg(visible_options, command_line::arg_test_dbg_lock_sleep); command_line::add_arg(visible_options, command_line::arg_test_dbg_lock_sleep);
cryptonote::core::init_options(core_settings); cryptonote::core::init_options(core_settings);
// Settings // Settings
bf::path default_log = default_data_dir / std::string(CRYPTONOTE_NAME ".log"); bf::path default_log = default_data_dir / std::string(CRYPTONOTE_NAME ".log");
command_line::add_arg(core_settings, daemon_args::arg_log_file, default_log.string()); command_line::add_arg(core_settings, daemon_args::arg_log_file, default_log.string());
@ -132,7 +132,7 @@ int main(int argc, char const * argv[])
std::cout << "OS: " << tools::get_os_version_string() << ENDL; std::cout << "OS: " << tools::get_os_version_string() << ENDL;
return 0; return 0;
} }
epee::g_test_dbg_lock_sleep = command_line::get_arg(vm, command_line::arg_test_dbg_lock_sleep); epee::g_test_dbg_lock_sleep = command_line::get_arg(vm, command_line::arg_test_dbg_lock_sleep);
std::string db_type = command_line::get_arg(vm, command_line::arg_db_type); std::string db_type = command_line::get_arg(vm, command_line::arg_db_type);
@ -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);
} }

66
src/p2p/net_node.h
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#pragma once #pragma once
@ -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()
{} {}
@ -128,7 +128,7 @@ namespace nodetool
, "seeds.moneroseeds.ch" , "seeds.moneroseeds.ch"
, "seeds.moneroseeds.li" , "seeds.moneroseeds.li"
}; };
bool islimitup=false; bool islimitup=false;
bool islimitdown=false; bool islimitdown=false;
@ -201,7 +201,7 @@ namespace nodetool
bool try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist = false, uint64_t last_seen_stamp = 0, bool white = true); bool try_to_connect_and_handshake_with_new_peer(const net_address& na, bool just_take_peerlist = false, uint64_t last_seen_stamp = 0, bool white = true);
size_t get_random_index_with_fixed_probability(size_t max_index); size_t get_random_index_with_fixed_probability(size_t max_index);
bool is_peer_used(const peerlist_entry& peer); bool is_peer_used(const peerlist_entry& peer);
bool is_addr_connected(const net_address& peer); bool is_addr_connected(const net_address& peer);
template<class t_callback> template<class t_callback>
bool try_ping(basic_node_data& node_data, p2p_connection_context& context, t_callback cb); bool try_ping(basic_node_data& node_data, p2p_connection_context& context, t_callback cb);
bool make_expected_connections_count(bool white_list, size_t expected_connections); bool make_expected_connections_count(bool white_list, size_t expected_connections);
@ -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;

404
src/p2p/net_node.inl
View file

@ -1,21 +1,21 @@
// Copyright (c) 2014-2015, The Monero Project // Copyright (c) 2014-2015, The Monero Project
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met: // permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other // of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution. // materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific // used to endorse or promote products derived from this software without specific
// prior written permission. // prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -25,7 +25,7 @@
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
// IP blocking adapted from Boolberry // IP blocking adapted from Boolberry
@ -34,7 +34,7 @@
#include <algorithm> #include <algorithm>
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread/thread.hpp> #include <boost/thread/thread.hpp>
#include <atomic> #include <atomic>
#include "version.h" #include "version.h"
@ -89,17 +89,17 @@ namespace nodetool
" If this option is given the options add-priority-node and seed-node are ignored"}; " If this option is given the options add-priority-node and seed-node are ignored"};
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>
@ -113,7 +113,7 @@ namespace nodetool
command_line::add_arg(desc, arg_p2p_add_peer); command_line::add_arg(desc, arg_p2p_add_peer);
command_line::add_arg(desc, arg_p2p_add_priority_node); command_line::add_arg(desc, arg_p2p_add_priority_node);
command_line::add_arg(desc, arg_p2p_add_exclusive_node); command_line::add_arg(desc, arg_p2p_add_exclusive_node);
command_line::add_arg(desc, arg_p2p_seed_node); command_line::add_arg(desc, arg_p2p_seed_node);
command_line::add_arg(desc, arg_p2p_hide_my_port); command_line::add_arg(desc, arg_p2p_hide_my_port);
command_line::add_arg(desc, arg_no_igd); command_line::add_arg(desc, arg_no_igd);
command_line::add_arg(desc, arg_offline); command_line::add_arg(desc, arg_offline);
@ -254,7 +254,7 @@ namespace nodetool
m_offline = command_line::get_arg(vm, arg_offline); m_offline = command_line::get_arg(vm, arg_offline);
if (command_line::has_arg(vm, arg_p2p_add_peer)) if (command_line::has_arg(vm, arg_p2p_add_peer))
{ {
std::vector<std::string> perrs = command_line::get_arg(vm, arg_p2p_add_peer); std::vector<std::string> perrs = command_line::get_arg(vm, arg_p2p_add_peer);
for(const std::string& pr_str: perrs) for(const std::string& pr_str: perrs)
{ {
@ -265,24 +265,24 @@ namespace nodetool
m_command_line_peers.push_back(pe); m_command_line_peers.push_back(pe);
} }
} }
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))
{ {
if (!parse_peers_and_add_to_container(vm, arg_p2p_add_exclusive_node, m_exclusive_peers)) if (!parse_peers_and_add_to_container(vm, arg_p2p_add_exclusive_node, m_exclusive_peers))
return false; return false;
} }
if (command_line::has_arg(vm, arg_p2p_add_priority_node)) if (command_line::has_arg(vm, arg_p2p_add_priority_node))
{ {
if (!parse_peers_and_add_to_container(vm, arg_p2p_add_priority_node, m_priority_peers)) if (!parse_peers_and_add_to_container(vm, arg_p2p_add_priority_node, m_priority_peers))
return false; return false;
} }
if (command_line::has_arg(vm, arg_p2p_seed_node)) if (command_line::has_arg(vm, arg_p2p_seed_node))
{ {
if (!parse_peers_and_add_to_container(vm, arg_p2p_seed_node, m_seed_nodes)) if (!parse_peers_and_add_to_container(vm, arg_p2p_seed_node, m_seed_nodes))
@ -291,21 +291,21 @@ namespace nodetool
if(command_line::has_arg(vm, arg_p2p_hide_my_port)) if(command_line::has_arg(vm, arg_p2p_hide_my_port))
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) ) )
return false;
if ( !set_rate_up_limit(vm, command_line::get_arg(vm, arg_limit_rate_up) ) ) if ( !set_tos_flag(vm, command_line::get_arg(vm, arg_tos_flag) ) )
return false; return false;
if ( !set_rate_down_limit(vm, command_line::get_arg(vm, arg_limit_rate_down) ) ) if ( !set_rate_up_limit(vm, command_line::get_arg(vm, arg_limit_rate_up) ) )
return false; return false;
if ( !set_rate_limit(vm, command_line::get_arg(vm, arg_limit_rate) ) ) 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) ) )
return false;
return true; return true;
} }
@ -370,7 +370,7 @@ namespace nodetool
// add the result addresses as seed nodes // add the result addresses as seed nodes
// TODO: at some point add IPv6 support, but that won't be relevant // TODO: at some point add IPv6 support, but that won't be relevant
// for some time yet. // for some time yet.
std::vector<std::vector<std::string>> dns_results; std::vector<std::vector<std::string>> dns_results;
dns_results.resize(m_seed_nodes_list.size()); dns_results.resize(m_seed_nodes_list.size());
@ -484,7 +484,7 @@ namespace nodetool
for(auto& p: m_command_line_peers) for(auto& p: m_command_line_peers)
m_peerlist.append_with_peer_white(p); m_peerlist.append_with_peer_white(p);
//only in case if we really sure that we have external visible ip //only in case if we really sure that we have external visible ip
m_have_address = true; m_have_address = true;
m_ip_address = 0; m_ip_address = 0;
@ -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
UPNP_DeletePortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), "TCP", 0);
int portMappingResult; // Delete the port mapping before we create it, just in case we have dangling port mapping from the daemon not being shut down correctly
portMappingResult = UPNP_AddPortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), portString.str().c_str(), lanAddress, CRYPTONOTE_NAME, "TCP", 0, "0"); UPNP_DeletePortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), "TCP", 0);
if (portMappingResult != 0) {
LOG_ERROR("UPNP_AddPortMapping failed, error: " << strupnperror(portMappingResult));
} else {
LOG_PRINT_GREEN("Added IGD port mapping.", LOG_LEVEL_0);
}
} else if (result == 2) {
LOG_PRINT_L0("IGD was found but reported as not connected.");
} else if (result == 3) {
LOG_PRINT_L0("UPnP device was found but not recoginzed as IGD.");
} else {
LOG_ERROR("UPNP_GetValidIGD returned an unknown result code.");
}
FreeUPNPUrls(&urls); int portMappingResult;
} else { portMappingResult = UPNP_AddPortMapping(urls.controlURL, igdData.first.servicetype, portString.str().c_str(), portString.str().c_str(), lanAddress, CRYPTONOTE_NAME, "TCP", 0, "0");
LOG_PRINT_L0("No IGD was found."); if (portMappingResult != 0) {
} LOG_ERROR("UPNP_AddPortMapping failed, error: " << strupnperror(portMappingResult));
} } else {
LOG_PRINT_GREEN("Added IGD port mapping.", LOG_LEVEL_0);
}
} else if (result == 2) {
LOG_PRINT_L0("IGD was found but reported as not connected.");
} else if (result == 3) {
LOG_PRINT_L0("UPnP device was found but not recoginzed as IGD.");
} else {
LOG_ERROR("UPNP_GetValidIGD returned an unknown result code.");
}
FreeUPNPUrls(&urls);
} else {
LOG_PRINT_L0("No IGD was found.");
}
}
return res; return res;
} }
//----------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------
@ -566,30 +566,30 @@ 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();
@ -662,7 +662,7 @@ namespace nodetool
return true; return true;
} }
//----------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------
template<class t_payload_net_handler> template<class t_payload_net_handler>
bool node_server<t_payload_net_handler>::do_handshake_with_peer(peerid_type& pi, p2p_connection_context& context_, bool just_take_peerlist) bool node_server<t_payload_net_handler>::do_handshake_with_peer(peerid_type& pi, p2p_connection_context& context_, bool just_take_peerlist)
@ -671,11 +671,11 @@ namespace nodetool
typename COMMAND_HANDSHAKE::response rsp; typename COMMAND_HANDSHAKE::response rsp;
get_local_node_data(arg.node_data); get_local_node_data(arg.node_data);
m_payload_handler.get_payload_sync_data(arg.payload_data); m_payload_handler.get_payload_sync_data(arg.payload_data);
epee::simple_event ev; epee::simple_event ev;
std::atomic<bool> hsh_result(false); std::atomic<bool> hsh_result(false);
bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_HANDSHAKE::response>(context_.m_connection_id, COMMAND_HANDSHAKE::ID, arg, m_net_server.get_config_object(), bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_HANDSHAKE::response>(context_.m_connection_id, COMMAND_HANDSHAKE::ID, arg, m_net_server.get_config_object(),
[this, &pi, &ev, &hsh_result, &just_take_peerlist](int code, const typename COMMAND_HANDSHAKE::response& rsp, p2p_connection_context& context) [this, &pi, &ev, &hsh_result, &just_take_peerlist](int code, const typename COMMAND_HANDSHAKE::response& rsp, p2p_connection_context& context)
{ {
epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ev.raise();}); epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ev.raise();});
@ -744,7 +744,7 @@ namespace nodetool
typename COMMAND_TIMED_SYNC::request arg = AUTO_VAL_INIT(arg); typename COMMAND_TIMED_SYNC::request arg = AUTO_VAL_INIT(arg);
m_payload_handler.get_payload_sync_data(arg.payload_data); m_payload_handler.get_payload_sync_data(arg.payload_data);
bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_TIMED_SYNC::response>(context_.m_connection_id, COMMAND_TIMED_SYNC::ID, arg, m_net_server.get_config_object(), bool r = epee::net_utils::async_invoke_remote_command2<typename COMMAND_TIMED_SYNC::response>(context_.m_connection_id, COMMAND_TIMED_SYNC::ID, arg, m_net_server.get_config_object(),
[this](int code, const typename COMMAND_TIMED_SYNC::response& rsp, p2p_connection_context& context) [this](int code, const typename COMMAND_TIMED_SYNC::response& rsp, p2p_connection_context& context)
{ {
if(code < 0) if(code < 0)
@ -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;
@ -963,11 +963,11 @@ namespace nodetool
<< ":" << boost::lexical_cast<std::string>(pe.adr.port) << ":" << boost::lexical_cast<std::string>(pe.adr.port)
<< "[white=" << use_white_list << "[white=" << use_white_list
<< "] 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;
} }
@ -986,7 +986,7 @@ namespace nodetool
size_t try_count = 0; size_t try_count = 0;
size_t current_index = crypto::rand<size_t>()%m_seed_nodes.size(); size_t current_index = crypto::rand<size_t>()%m_seed_nodes.size();
while(true) while(true)
{ {
if(m_net_server.is_stop_signal_sent()) if(m_net_server.is_stop_signal_sent())
return false; return false;
@ -1135,7 +1135,7 @@ namespace nodetool
node_data.peer_id = m_config.m_peer_id; node_data.peer_id = m_config.m_peer_id;
if(!m_hide_my_port) if(!m_hide_my_port)
node_data.my_port = m_external_port ? m_external_port : m_listenning_port; node_data.my_port = m_external_port ? m_external_port : m_listenning_port;
else else
node_data.my_port = 0; node_data.my_port = 0;
node_data.network_id = m_network_id; node_data.network_id = m_network_id;
return true; return true;
@ -1515,92 +1515,92 @@ namespace nodetool
return true; return true;
} }
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>
bool node_server<t_payload_net_handler>::set_rate_down_limit(const boost::program_options::variables_map& vm, int64_t limit)
{
this->islimitdown=true;
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;
}
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_up_limit(const boost::program_options::variables_map& vm, int64_t limit)
{ {
int64_t limit_up = 0; this->islimitup=true;
int64_t limit_down = 0;
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; 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>
bool node_server<t_payload_net_handler>::set_rate_down_limit(const boost::program_options::variables_map& vm, int64_t limit)
{
this->islimitdown=true;
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;
}
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)
{
int64_t limit_up = 0;
int64_t limit_down = 0;
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;
}
} }