Store the UDP "connections"

kernel/include/conc/rw_lock.hpp

@@ -159,19 +159,19 @@ private:
     bool writer    = false;   ///< Boolean flag indicating if there is a writer
 };
 
-void writer_rw_lock::lock(){
+inline void writer_rw_lock::lock(){
     l.read_lock();
 }
 
-void writer_rw_lock::unlock(){
+inline void writer_rw_lock::unlock(){
     l.read_unlock();
 }
 
-void reader_rw_lock::lock(){
+inline void reader_rw_lock::lock(){
     l.write_lock();
 }
 
-void reader_rw_lock::unlock(){
+inline void reader_rw_lock::unlock(){
     l.write_unlock();
 }
 

kernel/include/net/connection_handler.hpp

@@ -8,6 +8,8 @@
 #ifndef NET_CONNECTION_HANDLER_H
 #define NET_CONNECTION_HANDLER_H
 
+#include <list.hpp>
+
 #include "conc/rw_lock.hpp"
 
 namespace network {
@@ -33,11 +35,7 @@ struct connection_handler {
         auto lock = connections_lock.writer_lock();
         std::lock_guard<writer_rw_lock> l(lock);
 
-        auto& connection = connections.emplace_back();
-
-        connection.listening = false;
-
-        return connection;
+        return connections.emplace_back();
     }
 
     void remove_connection(connection_type& connection) {

kernel/src/net/tcp_layer.cpp

@@ -54,6 +54,10 @@ struct tcp_connection {
     uint32_t seq_number = 0; ///< The next sequence number
 
     network::socket* socket = nullptr;
+
+    tcp_connection(){
+        listening = false;
+    }
 };
 
 network::connection_handler<tcp_connection> connections;

kernel/src/net/udp_layer.cpp

@@ -5,14 +5,29 @@
 //  http://www.opensource.org/licenses/MIT)
 //=======================================================================
 
+#include "net/connection_handler.hpp"
 #include "net/udp_layer.hpp"
 #include "net/dns_layer.hpp"
 #include "net/checksum.hpp"
 
+#include "tlib/errors.hpp"
+
 #include "kernel_utils.hpp"
 
 namespace {
 
+struct udp_connection {
+    size_t local_port;                   ///< The local source port
+    size_t server_port;                  ///< The server port
+    network::ip::address server_address; ///< The server address
+
+    bool connected = false;
+
+    network::socket* socket = nullptr;
+};
+
+network::connection_handler<udp_connection> connections;
+
 void compute_checksum(network::ethernet::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.index);
@@ -109,10 +124,38 @@ std::expected<void> network::udp::finalize_packet(network::interface_descriptor&
     return network::ip::finalize_packet(interface, p);
 }
 
-std::expected<void> network::udp::client_bind(network::socket& socket, network::interface_descriptor& interface, size_t local_port, size_t server_port, network::ip::address server){
+std::expected<void> network::udp::client_bind(network::socket& sock, network::interface_descriptor& interface, size_t local_port, size_t server_port, network::ip::address server){
+    // Create the connection
 
+    auto& connection = connections.create_connection();
+
+    connection.local_port     = local_port;
+    connection.server_port    = server_port;
+    connection.server_address = server;
+
+    // Link the socket and connection
+    sock.connection_data = &connection;
+    connection.socket = &sock;
+
+    // Mark the connection as connected
+
+    connection.connected = true;
+
+    return {};
 }
 
-std::expected<void> network::udp::client_unbind(network::socket& socket){
+std::expected<void> network::udp::client_unbind(network::socket& sock){
+    auto& connection = sock.get_connection_data<udp_connection>();
 
+    if(!connection.connected){
+        return std::make_unexpected<void>(std::ERROR_SOCKET_NOT_CONNECTED);
+    }
+
+    // Mark the connection as not connected
+
+    connection.connected = false;
+
+    connections.remove_connection(connection);
+
+    return {};
 }