mirror of
https://github.com/boostorg/mqtt5.git
synced 2026-01-19 04:22:11 +00:00
f3c1b0c770
Reviewers: ljudevit Reviewed By: ljudevit Subscribers: korina, miljen Differential Revision: https://repo.mireo.local/D36289
405 lines
14 KiB
C++
405 lines
14 KiB
C++
//
|
|
// Copyright (c) 2023-2025 Ivica Siladic, Bruno Iljazovic, Korina Simicevic
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
#ifndef BOOST_MQTT5_TEST_PACKET_UTIL_HPP
|
|
#define BOOST_MQTT5_TEST_PACKET_UTIL_HPP
|
|
|
|
#include <boost/mqtt5/detail/control_packet.hpp>
|
|
#include <boost/mqtt5/detail/traits.hpp>
|
|
|
|
#include <boost/mqtt5/impl/codecs/message_decoders.hpp>
|
|
#include <boost/mqtt5/impl/codecs/message_encoders.hpp>
|
|
|
|
#include <boost/algorithm/string/join.hpp>
|
|
#include <boost/asio/buffer.hpp>
|
|
#include <boost/range/algorithm/transform.hpp>
|
|
|
|
#include <bitset>
|
|
#include <cstdint>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
namespace boost::mqtt5::test {
|
|
|
|
using control_code_e = boost::mqtt5::detail::control_code_e;
|
|
|
|
template <typename ...Strings>
|
|
std::string concat_strings(Strings&&... strings) {
|
|
std::ostringstream stream;
|
|
(stream << ... << std::forward<Strings>(strings));
|
|
return stream.str();
|
|
}
|
|
|
|
namespace detail {
|
|
|
|
inline qos_e extract_qos(uint8_t flags) {
|
|
auto byte = (flags & 0b0110) >> 1;
|
|
return qos_e(byte);
|
|
}
|
|
|
|
inline control_code_e extract_code(uint8_t control_byte) {
|
|
constexpr uint8_t mask = 0b11110000;
|
|
constexpr uint8_t publish_bits = 0b0011;
|
|
constexpr uint8_t special_mask = 0b00000010;
|
|
constexpr control_code_e codes_with_non_zero_end[] = {
|
|
control_code_e::pubrel, control_code_e::subscribe,
|
|
control_code_e::unsubscribe
|
|
};
|
|
|
|
if ((control_byte >> 4) == publish_bits)
|
|
return control_code_e::publish;
|
|
if ((control_byte & mask) == control_byte)
|
|
return control_code_e(control_byte & mask);
|
|
|
|
for (const auto& special_code : codes_with_non_zero_end)
|
|
if (control_byte == (uint8_t(special_code) | special_mask))
|
|
return special_code;
|
|
|
|
return control_code_e::no_packet;
|
|
}
|
|
|
|
|
|
inline std::string_view code_to_str(control_code_e code) {
|
|
switch (code) {
|
|
case control_code_e::connect: return "CONNECT";
|
|
case control_code_e::connack: return "CONNACK";
|
|
case control_code_e::publish: return "PUBLISH";
|
|
case control_code_e::puback: return "PUBACK";
|
|
case control_code_e::pubrec: return "PUBREC";
|
|
case control_code_e::pubrel: return "PUBREL";
|
|
case control_code_e::pubcomp: return "PUBCOMP";
|
|
case control_code_e::subscribe: return "SUBSCRIBE";
|
|
case control_code_e::suback: return "SUBACK";
|
|
case control_code_e::unsubscribe: return "UNSUBSCRIBE";
|
|
case control_code_e::unsuback: return "UNSUBACK";
|
|
case control_code_e::auth: return "AUTH";
|
|
case control_code_e::disconnect: return "DISCONNECT";
|
|
case control_code_e::pingreq: return "PINGREQ";
|
|
case control_code_e::pingresp: return "PINGRESP";
|
|
default: return "NO PACKET";
|
|
}
|
|
}
|
|
|
|
template <typename Props>
|
|
inline std::string to_readable_props(Props props) {
|
|
std::ostringstream stream;
|
|
props.visit([&stream](const auto&, const auto& v) -> bool {
|
|
using namespace boost::mqtt5::detail;
|
|
if constexpr (is_optional<decltype(v)>)
|
|
if (v.has_value())
|
|
stream << *v << " ";
|
|
if constexpr (is_vector<decltype(v)>)
|
|
for (size_t i = 0; i < v.size(); i++) {
|
|
if constexpr (is_pair<decltype(v[i])>)
|
|
stream << "(" << v[i].first << ", " << v[i].second << ")";
|
|
else
|
|
stream << v[i];
|
|
if (i + 1 < v.size())
|
|
stream << ", ";
|
|
}
|
|
return true;
|
|
});
|
|
return stream.str();
|
|
}
|
|
|
|
using byte_citer = std::string::const_iterator;
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::connect, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
auto connect = decoders::decode_connect(remain_length, it);
|
|
if (!connect.has_value())
|
|
return "Cannot decode Connect packet!";
|
|
auto& [cli_id, uname, pwd, keep_alive, clean_start, props, will] = *connect;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" uname: ", uname.value_or(""), " pwd: ", pwd.value_or(""),
|
|
" keep_alive: ", keep_alive, " clean_start: ", clean_start,
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::connack, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
auto connack = decoders::decode_connack(remain_length, it);
|
|
if (!connack.has_value())
|
|
return "Cannot decode Connack packet!";
|
|
auto& [session_present, reason_code, props] = *connack;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" session_present: ", session_present, " reason_code: ", reason_code,
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::disconnect, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
auto disconnect = decoders::decode_disconnect(remain_length, it);
|
|
if (!disconnect.has_value())
|
|
return "Cannot decode Disconnect packet!";
|
|
auto& [reason_code, props] = *disconnect;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" reason_code: ", std::to_string(uint8_t(reason_code)),
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::publish, bool> = true
|
|
>
|
|
inline std::string to_string(
|
|
uint8_t control_byte, uint32_t remain_length, byte_citer& it
|
|
) {
|
|
auto publish = decoders::decode_publish(control_byte, remain_length, it);
|
|
if (!publish.has_value())
|
|
return "Cannot decode Publish packet!";
|
|
auto& [topic, packet_id, flags, props, payload] = *publish;
|
|
|
|
return concat_strings(
|
|
code_to_str(code), (packet_id ? " " + std::to_string(*packet_id) : ""),
|
|
" flags: ", std::bitset<8>(flags),
|
|
" topic: ", topic, " payload: ", payload,
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<
|
|
code == control_code_e::puback || code == control_code_e::pubrec ||
|
|
code == control_code_e::pubrel || code == control_code_e::pubcomp,
|
|
bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
const auto packet_id = decoders::decode_packet_id(it).value_or(0);
|
|
remain_length -= sizeof(uint16_t);
|
|
uint8_t reason_code = remain_length == 0 ? 0 : uint8_t(*it);
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" packet_id: ", packet_id, " reason_code: ", std::to_string(reason_code)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::auth, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
auto auth = decoders::decode_auth(remain_length, it);
|
|
if (!auth.has_value())
|
|
return "Cannot decode Auth packet!";
|
|
auto& [reason_code, props] = *auth;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" reason_code: ", std::to_string(uint8_t(reason_code)),
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::subscribe, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
const auto packet_id = decoders::decode_packet_id(it).value_or(0);
|
|
remain_length -= sizeof(uint16_t);
|
|
auto subscribe = decoders::decode_subscribe(remain_length, it);
|
|
if (!subscribe.has_value())
|
|
return "Cannot decode Subscribe packet!";
|
|
auto& [props, topics] = *subscribe;
|
|
|
|
std::vector<std::string> topics_str;
|
|
topics_str.resize(topics.size());
|
|
boost::transform(
|
|
boost::make_iterator_range(topics.cbegin(), topics.cend()),
|
|
topics_str.begin(),
|
|
[](const auto& tuple) {
|
|
auto& [topic, options] = tuple;
|
|
return concat_strings(topic, " ", std::bitset<8>(options));
|
|
}
|
|
);
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" packet_id: ", packet_id,
|
|
" topics: ", boost::algorithm::join(topics_str, ","),
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::unsubscribe, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
const auto packet_id = decoders::decode_packet_id(it).value_or(0);
|
|
remain_length -= sizeof(uint16_t);
|
|
auto unsubscribe = decoders::decode_unsubscribe(remain_length, it);
|
|
if (!unsubscribe.has_value())
|
|
return "Cannot decode Unsubscribe packet!";
|
|
auto& [props, topics] = *unsubscribe;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" packet_id: ", packet_id,
|
|
" topics: ", boost::algorithm::join(topics, ","),
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
inline std::string reason_codes_to_string(const std::vector<uint8_t>& rcs) {
|
|
std::vector<std::string> rcs_str;
|
|
rcs_str.resize(rcs.size());
|
|
boost::transform(
|
|
boost::make_iterator_range(rcs.cbegin(), rcs.cend()),
|
|
rcs_str.begin(),
|
|
[](const auto& rc) { return std::to_string(rc); }
|
|
);
|
|
return boost::algorithm::join(rcs_str, ",");
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::suback, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
const auto packet_id = decoders::decode_packet_id(it).value_or(0);
|
|
remain_length -= sizeof(uint16_t);
|
|
auto suback = decoders::decode_suback(remain_length, it);
|
|
if (!suback.has_value())
|
|
return "Cannot decode Suback packet!";
|
|
auto& [props, reason_codes] = *suback;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" packet_id: ", packet_id,
|
|
" reason_codes: ", reason_codes_to_string(reason_codes),
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
template <
|
|
control_code_e code,
|
|
std::enable_if_t<code == control_code_e::unsuback, bool> = true
|
|
>
|
|
inline std::string to_string(uint32_t remain_length, byte_citer& it) {
|
|
const auto packet_id = decoders::decode_packet_id(it).value_or(0);
|
|
remain_length -= sizeof(uint16_t);
|
|
auto unsuback = decoders::decode_unsuback(remain_length, it);
|
|
if (!unsuback.has_value())
|
|
return "Cannot decode Unuback packet!";
|
|
auto& [props, reason_codes] = *unsuback;
|
|
|
|
return concat_strings(
|
|
code_to_str(code),
|
|
" packet_id: ", packet_id,
|
|
" reason_codes: ", reason_codes_to_string(reason_codes),
|
|
" props: ", to_readable_props(props)
|
|
);
|
|
}
|
|
|
|
} // end namespace detail
|
|
|
|
inline std::string to_readable_packet(std::string packet) {
|
|
auto control_byte = uint8_t(*packet.data());
|
|
auto code = detail::extract_code(control_byte);
|
|
|
|
if (
|
|
code == control_code_e::pingreq ||
|
|
code == control_code_e::pingresp
|
|
) {
|
|
return concat_strings(detail::code_to_str(code));
|
|
}
|
|
|
|
auto begin = ++packet.cbegin();
|
|
auto varlen = decoders::type_parse(
|
|
begin, packet.cend(), decoders::basic::varint_
|
|
);
|
|
|
|
switch (code) {
|
|
case control_code_e::connect:
|
|
return detail::to_string<control_code_e::connect>(*varlen, begin);
|
|
case control_code_e::connack:
|
|
return detail::to_string<control_code_e::connack>(*varlen, begin);
|
|
case control_code_e::disconnect:
|
|
return detail::to_string<control_code_e::disconnect>(*varlen, begin);
|
|
case control_code_e::publish:
|
|
return detail::to_string<control_code_e::publish>(
|
|
control_byte, *varlen, begin
|
|
);
|
|
case control_code_e::puback:
|
|
return detail::to_string<control_code_e::puback>(*varlen, begin);
|
|
case control_code_e::pubrec:
|
|
return detail::to_string<control_code_e::pubrec>(*varlen, begin);
|
|
case control_code_e::pubrel:
|
|
return detail::to_string<control_code_e::pubrel>(*varlen, begin);
|
|
case control_code_e::pubcomp:
|
|
return detail::to_string<control_code_e::pubcomp>(*varlen, begin);
|
|
case control_code_e::auth:
|
|
return detail::to_string<control_code_e::auth>(*varlen, begin);
|
|
case control_code_e::subscribe:
|
|
return detail::to_string<control_code_e::subscribe>(*varlen, begin);
|
|
case control_code_e::suback:
|
|
return detail::to_string<control_code_e::suback>(*varlen, begin);
|
|
case control_code_e::unsubscribe:
|
|
return detail::to_string<control_code_e::unsubscribe>(*varlen, begin);
|
|
case control_code_e::unsuback:
|
|
return detail::to_string<control_code_e::unsuback>(*varlen, begin);
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
template <typename ConstBufferSequence>
|
|
std::vector<std::string> to_readable_packets(const ConstBufferSequence& buffers) {
|
|
namespace asio = boost::asio;
|
|
|
|
std::vector<std::string> content;
|
|
|
|
for (
|
|
auto it = asio::buffer_sequence_begin(buffers);
|
|
it != asio::buffer_sequence_end(buffers);
|
|
it++
|
|
)
|
|
content.push_back(
|
|
to_readable_packet(std::string { (const char*)it->data(), it->size() })
|
|
);
|
|
|
|
return content;
|
|
}
|
|
|
|
inline disconnect_props dprops_with_reason_string(const std::string& reason_string) {
|
|
disconnect_props dprops;
|
|
dprops[prop::reason_string] = reason_string;
|
|
return dprops;
|
|
}
|
|
|
|
static const auto dflt_cprops = std::invoke([] {
|
|
connect_props ret;
|
|
ret[prop::maximum_packet_size] = ::boost::mqtt5::detail::default_max_recv_size;
|
|
return ret;
|
|
});
|
|
|
|
} // end namespace boost::mqtt5::test
|
|
|
|
#endif // BOOST_MQTT5_TEST_PACKET_UTIL_HPP
|