protocol.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2019 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_PROTOCOL_H
#define BITCOIN_PROTOCOL_H
 
#include <netaddress.h>
#include <serialize.h>
#include <streams.h>
#include <uint256.h>
#include <util/time.h>
 
#include <array>
#include <cstdint>
#include <string>
 
class Config;
 
static const unsigned int MAX_PROTOCOL_MESSAGE_LENGTH = 2 * 1024 * 1024;
 
class CMessageHeader {
public:
    static constexpr size_t MESSAGE_START_SIZE = 4;
    static constexpr size_t COMMAND_SIZE = 12;
    static constexpr size_t MESSAGE_SIZE_SIZE = 4;
    static constexpr size_t CHECKSUM_SIZE = 4;
    static constexpr size_t MESSAGE_SIZE_OFFSET =
        MESSAGE_START_SIZE + COMMAND_SIZE;
    static constexpr size_t CHECKSUM_OFFSET =
        MESSAGE_SIZE_OFFSET + MESSAGE_SIZE_SIZE;
    static constexpr size_t HEADER_SIZE =
        MESSAGE_START_SIZE + COMMAND_SIZE + MESSAGE_SIZE_SIZE + CHECKSUM_SIZE;
    typedef std::array<uint8_t, MESSAGE_START_SIZE> MessageMagic;
 
    explicit CMessageHeader(const MessageMagic &pchMessageStartIn);
 
    CMessageHeader(const MessageMagic &pchMessageStartIn,
                   const char *pszCommand, unsigned int nMessageSizeIn);
 
    std::string GetCommand() const;
    bool IsValid(const Config &config) const;
    bool IsValidWithoutConfig(const MessageMagic &magic) const;
    bool IsOversized(const Config &config) const;
 
    SERIALIZE_METHODS(CMessageHeader, obj) {
        READWRITE(obj.pchMessageStart, obj.pchCommand, obj.nMessageSize,
                  obj.pchChecksum);
    }
 
    MessageMagic pchMessageStart;
    std::array<char, COMMAND_SIZE> pchCommand;
    uint32_t nMessageSize;
    uint8_t pchChecksum[CHECKSUM_SIZE];
};
 
namespace NetMsgType {
 
extern const char *VERSION;
extern const char *VERACK;
extern const char *ADDR;
extern const char *ADDRV2;
extern const char *SENDADDRV2;
extern const char *INV;
extern const char *GETDATA;
extern const char *MERKLEBLOCK;
extern const char *GETBLOCKS;
extern const char *GETHEADERS;
extern const char *TX;
extern const char *HEADERS;
extern const char *BLOCK;
extern const char *GETADDR;
extern const char *MEMPOOL;
extern const char *PING;
extern const char *PONG;
extern const char *NOTFOUND;
extern const char *FILTERLOAD;
extern const char *FILTERADD;
extern const char *FILTERCLEAR;
extern const char *SENDHEADERS;
extern const char *FEEFILTER;
extern const char *SENDCMPCT;
extern const char *CMPCTBLOCK;
extern const char *GETBLOCKTXN;
extern const char *BLOCKTXN;
extern const char *GETCFILTERS;
extern const char *CFILTER;
extern const char *GETCFHEADERS;
extern const char *CFHEADERS;
extern const char *GETCFCHECKPT;
extern const char *CFCHECKPT;
extern const char *AVAHELLO;
extern const char *AVAPOLL;
extern const char *AVARESPONSE;
extern const char *AVAPROOF;
 
extern const char *GETAVAADDR;
 
extern const char *GETAVAPROOFS;
 
extern const char *AVAPROOFS;
 
extern const char *AVAPROOFSREQ;
 
bool IsBlockLike(const std::string &strCommand);
}; // namespace NetMsgType
 
const std::vector<std::string> &getAllNetMessageTypes();
 
enum ServiceFlags : uint64_t {
    // NOTE: When adding here, be sure to update serviceFlagToStr too
    // Nothing
    NODE_NONE = 0,
    // NODE_NETWORK means that the node is capable of serving the complete block
    // chain. It is currently set by all Bitcoin ABC non pruned nodes, and is
    // unset by SPV clients or other light clients.
    NODE_NETWORK = (1 << 0),
    // NODE_GETUTXO means the node is capable of responding to the getutxo
    // protocol request. Bitcoin ABC does not support this but a patch set
    // called Bitcoin XT does. See BIP 64 for details on how this is
    // implemented.
    NODE_GETUTXO = (1 << 1),
    // NODE_BLOOM means the node is capable and willing to handle bloom-filtered
    // connections. Bitcoin ABC nodes used to support this by default, without
    // advertising this bit, but no longer do as of protocol version 70011 (=
    // NO_BLOOM_VERSION)
    NODE_BLOOM = (1 << 2),
    // Bit 4 was NODE_XTHIN, removed in v0.22.12
 
    // Bit 5 was NODE_BITCOIN_CASH, removed in v0.22.8
 
    // NODE_COMPACT_FILTERS means the node will service basic block filter
    // requests.
    // See BIP157 and BIP158 for details on how this is implemented.
    NODE_COMPACT_FILTERS = (1 << 6),
 
    // NODE_NETWORK_LIMITED means the same as NODE_NETWORK with the limitation
    // of only serving the last 288 (2 day) blocks
    // See BIP159 for details on how this is implemented.
    NODE_NETWORK_LIMITED = (1 << 10),
 
    // The last non experimental service bit, helper for looping over the flags
    NODE_LAST_NON_EXPERIMENTAL_SERVICE_BIT = (1 << 23),
 
    // Bits 24-31 are reserved for temporary experiments. Just pick a bit that
    // isn't getting used, or one not being used much, and notify the
    // bitcoin-development mailing list. Remember that service bits are just
    // unauthenticated advertisements, so your code must be robust against
    // collisions and other cases where nodes may be advertising a service they
    // do not actually support. Other service bits should be allocated via the
    // BIP process.
 
    // NODE_AVALANCHE means the node supports Bitcoin Cash's avalanche
    // preconsensus mechanism.
    NODE_AVALANCHE = (1 << 24),
};
 
std::vector<std::string> serviceFlagsToStr(const uint64_t flags);
 
ServiceFlags GetDesirableServiceFlags(ServiceFlags services);
 
void SetServiceFlagsIBDCache(bool status);
 
static inline bool HasAllDesirableServiceFlags(ServiceFlags services) {
    return !(GetDesirableServiceFlags(services) & (~services));
}
 
static inline bool MayHaveUsefulAddressDB(ServiceFlags services) {
    return (services & NODE_NETWORK) || (services & NODE_NETWORK_LIMITED);
}
 
class CAddress : public CService {
    static constexpr auto TIME_INIT{100000000s};
 
    static constexpr uint32_t DISK_VERSION_INIT{220000};
    static constexpr uint32_t DISK_VERSION_IGNORE_MASK{
        0b00000000'00000111'11111111'11111111};
    static constexpr uint32_t DISK_VERSION_ADDRV2{1 << 29};
    static_assert(
        (DISK_VERSION_INIT & ~DISK_VERSION_IGNORE_MASK) == 0,
        "DISK_VERSION_INIT must be covered by DISK_VERSION_IGNORE_MASK");
    static_assert(
        (DISK_VERSION_ADDRV2 & DISK_VERSION_IGNORE_MASK) == 0,
        "DISK_VERSION_ADDRV2 must not be covered by DISK_VERSION_IGNORE_MASK");
 
public:
    CAddress() : CService{} {};
    CAddress(CService ipIn, ServiceFlags nServicesIn)
        : CService{ipIn}, nServices{nServicesIn} {};
    CAddress(CService ipIn, ServiceFlags nServicesIn, NodeSeconds time)
        : CService{ipIn}, nTime{time}, nServices{nServicesIn} {};
 
    SERIALIZE_METHODS(CAddress, obj) {
        // CAddress has a distinct network serialization and a disk
        // serialization, but it should never be hashed (except through
        // CHashWriter in addrdb.cpp, which sets SER_DISK), and it's ambiguous
        // what that would mean. Make sure no code relying on that is
        // introduced:
        assert(!(s.GetType() & SER_GETHASH));
        bool use_v2;
        if (s.GetType() & SER_DISK) {
            // In the disk serialization format, the encoding (v1 or v2) is
            // determined by a flag version that's part of the serialization
            // itself. ADDRV2_FORMAT in the stream version only determines
            // whether V2 is chosen/permitted at all.
            uint32_t stored_format_version = DISK_VERSION_INIT;
            if (s.GetVersion() & ADDRV2_FORMAT) {
                stored_format_version |= DISK_VERSION_ADDRV2;
            }
            READWRITE(stored_format_version);
            stored_format_version &=
                ~DISK_VERSION_IGNORE_MASK; // ignore low bits
            if (stored_format_version == 0) {
                use_v2 = false;
            } else if (stored_format_version == DISK_VERSION_ADDRV2 &&
                       (s.GetVersion() & ADDRV2_FORMAT)) {
                // Only support v2 deserialization if ADDRV2_FORMAT is set.
                use_v2 = true;
            } else {
                throw std::ios_base::failure(
                    "Unsupported CAddress disk format version");
            }
        } else {
            // In the network serialization format, the encoding (v1 or v2) is
            // determined directly by the value of ADDRV2_FORMAT in the stream
            // version, as no explicitly encoded version exists in the stream.
            assert(s.GetType() & SER_NETWORK);
            use_v2 = s.GetVersion() & ADDRV2_FORMAT;
        }
 
        READWRITE(Using<LossyChronoFormatter<uint32_t>>(obj.nTime));
        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
        if (use_v2) {
            uint64_t services_tmp;
            SER_WRITE(obj, services_tmp = obj.nServices);
            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
            SER_READ(obj,
                     obj.nServices = static_cast<ServiceFlags>(services_tmp));
        } else {
            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
        }
        // Invoke V1/V2 serializer for CService parent object.
        OverrideStream<Stream> os(&s, s.GetType(), use_v2 ? ADDRV2_FORMAT : 0);
        SerReadWriteMany(os, ser_action, ReadWriteAsHelper<CService>(obj));
    }
 
    NodeSeconds nTime{TIME_INIT};
    ServiceFlags nServices{NODE_NONE};
 
    friend bool operator==(const CAddress &a, const CAddress &b) {
        return a.nTime == b.nTime && a.nServices == b.nServices &&
               static_cast<const CService &>(a) ==
                   static_cast<const CService &>(b);
    }
};
 
const uint32_t MSG_TYPE_MASK = 0xffffffff >> 3;
 
enum GetDataMsg {
    UNDEFINED = 0,
    MSG_TX = 1,
    MSG_BLOCK = 2,
    // The following can only occur in getdata. Invs always use TX or BLOCK.
    MSG_FILTERED_BLOCK = 3,
    MSG_CMPCT_BLOCK = 4,
    MSG_AVA_PROOF = 0x1f000001,
    MSG_AVA_STAKE_CONTENDER = 0x1f000002,
};
 
class CInv {
public:
    uint32_t type;
    uint256 hash;
 
    CInv() : type(0), hash() {}
    CInv(uint32_t typeIn, const uint256 &hashIn) : type(typeIn), hash(hashIn) {}
 
    SERIALIZE_METHODS(CInv, obj) { READWRITE(obj.type, obj.hash); }
 
    friend bool operator<(const CInv &a, const CInv &b) {
        return a.type < b.type || (a.type == b.type && a.hash < b.hash);
    }
 
    std::string GetCommand() const;
    std::string ToString() const;
 
    uint32_t GetKind() const { return type & MSG_TYPE_MASK; }
 
    bool IsMsgTx() const {
        auto k = GetKind();
        return k == MSG_TX;
    }
    bool IsMsgProof() const {
        auto k = GetKind();
        return k == MSG_AVA_PROOF;
    }
    bool IsMsgStakeContender() const {
        auto k = GetKind();
        return k == MSG_AVA_STAKE_CONTENDER;
    }
    bool IsMsgBlk() const {
        auto k = GetKind();
        return k == MSG_BLOCK;
    }
    bool IsMsgFilteredBlk() const {
        auto k = GetKind();
        return k == MSG_FILTERED_BLOCK;
    }
    bool IsMsgCmpctBlk() const {
        auto k = GetKind();
        return k == MSG_CMPCT_BLOCK;
    }
 
    bool IsGenBlkMsg() const {
        auto k = GetKind();
        return k == MSG_BLOCK || k == MSG_FILTERED_BLOCK ||
               k == MSG_CMPCT_BLOCK;
    }
};
 
#endif // BITCOIN_PROTOCOL_H