Create fulfilled requests manager.

And unify peer full sync request blockage time in chainparams.

CMakeLists.txt

@@ -454,6 +454,7 @@ set(COMMON_SOURCES
         ./src/tiertwo/masternode_meta_manager.cpp
         ./src/evo/mnauth.cpp
         ./src/tiertwo/net_masternodes.cpp
+        ./src/tiertwo/netfulfilledman.cpp
         ./src/tiertwo/tiertwo_sync_state.cpp
         ./src/warnings.cpp
         )

src/Makefile.am

@@ -291,6 +291,7 @@ BITCOIN_CORE_H = \
   threadinterrupt.h \
   timedata.h \
   tinyformat.h \
+  tiertwo/netfulfilledman.h \
   tiertwo/tiertwo_sync_state.h \
   torcontrol.h \
   txdb.h \
@@ -556,6 +557,7 @@ libbitcoin_common_a_SOURCES = \
   script/sign.cpp \
   script/standard.cpp \
   tiertwo_networksync.cpp \
+  tiertwo/netfulfilledman.cpp \
   tiertwo/tiertwo_sync_state.cpp \
   warnings.cpp \
   script/script_error.cpp \

src/chainparams.cpp

@@ -352,6 +352,9 @@ class CMainParams : public CChainParams
         consensus.llmqs[Consensus::LLMQ_400_85] = llmq400_85;
 
         nLLMQConnectionRetryTimeout = 60;
+
+        // Tier two
+        nFulfilledRequestExpireTime = 60 * 60; // fulfilled requests expire in 1 hour
     }
 
     const CCheckpointData& Checkpoints() const
@@ -490,6 +493,9 @@ class CTestNetParams : public CChainParams
         consensus.llmqs[Consensus::LLMQ_400_85] = llmq400_85;
 
         nLLMQConnectionRetryTimeout = 60;
+
+        // Tier two
+        nFulfilledRequestExpireTime = 60 * 60; // fulfilled requests expire in 1 hour
     }
 
     const CCheckpointData& Checkpoints() const
@@ -625,6 +631,9 @@ class CRegTestParams : public CChainParams
         // long living quorum params
         consensus.llmqs[Consensus::LLMQ_TEST] = llmq_test;
         nLLMQConnectionRetryTimeout = 5;
+
+        // Tier two
+        nFulfilledRequestExpireTime = 60 * 60; // fulfilled requests expire in 1 hour
     }
 
     const CCheckpointData& Checkpoints() const

src/chainparams.h

@@ -97,6 +97,9 @@ class CChainParams
     bool IsRegTestNet() const { return NetworkIDString() == CBaseChainParams::REGTEST; }
     bool IsTestnet() const { return NetworkIDString() == CBaseChainParams::TESTNET; }
 
+    /** Tier two requests blockage mark expiration time */
+    int FulfilledRequestExpireTime() const { return nFulfilledRequestExpireTime; }
+
     void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivationHeight);
 protected:
     CChainParams() {}
@@ -114,6 +117,7 @@ class CChainParams
 
     // Tier two
     int nLLMQConnectionRetryTimeout;
+    int nFulfilledRequestExpireTime;
 };
 
 /**

src/tiertwo/netfulfilledman.cpp

@@ -0,0 +1,71 @@
+// Copyright (c) 2014-2020 The Dash Core developers
+// Copyright (c) 2022 The PIVX Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://www.opensource.org/licenses/mit-license.php.
+
+#include "tiertwo/netfulfilledman.h"
+#include "chainparams.h"
+#include "netaddress.h"
+#include "shutdown.h"
+#include "utiltime.h"
+
+CNetFulfilledRequestManager g_netfulfilledman;
+
+void CNetFulfilledRequestManager::AddFulfilledRequest(const CService& addr, const std::string& strRequest)
+{
+    LOCK(cs_mapFulfilledRequests);
+    mapFulfilledRequests[addr][strRequest] = GetTime() + Params().FulfilledRequestExpireTime();
+}
+
+bool CNetFulfilledRequestManager::HasFulfilledRequest(const CService& addr, const std::string& strRequest) const
+{
+    LOCK(cs_mapFulfilledRequests);
+    auto it = mapFulfilledRequests.find(addr);
+    if (it != mapFulfilledRequests.end()) {
+        auto itReq = it->second.find(strRequest);
+        if (itReq != it->second.end()) {
+            return itReq->second > GetTime();
+        }
+    }
+    return false;
+}
+
+void CNetFulfilledRequestManager::CheckAndRemove()
+{
+    LOCK(cs_mapFulfilledRequests);
+    int64_t now = GetTime();
+    for (auto it = mapFulfilledRequests.begin(); it != mapFulfilledRequests.end();) {
+        for (auto it_entry = it->second.begin(); it_entry != it->second.end();) {
+            if (now > it_entry->second) {
+                it_entry = it->second.erase(it_entry);
+            } else {
+                it_entry++;
+            }
+        }
+        if (it->second.empty()) {
+            it = mapFulfilledRequests.erase(it);
+        } else {
+            it++;
+        }
+    }
+}
+
+void CNetFulfilledRequestManager::Clear()
+{
+    LOCK(cs_mapFulfilledRequests);
+    mapFulfilledRequests.clear();
+}
+
+std::string CNetFulfilledRequestManager::ToString() const
+{
+    LOCK(cs_mapFulfilledRequests);
+    std::ostringstream info;
+    info << "Nodes with fulfilled requests: " << (int)mapFulfilledRequests.size();
+    return info.str();
+}
+
+void CNetFulfilledRequestManager::DoMaintenance()
+{
+    if (ShutdownRequested()) return;
+    CheckAndRemove();
+}

src/tiertwo/netfulfilledman.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2014-2020 The Dash Core developers
+// Copyright (c) 2022 The PIVX Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://www.opensource.org/licenses/mit-license.php.
+
+#ifndef PIVX_NETFULFILLEDMAN_H
+#define PIVX_NETFULFILLEDMAN_H
+
+#include "serialize.h"
+#include "sync.h"
+
+#include <map>
+
+class CService;
+
+static const std::string NET_REQUESTS_CACHE_FILENAME = "netrequests.dat";
+static const std::string NET_REQUESTS_CACHE_FILE_ID = "magicNetRequestsCache";
+
+// Fulfilled requests are used to prevent nodes from asking the same data on sync
+// and being banned for doing it too often.
+class CNetFulfilledRequestManager
+{
+private:
+    typedef std::map<std::string, int64_t> fulfilledreqmapentry_t;
+    typedef std::map<CService, fulfilledreqmapentry_t> fulfilledreqmap_t;
+
+    // Keep track of what node has/was asked for and when
+    fulfilledreqmap_t mapFulfilledRequests;
+    mutable Mutex cs_mapFulfilledRequests;
+
+public:
+    CNetFulfilledRequestManager() = default;
+
+    SERIALIZE_METHODS(CNetFulfilledRequestManager, obj) {
+        LOCK(obj.cs_mapFulfilledRequests);
+        READWRITE(obj.mapFulfilledRequests);
+    }
+
+    void AddFulfilledRequest(const CService& addr, const std::string& strRequest);
+    bool HasFulfilledRequest(const CService& addr, const std::string& strRequest) const;
+
+    void CheckAndRemove();
+    void Clear();
+
+    std::string ToString() const;
+
+    void DoMaintenance();
+};
+
+extern CNetFulfilledRequestManager g_netfulfilledman;
+
+#endif // PIVX_NETFULFILLEDMAN_H