From 2e1f21b2a132ba287e4466924aefc5d59406c31b Mon Sep 17 00:00:00 2001 From: Thiago Silva Date: Fri, 3 Mar 2023 14:45:50 -0300 Subject: [PATCH] Remove message_parser class --- nano/node/messages.cpp | 283 ----------------------------------------- nano/node/messages.hpp | 40 ------ 2 files changed, 323 deletions(-) diff --git a/nano/node/messages.cpp b/nano/node/messages.cpp index 08a2796d..cc5591cd 100644 --- a/nano/node/messages.cpp +++ b/nano/node/messages.cpp @@ -385,289 +385,6 @@ nano::message_type nano::message::type () const return header.type; } -/* - * message_parser - */ - -// MTU - IP header - UDP header -std::size_t const nano::message_parser::max_safe_udp_message_size = 508; - -std::string nano::message_parser::status_string () -{ - switch (status) - { - case nano::message_parser::parse_status::success: - { - return "success"; - } - case nano::message_parser::parse_status::insufficient_work: - { - return "insufficient_work"; - } - case nano::message_parser::parse_status::invalid_header: - { - return "invalid_header"; - } - case nano::message_parser::parse_status::invalid_message_type: - { - return "invalid_message_type"; - } - case nano::message_parser::parse_status::invalid_keepalive_message: - { - return "invalid_keepalive_message"; - } - case nano::message_parser::parse_status::invalid_publish_message: - { - return "invalid_publish_message"; - } - case nano::message_parser::parse_status::invalid_confirm_req_message: - { - return "invalid_confirm_req_message"; - } - case nano::message_parser::parse_status::invalid_confirm_ack_message: - { - return "invalid_confirm_ack_message"; - } - case nano::message_parser::parse_status::invalid_node_id_handshake_message: - { - return "invalid_node_id_handshake_message"; - } - case nano::message_parser::parse_status::invalid_telemetry_req_message: - { - return "invalid_telemetry_req_message"; - } - case nano::message_parser::parse_status::invalid_telemetry_ack_message: - { - return "invalid_telemetry_ack_message"; - } - case nano::message_parser::parse_status::outdated_version: - { - return "outdated_version"; - } - case nano::message_parser::parse_status::duplicate_publish_message: - { - return "duplicate_publish_message"; - } - } - - debug_assert (false); - - return "[unknown parse_status]"; -} - -nano::message_parser::message_parser (nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a, nano::network_constants const & network) : - publish_filter (publish_filter_a), - block_uniquer (block_uniquer_a), - vote_uniquer (vote_uniquer_a), - visitor (visitor_a), - pool (pool_a), - status (parse_status::success), - network{ network } -{ -} - -void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, std::size_t size_a) -{ - status = parse_status::success; - auto error (false); - if (size_a <= max_safe_udp_message_size) - { - // Guaranteed to be deliverable - nano::bufferstream stream (buffer_a, size_a); - nano::message_header header (error, stream); - if (!error) - { - if (header.network != network.current_network) - { - status = parse_status::invalid_header; - return; - } - - if (header.version_using < network.protocol_version_min) - { - status = parse_status::outdated_version; - } - else - { - switch (header.type) - { - case nano::message_type::keepalive: - { - deserialize_keepalive (stream, header); - break; - } - case nano::message_type::publish: - { - nano::uint128_t digest; - if (!publish_filter.apply (buffer_a + header.size, size_a - header.size, &digest)) - { - deserialize_publish (stream, header, digest); - } - else - { - status = parse_status::duplicate_publish_message; - } - break; - } - case nano::message_type::confirm_req: - { - deserialize_confirm_req (stream, header); - break; - } - case nano::message_type::confirm_ack: - { - deserialize_confirm_ack (stream, header); - break; - } - case nano::message_type::node_id_handshake: - { - deserialize_node_id_handshake (stream, header); - break; - } - case nano::message_type::telemetry_req: - { - deserialize_telemetry_req (stream, header); - break; - } - case nano::message_type::telemetry_ack: - { - deserialize_telemetry_ack (stream, header); - break; - } - default: - { - status = parse_status::invalid_message_type; - break; - } - } - } - } - else - { - status = parse_status::invalid_header; - } - } -} - -void nano::message_parser::deserialize_keepalive (nano::stream & stream_a, nano::message_header const & header_a) -{ - auto error (false); - nano::keepalive incoming (error, stream_a, header_a); - if (!error && at_end (stream_a)) - { - visitor.keepalive (incoming); - } - else - { - status = parse_status::invalid_keepalive_message; - } -} - -void nano::message_parser::deserialize_publish (nano::stream & stream_a, nano::message_header const & header_a, nano::uint128_t const & digest_a) -{ - auto error (false); - nano::publish incoming (error, stream_a, header_a, digest_a, &block_uniquer); - if (!error && at_end (stream_a)) - { - if (!network.work.validate_entry (*incoming.block)) - { - visitor.publish (incoming); - } - else - { - status = parse_status::insufficient_work; - } - } - else - { - status = parse_status::invalid_publish_message; - } -} - -void nano::message_parser::deserialize_confirm_req (nano::stream & stream_a, nano::message_header const & header_a) -{ - auto error (false); - nano::confirm_req incoming (error, stream_a, header_a, &block_uniquer); - if (!error && at_end (stream_a)) - { - if (incoming.block == nullptr || !network.work.validate_entry (*incoming.block)) - { - visitor.confirm_req (incoming); - } - else - { - status = parse_status::insufficient_work; - } - } - else - { - status = parse_status::invalid_confirm_req_message; - } -} - -void nano::message_parser::deserialize_confirm_ack (nano::stream & stream_a, nano::message_header const & header_a) -{ - auto error (false); - nano::confirm_ack incoming (error, stream_a, header_a, &vote_uniquer); - if (!error && at_end (stream_a)) - { - visitor.confirm_ack (incoming); - } - else - { - status = parse_status::invalid_confirm_ack_message; - } -} - -void nano::message_parser::deserialize_node_id_handshake (nano::stream & stream_a, nano::message_header const & header_a) -{ - bool error_l (false); - nano::node_id_handshake incoming (error_l, stream_a, header_a); - if (!error_l && at_end (stream_a)) - { - visitor.node_id_handshake (incoming); - } - else - { - status = parse_status::invalid_node_id_handshake_message; - } -} - -void nano::message_parser::deserialize_telemetry_req (nano::stream & stream_a, nano::message_header const & header_a) -{ - nano::telemetry_req incoming (header_a); - if (at_end (stream_a)) - { - visitor.telemetry_req (incoming); - } - else - { - status = parse_status::invalid_telemetry_req_message; - } -} - -void nano::message_parser::deserialize_telemetry_ack (nano::stream & stream_a, nano::message_header const & header_a) -{ - bool error_l (false); - nano::telemetry_ack incoming (error_l, stream_a, header_a); - // Intentionally not checking if at the end of stream, because these messages support backwards/forwards compatibility - if (!error_l) - { - visitor.telemetry_ack (incoming); - } - else - { - status = parse_status::invalid_telemetry_ack_message; - } -} - -bool nano::message_parser::at_end (nano::stream & stream_a) -{ - uint8_t junk; - auto end (nano::try_read (stream_a, junk)); - return end; -} - /* * keepalive */ diff --git a/nano/node/messages.hpp b/nano/node/messages.hpp index 55222546..953350d1 100644 --- a/nano/node/messages.hpp +++ b/nano/node/messages.hpp @@ -116,46 +116,6 @@ public: class work_pool; class network_constants; -class message_parser final -{ -public: - enum class parse_status - { - success, - insufficient_work, - invalid_header, - invalid_message_type, - invalid_keepalive_message, - invalid_publish_message, - invalid_confirm_req_message, - invalid_confirm_ack_message, - invalid_node_id_handshake_message, - invalid_telemetry_req_message, - invalid_telemetry_ack_message, - outdated_version, - duplicate_publish_message - }; - message_parser (nano::network_filter &, nano::block_uniquer &, nano::vote_uniquer &, nano::message_visitor &, nano::work_pool &, nano::network_constants const & protocol); - void deserialize_buffer (uint8_t const *, std::size_t); - void deserialize_keepalive (nano::stream &, nano::message_header const &); - void deserialize_publish (nano::stream &, nano::message_header const &, nano::uint128_t const & = 0); - void deserialize_confirm_req (nano::stream &, nano::message_header const &); - void deserialize_confirm_ack (nano::stream &, nano::message_header const &); - void deserialize_node_id_handshake (nano::stream &, nano::message_header const &); - void deserialize_telemetry_req (nano::stream &, nano::message_header const &); - void deserialize_telemetry_ack (nano::stream &, nano::message_header const &); - bool at_end (nano::stream &); - nano::network_filter & publish_filter; - nano::block_uniquer & block_uniquer; - nano::vote_uniquer & vote_uniquer; - nano::message_visitor & visitor; - nano::work_pool & pool; - parse_status status; - nano::network_constants const & network; - std::string status_string (); - static std::size_t const max_safe_udp_message_size; -}; - class keepalive final : public message { public: