Replace tabs with two spaces for consistency with rest of codebase

Remove trailing whitespace in same files.

CMakeLists.txt

@@ -1,21 +1,21 @@
 # Copyright (c) 2014-2015, The Monero Project
-# 
+#
 # All rights reserved.
-# 
+#
 # Redistribution and use in source and binary forms, with or without modification, are
 # permitted provided that the following conditions are met:
-# 
+#
 # 1. Redistributions of source code must retain the above copyright notice, this list of
 #    conditions and the following disclaimer.
-# 
+#
 # 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
 #    materials provided with the distribution.
-# 
+#
 # 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
 #    prior written permission.
-# 
+#
 # 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
 # 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,
 # 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.
-# 
+#
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 cmake_minimum_required(VERSION 2.8.7)
@@ -46,30 +46,30 @@ function (die msg)
 endfunction ()
 
 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()
 
 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()
 
 # set this to 0 if per-block checkpoint needs to be disabled
@@ -137,7 +137,7 @@ elseif(CMAKE_SYSTEM_NAME MATCHES "DragonFly.*|FreeBSD")
 endif()
 
 # TODO: check bsdi, NetBSD, OpenBSD, to see if they need the same FreeBSD changes
-# 
+#
 # elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*")
 #   set(NETBSD TRUE)
 # elseif(CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*")
@@ -194,27 +194,27 @@ endif()
 set(BERKELEY_DB 0)
 if (DATABASE STREQUAL "lmdb")
   set(BLOCKCHAIN_DB DB_LMDB)
-  
+
   # temporarily allow mingw to compile with berkeley_db,
   # regardless if building static or not
   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()
 
   if (BERKELEY_DB AND (ARCH_WIDTH STREQUAL "32" OR ARM6 OR ARM7))
@@ -234,7 +234,7 @@ endif()
 if(BERKELEY_DB)
   add_definitions("-DBERKELEY_DB")
 endif()
-	
+
 add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")
 
 if (UNIX AND NOT APPLE)

src/CMakeLists.txt

@@ -1,21 +1,21 @@
 # Copyright (c) 2014-2015, The Monero Project
-# 
+#
 # All rights reserved.
-# 
+#
 # Redistribution and use in source and binary forms, with or without modification, are
 # permitted provided that the following conditions are met:
-# 
+#
 # 1. Redistributions of source code must retain the above copyright notice, this list of
 #    conditions and the following disclaimer.
-# 
+#
 # 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
 #    materials provided with the distribution.
-# 
+#
 # 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
 #    prior written permission.
-# 
+#
 # 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
 # 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,
 # 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.
-# 
+#
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 if (WIN32 OR STATIC)
@@ -105,5 +105,5 @@ add_subdirectory(daemon)
 add_subdirectory(blockchain_utilities)
 
 if(PER_BLOCK_CHECKPOINT)
-	add_subdirectory(blocks)
+  add_subdirectory(blocks)
 endif()

src/blockchain_db/berkeleydb/db_bdb.h

@@ -1,20 +1,20 @@
 // Copyright (c) 2014, The Monero Project
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@@ -99,18 +99,18 @@ private:
 template <typename T>
 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:
     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()

src/blockchain_db/blockchain_db.h

@@ -1,21 +1,21 @@
 // Copyright (c) 2014, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@@ -85,7 +85,7 @@
  *   size_t      get_block_size(height)
  *   difficulty  get_block_cumulative_difficulty(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()
  *   hash        get_block_hash_from_height(height)
  *   blocks      get_blocks_range(height1, height2)
@@ -139,12 +139,12 @@ typedef std::pair<crypto::hash, uint64_t> tx_out_index;
 #pragma pack(push, 1)
 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)
-	
+
 /***********************************
  * Exception Definitions
  ***********************************/
@@ -300,7 +300,7 @@ private:
 
   /*********************************************************************
    * private concrete members
-   *********************************************************************/ 
+   *********************************************************************/
   // private version of pop_block, for undoing if an add_block goes tits up
   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 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 bool can_thread_bulk_indices() const = 0;
 
   // return a vector of indices corresponding to the global output index for

src/blockchain_db/lmdb/db_lmdb.cpp

@@ -1,20 +1,20 @@
 // Copyright (c) 2014, The Monero Project
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@@ -72,19 +72,19 @@ struct lmdb_cur
     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()
   {
@@ -103,8 +103,8 @@ private:
 template<typename T>
 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_data = &t_copy;
@@ -116,8 +116,8 @@ private:
 template<>
 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());
     mv_size = bd.size();
@@ -130,8 +130,8 @@ private:
 template<>
 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_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)
 {
-	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)
@@ -313,18 +313,18 @@ void BlockchainLMDB::do_resize(uint64_t increase_size)
   // check disk capacity
   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(...)
   {
-	// 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;
@@ -417,7 +417,7 @@ bool BlockchainLMDB::need_resize(uint64_t threshold_size) const
   }
   return false;
 #else
-	return false;
+  return false;
 #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,
-		const crypto::hash& blk_hash)
+    const crypto::hash& blk_hash)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   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))
   {
-		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++;
@@ -891,17 +891,17 @@ tx_out BlockchainLMDB::output_from_blob(const blobdata& blob) const
   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__);
-	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"));
 
-	return global_indices[0];
+  return global_indices[0];
 }
 
 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
   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("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_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_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;
 
-	// 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 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)
 {
-	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
@@ -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)
 {
   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"));
 
-	return indices[0];
+  return indices[0];
 }
 
 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,
-		const std::vector<transaction>& txs)
+    const std::vector<transaction>& txs)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   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,
-		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,
-		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)
 {
-	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)
 {
-	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)

src/blockchain_db/lmdb/db_lmdb.h

@@ -1,20 +1,20 @@
 // Copyright (c) 2014, The Monero Project
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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 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 void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices);

src/blocks/blockexports.c

@@ -49,18 +49,18 @@ extern const unsigned char _binary_testnet_blocks_end[];
 
 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)
 {
-	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

src/crypto/aesb.c

@@ -25,11 +25,11 @@ extern "C"
 {
 #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)
 #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 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) {\
-	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) | \
-	((uint32_t)(b2) << 16) | ((uint32_t)(b1) << 8) | (b0))
+    ((uint32_t)(b2) << 16) | ((uint32_t)(b1) << 8) | (b0))
 
 #define h0(x)   (x)
 #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 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);
 
@@ -149,34 +149,34 @@ d_4(uint32_t, t_dec(f,n), sb_data, u0, u1, u2, u3);
 #endif
 
 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)
-{   
+{
-	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);
 }
 
 

src/crypto/slow-hash.c

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include <assert.h>
@@ -104,33 +104,33 @@
 #endif
 
 #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.
- * 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
  * read/write from the scratchpad, but this time mixes the values using a 64
  * bit multiply.
  * This code is based upon an optimized implementation by dga.
  */
 #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)
 #define THREADV __declspec(thread)
 #else
@@ -226,14 +226,14 @@ STATIC INLINE void aes_256_assist2(__m128i* t1, __m128i * t3)
     *t3 = _mm_xor_si128(*t3, t2);
 }
 
-/** 
+/**
  * @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
  * 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)
  * 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
  * AESKEYGENASSIST instruction to speed key generation, and thus requires
  * 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
  *
- * 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
  * during the random accesses to the scratch buffer.  This is one of the
  * important speed optimizations needed to make CryptoNight faster.
@@ -423,7 +423,7 @@ void slow_hash_allocate_state(void)
 #else
 #if defined(__APPLE__) || defined(__FreeBSD__)
     hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE,
-                    MAP_PRIVATE | MAP_ANON, 0, 0);    
+                    MAP_PRIVATE | MAP_ANON, 0, 0);
 #else
     hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE,
                     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));
-    // 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.
     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)
 {
-	// 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)
 {
-	___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)
 {
-	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)
 {
-	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)
 {
-	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)
@@ -774,25 +774,25 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
 
     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);
@@ -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){
-	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) {
@@ -916,11 +916,11 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
   memcpy(text, state.init, INIT_SIZE_BYTE);
   memcpy(aes_key, state.hs.b, AES_KEY_SIZE);
   aes_ctx = (oaes_ctx *) oaes_alloc();
-  
+
   oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE);
   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);
   }
@@ -938,7 +938,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash) {
     /* Iteration 1 */
     j = e2i(a, MEMORY / 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);
     swap_blocks(b, 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 (j = 0; j < INIT_SIZE_BLK; j++) {
       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);

src/cryptonote_core/CMakeLists.txt

@@ -65,9 +65,9 @@ set(cryptonote_core_private_headers
   hardfork.h)
 
 if(PER_BLOCK_CHECKPOINT)
-	set(Blocks "blocks")
+  set(Blocks "blocks")
 else()
-	set(Blocks "")
+  set(Blocks "")
 endif()
 
 bitmonero_private_headers(cryptonote_core
@@ -86,7 +86,7 @@ target_link_libraries(cryptonote_core
     ${Boost_PROGRAM_OPTIONS_LIBRARY}
     ${Boost_SERIALIZATION_LIBRARY}
   LINK_PRIVATE
-    ${Blocks}  
+    ${Blocks}
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_SYSTEM_LIBRARY}
     ${Boost_THREAD_LIBRARY}

src/cryptonote_core/blockchain.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include <algorithm>
@@ -99,8 +99,8 @@ static const uint64_t testnet_hard_fork_version_1_till = 624633;
 
 //------------------------------------------------------------------
 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__);
 }
@@ -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;
     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;
 
     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()  \
         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);
 
 #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
 
         // 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);
         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)
@@ -2131,21 +2131,21 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
         }
         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++;
@@ -2155,21 +2155,21 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
 
     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);
     return true;
@@ -3154,9 +3154,9 @@ bool Blockchain::prepare_handle_incoming_blocks(const std::list<block_complete_e
     TIME_MEASURE_FINISH(scantable);
     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;

src/cryptonote_core/blockchain.h

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #pragma once
@@ -61,11 +61,11 @@ namespace cryptonote
 
   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()
     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; }
-    
+
     HardFork::State get_hard_fork_state() const;
     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(); }
@@ -174,12 +174,12 @@ namespace cryptonote
       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:
     typedef std::unordered_map<crypto::hash, size_t> blocks_by_id_index;
     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
     std::vector<crypto::hash> m_blocks_hash_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_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
     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;
     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,
-    		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

src/cryptonote_core/blockchain_storage.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include <algorithm>
@@ -97,11 +97,11 @@ bool blockchain_storage::init(const std::string& config_folder, bool testnet)
   {
 
       // checkpoints
-      
+
       // 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
@@ -110,7 +110,7 @@ bool blockchain_storage::init(const std::string& config_folder, bool testnet)
       // see issue #118
       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
   }
@@ -1072,13 +1072,13 @@ bool blockchain_storage::get_random_outs_for_amounts(const COMMAND_RPC_GET_RANDO
       size_t try_count = 0;
       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);
-	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))
           continue;
         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
 {
-		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
@@ -1248,7 +1248,7 @@ bool blockchain_storage::find_blockchain_supplement(const uint64_t req_start_blo
 {
   CRITICAL_REGION_LOCAL(m_blockchain_lock);
   if(req_start_block > 0) {
-     start_height = req_start_block; 
+     start_height = req_start_block;
   } else {
     if(!find_blockchain_supplement(qblock_ids, start_height))
       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.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.
 
   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
     << ", " << 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;
   /*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 (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
       {
-	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");
       }
     }
   }

src/cryptonote_core/checkpoints_create.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include "checkpoints_create.h"
@@ -46,11 +46,11 @@ namespace
       bool ok = false;
       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;
     }
@@ -62,25 +62,25 @@ namespace
 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 {
- 	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)
-{      
+{
   ADD_CHECKPOINT(1,     "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148");
   ADD_CHECKPOINT(10,    "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381");
   ADD_CHECKPOINT(100,   "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d");
@@ -126,11 +126,11 @@ bool load_checkpoints_from_json(cryptonote::checkpoints& checkpoints, std::strin
       uint64_t height;
       height = it->height;
       if (height <= prev_max_height) {
-	LOG_PRINT_L1("ignoring checkpoint height " << height);
+        LOG_PRINT_L1("ignoring checkpoint height " << height);
       } 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;
   }
@@ -142,15 +142,15 @@ bool load_checkpoints_from_dns(cryptonote::checkpoints& checkpoints, bool testne
 {
   // All four MoneroPulse domains have DNSSEC on and valid
   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"
-							   , "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;
@@ -220,8 +220,8 @@ bool load_checkpoints_from_dns(cryptonote::checkpoints& checkpoints, bool testne
     {
       if (dns_records_match(records[i], records[j]))
       {
-	good_records_index = i;
+        good_records_index = i;
-	break;
+        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));
       if (!(ss >> height))
       {
-	continue;
+        continue;
       }
 
       // 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);
       if (!epee::string_tools::parse_tpod_from_hex_string(hashStr, hash))
       {
-	continue;
+        continue;
       }
 
       ADD_CHECKPOINT(height, hashStr);

src/cryptonote_core/cryptonote_basic_impl.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include "include_base_utils.h"
@@ -106,8 +106,8 @@ namespace cryptonote {
     assert(current_block_size < std::numeric_limits<uint32_t>::max());
 
     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;
     multiplicand *= current_block_size;
     uint64_t product_lo = mul128(base_reward, multiplicand, &product_hi);

src/cryptonote_core/cryptonote_core.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include "include_base_utils.h"
@@ -63,7 +63,7 @@ namespace cryptonote
               m_blockchain_storage(&m_mempool),
 #endif
               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_target_blockchain_height(0),
               m_checkpoints_path(""),
@@ -176,10 +176,10 @@ namespace cryptonote
 
     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));
-    
+
     if (command_line::get_arg(vm, command_line::arg_test_drop_download) == true)
-		test_drop_download();
+      test_drop_download();
-    
+
     return true;
   }
   //-----------------------------------------------------------------------------------------------
@@ -331,7 +331,7 @@ namespace cryptonote
       db->set_auto_remove_logs(auto_remove_logs);
       db->open(filename, db_flags);
       if(!db->m_open)
-    	  return false;
+        return false;
     }
     catch (const DB_ERROR& e)
     {
@@ -374,12 +374,12 @@ namespace cryptonote
   //-----------------------------------------------------------------------------------------------
     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;
   }
   //-----------------------------------------------------------------------------------------------
@@ -395,28 +395,28 @@ namespace cryptonote
   //-----------------------------------------------------------------------------------------------
   void core::test_drop_download()
   {
-	  m_test_drop_download = false;
+    m_test_drop_download = false;
   }
   //-----------------------------------------------------------------------------------------------
   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
   {
-	  return m_test_drop_download;
+    return m_test_drop_download;
   }
   //-----------------------------------------------------------------------------------------------
   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)
@@ -852,14 +852,14 @@ namespace cryptonote
   {
     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
         << "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
         << "Use \"help\" command to see the list of available commands." << 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;
     }
@@ -915,6 +915,6 @@ namespace cryptonote
   {
     raise(SIGTERM);
   }
-  
+
   std::atomic<bool> core::m_fast_exit(false);
 }

src/cryptonote_core/cryptonote_core.h

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #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 prepare_handle_incoming_blocks(const std::list<block_complete_entry>  &blocks);
      bool cleanup_handle_incoming_blocks(bool force_sync = false);
-     	     	
+
      bool check_incoming_block_size(const blobdata& block_blob) const;
      i_cryptonote_protocol* get_protocol(){return m_pprotocol;}
 
@@ -175,7 +175,7 @@ namespace cryptonote
 
      static std::atomic<bool> m_fast_exit;
      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;
 #if BLOCKCHAIN_DB == DB_LMDB

src/cryptonote_core/difficulty.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include <algorithm>
@@ -53,40 +53,40 @@ namespace cryptonote {
 #else
 
   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

src/cryptonote_core/miner.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include <sstream>
@@ -68,9 +68,9 @@ namespace cryptonote
     m_thread_index(0),
     m_phandler(phandler),
     m_height(0),
-    m_pausers_count(0), 
+    m_pausers_count(0),
     m_threads_total(0),
-    m_starter_nonce(0), 
+    m_starter_nonce(0),
     m_last_hr_merge_time(0),
     m_hashes(0),
     m_do_print_hashrate(false),
@@ -109,7 +109,7 @@ namespace cryptonote
     block bl = AUTO_VAL_INIT(bl);
     difficulty_type di = AUTO_VAL_INIT(di);
     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())
     {
       extra_nonce = m_extra_messages[m_config.current_extra_message_index];
@@ -135,7 +135,7 @@ namespace cryptonote
       merge_hr();
       return true;
     });
-    
+
     return true;
   }
   //-----------------------------------------------------------------------------------------------------
@@ -227,7 +227,7 @@ namespace cryptonote
   uint32_t miner::get_threads_count() const {
     return m_threads_total;
   }
-  //----------------------------------------------------------------------------------------------------- 
+  //-----------------------------------------------------------------------------------------------------
   bool miner::start(const account_public_address& adr, size_t threads_count, const boost::thread::attributes& attrs)
   {
     m_mine_address = adr;
@@ -346,7 +346,7 @@ namespace cryptonote
     difficulty_type local_diff = 0;
     uint32_t local_template_ver = 0;
     block b;
-	  slow_hash_allocate_state();
+    slow_hash_allocate_state();
     while(!m_stop)
     {
       if(m_pausers_count)//anti split workaround
@@ -357,7 +357,6 @@ namespace cryptonote
 
       if(local_template_ver != m_template_no)
       {
-        
         CRITICAL_REGION_BEGIN(m_template_lock);
         b = m_template;
         local_diff = m_diffic;
@@ -395,7 +394,7 @@ namespace cryptonote
       nonce+=m_threads_total;
       ++m_hashes;
     }
-	  slow_hash_free_state();
+    slow_hash_free_state();
     LOG_PRINT_L0("Miner thread stopped ["<< th_local_index << "]");
     return true;
   }

src/cryptonote_core/tx_pool.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #include <algorithm>
@@ -228,8 +228,8 @@ namespace cryptonote
   bool tx_memory_pool::remove_transaction_keyimages(const transaction& tx)
   {
     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);
     BOOST_FOREACH(const txin_v& vi, tx.vin)
     {
@@ -299,7 +299,7 @@ namespace cryptonote
     {
       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) )
       {
         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
       // 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
       // to propagate at 60s block times.
       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,
       // stop including more tx
       if (total_size > median_size)
-        break;      
+        break;
 
       // Skip transactions that are not ready to be
       // included into the blockchain or that are

src/cryptonote_core/tx_pool.h

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #pragma once
@@ -139,7 +139,7 @@ namespace cryptonote
     };
 
   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_keyimges_as_spent(const transaction& tx) const;
     bool remove_transaction_keyimages(const transaction& tx);

src/cryptonote_protocol/cryptonote_protocol_handler.inl

@@ -3,23 +3,23 @@
 /// @brief This is the orginal cryptonote protocol network-events handler, modified by us
 
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote 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>
-    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_syncronized_connections_count(0),
                                                                                                               m_synchronized(false)
@@ -66,21 +66,21 @@ namespace cryptonote
       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)
   {
     return true;
   }
-  //------------------------------------------------------------------------------------------------------------------------  
+  //------------------------------------------------------------------------------------------------------------------------
-  template<class t_core> 
+  template<class t_core>
   bool t_cryptonote_protocol_handler<t_core>::deinit()
   {
-    
+
 
     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)
   {
     if(p2p)
@@ -88,8 +88,8 @@ namespace cryptonote
     else
       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)
   {
     LOG_PRINT_CCONTEXT_L2("callback fired");
@@ -107,22 +107,22 @@ namespace cryptonote
     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)
   {
     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()
   {
     std::stringstream ss;
     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"
       << std::setw(20) << "Peer id"
@@ -131,19 +131,19 @@ namespace cryptonote
       << std::setw(20) << "Livetime(sec)"
       << std::setw(12) << "Down (kB/s)"
       << std::setw(14) << "Down(now)"
-      << std::setw(10) << "Up (kB/s)" 
+      << std::setw(10) << "Up (kB/s)"
       << std::setw(13) << "Up(now)"
       << ENDL;
 
-	uint32_t ip;
+    uint32_t ip;
     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]") +
         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
@@ -157,30 +157,30 @@ namespace cryptonote
         << (local_ip ? "[LAN]" : "")
         << std::left << (ip == LOCALHOST_INT ? "[LOCALHOST]" : "") // 127.0.0.1
         << 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;
     });
-	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
-  //------------------------------------------------------------------------------------------------------------------------   
+  //------------------------------------------------------------------------------------------------------------------------
   template<class t_core>
   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.live_time = timestamp - cntxt.m_started;
-      
+
       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
       {
-		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);
 
       return true;
@@ -254,7 +254,7 @@ namespace cryptonote
     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)
   {
     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)
       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;
       if(is_inital)
@@ -271,11 +271,11 @@ namespace cryptonote
       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.
     Nz. */
     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());
     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) "
@@ -290,16 +290,16 @@ namespace cryptonote
     m_p2p->request_callback(context);
     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)
   {
     m_core.get_blockchain_top(hshd.current_height, hshd.top_id);
     hshd.current_height +=1;
     return true;
   }
-  //------------------------------------------------------------------------------------------------------------------------  
+  //------------------------------------------------------------------------------------------------------------------------
-    template<class t_core> 
+    template<class t_core>
     bool t_cryptonote_protocol_handler<t_core>::get_payload_sync_data(blobdata& 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);
     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)
   {
     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>();
-    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.resume_mine();
     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() );
       post_notify<NOTIFY_REQUEST_CHAIN>(r, context);
     }
-      
+
     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)
   {
     LOG_PRINT_CCONTEXT_L2("NOTIFY_NEW_TRANSACTIONS");
@@ -391,7 +391,7 @@ namespace cryptonote
     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)
   {
     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");
       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());
     post_notify<NOTIFY_RESPONSE_GET_OBJECTS>(rsp, context);
     //handler_response_blocks_now(sizeof(rsp)); // XXX
@@ -410,67 +410,67 @@ namespace cryptonote
   }
   //------------------------------------------------------------------------------------------------------------------------
 
-  
+
   template<class t_core>
   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>
   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");
-    
+
     // calculate size of request - mainly for logging/debug
     size_t size = 0;
     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)
     {
-      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_p2p->drop_connection(context);
       return 1;
@@ -485,14 +485,14 @@ namespace cryptonote
       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");
         m_p2p->drop_connection(context);
         return 1;
-      }      
+      }
       //to avoid concurrency in core between connections, suspend connections which delivered block later then first one
       if(count == 2)
-      { 
+      {
         if(m_core.have_block(get_block_hash(b)))
         {
           context.m_state = cryptonote_connection_context::state_idle;
@@ -502,18 +502,18 @@ namespace cryptonote
           return 1;
         }
       }
-      
+
       auto req_it = context.m_requested_objects.find(get_block_hash(b));
       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");
         m_p2p->drop_connection(context);
         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");
         m_p2p->drop_connection(context);
         return 1;
@@ -524,7 +524,7 @@ namespace cryptonote
 
     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);
       m_p2p->drop_connection(context);
       return 1;
@@ -537,78 +537,77 @@ namespace cryptonote
         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);
-			
+
       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);
     return 1;
   }
   //------------------------------------------------------------------------------------------------------------------------
-  template<class t_core> 
+  template<class t_core>
   bool t_cryptonote_protocol_handler<t_core>::on_idle()
   {
     return m_core.on_idle();
@@ -629,18 +628,18 @@ namespace cryptonote
     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)
   {
-	//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())
     {
       //we know objects that we need, request this objects
@@ -648,8 +647,8 @@ namespace cryptonote
       size_t count = 0;
       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)
       {
         if( !(check_having_blocks && m_core.have_block(*it)))
@@ -661,35 +660,35 @@ namespace cryptonote
         context.m_needed_objects.erase(it++);
       }
       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)
     {//we have to fetch more objects ids, request blockchain entry
-     
+
       NOTIFY_REQUEST_CHAIN::request r = boost::value_initialized<NOTIFY_REQUEST_CHAIN::request>();
       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() );
       post_notify<NOTIFY_REQUEST_CHAIN>(r, context);
     }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_remote_blockchain_height=" << context.m_remote_blockchain_height
                            << "\r\nm_needed_objects.size()=" << context.m_needed_objects.size()
                            << "\r\nm_requested_objects.size()=" << context.m_requested_objects.size()
                            << "\r\non connection [" << epee::net_utils::print_connection_context_short(context)<< "]");
-      
+
       context.m_state = cryptonote_connection_context::state_normal;
       LOG_PRINT_CCONTEXT_GREEN(" SYNCHRONIZED OK", LOG_LEVEL_0);
       on_connection_synchronized();
@@ -697,16 +696,16 @@ namespace cryptonote
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------
-  template<class t_core> 
+  template<class t_core>
   bool t_cryptonote_protocol_handler<t_core>::on_connection_synchronized()
   {
     bool val_expected = false;
     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
-        << "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
         << ENDL
         << "Use \"help\" command to see the list of available commands." << ENDL
@@ -716,7 +715,7 @@ namespace cryptonote
     return true;
   }
   //------------------------------------------------------------------------------------------------------------------------
-  template<class t_core> 
+  template<class t_core>
   size_t t_cryptonote_protocol_handler<t_core>::get_synchronizing_connections_count()
   {
     size_t count = 0;
@@ -728,12 +727,12 @@ namespace cryptonote
     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)
   {
-    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);
-    
+
     if(!arg.m_block_ids.size())
     {
       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);
       return 1;
     }
-    
+
     context.m_remote_blockchain_height = arg.total_height;
     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)
@@ -771,29 +770,29 @@ namespace cryptonote
     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)
   {
     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)
   {
     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

src/daemon/CMakeLists.txt

@@ -28,12 +28,12 @@
 
 set(blocksdat "")
 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()
 
 set(daemon_sources

src/daemon/main.cpp

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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 {
 
-		_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();
 
@@ -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, command_line::arg_test_dbg_lock_sleep);
       cryptonote::core::init_options(core_settings);
-    
+
       // Settings
       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());
@@ -132,7 +132,7 @@ int main(int argc, char const * argv[])
       std::cout << "OS: " << tools::get_os_version_string() << ENDL;
       return 0;
     }
-    
+
     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);
@@ -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);
   }

src/p2p/net_node.h

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 #pragma once
@@ -83,15 +83,15 @@ namespace nodetool
     typedef t_payload_net_handler payload_net_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_allow_local_ip(false),
+    m_allow_local_ip(false),
-		m_hide_my_port(false),
+    m_hide_my_port(false),
     m_no_igd(false),
     m_offline(false),
     m_save_graph(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()
     {}
@@ -128,7 +128,7 @@ namespace nodetool
     , "seeds.moneroseeds.ch"
     , "seeds.moneroseeds.li"
     };
-    
+
     bool islimitup=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);
     size_t get_random_index_with_fixed_probability(size_t max_index);
     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>
     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);
@@ -215,20 +215,20 @@ namespace nodetool
     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 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()
-			_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
     std::string print_connections_container();
@@ -247,16 +247,16 @@ namespace nodetool
       END_KV_SERIALIZE_MAP()
     };
 
-	public:
+  public:
     config m_config; // TODO was private, add getters?
     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;
 
     bool m_have_address;
@@ -270,7 +270,7 @@ namespace nodetool
     bool m_offline;
     std::atomic<bool> m_save_graph;
     std::atomic<bool> is_closing;
-	std::unique_ptr<std::thread> mPeersLoggerThread;
+    std::unique_ptr<std::thread> mPeersLoggerThread;
     //critical_section m_connections_lock;
     //connections_indexed_container m_connections;
 

src/p2p/net_node.inl

@@ -1,21 +1,21 @@
 // Copyright (c) 2014-2015, The Monero Project
-// 
+//
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without modification, are
 // permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice, this list of
 //    conditions and the following disclaimer.
-// 
+//
 // 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
 //    materials provided with the distribution.
-// 
+//
 // 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
 //    prior written permission.
-// 
+//
 // 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
 // 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,
 // 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.
-// 
+//
 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
 // IP blocking adapted from Boolberry
@@ -34,7 +34,7 @@
 
 #include <algorithm>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/thread/thread.hpp> 
+#include <boost/thread/thread.hpp>
 #include <atomic>
 
 #include "version.h"
@@ -89,17 +89,17 @@ namespace nodetool
                                                                                                   " 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<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>
@@ -113,7 +113,7 @@ namespace nodetool
     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_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_no_igd);
     command_line::add_arg(desc, arg_offline);
@@ -254,7 +254,7 @@ namespace nodetool
     m_offline = command_line::get_arg(vm, arg_offline);
 
     if (command_line::has_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)
       {
@@ -265,24 +265,24 @@ namespace nodetool
         m_command_line_peers.push_back(pe);
       }
     }
-    
+
     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 (!parse_peers_and_add_to_container(vm, arg_p2p_add_exclusive_node, m_exclusive_peers))
         return false;
     }
-    
+
     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))
         return false;
     }
-    
+
     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))
@@ -291,21 +291,21 @@ namespace nodetool
 
     if(command_line::has_arg(vm, arg_p2p_hide_my_port))
       m_hide_my_port = true;
-      
+
     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;
   }
@@ -370,7 +370,7 @@ namespace nodetool
       // add the result addresses as seed nodes
       // TODO: at some point add IPv6 support, but that won't be relevant
       // for some time yet.
-      
+
       std::vector<std::vector<std::string>> dns_results;
       dns_results.resize(m_seed_nodes_list.size());
 
@@ -484,7 +484,7 @@ namespace nodetool
 
     for(auto& p: m_command_line_peers)
       m_peerlist.append_with_peer_white(p);
-    
+
     //only in case if we really sure that we have external visible ip
     m_have_address = true;
     m_ip_address = 0;
@@ -512,48 +512,48 @@ namespace nodetool
 
     // Add UPnP port mapping
     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
-		// 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
-		UPNPDev* deviceList = upnpDiscover(1000, NULL, NULL, 0, 0, &result);
+      UPNPDev* deviceList = upnpDiscover(1000, NULL, NULL, 0, 0, &result);
 #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;
   }
   //-----------------------------------------------------------------------------------
@@ -566,30 +566,30 @@ namespace nodetool
   template<class t_payload_net_handler>
   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
     int thrds_count = 10;
 
@@ -620,7 +620,7 @@ namespace nodetool
   template<class t_payload_net_handler>
   bool node_server<t_payload_net_handler>::deinit()
   {
-	kill();
+    kill();
     m_peerlist.deinit();
     m_net_server.deinit_server();
     return store_config();
@@ -662,7 +662,7 @@ namespace nodetool
     return true;
   }
   //-----------------------------------------------------------------------------------
- 
+
 
   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)
@@ -671,11 +671,11 @@ namespace nodetool
     typename COMMAND_HANDSHAKE::response rsp;
     get_local_node_data(arg.node_data);
     m_payload_handler.get_payload_sync_data(arg.payload_data);
-    
+
     epee::simple_event ev;
     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)
     {
       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);
     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)
     {
       if(code < 0)
@@ -835,16 +835,16 @@ namespace nodetool
   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)
   {
-	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)  << ":"
         << 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")
@@ -946,12 +946,12 @@ namespace nodetool
 
       ++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)) {
-				_note("Peer is used");
+        _note("Peer is used");
         continue;
-			}
+      }
 
       if(!is_remote_ip_allowed(pe.adr.ip))
         continue;
@@ -963,11 +963,11 @@ namespace nodetool
                     << ":" << boost::lexical_cast<std::string>(pe.adr.port)
                     << "[white=" << use_white_list
                     << "] 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)) {
-				_note("Handshake failed");
+        _note("Handshake failed");
         continue;
-			}
+      }
 
       return true;
     }
@@ -986,7 +986,7 @@ namespace nodetool
       size_t try_count = 0;
       size_t current_index = crypto::rand<size_t>()%m_seed_nodes.size();
       while(true)
-      {        
+      {
         if(m_net_server.is_stop_signal_sent())
           return false;
 
@@ -1135,7 +1135,7 @@ namespace nodetool
     node_data.peer_id = m_config.m_peer_id;
     if(!m_hide_my_port)
       node_data.my_port = m_external_port ? m_external_port : m_listenning_port;
-    else 
+    else
       node_data.my_port = 0;
     node_data.network_id = m_network_id;
     return true;
@@ -1515,92 +1515,92 @@ namespace nodetool
 
     return true;
   }
-  
+
   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)
-	{		
+  {
-		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>
   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)
-	{
+  {
-		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>
-	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;
+  }
 }