forked from bitcoin/bitcoin
-
Notifications
You must be signed in to change notification settings - Fork 11
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Move CNetMessage and Transport headers to common
This avoids a circular dependency between bitcoin-sv2 and bitcoin-node.
- Loading branch information
Showing
4 changed files
with
191 additions
and
176 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,189 @@ | ||
| // Copyright (c) 2024 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_COMMON_TRANSPORT_H | ||
| #define BITCOIN_COMMON_TRANSPORT_H | ||
|
|
||
| #include <chrono> | ||
| #include <span.h> | ||
| #include <stdint.h> | ||
| #include <streams.h> | ||
| #include <string> | ||
| #include <uint256.h> | ||
|
|
||
| /** Transport layer version */ | ||
| enum class TransportProtocolType : uint8_t { | ||
| DETECTING, //!< Peer could be v1 or v2 | ||
| V1, //!< Unencrypted, plaintext protocol | ||
| V2, //!< BIP324 protocol | ||
| }; | ||
|
|
||
| /** Convert TransportProtocolType enum to a string value */ | ||
| std::string TransportTypeAsString(TransportProtocolType transport_type); | ||
|
|
||
| /** Transport protocol agnostic message container. | ||
| * Ideally it should only contain receive time, payload, | ||
| * type and size. | ||
| */ | ||
| class CNetMessage | ||
| { | ||
| public: | ||
| DataStream m_recv; //!< received message data | ||
| std::chrono::microseconds m_time{0}; //!< time of message receipt | ||
| uint32_t m_message_size{0}; //!< size of the payload | ||
| uint32_t m_raw_message_size{0}; //!< used wire size of the message (including header/checksum) | ||
| std::string m_type; | ||
|
|
||
| explicit CNetMessage(DataStream&& recv_in) : m_recv(std::move(recv_in)) {} | ||
| // Only one CNetMessage object will exist for the same message on either | ||
| // the receive or processing queue. For performance reasons we therefore | ||
| // delete the copy constructor and assignment operator to avoid the | ||
| // possibility of copying CNetMessage objects. | ||
| CNetMessage(CNetMessage&&) = default; | ||
| CNetMessage(const CNetMessage&) = delete; | ||
| CNetMessage& operator=(CNetMessage&&) = default; | ||
| CNetMessage& operator=(const CNetMessage&) = delete; | ||
|
|
||
| /** Compute total memory usage of this object (own memory + any dynamic memory). */ | ||
| size_t GetMemoryUsage() const noexcept; | ||
| }; | ||
|
|
||
| struct CSerializedNetMsg { | ||
| CSerializedNetMsg() = default; | ||
| CSerializedNetMsg(CSerializedNetMsg&&) = default; | ||
| CSerializedNetMsg& operator=(CSerializedNetMsg&&) = default; | ||
| // No implicit copying, only moves. | ||
| CSerializedNetMsg(const CSerializedNetMsg& msg) = delete; | ||
| CSerializedNetMsg& operator=(const CSerializedNetMsg&) = delete; | ||
|
|
||
| CSerializedNetMsg Copy() const | ||
| { | ||
| CSerializedNetMsg copy; | ||
| copy.data = data; | ||
| copy.m_type = m_type; | ||
| return copy; | ||
| } | ||
|
|
||
| std::vector<unsigned char> data; | ||
| std::string m_type; | ||
|
|
||
| /** Compute total memory usage of this object (own memory + any dynamic memory). */ | ||
| size_t GetMemoryUsage() const noexcept; | ||
| }; | ||
|
|
||
| /** The Transport converts one connection's sent messages to wire bytes, and received bytes back. */ | ||
| class Transport { | ||
| public: | ||
| virtual ~Transport() = default; | ||
|
|
||
| struct Info | ||
| { | ||
| TransportProtocolType transport_type; | ||
| std::optional<uint256> session_id; | ||
| }; | ||
|
|
||
| /** Retrieve information about this transport. */ | ||
| virtual Info GetInfo() const noexcept = 0; | ||
|
|
||
| // 1. Receiver side functions, for decoding bytes received on the wire into transport protocol | ||
| // agnostic CNetMessage (message type & payload) objects. | ||
|
|
||
| /** Returns true if the current message is complete (so GetReceivedMessage can be called). */ | ||
| virtual bool ReceivedMessageComplete() const = 0; | ||
|
|
||
| /** Feed wire bytes to the transport. | ||
| * | ||
| * @return false if some bytes were invalid, in which case the transport can't be used anymore. | ||
| * | ||
| * Consumed bytes are chopped off the front of msg_bytes. | ||
| */ | ||
| virtual bool ReceivedBytes(Span<const uint8_t>& msg_bytes) = 0; | ||
|
|
||
| /** Retrieve a completed message from transport. | ||
| * | ||
| * This can only be called when ReceivedMessageComplete() is true. | ||
| * | ||
| * If reject_message=true is returned the message itself is invalid, but (other than false | ||
| * returned by ReceivedBytes) the transport is not in an inconsistent state. | ||
| */ | ||
| virtual CNetMessage GetReceivedMessage(std::chrono::microseconds time, bool& reject_message) = 0; | ||
|
|
||
| // 2. Sending side functions, for converting messages into bytes to be sent over the wire. | ||
|
|
||
| /** Set the next message to send. | ||
| * | ||
| * If no message can currently be set (perhaps because the previous one is not yet done being | ||
| * sent), returns false, and msg will be unmodified. Otherwise msg is enqueued (and | ||
| * possibly moved-from) and true is returned. | ||
| */ | ||
| virtual bool SetMessageToSend(CSerializedNetMsg& msg) noexcept = 0; | ||
|
|
||
| /** Return type for GetBytesToSend, consisting of: | ||
| * - Span<const uint8_t> to_send: span of bytes to be sent over the wire (possibly empty). | ||
| * - bool more: whether there will be more bytes to be sent after the ones in to_send are | ||
| * all sent (as signaled by MarkBytesSent()). | ||
| * - const std::string& m_type: message type on behalf of which this is being sent | ||
| * ("" for bytes that are not on behalf of any message). | ||
| */ | ||
| using BytesToSend = std::tuple< | ||
| Span<const uint8_t> /*to_send*/, | ||
| bool /*more*/, | ||
| const std::string& /*m_type*/ | ||
| >; | ||
|
|
||
| /** Get bytes to send on the wire, if any, along with other information about it. | ||
| * | ||
| * As a const function, it does not modify the transport's observable state, and is thus safe | ||
| * to be called multiple times. | ||
| * | ||
| * @param[in] have_next_message If true, the "more" return value reports whether more will | ||
| * be sendable after a SetMessageToSend call. It is set by the caller when they know | ||
| * they have another message ready to send, and only care about what happens | ||
| * after that. The have_next_message argument only affects this "more" return value | ||
| * and nothing else. | ||
| * | ||
| * Effectively, there are three possible outcomes about whether there are more bytes | ||
| * to send: | ||
| * - Yes: the transport itself has more bytes to send later. For example, for | ||
| * V1Transport this happens during the sending of the header of a | ||
| * message, when there is a non-empty payload that follows. | ||
| * - No: the transport itself has no more bytes to send, but will have bytes to | ||
| * send if handed a message through SetMessageToSend. In V1Transport this | ||
| * happens when sending the payload of a message. | ||
| * - Blocked: the transport itself has no more bytes to send, and is also incapable | ||
| * of sending anything more at all now, if it were handed another | ||
| * message to send. This occurs in V2Transport before the handshake is | ||
| * complete, as the encryption ciphers are not set up for sending | ||
| * messages before that point. | ||
| * | ||
| * The boolean 'more' is true for Yes, false for Blocked, and have_next_message | ||
| * controls what is returned for No. | ||
| * | ||
| * @return a BytesToSend object. The to_send member returned acts as a stream which is only | ||
| * ever appended to. This means that with the exception of MarkBytesSent (which pops | ||
| * bytes off the front of later to_sends), operations on the transport can only append | ||
| * to what is being returned. Also note that m_type and to_send refer to data that is | ||
| * internal to the transport, and calling any non-const function on this object may | ||
| * invalidate them. | ||
| */ | ||
| virtual BytesToSend GetBytesToSend(bool have_next_message) const noexcept = 0; | ||
|
|
||
| /** Report how many bytes returned by the last GetBytesToSend() have been sent. | ||
| * | ||
| * bytes_sent cannot exceed to_send.size() of the last GetBytesToSend() result. | ||
| * | ||
| * If bytes_sent=0, this call has no effect. | ||
| */ | ||
| virtual void MarkBytesSent(size_t bytes_sent) noexcept = 0; | ||
|
|
||
| /** Return the memory usage of this transport attributable to buffered data to send. */ | ||
| virtual size_t GetSendMemoryUsage() const noexcept = 0; | ||
|
|
||
| // 3. Miscellaneous functions. | ||
|
|
||
| /** Whether upon disconnections, a reconnect with V1 is warranted. */ | ||
| virtual bool ShouldReconnectV1() const noexcept = 0; | ||
| }; | ||
|
|
||
| #endif // BITCOIN_COMMON_TRANSPORT_H |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.