From 56e865c6deefcc602fc050d7d4e2e04df04663c3 Mon Sep 17 00:00:00 2001
From: Baptiste Wicht <baptiste.wicht@gmail.com>
Date: Thu, 29 Sep 2016 09:47:05 +0200
Subject: [PATCH] Move packet out of ethernet

---
 kernel/include/net/arp_layer.hpp              |  4 ++--
 kernel/include/net/dhcp_layer.hpp             |  6 +++---
 kernel/include/net/dns_layer.hpp              |  8 ++++----
 kernel/include/net/ethernet_layer.hpp         |  2 +-
 kernel/include/net/icmp_layer.hpp             | 10 +++++-----
 kernel/include/net/interface.hpp              | 10 +++++-----
 kernel/include/net/ip_layer.hpp               | 10 +++++-----
 kernel/include/net/network.hpp                |  4 ++--
 .../net/{ethernet_packet.hpp => packet.hpp}   | 10 +++-------
 kernel/include/net/socket.hpp                 | 12 +++++------
 kernel/include/net/tcp_layer.hpp              | 16 +++++++--------
 kernel/include/net/udp_layer.hpp              | 12 +++++------
 kernel/src/drivers/loopback.cpp               |  2 +-
 kernel/src/drivers/rtl8139.cpp                |  4 ++--
 kernel/src/net/arp_layer.cpp                  |  2 +-
 kernel/src/net/dhcp_layer.cpp                 |  4 ++--
 kernel/src/net/dns_layer.cpp                  | 10 +++++-----
 kernel/src/net/ethernet_layer.cpp             | 10 +++++-----
 kernel/src/net/icmp_layer.cpp                 | 10 +++++-----
 kernel/src/net/ip_layer.cpp                   | 14 ++++++-------
 kernel/src/net/network.cpp                    |  4 ++--
 kernel/src/net/tcp_layer.cpp                  | 20 +++++++++----------
 kernel/src/net/udp_layer.cpp                  | 14 ++++++-------
 23 files changed, 97 insertions(+), 101 deletions(-)
 rename kernel/include/net/{ethernet_packet.hpp => packet.hpp} (89%)

diff --git a/kernel/include/net/arp_layer.hpp b/kernel/include/net/arp_layer.hpp
index 928f41e5..e928c678 100644
--- a/kernel/include/net/arp_layer.hpp
+++ b/kernel/include/net/arp_layer.hpp
@@ -14,7 +14,7 @@
 
 #include "tlib/net_constants.hpp"
 
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 #include "net/interface.hpp"
 #include "net/arp_cache.hpp"
 
@@ -55,7 +55,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     network::arp::cache& get_cache();
 
diff --git a/kernel/include/net/dhcp_layer.hpp b/kernel/include/net/dhcp_layer.hpp
index 1f60c035..f5aba232 100644
--- a/kernel/include/net/dhcp_layer.hpp
+++ b/kernel/include/net/dhcp_layer.hpp
@@ -13,7 +13,7 @@
 #include <atomic.hpp>
 
 #include "net/interface.hpp"
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 namespace network {
 
@@ -66,7 +66,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     /*!
      * \brief Request an IP address on the network
@@ -78,7 +78,7 @@ private:
     network::udp::layer* parent;
 
     std::atomic<bool> listening;
-    circular_buffer<network::ethernet::packet, 16> packets;
+    circular_buffer<network::packet, 16> packets;
     condition_variable listen_queue;
 };
 
diff --git a/kernel/include/net/dns_layer.hpp b/kernel/include/net/dns_layer.hpp
index 708424f5..d91ba062 100644
--- a/kernel/include/net/dns_layer.hpp
+++ b/kernel/include/net/dns_layer.hpp
@@ -12,7 +12,7 @@
 
 #include "tlib/net_constants.hpp"
 
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 #include "net/interface.hpp"
 
 namespace network {
@@ -36,7 +36,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     /*!
      * \brief Prepare a packet for the user
@@ -45,7 +45,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
+    std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
 
     /*!
      * \brief Finalize a prepared packet
@@ -53,7 +53,7 @@ struct layer {
      * \param p The packet to finalize
      * \return nothing or an error
      */
-    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
+    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
 
 private:
     network::udp::layer* parent;
diff --git a/kernel/include/net/ethernet_layer.hpp b/kernel/include/net/ethernet_layer.hpp
index ffec0b22..7e59071a 100644
--- a/kernel/include/net/ethernet_layer.hpp
+++ b/kernel/include/net/ethernet_layer.hpp
@@ -14,7 +14,7 @@
 #include "tlib/net_constants.hpp"
 
 #include "net/interface.hpp"
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 namespace network {
 
diff --git a/kernel/include/net/icmp_layer.hpp b/kernel/include/net/icmp_layer.hpp
index 778c88b0..873183d8 100644
--- a/kernel/include/net/icmp_layer.hpp
+++ b/kernel/include/net/icmp_layer.hpp
@@ -14,7 +14,7 @@
 #include "tlib/net_constants.hpp"
 
 #include "net/interface.hpp"
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 namespace network {
 
@@ -37,7 +37,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     /*!
      * \brief Prepare a packet for the kernel
@@ -45,7 +45,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor);
+    std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor);
 
     /*!
      * \brief Prepare a packet for the user
@@ -54,7 +54,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
+    std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
 
     /*!
      * \brief Finalize a prepared packet
@@ -62,7 +62,7 @@ struct layer {
      * \param p The packet to finalize
      * \return nothing or an error
      */
-    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
+    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
 
 private:
     network::ip::layer* parent;
diff --git a/kernel/include/net/interface.hpp b/kernel/include/net/interface.hpp
index 4429a2cf..4c7286a1 100644
--- a/kernel/include/net/interface.hpp
+++ b/kernel/include/net/interface.hpp
@@ -17,7 +17,7 @@
 #include "conc/semaphore.hpp"
 #include "conc/deferred_unique_semaphore.hpp"
 
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 #include "tlib/net_constants.hpp"
 
@@ -49,15 +49,15 @@ struct interface_descriptor {
     mutable semaphore tx_sem;                 ///< Semaphore for transmission
     mutable deferred_unique_semaphore rx_sem; ///< Semaphore for reception
 
-    circular_buffer<ethernet::packet, 32> rx_queue; ///< The reception queue
-    circular_buffer<ethernet::packet, 32> tx_queue; ///< The transmission queue
+    circular_buffer<packet, 32> rx_queue; ///< The reception queue
+    circular_buffer<packet, 32> tx_queue; ///< The transmission queue
 
-    void (*hw_send)(interface_descriptor&, ethernet::packet& p); ///< Driver hardware send function
+    void (*hw_send)(interface_descriptor&, packet& p); ///< Driver hardware send function
 
     /*!
      * \brief Send a packet through this interface
      */
-    void send(ethernet::packet& p){
+    void send(packet& p){
         std::lock_guard<mutex> l(tx_lock);
         tx_queue.push(p);
         tx_sem.unlock();
diff --git a/kernel/include/net/ip_layer.hpp b/kernel/include/net/ip_layer.hpp
index 6ecc70f8..39baa83f 100644
--- a/kernel/include/net/ip_layer.hpp
+++ b/kernel/include/net/ip_layer.hpp
@@ -14,7 +14,7 @@
 #include "tlib/net_constants.hpp"
 
 #include "net/interface.hpp"
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 namespace network {
 
@@ -59,7 +59,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     /*!
      * \brief Prepare a packet for the kernel
@@ -67,7 +67,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& desc);
+    std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& desc);
 
     /*!
      * \brief Prepare a packet for the user
@@ -76,7 +76,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* desc);
+    std::expected<network::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* desc);
 
     /*!
      * \brief Finalize a prepared packet
@@ -84,7 +84,7 @@ struct layer {
      * \param p The packet to finalize
      * \return nothing or an error
      */
-    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
+    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
 
     void register_icmp_layer(network::icmp::layer* layer);
     void register_arp_layer(network::arp::layer* layer);
diff --git a/kernel/include/net/network.hpp b/kernel/include/net/network.hpp
index f20fe098..3ec95bf8 100644
--- a/kernel/include/net/network.hpp
+++ b/kernel/include/net/network.hpp
@@ -15,7 +15,7 @@
 #include "tlib/net_constants.hpp"
 
 #include "net/interface.hpp"
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 namespace network {
 
@@ -229,7 +229,7 @@ std::expected<size_t> wait_for_packet(char* buffer, socket_fd_t socket_fd, size_
  * \param packet The packet to propagate
  * \param protocol The destination protocol
  */
-void propagate_packet(const ethernet::packet& packet, socket_protocol protocol);
+void propagate_packet(const packet& packet, socket_protocol protocol);
 
 /*!
  * \brief Return the IP address of the DNS server
diff --git a/kernel/include/net/ethernet_packet.hpp b/kernel/include/net/packet.hpp
similarity index 89%
rename from kernel/include/net/ethernet_packet.hpp
rename to kernel/include/net/packet.hpp
index f8906800..89cb0f74 100644
--- a/kernel/include/net/ethernet_packet.hpp
+++ b/kernel/include/net/packet.hpp
@@ -5,8 +5,8 @@
 //  http://www.opensource.org/licenses/MIT)
 //=======================================================================
 
-#ifndef NET_ETHERNET_PACKET_H
-#define NET_ETHERNET_PACKET_H
+#ifndef NET_PACKET_H
+#define NET_PACKET_H
 
 #include <types.hpp>
 
@@ -14,10 +14,8 @@
 
 namespace network {
 
-namespace ethernet {
-
 /*!
- * \brief A packet on the ethernet layer
+ * \brief A network packet.
  */
 struct packet {
     // Set from the beginning
@@ -45,8 +43,6 @@ struct packet {
     }
 };
 
-} // end of ethernet namespace
-
 } // end of network namespace
 
 #endif
diff --git a/kernel/include/net/socket.hpp b/kernel/include/net/socket.hpp
index 1ce744c7..897fe452 100644
--- a/kernel/include/net/socket.hpp
+++ b/kernel/include/net/socket.hpp
@@ -18,7 +18,7 @@
 
 #include "conc/condition_variable.hpp"
 
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 
 #include "assert.hpp"
 
@@ -36,9 +36,9 @@ struct socket {
     bool listen;                     ///< Indicates if the socket is listening to packets
     void* connection_data = nullptr; ///< Optional pointer to the connection data (TCP/UDP)
 
-    std::vector<network::ethernet::packet> packets; ///< Packets that are prepared with their fd
+    std::vector<network::packet> packets; ///< Packets that are prepared with their fd
 
-    circular_buffer<network::ethernet::packet, 32> listen_packets; ///< The packets that wait to be read in listen mode
+    circular_buffer<network::packet, 32> listen_packets; ///< The packets that wait to be read in listen mode
     condition_variable listen_queue;                               ///< Condition variable to wait for packets
 
     socket() {}
@@ -63,7 +63,7 @@ struct socket {
      * \brief Register a new packet into the socket
      * \return The file descriptor of the packet
      */
-    size_t register_packet(network::ethernet::packet packet) {
+    size_t register_packet(network::packet packet) {
         auto fd = next_fd++;
 
         packet.fd = fd;
@@ -89,7 +89,7 @@ struct socket {
     /*!
      * \brief Returns the packet with the given file descriptor
      */
-    network::ethernet::packet& get_packet(size_t fd) {
+    network::packet& get_packet(size_t fd) {
         for (auto& packet : packets) {
             if (packet.fd == fd) {
                 return packet;
@@ -103,7 +103,7 @@ struct socket {
      * \brief Removes the packet with the given file descriptor
      */
     void erase_packet(size_t fd) {
-        packets.erase(std::remove_if(packets.begin(), packets.end(), [fd](network::ethernet::packet& packet) {
+        packets.erase(std::remove_if(packets.begin(), packets.end(), [fd](network::packet& packet) {
                           return packet.fd == fd;
                       }), packets.end());
     }
diff --git a/kernel/include/net/tcp_layer.hpp b/kernel/include/net/tcp_layer.hpp
index 38b4f48c..5580c3f7 100644
--- a/kernel/include/net/tcp_layer.hpp
+++ b/kernel/include/net/tcp_layer.hpp
@@ -14,7 +14,7 @@
 
 #include "conc/condition_variable.hpp"
 
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 #include "net/connection_handler.hpp"
 #include "net/interface.hpp"
 #include "net/socket.hpp"
@@ -34,7 +34,7 @@ struct tcp_connection {
 
     std::atomic<bool> listening;                            ///< Indicates if a kernel thread is listening on this connection
     condition_variable queue;                               ///< The listening queue
-    circular_buffer<network::ethernet::packet, 32> packets; ///< The packets for the listening queue
+    circular_buffer<network::packet, 32> packets; ///< The packets for the listening queue
 
     bool connected = false; ///< Indicate if the connection is connnected
     bool server    = false; ///< Indicate if the connection is a server (true) or a client (false)
@@ -63,7 +63,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     /*!
      * \brief Prepare a packet for the user
@@ -72,7 +72,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
+    std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
 
     /*!
      * \brief Finalize a prepared packet
@@ -80,7 +80,7 @@ struct layer {
      * \param p The packet to finalize
      * \return nothing or an error
      */
-    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::ethernet::packet& p);
+    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::packet& p);
 
     std::expected<void> send(char* target_buffer, network::socket& socket, const char* buffer, size_t n);
     std::expected<size_t> receive(char* buffer, network::socket& socket, size_t n);
@@ -93,9 +93,9 @@ struct layer {
     std::expected<void> disconnect(network::socket& socket);
 
 private:
-    std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size);
-    std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size);
-    std::expected<void> finalize_packet_direct(network::interface_descriptor& interface, network::ethernet::packet& p);
+    std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size);
+    std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size);
+    std::expected<void> finalize_packet_direct(network::interface_descriptor& interface, network::packet& p);
 
     network::ip::layer* parent;
 
diff --git a/kernel/include/net/udp_layer.hpp b/kernel/include/net/udp_layer.hpp
index 34ffe17f..81c250aa 100644
--- a/kernel/include/net/udp_layer.hpp
+++ b/kernel/include/net/udp_layer.hpp
@@ -14,7 +14,7 @@
 #include "tlib/net_constants.hpp"
 
 #include "net/interface.hpp"
-#include "net/ethernet_packet.hpp"
+#include "net/packet.hpp"
 #include "net/connection_handler.hpp"
 #include "net/socket.hpp"
 
@@ -71,7 +71,7 @@ struct layer {
      * \param interface The interface on which the packet was received
      * \param packet The packet to decode
      */
-    void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
+    void decode(network::interface_descriptor& interface, network::packet& packet);
 
     /*!
      * \brief Prepare a packet for the kernel
@@ -79,7 +79,7 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor);
+    std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor);
 
     /*!
      * \brief Prepare a packet for the user
@@ -88,9 +88,9 @@ struct layer {
      * \param descriptor The packet descriptor
      * \return the prepared packet or an error
      */
-    std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
+    std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
 
-    std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address);
+    std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address);
 
     /*!
      * \brief Finalize a prepared packet
@@ -98,7 +98,7 @@ struct layer {
      * \param p The packet to finalize
      * \return nothing or an error
      */
-    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
+    std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
 
     std::expected<size_t> client_bind(network::socket& socket, size_t server_port, network::ip::address server);
     std::expected<void> server_bind(network::socket& socket, size_t server_port, network::ip::address server);
diff --git a/kernel/src/drivers/loopback.cpp b/kernel/src/drivers/loopback.cpp
index bed7365a..47ef65e6 100644
--- a/kernel/src/drivers/loopback.cpp
+++ b/kernel/src/drivers/loopback.cpp
@@ -22,7 +22,7 @@ struct loopback_t {
     network::interface_descriptor* interface;
 };
 
-void send_packet(network::interface_descriptor& interface, network::ethernet::packet& packet){
+void send_packet(network::interface_descriptor& interface, network::packet& packet){
     logging::logf(logging::log_level::TRACE, "loopback: Transmit packet\n");
 
     auto packet_buffer = new char[packet.payload_size];
diff --git a/kernel/src/drivers/rtl8139.cpp b/kernel/src/drivers/rtl8139.cpp
index 2b928ab6..33eda05b 100644
--- a/kernel/src/drivers/rtl8139.cpp
+++ b/kernel/src/drivers/rtl8139.cpp
@@ -131,7 +131,7 @@ void packet_handler(interrupt::syscall_regs*, void* data){
 
                 std::copy_n(packet_payload, packet_only_length, packet_buffer);
 
-                network::ethernet::packet packet(packet_buffer, packet_only_length);
+                network::packet packet(packet_buffer, packet_only_length);
 
                 interface.rx_queue.push(packet);
                 interface.rx_sem.notify();
@@ -186,7 +186,7 @@ void packet_handler(interrupt::syscall_regs*, void* data){
     }
 }
 
-void send_packet(network::interface_descriptor& interface, network::ethernet::packet& packet){
+void send_packet(network::interface_descriptor& interface, network::packet& packet){
     logging::logf(logging::log_level::TRACE, "rtl8139: Start transmitting packet\n");
 
     auto* ether_header = reinterpret_cast<network::ethernet::header*>(packet.payload);
diff --git a/kernel/src/net/arp_layer.cpp b/kernel/src/net/arp_layer.cpp
index ef0a3ecd..6c527263 100644
--- a/kernel/src/net/arp_layer.cpp
+++ b/kernel/src/net/arp_layer.cpp
@@ -52,7 +52,7 @@ network::arp::layer::layer(network::ethernet::layer* parent) : parent(parent), _
     parent->register_arp_layer(this);
 }
 
-void network::arp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
+void network::arp::layer::decode(network::interface_descriptor& interface, network::packet& packet){
     packet.tag(1, packet.index);
 
     header* arp_header = reinterpret_cast<header*>(packet.payload + packet.index);
diff --git a/kernel/src/net/dhcp_layer.cpp b/kernel/src/net/dhcp_layer.cpp
index 38ad76e6..b1207e19 100644
--- a/kernel/src/net/dhcp_layer.cpp
+++ b/kernel/src/net/dhcp_layer.cpp
@@ -15,7 +15,7 @@
 
 namespace {
 
-void prepare_packet(network::ethernet::packet& packet, network::interface_descriptor& interface) {
+void prepare_packet(network::packet& packet, network::interface_descriptor& interface) {
     packet.tag(3, packet.index);
 
     // Set the DHCP header
@@ -54,7 +54,7 @@ network::dhcp::layer::layer(network::udp::layer* parent) : parent(parent) {
     parent->register_dhcp_layer(this);
 }
 
-void network::dhcp::layer::decode(network::interface_descriptor& /*interface*/, network::ethernet::packet& packet) {
+void network::dhcp::layer::decode(network::interface_descriptor& /*interface*/, network::packet& packet) {
     packet.tag(3, packet.index);
 
     logging::logf(logging::log_level::TRACE, "dhcp: Start DHCP packet handling\n");
diff --git a/kernel/src/net/dns_layer.cpp b/kernel/src/net/dns_layer.cpp
index 403d6616..b7e5f96d 100644
--- a/kernel/src/net/dns_layer.cpp
+++ b/kernel/src/net/dns_layer.cpp
@@ -26,7 +26,7 @@ using flag_ra     = std::bit_field<uint16_t, uint8_t, 7, 1>;
 using flag_zeroes = std::bit_field<uint16_t, uint8_t, 4, 3>;
 using flag_rcode  = std::bit_field<uint16_t, uint8_t, 0, 4>;
 
-void prepare_packet_query(network::ethernet::packet& packet, uint16_t identification) {
+void prepare_packet_query(network::packet& packet, uint16_t identification) {
     packet.tag(3, packet.index);
 
     // Set the DNS header
@@ -91,7 +91,7 @@ network::dns::layer::layer(network::udp::layer* parent) : parent(parent) {
     parent->register_dns_layer(this);
 }
 
-void network::dns::layer::decode(network::interface_descriptor& /*interface*/, network::ethernet::packet& packet) {
+void network::dns::layer::decode(network::interface_descriptor& /*interface*/, network::packet& packet) {
     packet.tag(3, packet.index);
 
     auto* dns_header = reinterpret_cast<header*>(packet.payload + packet.index);
@@ -199,10 +199,10 @@ void network::dns::layer::decode(network::interface_descriptor& /*interface*/, n
     // Note: Propagate is handled by UDP connections
 }
 
-std::expected<network::ethernet::packet> network::dns::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
+std::expected<network::packet> network::dns::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
     // Check the packet descriptor
     if(!descriptor->query){
-        return std::make_unexpected<network::ethernet::packet>(std::ERROR_SOCKET_INVALID_PACKET_DESCRIPTOR);
+        return std::make_unexpected<network::packet>(std::ERROR_SOCKET_INVALID_PACKET_DESCRIPTOR);
     }
 
     // Ask the UDP layer to craft a packet
@@ -216,7 +216,7 @@ std::expected<network::ethernet::packet> network::dns::layer::user_prepare_packe
     return packet;
 }
 
-std::expected<void> network::dns::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p) {
+std::expected<void> network::dns::layer::finalize_packet(network::interface_descriptor& interface, network::packet& p) {
     p.index -= sizeof(header);
 
     // Give the packet to the UDP layer for finalization
diff --git a/kernel/src/net/ethernet_layer.cpp b/kernel/src/net/ethernet_layer.cpp
index 579429da..7d520f48 100644
--- a/kernel/src/net/ethernet_layer.cpp
+++ b/kernel/src/net/ethernet_layer.cpp
@@ -45,7 +45,7 @@ uint16_t type_to_code(network::ethernet::ether_type type){
     return 0x0;
 }
 
-void prepare_packet(network::ethernet::packet& p, network::interface_descriptor& interface, const network::ethernet::packet_descriptor& descriptor){
+void prepare_packet(network::packet& p, network::interface_descriptor& interface, const network::ethernet::packet_descriptor& descriptor){
     p.tag(0, 0);
     p.index = sizeof(network::ethernet::header);
     p.interface = interface.id;
@@ -124,20 +124,20 @@ void network::ethernet::layer::decode(network::interface_descriptor& interface,
     logging::logf(logging::log_level::TRACE, "ethernet: Finished decoding packet\n");
 }
 
-std::expected<network::ethernet::packet> network::ethernet::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
+std::expected<network::packet> network::ethernet::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
     auto total_size = descriptor.size + sizeof(header);
 
-    network::ethernet::packet p(new char[total_size], total_size);
+    network::packet p(new char[total_size], total_size);
 
     ::prepare_packet(p, interface, descriptor);
 
     return p;
 }
 
-std::expected<network::ethernet::packet> network::ethernet::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
+std::expected<network::packet> network::ethernet::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
     auto total_size = descriptor->size + sizeof(header);
 
-    network::ethernet::packet p(buffer, total_size);
+    network::packet p(buffer, total_size);
     p.user = true;
 
     ::prepare_packet(p, interface, *descriptor);
diff --git a/kernel/src/net/icmp_layer.cpp b/kernel/src/net/icmp_layer.cpp
index 8164b192..38443fd3 100644
--- a/kernel/src/net/icmp_layer.cpp
+++ b/kernel/src/net/icmp_layer.cpp
@@ -38,7 +38,7 @@ void compute_checksum(network::icmp::header* icmp_header, size_t payload_size){
     icmp_header->checksum = ~value;
 }
 
-void prepare_packet(network::ethernet::packet& packet, network::icmp::type t, size_t code){
+void prepare_packet(network::packet& packet, network::icmp::type t, size_t code){
     packet.tag(2, packet.index);
 
     // Set the ICMP header
@@ -57,7 +57,7 @@ network::icmp::layer::layer(network::ip::layer* parent) : parent(parent) {
     parent->register_icmp_layer(this);
 }
 
-void network::icmp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
+void network::icmp::layer::decode(network::interface_descriptor& interface, network::packet& packet){
     packet.tag(2, packet.index);
 
     logging::logf(logging::log_level::TRACE, "icmp: Start ICMP packet handling\n");
@@ -116,7 +116,7 @@ void network::icmp::layer::decode(network::interface_descriptor& interface, netw
     network::propagate_packet(packet, network::socket_protocol::ICMP);
 }
 
-std::expected<network::ethernet::packet> network::icmp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
+std::expected<network::packet> network::icmp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
     // Ask the IP layer to craft a packet
     network::ip::packet_descriptor desc{sizeof(header) + descriptor.payload_size, descriptor.target_ip, 0x01};
     auto packet = parent->kernel_prepare_packet(interface, desc);
@@ -128,7 +128,7 @@ std::expected<network::ethernet::packet> network::icmp::layer::kernel_prepare_pa
     return packet;
 }
 
-std::expected<network::ethernet::packet> network::icmp::layer::user_prepare_packet(char* buffer, network::socket& /*socket*/, const packet_descriptor* descriptor){
+std::expected<network::packet> network::icmp::layer::user_prepare_packet(char* buffer, network::socket& /*socket*/, const packet_descriptor* descriptor){
     auto& interface = network::select_interface(descriptor->target_ip);
 
     // Ask the IP layer to craft a packet
@@ -142,7 +142,7 @@ std::expected<network::ethernet::packet> network::icmp::layer::user_prepare_pack
     return packet;
 }
 
-std::expected<void> network::icmp::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& packet){
+std::expected<void> network::icmp::layer::finalize_packet(network::interface_descriptor& interface, network::packet& packet){
     packet.index -= sizeof(header) - sizeof(uint32_t);
 
     auto* icmp_header = reinterpret_cast<header*>(packet.payload + packet.index);
diff --git a/kernel/src/net/ip_layer.cpp b/kernel/src/net/ip_layer.cpp
index 92d47dd3..ddf3eb0f 100644
--- a/kernel/src/net/ip_layer.cpp
+++ b/kernel/src/net/ip_layer.cpp
@@ -42,7 +42,7 @@ void compute_checksum(network::ip::header* header){
     header->header_checksum = ~uint16_t(value);
 }
 
-void prepare_packet(network::ethernet::packet& packet, network::interface_descriptor& interface, size_t size, network::ip::address target_ip, size_t protocol){
+void prepare_packet(network::packet& packet, network::interface_descriptor& interface, size_t size, network::ip::address target_ip, size_t protocol){
     packet.tag(1, packet.index);
 
     auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.index);
@@ -93,7 +93,7 @@ network::ip::layer::layer(network::ethernet::layer* parent) : parent(parent) {
     parent->register_ip_layer(this);
 }
 
-void network::ip::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
+void network::ip::layer::decode(network::interface_descriptor& interface, network::packet& packet){
     packet.tag(1, packet.index);
 
     header* ip_header = reinterpret_cast<header*>(packet.payload + packet.index);
@@ -138,11 +138,11 @@ void network::ip::layer::decode(network::interface_descriptor& interface, networ
     }
 }
 
-std::expected<network::ethernet::packet> network::ip::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
+std::expected<network::packet> network::ip::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
     auto target_mac = get_target_mac(interface, descriptor.destination);
 
     if(!target_mac){
-        return std::make_expected_from_error<network::ethernet::packet>(target_mac.error());
+        return std::make_expected_from_error<network::packet>(target_mac.error());
     }
 
     // Ask the ethernet layer to craft a packet
@@ -156,11 +156,11 @@ std::expected<network::ethernet::packet> network::ip::layer::kernel_prepare_pack
     return packet;
 }
 
-std::expected<network::ethernet::packet> network::ip::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
+std::expected<network::packet> network::ip::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
     auto target_mac = get_target_mac(interface, descriptor->destination);
 
     if(!target_mac){
-        return std::make_expected_from_error<network::ethernet::packet>(target_mac.error());
+        return std::make_expected_from_error<network::packet>(target_mac.error());
     }
 
     // Ask the ethernet layer to craft a packet
@@ -174,7 +174,7 @@ std::expected<network::ethernet::packet> network::ip::layer::user_prepare_packet
     return packet;
 }
 
-std::expected<void> network::ip::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p){
+std::expected<void> network::ip::layer::finalize_packet(network::interface_descriptor& interface, network::packet& p){
     // Send the packet to the ethernet layer
     return parent->finalize_packet(interface, p);
 }
diff --git a/kernel/src/net/network.cpp b/kernel/src/net/network.cpp
index ca99a5ed..60ca1c85 100644
--- a/kernel/src/net/network.cpp
+++ b/kernel/src/net/network.cpp
@@ -404,7 +404,7 @@ std::tuple<size_t, size_t> network::prepare_packet(socket_fd_t socket_fd, void*
 
     auto& socket = scheduler::get_socket(socket_fd);
 
-    auto return_from_packet = [&socket](std::expected<network::ethernet::packet>& packet) -> std::tuple<size_t, size_t> {
+    auto return_from_packet = [&socket](std::expected<network::packet>& packet) -> std::tuple<size_t, size_t> {
         if (packet) {
             auto fd = socket.register_packet(*packet);
 
@@ -926,7 +926,7 @@ std::expected<size_t> network::wait_for_packet(char* buffer, socket_fd_t socket_
     return {packet.index};
 }
 
-void network::propagate_packet(const ethernet::packet& packet, socket_protocol protocol){
+void network::propagate_packet(const packet& packet, socket_protocol protocol){
     // TODO Need something better for this
 
     for(size_t pid = 0; pid < scheduler::MAX_PROCESS; ++pid){
diff --git a/kernel/src/net/tcp_layer.cpp b/kernel/src/net/tcp_layer.cpp
index 3bb4d1f0..5cdd1ca5 100644
--- a/kernel/src/net/tcp_layer.cpp
+++ b/kernel/src/net/tcp_layer.cpp
@@ -35,7 +35,7 @@ using flag_rst         = std::bit_field<uint16_t, uint8_t, 2, 1>;
 using flag_syn         = std::bit_field<uint16_t, uint8_t, 1, 1>;
 using flag_fin         = std::bit_field<uint16_t, uint8_t, 0, 1>;
 
-void compute_checksum(network::ethernet::packet& packet) {
+void compute_checksum(network::packet& packet) {
     auto* ip_header  = reinterpret_cast<network::ip::header*>(packet.payload + packet.tag(1));
     auto* tcp_header = reinterpret_cast<network::tcp::header*>(packet.payload + packet.tag(2));
 
@@ -67,7 +67,7 @@ uint16_t get_default_flags() {
     return flags;
 }
 
-void prepare_packet(network::ethernet::packet& packet, size_t source, size_t target) {
+void prepare_packet(network::packet& packet, size_t source, size_t target) {
     packet.tag(2, packet.index);
 
     // Set the TCP header
@@ -82,7 +82,7 @@ void prepare_packet(network::ethernet::packet& packet, size_t source, size_t tar
     packet.index += default_tcp_header_length;
 }
 
-size_t tcp_payload_len(const network::ethernet::packet& packet){
+size_t tcp_payload_len(const network::packet& packet){
     auto* ip_header  = reinterpret_cast<const network::ip::header*>(packet.payload + packet.tag(1));
     auto* tcp_header = reinterpret_cast<const network::tcp::header*>(packet.payload + packet.tag(2));
 
@@ -105,7 +105,7 @@ network::tcp::layer::layer(network::ip::layer* parent) : parent(parent) {
     local_port = 1023;
 }
 
-void network::tcp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet) {
+void network::tcp::layer::decode(network::interface_descriptor& interface, network::packet& packet) {
     packet.tag(2, packet.index);
 
     auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.tag(1));
@@ -287,12 +287,12 @@ std::expected<size_t> network::tcp::layer::receive(char* buffer, network::socket
     return payload_len;
 }
 
-std::expected<network::ethernet::packet> network::tcp::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
+std::expected<network::packet> network::tcp::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
     auto& connection = socket.get_connection_data<tcp_connection>();
 
     // Make sure stream sockets are connected
     if(!connection.connected){
-        return std::make_unexpected<network::ethernet::packet>(std::ERROR_SOCKET_NOT_CONNECTED);
+        return std::make_unexpected<network::packet>(std::ERROR_SOCKET_NOT_CONNECTED);
     }
 
     auto target_ip  = connection.server_address;
@@ -322,7 +322,7 @@ std::expected<network::ethernet::packet> network::tcp::layer::user_prepare_packe
     return packet;
 }
 
-std::expected<void> network::tcp::layer::finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::ethernet::packet& p) {
+std::expected<void> network::tcp::layer::finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::packet& p) {
     auto* tcp_header = reinterpret_cast<network::tcp::header*>(p.payload + p.tag(2));
 
     auto source_flags = switch_endian_16(tcp_header->flags);
@@ -862,7 +862,7 @@ std::expected<void> network::tcp::layer::disconnect(network::socket& sock) {
 }
 
 // This is used for raw answer
-std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size) {
+std::expected<network::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size) {
     // Ask the IP layer to craft a packet
     network::ip::packet_descriptor desc{payload_size + default_tcp_header_length, target_ip, 0x06};
     auto packet = parent->kernel_prepare_packet(interface, desc);
@@ -875,7 +875,7 @@ std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_pac
 }
 
 // This is used for TCP connection answers
-std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size) {
+std::expected<network::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size) {
     auto target_ip   = connection.server_address;
     auto local_port  = connection.local_port;
     auto server_port = connection.server_port;
@@ -897,7 +897,7 @@ std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_pac
 }
 
 // finalize without waiting for ACK
-std::expected<void> network::tcp::layer::finalize_packet_direct(network::interface_descriptor& interface, network::ethernet::packet& p) {
+std::expected<void> network::tcp::layer::finalize_packet_direct(network::interface_descriptor& interface, network::packet& p) {
     auto* tcp_header = reinterpret_cast<network::tcp::header*>(p.payload + p.tag(2));
 
     auto flags = switch_endian_16(tcp_header->flags);
diff --git a/kernel/src/net/udp_layer.cpp b/kernel/src/net/udp_layer.cpp
index 91b2af1e..984ec6a0 100644
--- a/kernel/src/net/udp_layer.cpp
+++ b/kernel/src/net/udp_layer.cpp
@@ -18,7 +18,7 @@
 
 namespace {
 
-void compute_checksum(network::ethernet::packet& packet){
+void compute_checksum(network::packet& packet){
     auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.tag(1));
     auto* udp_header = reinterpret_cast<network::udp::header*>(packet.payload + packet.tag(2));
 
@@ -42,7 +42,7 @@ void compute_checksum(network::ethernet::packet& packet){
     udp_header->checksum = switch_endian_16(network::checksum_finalize_nz(sum));
 }
 
-void prepare_packet(network::ethernet::packet& packet, size_t source, size_t target, size_t payload_size){
+void prepare_packet(network::packet& packet, size_t source, size_t target, size_t payload_size){
     packet.tag(2, packet.index);
 
     // Set the UDP header
@@ -65,7 +65,7 @@ network::udp::layer::layer(network::ip::layer* parent) : parent(parent) {
     local_port = 1023;
 }
 
-void network::udp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
+void network::udp::layer::decode(network::interface_descriptor& interface, network::packet& packet){
     packet.tag(2, packet.index);
 
     auto* udp_header = reinterpret_cast<header*>(packet.payload + packet.index);
@@ -112,7 +112,7 @@ void network::udp::layer::decode(network::interface_descriptor& interface, netwo
     }
 }
 
-std::expected<network::ethernet::packet> network::udp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor){
+std::expected<network::packet> network::udp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor){
     // Ask the IP layer to craft a packet
     network::ip::packet_descriptor desc{sizeof(header) + descriptor.payload_size, descriptor.target_ip, 0x11};
     auto packet = parent->kernel_prepare_packet(interface, desc);
@@ -124,7 +124,7 @@ std::expected<network::ethernet::packet> network::udp::layer::kernel_prepare_pac
     return packet;
 }
 
-std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor){
+std::expected<network::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor){
     auto& connection = sock.get_connection_data<udp_connection>();
 
     auto ip = connection.server_address;
@@ -142,7 +142,7 @@ std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packe
     return packet;
 }
 
-std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address){
+std::expected<network::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address){
     auto& connection = sock.get_connection_data<udp_connection>();
 
     auto ip = connection.server_address;
@@ -160,7 +160,7 @@ std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packe
     return packet;
 }
 
-std::expected<void> network::udp::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p){
+std::expected<void> network::udp::layer::finalize_packet(network::interface_descriptor& interface, network::packet& p){
     p.index -= sizeof(header);
 
     // Compute the checksum