highperfocused/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-06-15 19:31:35 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: rename Transport class receive functions

Browse Source 
Now that the Transport class deals with both the sending and receiving side
of things, make the receive side have function names that clearly indicate
they're about receiving.

* Transport::Read() -> Transport::ReceivedBytes()
* Transport::Complete() -> Transport::ReceivedMessageComplete()
* Transport::GetMessage() -> Transport::GetReceivedMessage()
* Transport::SetVersion() -> Transport::SetReceiveVersion()

Further, also update the comments on these functions to (among others) remove
the "deserialization" terminology. That term is better reserved for just the
serialization/deserialization between objects and bytes (see serialize.h), and
not the conversion from/to wire bytes as performed by the Transport.
This commit is contained in:
Pieter Wuille 2023-08-14 16:37:05 -04:00
parent 27f9ba23ef
commit 649a83c7f7
3 changed files with 20 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/net.cpp
View File

@ -681,16 +681,16 @@ bool CNode::ReceiveMsgBytes(Span<const uint8_t> msg_bytes, bool& complete)
nRecvBytes += msg_bytes.size(); nRecvBytes += msg_bytes.size();
while (msg_bytes.size() > 0) { while (msg_bytes.size() > 0) {
// absorb network data // absorb network data
int handled = m_transport->Read(msg_bytes); int handled = m_transport->ReceivedBytes(msg_bytes);
if (handled < 0) { if (handled < 0) {
// Serious header problem, disconnect from the peer. // Serious header problem, disconnect from the peer.
return false; return false;
} }
if (m_transport->Complete()) { if (m_transport->ReceivedMessageComplete()) {
// decompose a transport agnostic CNetMessage from the deserializer // decompose a transport agnostic CNetMessage from the deserializer
bool reject_message{false}; bool reject_message{false};
CNetMessage msg = m_transport->GetMessage(time, reject_message); CNetMessage msg = m_transport->GetReceivedMessage(time, reject_message);
if (reject_message) { if (reject_message) {
// Message deserialization failed. Drop the message but don't disconnect the peer. // Message deserialization failed. Drop the message but don't disconnect the peer.
// store the size of the corrupt message // store the size of the corrupt message
@ -785,7 +785,7 @@ const uint256& V1Transport::GetMessageHash() const
return data_hash; return data_hash;
} }
CNetMessage V1Transport::GetMessage(const std::chrono::microseconds time, bool& reject_message) CNetMessage V1Transport::GetReceivedMessage(const std::chrono::microseconds time, bool& reject_message)
{ {
AssertLockNotHeld(m_recv_mutex); AssertLockNotHeld(m_recv_mutex);
// Initialize out parameter // Initialize out parameter

25
src/net.h
View File

@ -261,14 +261,14 @@ public:
// 1. Receiver side functions, for decoding bytes received on the wire into transport protocol // 1. Receiver side functions, for decoding bytes received on the wire into transport protocol
// agnostic CNetMessage (message type & payload) objects. // agnostic CNetMessage (message type & payload) objects.
// returns true if the current deserialization is complete /** Returns true if the current message is complete (so GetReceivedMessage can be called). */
virtual bool Complete() const = 0; virtual bool ReceivedMessageComplete() const = 0;
// set the deserialization context version /** Set the deserialization context version for objects returned by GetReceivedMessage. */
virtual void SetVersion(int version) = 0; virtual void SetReceiveVersion(int version) = 0;
/** read and deserialize data, advances msg_bytes data pointer */ /** Feed wire bytes to the transport; chops off consumed bytes off front of msg_bytes. */
virtual int Read(Span<const uint8_t>& msg_bytes) = 0; virtual int ReceivedBytes(Span<const uint8_t>& msg_bytes) = 0;
// decomposes a message from the context /** Retrieve a completed message from transport (only when ReceivedMessageComplete). */
virtual CNetMessage GetMessage(std::chrono::microseconds time, bool& reject_message) = 0; virtual CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) = 0;
// 2. Sending side functions: // 2. Sending side functions:
@ -325,13 +325,13 @@ public:
Reset(); Reset();
} }
bool Complete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex) bool ReceivedMessageComplete() const override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
{ {
AssertLockNotHeld(m_recv_mutex); AssertLockNotHeld(m_recv_mutex);
return WITH_LOCK(m_recv_mutex, return CompleteInternal()); return WITH_LOCK(m_recv_mutex, return CompleteInternal());
} }
void SetVersion(int nVersionIn) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex) void SetReceiveVersion(int nVersionIn) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
{ {
AssertLockNotHeld(m_recv_mutex); AssertLockNotHeld(m_recv_mutex);
LOCK(m_recv_mutex); LOCK(m_recv_mutex);
@ -339,7 +339,7 @@ public:
vRecv.SetVersion(nVersionIn); vRecv.SetVersion(nVersionIn);
} }
int Read(Span<const uint8_t>& msg_bytes) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex) int ReceivedBytes(Span<const uint8_t>& msg_bytes) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex)
{ {
AssertLockNotHeld(m_recv_mutex); AssertLockNotHeld(m_recv_mutex);
LOCK(m_recv_mutex); LOCK(m_recv_mutex);
@ -351,7 +351,8 @@ public:
} }
return ret; return ret;
} }
CNetMessage GetMessage(std::chrono::microseconds time, bool& reject_message) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);
CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) override EXCLUSIVE_LOCKS_REQUIRED(!m_recv_mutex);
void prepareForTransport(CSerializedNetMsg& msg, std::vector<unsigned char>& header) const override; void prepareForTransport(CSerializedNetMsg& msg, std::vector<unsigned char>& header) const override;
}; };

6
src/test/fuzz/p2p_transport_serialization.cpp
View File

@ -64,14 +64,14 @@ FUZZ_TARGET(p2p_transport_serialization, .init = initialize_p2p_transport_serial
mutable_msg_bytes.insert(mutable_msg_bytes.end(), payload_bytes.begin(), payload_bytes.end()); mutable_msg_bytes.insert(mutable_msg_bytes.end(), payload_bytes.begin(), payload_bytes.end());
Span<const uint8_t> msg_bytes{mutable_msg_bytes}; Span<const uint8_t> msg_bytes{mutable_msg_bytes};
while (msg_bytes.size() > 0) { while (msg_bytes.size() > 0) {
const int handled = recv_transport.Read(msg_bytes); const int handled = recv_transport.ReceivedBytes(msg_bytes);
if (handled < 0) { if (handled < 0) {
break; break;
} }
if (recv_transport.Complete()) { if (recv_transport.ReceivedMessageComplete()) {
const std::chrono::microseconds m_time{std::numeric_limits<int64_t>::max()}; const std::chrono::microseconds m_time{std::numeric_limits<int64_t>::max()};
bool reject_message{false}; bool reject_message{false};
CNetMessage msg = recv_transport.GetMessage(m_time, reject_message); CNetMessage msg = recv_transport.GetReceivedMessage(m_time, reject_message);
assert(msg.m_type.size() <= CMessageHeader::COMMAND_SIZE); assert(msg.m_type.size() <= CMessageHeader::COMMAND_SIZE);
assert(msg.m_raw_message_size <= mutable_msg_bytes.size()); assert(msg.m_raw_message_size <= mutable_msg_bytes.size());
assert(msg.m_raw_message_size == CMessageHeader::HEADER_SIZE + msg.m_message_size); assert(msg.m_raw_message_size == CMessageHeader::HEADER_SIZE + msg.m_message_size);