Line data    Source code

       1             : // Copyright (c) 2009-2022 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #include <netaddress.h>
       6             : 
       7             : #include <string>
       8             : #include <type_traits>
       9             : #include <vector>
      10             : 
      11             : #ifndef BITCOIN_NET_PERMISSIONS_H
      12             : #define BITCOIN_NET_PERMISSIONS_H
      13             : 
      14             : struct bilingual_str;
      15             : 
      16             : extern const std::vector<std::string> NET_PERMISSIONS_DOC;
      17             : 
      18             : enum class NetPermissionFlags : uint32_t {
      19             :     None = 0,
      20             :     // Can query bloomfilter even if -peerbloomfilters is false
      21             :     BloomFilter = (1U << 1),
      22             :     // Relay and accept transactions from this peer, even if -blocksonly is true
      23             :     // This peer is also not subject to limits on how many transaction INVs are tracked
      24             :     Relay = (1U << 3),
      25             :     // Always relay transactions from this peer, even if already in mempool
      26             :     // Keep parameter interaction: forcerelay implies relay
      27             :     ForceRelay = (1U << 2) | Relay,
      28             :     // Allow getheaders during IBD and block-download after maxuploadtarget limit
      29             :     Download = (1U << 6),
      30             :     // Can't be banned/disconnected/discouraged for misbehavior
      31             :     NoBan = (1U << 4) | Download,
      32             :     // Can query the mempool
      33             :     Mempool = (1U << 5),
      34             :     // Can request addrs without hitting a privacy-preserving cache, and send us
      35             :     // unlimited amounts of addrs.
      36             :     Addr = (1U << 7),
      37             : 
      38             :     // True if the user did not specifically set fine-grained permissions with
      39             :     // the -whitebind or -whitelist configuration options.
      40             :     Implicit = (1U << 31),
      41             :     All = BloomFilter | ForceRelay | Relay | NoBan | Mempool | Download | Addr,
      42             : };
      43           0 : static inline constexpr NetPermissionFlags operator|(NetPermissionFlags a, NetPermissionFlags b)
      44             : {
      45             :     using t = typename std::underlying_type<NetPermissionFlags>::type;
      46           0 :     return static_cast<NetPermissionFlags>(static_cast<t>(a) | static_cast<t>(b));
      47             : }
      48             : 
      49             : class NetPermissions
      50             : {
      51             : public:
      52             :     NetPermissionFlags m_flags;
      53             :     static std::vector<std::string> ToStrings(NetPermissionFlags flags);
      54           0 :     static inline bool HasFlag(NetPermissionFlags flags, NetPermissionFlags f)
      55             :     {
      56             :         using t = typename std::underlying_type<NetPermissionFlags>::type;
      57           0 :         return (static_cast<t>(flags) & static_cast<t>(f)) == static_cast<t>(f);
      58             :     }
      59           0 :     static inline void AddFlag(NetPermissionFlags& flags, NetPermissionFlags f)
      60             :     {
      61           0 :         flags = flags | f;
      62           0 :     }
      63             :     //! ClearFlag is only called with `f` == NetPermissionFlags::Implicit.
      64             :     //! If that should change in the future, be aware that ClearFlag should not
      65             :     //! be called with a subflag of a multiflag, e.g. NetPermissionFlags::Relay
      66             :     //! or NetPermissionFlags::Download, as that would leave `flags` in an
      67             :     //! invalid state corresponding to none of the existing flags.
      68           0 :     static inline void ClearFlag(NetPermissionFlags& flags, NetPermissionFlags f)
      69             :     {
      70           0 :         assert(f == NetPermissionFlags::Implicit);
      71             :         using t = typename std::underlying_type<NetPermissionFlags>::type;
      72           0 :         flags = static_cast<NetPermissionFlags>(static_cast<t>(flags) & ~static_cast<t>(f));
      73           0 :     }
      74             : };
      75             : 
      76             : class NetWhitebindPermissions : public NetPermissions
      77             : {
      78             : public:
      79             :     static bool TryParse(const std::string& str, NetWhitebindPermissions& output, bilingual_str& error);
      80             :     CService m_service;
      81             : };
      82             : 
      83             : class NetWhitelistPermissions : public NetPermissions
      84             : {
      85             : public:
      86             :     static bool TryParse(const std::string& str, NetWhitelistPermissions& output, bilingual_str& error);
      87             :     CSubNet m_subnet;
      88             : };
      89             : 
      90             : #endif // BITCOIN_NET_PERMISSIONS_H