Use RAII for packet memory

programs/ping/src/main.cpp

@@ -108,10 +108,6 @@ int main(int argc, char* argv[]) {
                     tlib::printf("Reply received from %s\n", ip.c_str());
                     handled = true;
                 }
-
-                // The rest of the packets are simply ignored
-
-                tlib::release_packet(p);
             }
 
             if (handled) {

tlib/include/tlib/net.hpp

@@ -12,26 +12,37 @@
 
 #include "tlib/net_constants.hpp"
 #include "tlib/config.hpp"
+#include "tlib/malloc.hpp"
 
 ASSERT_ONLY_THOR_PROGRAM
 
 namespace tlib {
 
 struct packet {
-    size_t fd;
-    char* payload;
-    size_t index;
+    size_t fd;     ///< The packet file descriptor
+    char* payload; ///< The payload pointer
+    size_t index;  ///< The index at which to read or write
+
+    packet();
+
+    packet(const packet& p) = delete;
+    packet& operator=(const packet& p) = delete;
+
+    packet(packet&& rhs);
+
+    packet& operator=(packet&& rhs);
+
+    ~packet();
 };
 
 std::expected<size_t> socket_open(socket_domain domain, socket_type type, socket_protocol protocol);
 void socket_close(size_t socket_fd);
 
 std::expected<packet> prepare_packet(size_t socket_fd, void* desc);
-std::expected<void> finalize_packet(size_t socket_fd, packet p);
+std::expected<void> finalize_packet(size_t socket_fd, const packet& p);
 std::expected<void> listen(size_t socket_fd, bool l);
 std::expected<packet> wait_for_packet(size_t socket_fd);
 std::expected<packet> wait_for_packet(size_t socket_fd, size_t ms);
-void release_packet(packet& packet);
 
 struct socket {
     socket(socket_domain domain, socket_type type, socket_protocol protocol);
@@ -69,7 +80,7 @@ struct socket {
     void listen(bool l);
 
     packet prepare_packet(void* desc);
-    void finalize_packet(packet p);
+    void finalize_packet(const packet& p);
     packet wait_for_packet();
     packet wait_for_packet(size_t ms);
 

tlib/src/net.cpp

@@ -8,6 +8,32 @@
 #include "tlib/net.hpp"
 #include "tlib/malloc.hpp"
 
+tlib::packet::packet() : fd(0), payload(nullptr), index(0) {
+    //Nothing else to init
+}
+
+tlib::packet::packet(packet&& rhs) : fd(rhs.fd), payload(rhs.payload), index(rhs.index) {
+    rhs.payload = nullptr;
+}
+
+tlib::packet& tlib::packet::operator=(packet&& rhs) {
+    if (this != &rhs) {
+        this->fd      = rhs.fd;
+        this->payload = rhs.payload;
+        this->index   = rhs.index;
+
+        rhs.payload = nullptr;
+    }
+
+    return *this;
+}
+
+tlib::packet::~packet() {
+    if (payload) {
+        tlib::free(payload);
+    }
+}
+
 std::expected<size_t> tlib::socket_open(socket_domain domain, socket_type type, socket_protocol protocol) {
     int64_t fd;
     asm volatile("mov rax, 0x3000; mov rbx, %[type]; mov rcx, %[type]; mov rdx, %[protocol]; int 50; mov %[fd], rax"
@@ -46,11 +72,11 @@ std::expected<tlib::packet> tlib::prepare_packet(size_t socket_fd, void* desc) {
         p.fd      = fd;
         p.index   = index;
         p.payload = static_cast<char*>(buffer);
-        return std::make_expected<packet>(p);
+        return std::make_expected<packet>(std::move(p));
     }
 }
 
-std::expected<void> tlib::finalize_packet(size_t socket_fd, tlib::packet p) {
+std::expected<void> tlib::finalize_packet(size_t socket_fd, const tlib::packet& p) {
     auto packet_fd = p.fd;
 
     int64_t code;
@@ -64,8 +90,6 @@ std::expected<void> tlib::finalize_packet(size_t socket_fd, tlib::packet p) {
     } else {
         return std::make_expected();
     }
-
-    free(p.payload);
 }
 
 std::expected<void> tlib::listen(size_t socket_fd, bool l) {
@@ -99,7 +123,7 @@ std::expected<tlib::packet> tlib::wait_for_packet(size_t socket_fd) {
         tlib::packet p;
         p.index   = code;
         p.payload = reinterpret_cast<char*>(payload);
-        return std::make_expected<packet>(p);
+        return std::make_expected<packet>(std::move(p));
     }
 }
 
@@ -120,13 +144,7 @@ std::expected<tlib::packet> tlib::wait_for_packet(size_t socket_fd, size_t ms) {
         tlib::packet p;
         p.index   = code;
         p.payload = reinterpret_cast<char*>(payload);
-        return std::make_expected<packet>(p);
-    }
-}
-
-void tlib::release_packet(packet& packet) {
-    if (packet.payload) {
-        free(packet.payload);
+        return std::make_expected<packet>(std::move(p));
     }
 }
 
@@ -189,11 +207,11 @@ tlib::packet tlib::socket::prepare_packet(void* desc) {
         error_code = packet.error();
         return tlib::packet();
     } else {
-        return *packet;
+        return std::move(*packet);
     }
 }
 
-void tlib::socket::finalize_packet(tlib::packet p) {
+void tlib::socket::finalize_packet(const tlib::packet& p) {
     if (!good() || !open()) {
         return;
     }
@@ -215,7 +233,7 @@ tlib::packet tlib::socket::wait_for_packet() {
         error_code = p.error();
         return tlib::packet();
     } else {
-        return *p;
+        return std::move(*p);
     }
 }
 
@@ -230,6 +248,6 @@ tlib::packet tlib::socket::wait_for_packet(size_t ms) {
         error_code = p.error();
         return tlib::packet();
     } else {
-        return *p;
+        return std::move(*p);
     }
 }