net_processing.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2015 The Bitcoin Core developers
// Copyright (c) 2015-2021 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_NET_PROCESSING_H
#define PIVX_NET_PROCESSING_H
 
#include "net.h"
#include "validationinterface.h"
 
extern RecursiveMutex cs_main; // !TODO: change mutex to cs_orphans
 
static const unsigned int DEFAULT_MAX_ORPHAN_TRANSACTIONS = 25;
static const int64_t ORPHAN_TX_EXPIRE_TIME = 20 * 60;
static const int64_t ORPHAN_TX_EXPIRE_INTERVAL = 5 * 60;
static const bool DEFAULT_BLOCK_SPAM_FILTER = true;
static const unsigned int DEFAULT_BLOCK_SPAM_FILTER_MAX_SIZE = 100;
static const unsigned int DEFAULT_BLOCK_SPAM_FILTER_MAX_AVG = 10;
 
static const unsigned int INVENTORY_BROADCAST_INTERVAL = 5;
static const unsigned int INVENTORY_BROADCAST_MAX = 7 * INVENTORY_BROADCAST_INTERVAL;
 
class PeerLogicValidation : public CValidationInterface, public NetEventsInterface {
private:
    CConnman* connman;
 
public:
    explicit PeerLogicValidation(CConnman* connman);
    ~PeerLogicValidation() = default;
 
    void BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex) override;
    void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override;
    void BlockChecked(const CBlock& block, const CValidationState& state) override;
 
 
    void InitializeNode(CNode* pnode) override;
    void FinalizeNode(NodeId nodeid, bool& fUpdateConnectionTime) override;
    bool ProcessMessages(CNode* pfrom, std::atomic<bool>& interrupt) override;
    bool SendMessages(CNode* pto, std::atomic<bool>& interrupt) override EXCLUSIVE_LOCKS_REQUIRED(pto->cs_sendProcessing);
};
 
struct CNodeStateStats {
    int nMisbehavior;
    int nSyncHeight;
    int nCommonHeight;
    std::vector<int> vHeightInFlight;
    uint64_t m_addr_processed = 0;
    uint64_t m_addr_rate_limited = 0;
};
 
bool GetNodeStateStats(NodeId nodeid, CNodeStateStats& stats);
void Misbehaving(NodeId nodeid, int howmuch, const std::string& message="") EXCLUSIVE_LOCKS_REQUIRED(cs_main);
bool IsBanned(NodeId nodeid);
 
 
using SecondsDouble = std::chrono::duration<double, std::chrono::seconds::period>;
inline double CountSecondsDouble(SecondsDouble t) { return t.count(); }
 
#endif // PIVX_NET_PROCESSING_H