Revert "Merge pull request #7136"

This reverts commit 63c7ca07fba2f063c760f786a986fb3e02fb040e, reversing
changes made to 2218e23e84a89e9a1e4c0be5d50f891ab836754f.

3 files changed, 24 insertions, 118 deletions

diff --git a/tests/unit_tests/epee_boosted_tcp_server.cpp b/tests/unit_tests/epee_boosted_tcp_server.cpp
index 84fc0a29b..457c05c15 100644
--- a/tests/unit_tests/epee_boosted_tcp_server.cpp
+++ b/tests/unit_tests/epee_boosted_tcp_server.cpp
@@ -153,7 +153,7 @@ TEST(test_epee_connection, test_lifetime)
       delay(delay),
       on_connection_close_f(on_connection_close_f)
     {}
-    virtual int invoke(int, const epee::span<const uint8_t>, epee::byte_stream&, context_t&) override { epee::misc_utils::sleep_no_w(delay); return {}; }
+    virtual int invoke(int, const epee::span<const uint8_t>, epee::byte_slice&, context_t&) override { epee::misc_utils::sleep_no_w(delay); return {}; }
     virtual int notify(int, const epee::span<const uint8_t>, context_t&) override { return {}; }
     virtual void callback(context_t&) override {}
     virtual void on_connection_new(context_t&) override {}
@@ -282,7 +282,7 @@ TEST(test_epee_connection, test_lifetime)
     for (auto i = 0; i < N; ++i) {
       tag = create_connection();
       ASSERT_TRUE(shared_state->get_connections_count() == 1);
-      success = shared_state->invoke_async(1, epee::levin::message_writer{}, tag, [](int, const epee::span<const uint8_t>, context_t&){}, TIMEOUT);
+      success = shared_state->invoke_async(1, {}, tag, [](int, const epee::span<const uint8_t>, context_t&){}, TIMEOUT);
       ASSERT_TRUE(success);
       while (shared_state->sock_count == 1) {
         success = shared_state->foreach_connection([&shared_state, &tag](context_t&){
diff --git a/tests/unit_tests/epee_levin_protocol_handler_async.cpp b/tests/unit_tests/epee_levin_protocol_handler_async.cpp
index d9de99b8b..a499fa608 100644
--- a/tests/unit_tests/epee_levin_protocol_handler_async.cpp
+++ b/tests/unit_tests/epee_levin_protocol_handler_async.cpp
@@ -59,13 +59,13 @@ namespace
     {
     }
 
-    virtual int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, test_levin_connection_context& context)
+    virtual int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_slice& buff_out, test_levin_connection_context& context)
     {
       m_invoke_counter.inc();
       boost::unique_lock<boost::mutex> lock(m_mutex);
       m_last_command = command;
       m_last_in_buf = std::string((const char*)in_buff.data(), in_buff.size());
-      buff_out.write(epee::to_span(m_invoke_out_buf));
+      buff_out = m_invoke_out_buf.clone();
       return m_return_code;
     }
 
@@ -434,11 +434,8 @@ TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_process
   const int expected_command = 4673261;
   const std::string in_data(256, 'e');
 
-  epee::levin::message_writer message{};
-  message.buffer.write(epee::to_span(in_data));
-
   const epee::byte_slice noise = epee::levin::make_noise_notify(1024);
-  const epee::byte_slice notify = message.finalize_notify(expected_command);
+  const epee::byte_slice notify = epee::levin::make_notify(expected_command, epee::strspan<std::uint8_t>(in_data));
 
   test_connection_ptr conn = create_connection();
 
@@ -471,16 +468,11 @@ TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_process
   const int expected_command = 4673261;
   const int expected_fragmented_command = 46732;
   const std::string in_data(256, 'e');
-
-  epee::levin::message_writer message{};
-  message.buffer.write(epee::to_span(in_data));
-
-  epee::levin::message_writer in_fragmented_data;
-  in_fragmented_data.buffer.put_n('c', 1024 * 4);
+  std::string in_fragmented_data(1024 * 4, 'c');
 
   const epee::byte_slice noise = epee::levin::make_noise_notify(1024);
-  const epee::byte_slice notify = message.finalize_notify(expected_command);
-  epee::byte_slice fragmented = epee::levin::make_fragmented_notify(noise.size(), expected_fragmented_command, std::move(in_fragmented_data));
+  const epee::byte_slice notify = epee::levin::make_notify(expected_command, epee::strspan<std::uint8_t>(in_data));
+  epee::byte_slice fragmented = epee::levin::make_fragmented_notify(noise, expected_fragmented_command, epee::strspan<std::uint8_t>(in_fragmented_data));
 
   EXPECT_EQ(5u, fragmented.size() / 1024);
   EXPECT_EQ(0u, fragmented.size() % 1024);
@@ -505,13 +497,11 @@ TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_process
     ASSERT_TRUE(conn->m_protocol_handler.handle_recv(next.data(), next.size()));
   }
 
-  std::string compare_buffer(1024 * 4, 'c');
-  compare_buffer.resize(((1024 - sizeof(epee::levin::bucket_head2)) * 5) - sizeof(epee::levin::bucket_head2)); // add padding zeroes
-
+  in_fragmented_data.resize(((1024 - sizeof(epee::levin::bucket_head2)) * 5) - sizeof(epee::levin::bucket_head2)); // add padding zeroes
   ASSERT_EQ(4u, m_commands_handler.notify_counter());
   ASSERT_EQ(0u, m_commands_handler.invoke_counter());
   ASSERT_EQ(expected_fragmented_command, m_commands_handler.last_command());
-  ASSERT_EQ(compare_buffer, m_commands_handler.last_in_buf());
+  ASSERT_EQ(in_fragmented_data, m_commands_handler.last_in_buf());
   ASSERT_EQ(0u, conn->send_counter());
   ASSERT_TRUE(conn->last_send_data().empty());
 
diff --git a/tests/unit_tests/levin.cpp b/tests/unit_tests/levin.cpp
index 30d6f8133..eee9e224d 100644
--- a/tests/unit_tests/levin.cpp
+++ b/tests/unit_tests/levin.cpp
@@ -245,9 +245,9 @@ namespace
             return out;
         }
 
-        virtual int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, cryptonote::levin::detail::p2p_context& context) override final
+        virtual int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_slice& buff_out, cryptonote::levin::detail::p2p_context& context) override final
         {
-            buff_out.clear();
+            buff_out = nullptr;
             invoked_.push_back(
                 {context.m_connection_id, command, std::string{reinterpret_cast<const char*>(in_buff.data()), in_buff.size()}}
             );
@@ -384,50 +384,21 @@ TEST(make_header, expect_return)
     EXPECT_EQ(0u, header1.m_flags);
 }
 
-TEST(message_writer, invoke_with_empty_payload)
+TEST(make_notify, empty_payload)
 {
-    const epee::byte_slice message = epee::levin::message_writer{}.finalize_invoke(443);
-    const epee::levin::bucket_head2 header =
-        epee::levin::make_header(443, 0, LEVIN_PACKET_REQUEST, true);
-    ASSERT_EQ(sizeof(header), message.size());
-    EXPECT_TRUE(std::memcmp(std::addressof(header), message.data(), sizeof(header)) == 0);
-}
-
-TEST(message_writer, invoke_with_payload)
-{
-    std::string bytes(100, 'a');
-    std::generate(bytes.begin(), bytes.end(), crypto::random_device{});
-
-    epee::levin::message_writer writer{};
-    writer.buffer.write(epee::to_span(bytes));
-
-    const epee::byte_slice message = writer.finalize_invoke(443);
-    const epee::levin::bucket_head2 header =
-        epee::levin::make_header(443, bytes.size(), LEVIN_PACKET_REQUEST, true);
-
-    ASSERT_EQ(sizeof(header) + bytes.size(), message.size());
-    EXPECT_TRUE(std::memcmp(std::addressof(header), message.data(), sizeof(header)) == 0);
-    EXPECT_TRUE(std::memcmp(bytes.data(), message.data() + sizeof(header), bytes.size()) == 0);
-}
-
-TEST(message_writer, notify_with_empty_payload)
-{
-    const epee::byte_slice message = epee::levin::message_writer{}.finalize_notify(443);
+    const epee::byte_slice message = epee::levin::make_notify(443, nullptr);
     const epee::levin::bucket_head2 header =
         epee::levin::make_header(443, 0, LEVIN_PACKET_REQUEST, false);
     ASSERT_EQ(sizeof(header), message.size());
     EXPECT_TRUE(std::memcmp(std::addressof(header), message.data(), sizeof(header)) == 0);
 }
 
-TEST(message_writer, notify_with_payload)
+TEST(make_notify, with_payload)
 {
     std::string bytes(100, 'a');
     std::generate(bytes.begin(), bytes.end(), crypto::random_device{});
 
-    epee::levin::message_writer writer{};
-    writer.buffer.write(epee::to_span(bytes));
-
-    const epee::byte_slice message = writer.finalize_notify(443);
+    const epee::byte_slice message = epee::levin::make_notify(443, epee::strspan<std::uint8_t>(bytes));
     const epee::levin::bucket_head2 header =
         epee::levin::make_header(443, bytes.size(), LEVIN_PACKET_REQUEST, false);
 
@@ -436,44 +407,6 @@ TEST(message_writer, notify_with_payload)
     EXPECT_TRUE(std::memcmp(bytes.data(), message.data() + sizeof(header), bytes.size()) == 0);
 }
 
-TEST(message_writer, response_with_empty_payload)
-{
-    const epee::byte_slice message = epee::levin::message_writer{}.finalize_response(443, 1);
-    epee::levin::bucket_head2 header =
-        epee::levin::make_header(443, 0, LEVIN_PACKET_RESPONSE, false);
-    header.m_return_code = SWAP32LE(1);
-    ASSERT_EQ(sizeof(header), message.size());
-    EXPECT_TRUE(std::memcmp(std::addressof(header), message.data(), sizeof(header)) == 0);
-}
-
-TEST(message_writer, response_with_payload)
-{
-    std::string bytes(100, 'a');
-    std::generate(bytes.begin(), bytes.end(), crypto::random_device{});
-
-    epee::levin::message_writer writer{};
-    writer.buffer.write(epee::to_span(bytes));
-
-    const epee::byte_slice message = writer.finalize_response(443, 6450);
-    epee::levin::bucket_head2 header =
-        epee::levin::make_header(443, bytes.size(), LEVIN_PACKET_RESPONSE, false);
-    header.m_return_code = SWAP32LE(6450);
-
-    ASSERT_EQ(sizeof(header) + bytes.size(), message.size());
-    EXPECT_TRUE(std::memcmp(std::addressof(header), message.data(), sizeof(header)) == 0);
-    EXPECT_TRUE(std::memcmp(bytes.data(), message.data() + sizeof(header), bytes.size()) == 0);
-}
-
-TEST(message_writer, error)
-{
-    epee::levin::message_writer writer{};
-    writer.buffer.clear();
-
-    EXPECT_THROW(writer.finalize_invoke(0), std::runtime_error);
-    EXPECT_THROW(writer.finalize_notify(0), std::runtime_error);
-    EXPECT_THROW(writer.finalize_response(0, 0), std::runtime_error);
-}
-
 TEST(make_noise, invalid)
 {
     EXPECT_TRUE(epee::levin::make_noise_notify(sizeof(epee::levin::bucket_head2) - 1).empty());
@@ -495,13 +428,13 @@ TEST(make_noise, valid)
 
 TEST(make_fragment, invalid)
 {
-    EXPECT_TRUE(epee::levin::make_fragmented_notify(0, 0, epee::levin::message_writer{}).empty());
+    EXPECT_TRUE(epee::levin::make_fragmented_notify(nullptr, 0, nullptr).empty());
 }
 
 TEST(make_fragment, single)
 {
     const epee::byte_slice noise = epee::levin::make_noise_notify(1024);
-    const epee::byte_slice fragment = epee::levin::make_fragmented_notify(noise.size(), 11, epee::levin::message_writer{});
+    const epee::byte_slice fragment = epee::levin::make_fragmented_notify(noise, 11, nullptr);
     const epee::levin::bucket_head2 header =
         epee::levin::make_header(11, 1024 - sizeof(epee::levin::bucket_head2), LEVIN_PACKET_REQUEST, false);
 
@@ -516,13 +449,8 @@ TEST(make_fragment, multiple)
     std::string bytes(1024 * 3 - 150, 'a');
     std::generate(bytes.begin(), bytes.end(), crypto::random_device{});
 
-    epee::levin::message_writer message;
-    message.buffer.write(epee::to_span(bytes));
-
     const epee::byte_slice noise = epee::levin::make_noise_notify(1024);
-    epee::byte_slice fragment = epee::levin::make_fragmented_notify(noise.size(), 114, std::move(message));
-
-    EXPECT_EQ(1024 * 3, fragment.size());
+    epee::byte_slice fragment = epee::levin::make_fragmented_notify(noise, 114, epee::strspan<std::uint8_t>(bytes));
 
     epee::levin::bucket_head2 header =
         epee::levin::make_header(0, 1024 - sizeof(epee::levin::bucket_head2), LEVIN_PACKET_BEGIN, false);
@@ -569,7 +497,6 @@ TEST(make_fragment, multiple)
 
     fragment.take_slice(bytes.size());
 
-    EXPECT_EQ(18, fragment.size());
     EXPECT_EQ(18, std::count(fragment.cbegin(), fragment.cend(), 0));
 }
 
@@ -2237,31 +2164,20 @@ TEST_F(levin_notify, command_max_bytes)
 
     add_connection(true);
 
-    std::string payload(4096, 'h');
-    epee::byte_slice bytes;
-    {
-        epee::levin::message_writer dest{};
-        dest.buffer.write(epee::to_span(payload));
-        bytes = dest.finalize_notify(ping_command);
-    }
+    std::string bytes(4096, 'h');
 
-    EXPECT_EQ(1, get_connections().send(bytes.clone(), contexts_.front().get_id()));
+    EXPECT_EQ(1, get_connections().notify(ping_command, epee::strspan<std::uint8_t>(bytes), contexts_.front().get_id()));
     EXPECT_EQ(1u, contexts_.front().process_send_queue(true));
     EXPECT_EQ(1u, receiver_.notified_size());
 
     const received_message msg = receiver_.get_raw_notification();
     EXPECT_EQ(ping_command, msg.command);
     EXPECT_EQ(contexts_.front().get_id(), msg.connection);
-    EXPECT_EQ(payload, msg.payload);
+    EXPECT_EQ(bytes, msg.payload);
 
-    {
-        payload.push_back('h');
-        epee::levin::message_writer dest{};
-        dest.buffer.write(epee::to_span(payload));
-        bytes = dest.finalize_notify(ping_command);
-    }
+    bytes.push_back('e');
 
-    EXPECT_EQ(1, get_connections().send(std::move(bytes), contexts_.front().get_id()));
+    EXPECT_EQ(1, get_connections().notify(ping_command, epee::strspan<std::uint8_t>(bytes), contexts_.front().get_id()));
     EXPECT_EQ(1u, contexts_.front().process_send_queue(false));
     EXPECT_EQ(0u, receiver_.notified_size());
 }