mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-01-10 03:47:29 -03:00
4120c7543e
-BEGIN VERIFY SCRIPT- sed -i s/COMMAND_SIZE/MESSAGE_TYPE_SIZE/g $(git grep -l COMMAND_SIZE) sed -i s/pszCommand/msg_type/g $(git grep -l pszCommand) sed -i s/pchCommand/m_msg_type/g $(git grep -l pchCommand) sed -i s/GetCommand/GetMessageType/g ./src/net.cpp ./src/protocol.cpp ./src/protocol.h ./src/test/fuzz/protocol.cpp sed -i s/IsCommandValid/IsMessageTypeValid/g $(git grep -l IsCommandValid) sed -i "s/command/message type/g" ./src/protocol.h ./src/protocol.cpp -END VERIFY SCRIPT-
125 lines
3.8 KiB
C++
125 lines
3.8 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2022 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 <protocol.h>
|
|
|
|
#include <common/system.h>
|
|
|
|
CMessageHeader::CMessageHeader(const MessageStartChars& pchMessageStartIn, const char* msg_type, unsigned int nMessageSizeIn)
|
|
: pchMessageStart{pchMessageStartIn}
|
|
{
|
|
// Copy the message type name
|
|
size_t i = 0;
|
|
for (; i < MESSAGE_TYPE_SIZE && msg_type[i] != 0; ++i) m_msg_type[i] = msg_type[i];
|
|
assert(msg_type[i] == 0); // Assert that the message type name passed in is not longer than MESSAGE_TYPE_SIZE
|
|
|
|
nMessageSize = nMessageSizeIn;
|
|
}
|
|
|
|
std::string CMessageHeader::GetMessageType() const
|
|
{
|
|
return std::string(m_msg_type, m_msg_type + strnlen(m_msg_type, MESSAGE_TYPE_SIZE));
|
|
}
|
|
|
|
bool CMessageHeader::IsMessageTypeValid() const
|
|
{
|
|
// Check the message type string for errors
|
|
for (const char* p1 = m_msg_type; p1 < m_msg_type + MESSAGE_TYPE_SIZE; ++p1) {
|
|
if (*p1 == 0) {
|
|
// Must be all zeros after the first zero
|
|
for (; p1 < m_msg_type + MESSAGE_TYPE_SIZE; ++p1) {
|
|
if (*p1 != 0) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (*p1 < ' ' || *p1 > 0x7E) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
CInv::CInv()
|
|
{
|
|
type = 0;
|
|
hash.SetNull();
|
|
}
|
|
|
|
CInv::CInv(uint32_t typeIn, const uint256& hashIn) : type(typeIn), hash(hashIn) {}
|
|
|
|
bool operator<(const CInv& a, const CInv& b)
|
|
{
|
|
return (a.type < b.type || (a.type == b.type && a.hash < b.hash));
|
|
}
|
|
|
|
std::string CInv::GetMessageType() const
|
|
{
|
|
std::string cmd;
|
|
if (type & MSG_WITNESS_FLAG)
|
|
cmd.append("witness-");
|
|
int masked = type & MSG_TYPE_MASK;
|
|
switch (masked)
|
|
{
|
|
case MSG_TX: return cmd.append(NetMsgType::TX);
|
|
// WTX is not a message type, just an inv type
|
|
case MSG_WTX: return cmd.append("wtx");
|
|
case MSG_BLOCK: return cmd.append(NetMsgType::BLOCK);
|
|
case MSG_FILTERED_BLOCK: return cmd.append(NetMsgType::MERKLEBLOCK);
|
|
case MSG_CMPCT_BLOCK: return cmd.append(NetMsgType::CMPCTBLOCK);
|
|
default:
|
|
throw std::out_of_range(strprintf("CInv::GetMessageType(): type=%d unknown type", type));
|
|
}
|
|
}
|
|
|
|
std::string CInv::ToString() const
|
|
{
|
|
try {
|
|
return strprintf("%s %s", GetMessageType(), hash.ToString());
|
|
} catch(const std::out_of_range &) {
|
|
return strprintf("0x%08x %s", type, hash.ToString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert a service flag (NODE_*) to a human readable string.
|
|
* It supports unknown service flags which will be returned as "UNKNOWN[...]".
|
|
* @param[in] bit the service flag is calculated as (1 << bit)
|
|
*/
|
|
static std::string serviceFlagToStr(size_t bit)
|
|
{
|
|
const uint64_t service_flag = 1ULL << bit;
|
|
switch ((ServiceFlags)service_flag) {
|
|
case NODE_NONE: abort(); // impossible
|
|
case NODE_NETWORK: return "NETWORK";
|
|
case NODE_BLOOM: return "BLOOM";
|
|
case NODE_WITNESS: return "WITNESS";
|
|
case NODE_COMPACT_FILTERS: return "COMPACT_FILTERS";
|
|
case NODE_NETWORK_LIMITED: return "NETWORK_LIMITED";
|
|
case NODE_P2P_V2: return "P2P_V2";
|
|
// Not using default, so we get warned when a case is missing
|
|
}
|
|
|
|
return strprintf("UNKNOWN[2^%u]", bit);
|
|
}
|
|
|
|
std::vector<std::string> serviceFlagsToStr(uint64_t flags)
|
|
{
|
|
std::vector<std::string> str_flags;
|
|
|
|
for (size_t i = 0; i < sizeof(flags) * 8; ++i) {
|
|
if (flags & (1ULL << i)) {
|
|
str_flags.emplace_back(serviceFlagToStr(i));
|
|
}
|
|
}
|
|
|
|
return str_flags;
|
|
}
|
|
|
|
GenTxid ToGenTxid(const CInv& inv)
|
|
{
|
|
assert(inv.IsGenTxMsg());
|
|
return inv.IsMsgWtx() ? GenTxid::Wtxid(inv.hash) : GenTxid::Txid(inv.hash);
|
|
}
|