Superblock validation - Part I

src/Makefile.am

@@ -57,11 +57,14 @@ endif
 .PHONY: FORCE
 # gridcoin core #
 GRIDCOIN_CORE_H = \
-	addrman.h \
+	addrdb.h \
+    addrman.h \
 	alert.h \
 	allocators.h \
+    attributes.h \
 	appcache.h \
 	backup.h \
+    banman.h \
 	base58.h \
 	beacon.h \
 	bignum.h \
@@ -76,6 +79,7 @@ GRIDCOIN_CORE_H = \
 	contract/contract.h \
 	crypter.h \
 	db.h \
+    fs.h \
 	fwd.h \
 	global_objects.hpp \
 	global_objects_noui.hpp \
@@ -100,9 +104,11 @@ GRIDCOIN_CORE_H = \
 	pbkdf2.h \
 	prevector.h \
 	protocol.h \
+    reverselock.h \
 	rpcclient.h \
 	rpcprotocol.h \
 	rpcserver.h \
+    scheduler.h \
 	scraper_net.h \
 	scraper/fwd.h \
     scraper/http.h \
@@ -124,11 +130,13 @@ GRIDCOIN_CORE_H = \
 	walletdb.h \
 	wallet.h
 
-GRIDCOIN_CORE_CPP = addrman.cpp \
+GRIDCOIN_CORE_CPP = addrdb.cpp \
+    addrman.cpp \
 	alert.cpp \
 	allocators.cpp \
 	appcache.cpp \
 	backup.cpp \
+    banman.cpp \
 	beacon.cpp \
 	block.cpp \
 	boinc.cpp \
@@ -137,6 +145,7 @@ GRIDCOIN_CORE_CPP = addrman.cpp \
 	contract/contract.cpp \
 	crypter.cpp \
 	db.cpp \
+    fs.cpp \
 	gridcoin.cpp \
 	init.cpp \
 	kernel.cpp \
@@ -172,6 +181,7 @@ GRIDCOIN_CORE_CPP = addrman.cpp \
 	scraper/scraper.cpp \
 	script.cpp \
 	scrypt.cpp \
+    scheduler.cpp \
 	sync.cpp \
 	tally.cpp \
 	txdb-leveldb.cpp \

src/addrdb.cpp

@@ -0,0 +1,149 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <addrdb.h>
+
+#include <addrman.h>
+// #include <chainparams.h>
+// #include <clientversion.h>
+#include <hash.h>
+// #include <random.h>
+// #include <streams.h>
+#include <tinyformat.h>
+// #include <util/system.h>
+// #include "main.h"
+#include "util.h"
+#include "net.h"
+#include "fs.h"
+
+namespace {
+
+template <typename Stream, typename Data>
+bool SerializeDB(Stream& stream, const Data& data)
+{
+    // Write and commit header, data
+    try {
+        CHashWriter hasher(SER_DISK, CLIENT_VERSION);
+        stream << FLATDATA(pchMessageStart) << data;
+        hasher << FLATDATA(pchMessageStart) << data;
+        stream << hasher.GetHash();
+    } catch (const std::exception& e) {
+        return error("%s: Serialize or I/O error - %s", __func__, e.what());
+    }
+
+    return true;
+}
+
+template <typename Data>
+bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data& data)
+{
+    // Generate random temporary filename
+    unsigned short randv = 0;
+    RAND_bytes((unsigned char*)&randv, sizeof(randv));
+    std::string tmpfn = strprintf("%s.%04x", prefix, randv);
+
+    // open temp output file, and associate with CAutoFile
+    fs::path pathTmp = GetDataDir() / tmpfn;
+    FILE *file = fsbridge::fopen(pathTmp, "wb");
+    CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
+    if (fileout.IsNull())
+        return error("%s: Failed to open file %s", __func__, pathTmp.string());
+
+    // Serialize
+    if (!SerializeDB(fileout, data)) return false;
+    if (!FileCommit(fileout.Get()))
+        return error("%s: Failed to flush file %s", __func__, pathTmp.string());
+    fileout.fclose();
+
+    // replace existing file, if any, with new file
+    if (!RenameOver(pathTmp, path))
+        return error("%s: Rename-into-place failed", __func__);
+
+    return true;
+}
+
+template <typename Stream, typename Data>
+bool DeserializeDB(Stream& stream, Data& data, bool fCheckSum = true)
+{
+    try {
+        CHashVerifier<Stream> verifier(&stream);
+        // de-serialize file header (network specific magic number) and ..
+        unsigned char pchMsgTmp[4];
+        verifier >> pchMsgTmp;
+        // ... verify the network matches ours
+        if (memcmp(pchMsgTmp, pchMessageStart, sizeof(pchMsgTmp)))
+            return error("%s: Invalid network magic number", __func__);
+
+        // de-serialize data
+        verifier >> data;
+
+        // verify checksum
+        if (fCheckSum) {
+            uint256 hashTmp;
+            stream >> hashTmp;
+            if (hashTmp != verifier.GetHash()) {
+                return error("%s: Checksum mismatch, data corrupted", __func__);
+            }
+        }
+    }
+    catch (const std::exception& e) {
+        return error("%s: Deserialize or I/O error - %s", __func__, e.what());
+    }
+
+    return true;
+}
+
+template <typename Data>
+bool DeserializeFileDB(const fs::path& path, Data& data)
+{
+    // open input file, and associate with CAutoFile
+    FILE *file = fsbridge::fopen(path, "rb");
+    CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
+    if (filein.IsNull())
+        return error("%s: Failed to open file %s", __func__, path.string());
+
+    return DeserializeDB(filein, data);
+}
+
+}
+
+CBanDB::CBanDB(fs::path ban_list_path) : m_ban_list_path(std::move(ban_list_path))
+{
+}
+
+bool CBanDB::Write(const banmap_t& banSet)
+{
+    return SerializeFileDB("banlist", m_ban_list_path, banSet);
+}
+
+bool CBanDB::Read(banmap_t& banSet)
+{
+    return DeserializeFileDB(m_ban_list_path, banSet);
+}
+
+CAddrDB::CAddrDB()
+{
+    pathAddr = GetDataDir() / "peers.dat";
+}
+
+bool CAddrDB::Write(const CAddrMan& addr)
+{
+    return SerializeFileDB("peers", pathAddr, addr);
+}
+
+bool CAddrDB::Read(CAddrMan& addr)
+{
+    return DeserializeFileDB(pathAddr, addr);
+}
+
+bool CAddrDB::Read(CAddrMan& addr, CDataStream& ssPeers)
+{
+    bool ret = DeserializeDB(ssPeers, addr, false);
+    if (!ret) {
+        // Ensure addrman is left in a clean state
+        addr.Clear();
+    }
+    return ret;
+}

src/addrdb.h

@@ -0,0 +1,108 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_ADDRDB_H
+#define BITCOIN_ADDRDB_H
+
+#include <fs.h>
+#include <serialize.h>
+
+#include <string>
+#include <map>
+
+class CSubNet;
+class CAddrMan;
+class CDataStream;
+
+typedef enum BanReason
+{
+    BanReasonUnknown          = 0,
+    BanReasonNodeMisbehaving  = 1,
+    BanReasonManuallyAdded    = 2
+} BanReason;
+
+class CBanEntry
+{
+public:
+    static const int CURRENT_VERSION=1;
+    int nVersion;
+    int64_t nCreateTime;
+    int64_t nBanUntil;
+    uint8_t banReason;
+
+    CBanEntry()
+    {
+        SetNull();
+    }
+
+    explicit CBanEntry(int64_t nCreateTimeIn)
+    {
+        SetNull();
+        nCreateTime = nCreateTimeIn;
+    }
+
+    explicit CBanEntry(int64_t n_create_time_in, BanReason ban_reason_in) : CBanEntry(n_create_time_in)
+    {
+        banReason = ban_reason_in;
+    }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITEVARIADIC(this->nVersion);
+        READWRITEVARIADIC(nCreateTime);
+        READWRITEVARIADIC(nBanUntil);
+        READWRITEVARIADIC(banReason);
+    }
+
+    void SetNull()
+    {
+        nVersion = CBanEntry::CURRENT_VERSION;
+        nCreateTime = 0;
+        nBanUntil = 0;
+        banReason = BanReasonUnknown;
+    }
+
+    std::string banReasonToString() const
+    {
+        switch (banReason) {
+        case BanReasonNodeMisbehaving:
+            return "node misbehaving";
+        case BanReasonManuallyAdded:
+            return "manually added";
+        default:
+            return "unknown";
+        }
+    }
+};
+
+typedef std::map<CSubNet, CBanEntry> banmap_t;
+
+/** Access to the (IP) address database (peers.dat) */
+class CAddrDB
+{
+private:
+    fs::path pathAddr;
+public:
+    CAddrDB();
+    bool Write(const CAddrMan& addr);
+    bool Read(CAddrMan& addr);
+
+    static bool Read(CAddrMan& addr, CDataStream& ssPeers);
+};
+
+/** Access to the banlist database (banlist.dat) */
+class CBanDB
+{
+private:
+    const fs::path m_ban_list_path;
+public:
+    explicit CBanDB(fs::path ban_list_path);
+    bool Write(const banmap_t& banSet);
+    bool Read(banmap_t& banSet);
+};
+
+#endif // BITCOIN_ADDRDB_H

src/addrman.h

@@ -500,6 +500,36 @@ class CAddrMan
             Check();
         }
     }
+
+    void Clear()
+    {
+        LOCK(cs);
+        std::vector<int>().swap(vRandom);
+        RAND_bytes(&nKey[0], 32);
+        vvTried = std::vector<std::vector<int>>(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0));
+        vvNew = std::vector<std::set<int>>(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>());
+        // Will need for Bitcoin rebase
+        // nKey = insecure_rand.rand256();
+        //for (size_t bucket = 0; bucket < ADDRMAN_NEW_BUCKET_COUNT; bucket++) {
+        //    for (size_t entry = 0; entry < ADDRMAN_BUCKET_SIZE; entry++) {
+        //        vvNew[bucket][entry] = -1;
+        //    }
+        //}
+        //for (size_t bucket = 0; bucket < ADDRMAN_TRIED_BUCKET_COUNT; bucket++) {
+        //    for (size_t entry = 0; entry < ADDRMAN_BUCKET_SIZE; entry++) {
+        //        vvTried[bucket][entry] = -1;
+        //    }
+        //}
+
+        nIdCount = 0;
+        nTried = 0;
+        nNew = 0;
+        // Will need for Bitcoin rebase
+        // nLastGood = 1; //Initially at 1 so that "never" is strictly worse.
+        mapInfo.clear();
+        mapAddr.clear();
+    }
+
 };
 
 #endif

src/attributes.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2018 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_ATTRIBUTES_H
+#define BITCOIN_ATTRIBUTES_H
+
+#if defined(__has_cpp_attribute)
+#  if __has_cpp_attribute(nodiscard)
+#    define NODISCARD [[nodiscard]]
+#  endif
+#endif
+#ifndef NODISCARD
+#  if defined(_MSC_VER) && _MSC_VER >= 1700
+#    define NODISCARD _Check_return_
+#  else
+#    define NODISCARD __attribute__((warn_unused_result))
+#  endif
+#endif
+
+#endif // BITCOIN_ATTRIBUTES_H