highperfocused/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-05-31 18:22:04 +02:00
Code Issues Packages Projects Releases Wiki Activity

Give V1TransportDeserializer CChainParams& member

Browse Source 
This adds a CChainParams& member to V1TransportDeserializer member, and
use it in place of many Params() calls.  In addition to reducing the
number of calls to a global, this removes a parameter from GetMessage
(and will later allow us to remove one from CMessageHeader::IsValid())
This commit is contained in:
Troy Giorshev 2020-06-08 22:26:22 -04:00
parent 5bceef6b12
commit 52d4ae46ab
3 changed files with 16 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/net.cpp
View File

@ -10,7 +10,6 @@
#include <net.h> #include <net.h>
#include <banman.h> #include <banman.h>
#include <chainparams.h>
#include <clientversion.h> #include <clientversion.h>
#include <consensus/consensus.h> #include <consensus/consensus.h>
#include <crypto/sha256.h> #include <crypto/sha256.h>
@ -615,7 +614,7 @@ bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes, bool& complete
if (m_deserializer->Complete()) { if (m_deserializer->Complete()) {
// decompose a transport agnostic CNetMessage from the deserializer // decompose a transport agnostic CNetMessage from the deserializer
uint32_t out_err_raw_size{0}; uint32_t out_err_raw_size{0};
Optional<CNetMessage> result{m_deserializer->GetMessage(Params().MessageStart(), time, out_err_raw_size)}; Optional<CNetMessage> result{m_deserializer->GetMessage(time, out_err_raw_size)};
if (!result) { if (!result) {
// store the size of the corrupt message // store the size of the corrupt message
mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER)->second += out_err_raw_size; mapRecvBytesPerMsgCmd.find(NET_MESSAGE_COMMAND_OTHER)->second += out_err_raw_size;
@ -697,15 +696,14 @@ const uint256& V1TransportDeserializer::GetMessageHash() const
return data_hash; return data_hash;
} }
Optional<CNetMessage> V1TransportDeserializer::GetMessage(const CMessageHeader::MessageStartChars& message_start, const std::chrono::microseconds time, uint32_t& out_err_raw_size) Optional<CNetMessage> V1TransportDeserializer::GetMessage(const std::chrono::microseconds time, uint32_t& out_err_raw_size)
{ {
// decompose a single CNetMessage from the TransportDeserializer // decompose a single CNetMessage from the TransportDeserializer
Optional<CNetMessage> msg(std::move(vRecv)); Optional<CNetMessage> msg(std::move(vRecv));
// store state about valid header, netmagic and checksum // store state about valid header, netmagic and checksum
msg->m_valid_header = hdr.IsValid(message_start); msg->m_valid_header = hdr.IsValid(m_chain_params.MessageStart());
msg->m_valid_netmagic = (memcmp(hdr.pchMessageStart, message_start, CMessageHeader::MESSAGE_START_SIZE) == 0); msg->m_valid_netmagic = (memcmp(hdr.pchMessageStart, m_chain_params.MessageStart(), CMessageHeader::MESSAGE_START_SIZE) == 0);
uint256 hash = GetMessageHash();
// store command string, time, and sizes // store command string, time, and sizes
msg->m_command = hdr.GetCommand(); msg->m_command = hdr.GetCommand();
@ -713,6 +711,8 @@ Optional<CNetMessage> V1TransportDeserializer::GetMessage(const CMessageHeader::
msg->m_message_size = hdr.nMessageSize; msg->m_message_size = hdr.nMessageSize;
msg->m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE; msg->m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
uint256 hash = GetMessageHash();
// We just received a message off the wire, harvest entropy from the time (and the message checksum) // We just received a message off the wire, harvest entropy from the time (and the message checksum)
RandAddEvent(ReadLE32(hash.begin())); RandAddEvent(ReadLE32(hash.begin()));
@ -2846,7 +2846,7 @@ CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, int nMyStartingHeightIn
LogPrint(BCLog::NET, "Added connection peer=%d\n", id); LogPrint(BCLog::NET, "Added connection peer=%d\n", id);
} }
m_deserializer = MakeUnique<V1TransportDeserializer>(V1TransportDeserializer(GetId(), SER_NETWORK, INIT_PROTO_VERSION)); m_deserializer = MakeUnique<V1TransportDeserializer>(V1TransportDeserializer(Params(), GetId(), SER_NETWORK, INIT_PROTO_VERSION));
m_serializer = MakeUnique<V1TransportSerializer>(V1TransportSerializer()); m_serializer = MakeUnique<V1TransportSerializer>(V1TransportSerializer());
} }

11
src/net.h
View File

@ -10,6 +10,7 @@
#include <addrman.h> #include <addrman.h>
#include <amount.h> #include <amount.h>
#include <bloom.h> #include <bloom.h>
#include <chainparams.h>
#include <compat.h> #include <compat.h>
#include <crypto/siphash.h> #include <crypto/siphash.h>
#include <hash.h> #include <hash.h>
@ -732,13 +733,14 @@ public:
// read and deserialize data // read and deserialize data
virtual int Read(const char *data, unsigned int bytes) = 0; virtual int Read(const char *data, unsigned int bytes) = 0;
// decomposes a message from the context // decomposes a message from the context
virtual Optional<CNetMessage> GetMessage(const CMessageHeader::MessageStartChars& message_start, std::chrono::microseconds time, uint32_t& out_err) = 0; virtual Optional<CNetMessage> GetMessage(std::chrono::microseconds time, uint32_t& out_err) = 0;
virtual ~TransportDeserializer() {} virtual ~TransportDeserializer() {}
}; };
class V1TransportDeserializer final : public TransportDeserializer class V1TransportDeserializer final : public TransportDeserializer
{ {
private: private:
const CChainParams& m_chain_params;
const NodeId m_node_id; // Only for logging const NodeId m_node_id; // Only for logging
mutable CHash256 hasher; mutable CHash256 hasher;
mutable uint256 data_hash; mutable uint256 data_hash;
@ -765,8 +767,9 @@ private:
} }
public: public:
V1TransportDeserializer(const NodeId node_id, int nTypeIn, int nVersionIn) V1TransportDeserializer(const CChainParams& chain_params, const NodeId node_id, int nTypeIn, int nVersionIn)
: m_node_id(node_id), : m_chain_params(chain_params),
m_node_id(node_id),
hdrbuf(nTypeIn, nVersionIn), hdrbuf(nTypeIn, nVersionIn),
vRecv(nTypeIn, nVersionIn) vRecv(nTypeIn, nVersionIn)
{ {
@ -789,7 +792,7 @@ public:
if (ret < 0) Reset(); if (ret < 0) Reset();
return ret; return ret;
} }
Optional<CNetMessage> GetMessage(const CMessageHeader::MessageStartChars& message_start, std::chrono::microseconds time, uint32_t& out_err_raw_size) override; Optional<CNetMessage> GetMessage(std::chrono::microseconds time, uint32_t& out_err_raw_size) override;
}; };
/** The TransportSerializer prepares messages for the network transport /** The TransportSerializer prepares messages for the network transport

4
src/test/fuzz/p2p_transport_deserializer.cpp
View File

@ -20,7 +20,7 @@ void initialize()
void test_one_input(const std::vector<uint8_t>& buffer) void test_one_input(const std::vector<uint8_t>& buffer)
{ {
// Construct deserializer, with a dummy NodeId // Construct deserializer, with a dummy NodeId
V1TransportDeserializer deserializer{(NodeId)0, SER_NETWORK, INIT_PROTO_VERSION}; V1TransportDeserializer deserializer{Params(), (NodeId)0, SER_NETWORK, INIT_PROTO_VERSION};
const char* pch = (const char*)buffer.data(); const char* pch = (const char*)buffer.data();
size_t n_bytes = buffer.size(); size_t n_bytes = buffer.size();
while (n_bytes > 0) { while (n_bytes > 0) {
@ -33,7 +33,7 @@ void test_one_input(const std::vector<uint8_t>& buffer)
if (deserializer.Complete()) { if (deserializer.Complete()) {
const std::chrono::microseconds m_time{std::numeric_limits<int64_t>::max()}; const std::chrono::microseconds m_time{std::numeric_limits<int64_t>::max()};
uint32_t out_err_raw_size{0}; uint32_t out_err_raw_size{0};
Optional<CNetMessage> result{deserializer.GetMessage(Params().MessageStart(), m_time, out_err_raw_size)}; Optional<CNetMessage> result{deserializer.GetMessage(m_time, out_err_raw_size)};
if (result) { if (result) {
assert(result->m_command.size() <= CMessageHeader::COMMAND_SIZE); assert(result->m_command.size() <= CMessageHeader::COMMAND_SIZE);
assert(result->m_raw_message_size <= buffer.size()); assert(result->m_raw_message_size <= buffer.size());