diff --git a/src/banman.cpp b/src/banman.cpp index 10190442c..a26b5be0b 100644 --- a/src/banman.cpp +++ b/src/banman.cpp @@ -1,218 +1,218 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2017 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 #include #include #include #include -BanMan::BanMan(fs::path ban_file, const CChainParams &chainParams, +BanMan::BanMan(fs::path ban_file, const CChainParams &chainparams, CClientUIInterface *client_interface, int64_t default_ban_time) : m_client_interface(client_interface), - m_ban_db(std::move(ban_file), chainParams), + m_ban_db(std::move(ban_file), chainparams), m_default_ban_time(default_ban_time) { if (m_client_interface) { m_client_interface->InitMessage(_("Loading banlist...")); } - int64_t nStart = GetTimeMillis(); + int64_t n_start = GetTimeMillis(); m_is_dirty = false; banmap_t banmap; if (m_ban_db.Read(banmap)) { // thread save setter SetBanned(banmap); // no need to write down, just read data SetBannedSetDirty(false); // sweep out unused entries SweepBanned(); LogPrint(BCLog::NET, "Loaded %d banned node ips/subnets from banlist.dat %dms\n", - banmap.size(), GetTimeMillis() - nStart); + banmap.size(), GetTimeMillis() - n_start); } else { LogPrintf("Invalid or missing banlist.dat; recreating\n"); // force write SetBannedSetDirty(true); DumpBanlist(); } } BanMan::~BanMan() { DumpBanlist(); } void BanMan::DumpBanlist() { // clean unused entries (if bantime has expired) SweepBanned(); if (!BannedSetIsDirty()) { return; } - int64_t nStart = GetTimeMillis(); + int64_t n_start = GetTimeMillis(); banmap_t banmap; GetBanned(banmap); if (m_ban_db.Write(banmap)) { SetBannedSetDirty(false); } LogPrint(BCLog::NET, "Flushed %d banned node ips/subnets to banlist.dat %dms\n", - banmap.size(), GetTimeMillis() - nStart); + banmap.size(), GetTimeMillis() - n_start); } void BanMan::ClearBanned() { { LOCK(m_cs_banned); m_banned.clear(); m_is_dirty = true; } // store banlist to disk DumpBanlist(); if (m_client_interface) { m_client_interface->BannedListChanged(); } } -bool BanMan::IsBanned(CNetAddr netAddr) { +bool BanMan::IsBanned(CNetAddr net_addr) { LOCK(m_cs_banned); for (const auto &it : m_banned) { - CSubNet subNet = it.first; - CBanEntry banEntry = it.second; + CSubNet sub_net = it.first; + CBanEntry ban_entry = it.second; - if (subNet.Match(netAddr) && GetTime() < banEntry.nBanUntil) { + if (sub_net.Match(net_addr) && GetTime() < ban_entry.nBanUntil) { return true; } } return false; } -bool BanMan::IsBanned(CSubNet subNet) { +bool BanMan::IsBanned(CSubNet sub_net) { LOCK(m_cs_banned); - banmap_t::iterator i = m_banned.find(subNet); + banmap_t::iterator i = m_banned.find(sub_net); if (i != m_banned.end()) { - CBanEntry banEntry = (*i).second; - if (GetTime() < banEntry.nBanUntil) { + CBanEntry ban_entry = (*i).second; + if (GetTime() < ban_entry.nBanUntil) { return true; } } return false; } -void BanMan::Ban(const CNetAddr &netAddr, const BanReason &banReason, - int64_t bantimeoffset, bool sinceUnixEpoch) { - CSubNet subNet(netAddr); - Ban(subNet, banReason, bantimeoffset, sinceUnixEpoch); +void BanMan::Ban(const CNetAddr &net_addr, const BanReason &ban_reason, + int64_t ban_time_offset, bool since_unix_epoch) { + CSubNet sub_net(net_addr); + Ban(sub_net, ban_reason, ban_time_offset, since_unix_epoch); } -void BanMan::Ban(const CSubNet &subNet, const BanReason &banReason, - int64_t bantimeoffset, bool sinceUnixEpoch) { - CBanEntry banEntry(GetTime(), banReason); +void BanMan::Ban(const CSubNet &sub_net, const BanReason &ban_reason, + int64_t ban_time_offset, bool since_unix_epoch) { + CBanEntry ban_entry(GetTime(), ban_reason); - int64_t normalized_bantimeoffset = bantimeoffset; - bool normalized_sinceUnixEpoch = sinceUnixEpoch; - if (bantimeoffset <= 0) { - normalized_bantimeoffset = m_default_ban_time; - normalized_sinceUnixEpoch = false; + int64_t normalized_ban_time_offset = ban_time_offset; + bool normalized_since_unix_epoch = since_unix_epoch; + if (ban_time_offset <= 0) { + normalized_ban_time_offset = m_default_ban_time; + normalized_since_unix_epoch = false; } - banEntry.nBanUntil = - (normalized_sinceUnixEpoch ? 0 : GetTime()) + normalized_bantimeoffset; + ban_entry.nBanUntil = (normalized_since_unix_epoch ? 0 : GetTime()) + + normalized_ban_time_offset; { LOCK(m_cs_banned); - if (m_banned[subNet].nBanUntil < banEntry.nBanUntil) { - m_banned[subNet] = banEntry; + if (m_banned[sub_net].nBanUntil < ban_entry.nBanUntil) { + m_banned[sub_net] = ban_entry; m_is_dirty = true; } else { return; } } if (m_client_interface) { m_client_interface->BannedListChanged(); } // store banlist to disk immediately if user requested ban - if (banReason == BanReasonManuallyAdded) { + if (ban_reason == BanReasonManuallyAdded) { DumpBanlist(); } } -bool BanMan::Unban(const CNetAddr &netAddr) { - CSubNet subNet(netAddr); - return Unban(subNet); +bool BanMan::Unban(const CNetAddr &net_addr) { + CSubNet sub_net(net_addr); + return Unban(sub_net); } -bool BanMan::Unban(const CSubNet &subNet) { +bool BanMan::Unban(const CSubNet &sub_net) { { LOCK(m_cs_banned); - if (m_banned.erase(subNet) == 0) { + if (m_banned.erase(sub_net) == 0) { return false; } m_is_dirty = true; } if (m_client_interface) { m_client_interface->BannedListChanged(); } // store banlist to disk immediately DumpBanlist(); return true; } -void BanMan::GetBanned(banmap_t &banMap) { +void BanMan::GetBanned(banmap_t &banmap) { LOCK(m_cs_banned); // Sweep the banlist so expired bans are not returned SweepBanned(); // create a thread safe copy - banMap = m_banned; + banmap = m_banned; } -void BanMan::SetBanned(const banmap_t &banMap) { +void BanMan::SetBanned(const banmap_t &banmap) { LOCK(m_cs_banned); - m_banned = banMap; + m_banned = banmap; m_is_dirty = true; } void BanMan::SweepBanned() { int64_t now = GetTime(); - bool notifyUI = false; + bool notify_ui = false; { LOCK(m_cs_banned); banmap_t::iterator it = m_banned.begin(); while (it != m_banned.end()) { - CSubNet subNet = (*it).first; - CBanEntry banEntry = (*it).second; - if (now > banEntry.nBanUntil) { + CSubNet sub_net = (*it).first; + CBanEntry ban_entry = (*it).second; + if (now > ban_entry.nBanUntil) { m_banned.erase(it++); m_is_dirty = true; - notifyUI = true; + notify_ui = true; LogPrint( BCLog::NET, "%s: Removed banned node ip/subnet from banlist.dat: %s\n", - __func__, subNet.ToString()); + __func__, sub_net.ToString()); } else { ++it; } } } // update UI - if (notifyUI && m_client_interface) { + if (notify_ui && m_client_interface) { m_client_interface->BannedListChanged(); } } bool BanMan::BannedSetIsDirty() { LOCK(m_cs_banned); return m_is_dirty; } void BanMan::SetBannedSetDirty(bool dirty) { // reuse m_banned lock for the m_is_dirty flag LOCK(m_cs_banned); m_is_dirty = dirty; } diff --git a/src/banman.h b/src/banman.h index c78751c6e..15e776721 100644 --- a/src/banman.h +++ b/src/banman.h @@ -1,73 +1,73 @@ // Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2017 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_BANMAN_H #define BITCOIN_BANMAN_H #include #include #include #include #include // Default 24-hour ban. // NOTE: When adjusting this, update rpcnet:setban's help ("24h") static constexpr unsigned int DEFAULT_MISBEHAVING_BANTIME = 60 * 60 * 24; class CClientUIInterface; class CNetAddr; class CSubNet; // Denial-of-service detection/prevention // The idea is to detect peers that are behaving // badly and disconnect/ban them, but do it in a // one-coding-mistake-won't-shatter-the-entire-network // way. // IMPORTANT: There should be nothing I can give a // node that it will forward on that will make that // node's peers drop it. If there is, an attacker // can isolate a node and/or try to split the network. // Dropping a node for sending stuff that is invalid // now but might be valid in a later version is also // dangerous, because it can cause a network split // between nodes running old code and nodes running // new code. class BanMan { public: ~BanMan(); - BanMan(fs::path ban_file, const CChainParams &chainParams, + BanMan(fs::path ban_file, const CChainParams &chainparams, CClientUIInterface *client_interface, int64_t default_ban_time); - void Ban(const CNetAddr &netAddr, const BanReason &banReason, - int64_t bantimeoffset = 0, bool sinceUnixEpoch = false); - void Ban(const CSubNet &subNet, const BanReason &banReason, - int64_t bantimeoffset = 0, bool sinceUnixEpoch = false); + void Ban(const CNetAddr &net_addr, const BanReason &ban_reason, + int64_t ban_time_offset = 0, bool since_unix_epoch = false); + void Ban(const CSubNet &sub_net, const BanReason &ban_reason, + int64_t ban_time_offset = 0, bool since_unix_epoch = false); void ClearBanned(); - bool IsBanned(CNetAddr netAddr); - bool IsBanned(CSubNet subNet); - bool Unban(const CNetAddr &netAddr); - bool Unban(const CSubNet &subNet); - void GetBanned(banmap_t &banMap); + bool IsBanned(CNetAddr net_addr); + bool IsBanned(CSubNet sub_net); + bool Unban(const CNetAddr &net_addr); + bool Unban(const CSubNet &sub_net); + void GetBanned(banmap_t &banmap); void DumpBanlist(); private: - void SetBanned(const banmap_t &banMap); + void SetBanned(const banmap_t &banmap); bool BannedSetIsDirty(); //! set the "dirty" flag for the banlist void SetBannedSetDirty(bool dirty = true); //! clean unused entries (if bantime has expired) void SweepBanned(); CCriticalSection m_cs_banned; banmap_t m_banned GUARDED_BY(m_cs_banned); bool m_is_dirty GUARDED_BY(m_cs_banned); CClientUIInterface *m_client_interface = nullptr; CBanDB m_ban_db; const int64_t m_default_ban_time; }; extern std::unique_ptr g_banman; #endif // BITCOIN_BANMAN_H