Message.h

#pragma once
 
#include <xrpld/overlay/Compression.h>
 
#include <xrpl/basics/ByteUtilities.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/server/Manifest.h>
 
#include <google/protobuf/message.h>
 
#include <xrpl.pb.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <vector>
 
namespace xrpl {
 
constexpr std::size_t kMaximumMessageSize = megabytes(64);
// Ping messages should be much smaller than the maximum message size,
// so we define a separate limit for them.
constexpr std::size_t kMaximumPingMessageSize = kilobytes(1);
 
// Allowance for protobuf framing around each manifest in a TMManifests message.
constexpr std::size_t kManifestFramingBytes = 8;

constexpr std::size_t
maximumManifestsMessageSize(std::size_t const trustedCount, std::size_t const untrustedCount)
{
    return (trustedCount + untrustedCount) * (kMaxManifestBytes + kManifestFramingBytes);
}
 
// The message size the defaults imply must stay within the overall protocol
// message limit. The same check for the largest configurable counts lives in
// OverlayImpl.h, where the configured bound is visible.
static_assert(
    maximumManifestsMessageSize(kMaxTrustedCount, kMaxUntrustedCount) < kMaximumMessageSize);
 
// VFALCO NOTE If we forward declare Message and write out shared_ptr
//             instead of using the in-class type alias, we can remove the
//             entire ripple.pb.h from the main headers.
//
 
// packaging of messages into length/type-prepended buffers
// ready for transmission.
//
// Message implements simple "packing" of protocol buffers Messages into
// a string prepended by a header specifying the message length.
// MessageType should be a Message class generated by the protobuf compiler.
//
 
class Message : public std::enable_shared_from_this<Message>
{
    using Compressed = compression::Compressed;
    using Algorithm = compression::Algorithm;
 
public:
    Message(
        ::google::protobuf::Message const& message,
        protocol::MessageType type,
        std::optional<PublicKey> const& validator = {});

    std::size_t
    getBufferSize();
 
    static std::size_t
    messageSize(::google::protobuf::Message const& message);
 
    static std::size_t
    totalSize(::google::protobuf::Message const& message);

    std::vector<uint8_t> const&
    getBuffer(Compressed tryCompressed);

    std::size_t
    getCategory() const
    {
        return category_;
    }

    std::optional<PublicKey> const&
    getValidatorKey() const
    {
        return validatorKey_;
    }
 
private:
    std::vector<uint8_t> buffer_;
    std::vector<uint8_t> bufferCompressed_;
    std::size_t category_;
    std::once_flag onceFlag_;
    std::optional<PublicKey> validatorKey_;

    static void
    setHeader(
        std::uint8_t* in,
        std::uint32_t payloadBytes,
        int type,
        Algorithm compression,
        std::uint32_t uncompressedBytes);

    void
    compress();

    static int
    getType(std::uint8_t const* in);
};
 
}  // namespace xrpl