Merge pull request #501

d887c18 hardfork: fix more major/minor issues (moneromooo-monero)
3b47ca2 hardfork: fix rescan on load (moneromooo-monero)
4cea2b1 Add IP blocking for misbehaving nodes (adapted from Boolberry) (Javier Smooth)
9c64b12 quiet down p2p logging a bit (Javier Smooth)
53c75ab blockchain: log versions as numbers, not characters (moneromooo-monero)
edade8d hardfork: fix actual/voting confusion (moneromooo-monero)

3 files changed, 34 insertions, 27 deletions

diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 8bb63ad09..af7713972 100644
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -257,13 +257,13 @@ bool Blockchain::init(BlockchainDB* db, const bool testnet)
     if (testnet) {
       m_hardfork = new HardFork(*db, 1, testnet_hard_fork_version_1_till);
       for (size_t n = 0; n < sizeof(testnet_hard_forks) / sizeof(testnet_hard_forks[0]); ++n)
-        m_hardfork->add(testnet_hard_forks[n].version, testnet_hard_forks[n].height, testnet_hard_forks[n].threshold, testnet_hard_forks[n].time);
+        m_hardfork->add_fork(testnet_hard_forks[n].version, testnet_hard_forks[n].height, testnet_hard_forks[n].threshold, testnet_hard_forks[n].time);
     }
     else
     {
       m_hardfork = new HardFork(*db, 1, mainnet_hard_fork_version_1_till);
       for (size_t n = 0; n < sizeof(mainnet_hard_forks) / sizeof(mainnet_hard_forks[0]); ++n)
-        m_hardfork->add(mainnet_hard_forks[n].version, mainnet_hard_forks[n].height, mainnet_hard_forks[n].threshold, mainnet_hard_forks[n].time);
+        m_hardfork->add_fork(mainnet_hard_forks[n].version, mainnet_hard_forks[n].height, mainnet_hard_forks[n].threshold, mainnet_hard_forks[n].time);
     }
     m_hardfork->init();
 
@@ -2338,7 +2338,7 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
     // this is a cheap test
     if (!m_hardfork->check(bl))
     {
-        LOG_PRINT_L1("Block with id: " << id << std::endl << "has old version: " << bl.major_version << std::endl << "current: " << m_hardfork->get_current_version());
+        LOG_PRINT_L1("Block with id: " << id << std::endl << "has old version: " << (unsigned)bl.major_version << std::endl << "current: " << (unsigned)m_hardfork->get_current_version());
         return false;
     }
 
diff --git a/src/cryptonote_core/hardfork.cpp b/src/cryptonote_core/hardfork.cpp
index edc2f33a9..2a2e25635 100644
--- a/src/cryptonote_core/hardfork.cpp
+++ b/src/cryptonote_core/hardfork.cpp
@@ -46,6 +46,11 @@ static uint8_t get_block_vote(const cryptonote::block &b)
   return b.minor_version;
 }
 
+static uint8_t get_block_version(const cryptonote::block &b)
+{
+  return b.major_version;
+}
+
 HardFork::HardFork(cryptonote::BlockchainDB &db, uint8_t original_version, uint64_t original_version_till_height, time_t forked_time, time_t update_time, uint64_t window_size, uint8_t default_threshold_percent):
   db(db),
   original_version(original_version),
@@ -61,7 +66,7 @@ HardFork::HardFork(cryptonote::BlockchainDB &db, uint8_t original_version, uint6
     throw "default_threshold_percent needs to be between 0 and 100";
 }
 
-bool HardFork::add(uint8_t version, uint64_t height, uint8_t threshold, time_t time)
+bool HardFork::add_fork(uint8_t version, uint64_t height, uint8_t threshold, time_t time)
 {
   CRITICAL_REGION_LOCAL(lock);
 
@@ -82,42 +87,43 @@ bool HardFork::add(uint8_t version, uint64_t height, uint8_t threshold, time_t t
   return true;
 }
 
-bool HardFork::add(uint8_t version, uint64_t height, time_t time)
+bool HardFork::add_fork(uint8_t version, uint64_t height, time_t time)
 {
-  return add(version, height, default_threshold_percent, time);
+  return add_fork(version, height, default_threshold_percent, time);
 }
 
-uint8_t HardFork::get_effective_version(uint8_t version) const
+uint8_t HardFork::get_effective_version(uint8_t voting_version) const
 {
   if (!heights.empty()) {
     uint8_t max_version = heights.back().version;
-    if (version > max_version)
-      version = max_version;
+    if (voting_version > max_version)
+      voting_version = max_version;
   }
-  return version;
+  return voting_version;
 }
 
-bool HardFork::do_check(uint8_t version) const
+bool HardFork::do_check(uint8_t block_version, uint8_t voting_version) const
 {
-  return version >= heights[current_fork_index].version;
+  return block_version >= heights[current_fork_index].version
+      && voting_version >= heights[current_fork_index].version;
 }
 
 bool HardFork::check(const cryptonote::block &block) const
 {
   CRITICAL_REGION_LOCAL(lock);
-  return do_check(get_block_vote(block));
+  return do_check(::get_block_version(block), ::get_block_vote(block));
 }
 
-bool HardFork::add(uint8_t block_version, uint64_t height)
+bool HardFork::add(uint8_t block_version, uint8_t voting_version, uint64_t height)
 {
   CRITICAL_REGION_LOCAL(lock);
 
-  if (!do_check(block_version))
+  if (!do_check(block_version, voting_version))
     return false;
 
   db.set_hard_fork_version(height, heights[current_fork_index].version);
 
-  const uint8_t version = get_effective_version(block_version);
+  voting_version = get_effective_version(voting_version);
 
   while (versions.size() >= window_size) {
     const uint8_t old_version = versions.front();
@@ -126,8 +132,8 @@ bool HardFork::add(uint8_t block_version, uint64_t height)
     versions.pop_front();
   }
 
-  last_versions[version]++;
-  versions.push_back(version);
+  last_versions[voting_version]++;
+  versions.push_back(voting_version);
 
   uint8_t voted = get_voted_fork_index(height + 1);
   if (voted > current_fork_index) {
@@ -143,7 +149,7 @@ bool HardFork::add(uint8_t block_version, uint64_t height)
 
 bool HardFork::add(const cryptonote::block &block, uint64_t height)
 {
-  return add(get_block_vote(block), height);
+  return add(::get_block_version(block), ::get_block_vote(block), height);
 }
 
 void HardFork::init()
@@ -185,7 +191,7 @@ uint8_t HardFork::get_block_version(uint64_t height) const
     return original_version;
 
   const cryptonote::block &block = db.get_block_from_height(height);
-  return get_block_vote(block);
+  return ::get_block_version(block);
 }
 
 bool HardFork::reorganize_from_block_height(uint64_t height)
@@ -225,7 +231,7 @@ bool HardFork::reorganize_from_block_height(uint64_t height)
 
   const uint64_t bc_height = db.height();
   for (uint64_t h = height + 1; h < bc_height; ++h) {
-    add(get_block_version(h), h);
+    add(db.get_block_from_height(h), h);
   }
 
   db.batch_stop();
@@ -258,7 +264,7 @@ bool HardFork::rescan_from_block_height(uint64_t height)
     versions.push_back(v);
   }
 
-  uint8_t lastv = db.get_hard_fork_version(height);
+  uint8_t lastv = db.get_hard_fork_version(db.height() - 1);
   current_fork_index = 0;
   while (current_fork_index + 1 < heights.size() && heights[current_fork_index].version != lastv)
     ++current_fork_index;
diff --git a/src/cryptonote_core/hardfork.h b/src/cryptonote_core/hardfork.h
index 6800749da..6d2a3c55b 100644
--- a/src/cryptonote_core/hardfork.h
+++ b/src/cryptonote_core/hardfork.h
@@ -71,7 +71,7 @@ namespace cryptonote
      * @param threshold The threshold of votes needed for this fork (0-100)
      * @param time Approximate time of the hardfork (seconds since epoch)
      */
-    bool add(uint8_t version, uint64_t height, uint8_t threshold, time_t time);
+    bool add_fork(uint8_t version, uint64_t height, uint8_t threshold, time_t time);
 
     /**
      * @brief add a new hardfork height
@@ -79,10 +79,11 @@ namespace cryptonote
      * returns true if no error, false otherwise
      *
      * @param version the major block version for the fork
+     * @param voting_version the minor block version for the fork, used for voting
      * @param height The height the hardfork takes effect
      * @param time Approximate time of the hardfork (seconds since epoch)
      */
-    bool add(uint8_t version, uint64_t height, time_t time);
+    bool add_fork(uint8_t version, uint64_t height, time_t time);
 
     /**
      * @brief initialize the object
@@ -203,10 +204,10 @@ namespace cryptonote
   private:
 
     uint8_t get_block_version(uint64_t height) const;
-    bool do_check(uint8_t version) const;
+    bool do_check(uint8_t block_version, uint8_t voting_version) const;
     int get_voted_fork_index(uint64_t height) const;
-    uint8_t get_effective_version(uint8_t version) const;
-    bool add(uint8_t block_version, uint64_t height);
+    uint8_t get_effective_version(uint8_t voting_version) const;
+    bool add(uint8_t block_version, uint8_t voting_version, uint64_t height);
 
     bool rescan_from_block_height(uint64_t height);
     bool rescan_from_chain_height(uint64_t height);