IPv4: More work on the TCP implementation.

I can now establish a connection to my little test server on the host.

Kernel/IPv4Socket.cpp

@@ -42,7 +42,6 @@ Retained<IPv4Socket> IPv4Socket::create(int type, int protocol)
 
 IPv4Socket::IPv4Socket(int type, int protocol)
     : Socket(AF_INET, type, protocol)
-    , m_lock("IPv4Socket")
 {
     kprintf("%s(%u) IPv4Socket{%p} created with type=%u, protocol=%d\n", current->name().characters(), current->pid(), this, type, protocol);
     LOCKER(all_sockets().lock());
@@ -103,8 +102,17 @@ KResult IPv4Socket::connect(const sockaddr* address, socklen_t address_size)
         auto* adapter = NetworkAdapter::from_ipv4_address(IPv4Address(192, 168, 5, 2));
         if (!adapter)
             ASSERT_NOT_REACHED();
+
+        allocate_source_port_if_needed();
+
         send_tcp_packet(*adapter, TCPFlags::SYN);
         m_tcp_state = TCPState::Connecting1;
+
+        current->set_blocked_socket(this);
+        block(Process::BlockedConnect);
+        Scheduler::yield();
+
+        ASSERT(is_connected());
         return KSuccess;
     }
 
@@ -216,11 +224,12 @@ void IPv4Socket::send_tcp_packet(NetworkAdapter& adapter, word flags, const void
 {
     auto buffer = ByteBuffer::create_zeroed(sizeof(TCPPacket) + payload_size);
     auto& tcp_packet = *(TCPPacket*)(buffer.pointer());
+    ASSERT(m_source_port);
     tcp_packet.set_source_port(m_source_port);
     tcp_packet.set_destination_port(m_destination_port);
     tcp_packet.set_window_size(1024);
     tcp_packet.set_sequence_number(m_tcp_sequence_number);
-    tcp_packet.set_data_offset(5);
+    tcp_packet.set_data_offset(sizeof(TCPPacket) / sizeof(dword));
     tcp_packet.set_flags(flags);
 
     if (flags & TCPFlags::ACK)
@@ -310,7 +319,7 @@ ssize_t IPv4Socket::recvfrom(void* buffer, size_t buffer_length, int flags, sock
 
     ByteBuffer packet_buffer;
     {
-        LOCKER(m_lock);
+        LOCKER(lock());
         if (!m_receive_queue.is_empty()) {
             packet_buffer = m_receive_queue.take_first();
             m_can_read = !m_receive_queue.is_empty();
@@ -322,7 +331,7 @@ ssize_t IPv4Socket::recvfrom(void* buffer, size_t buffer_length, int flags, sock
         block(Process::BlockedReceive);
         Scheduler::yield();
 
-        LOCKER(m_lock);
+        LOCKER(lock());
         if (!m_can_read) {
             // Unblocked due to timeout.
             return -EAGAIN;
@@ -378,7 +387,7 @@ ssize_t IPv4Socket::recvfrom(void* buffer, size_t buffer_length, int flags, sock
 
 void IPv4Socket::did_receive(ByteBuffer&& packet)
 {
-    LOCKER(m_lock);
+    LOCKER(lock());
     m_receive_queue.append(move(packet));
     m_can_read = true;
 #ifdef IPV4_SOCKET_DEBUG

Kernel/IPv4Socket.h

@@ -42,8 +42,6 @@ public:
 
     void did_receive(ByteBuffer&&);
 
-    Lock& lock() { return m_lock; }
-
     word source_port() const { return m_source_port; }
     word destination_port() const { return m_destination_port; }
 
@@ -78,7 +76,6 @@ private:
     dword m_tcp_ack_number { 0 };
     TCPState m_tcp_state { Disconnected };
 
-    Lock m_lock;
     bool m_can_read { false };
 };
 

Kernel/NetworkTask.cpp

@@ -281,8 +281,10 @@ void handle_tcp(const EthernetFrameHeader& eth, int frame_size)
     {
         LOCKER(IPv4Socket::sockets_by_tcp_port().lock());
         auto it = IPv4Socket::sockets_by_tcp_port().resource().find(tcp_packet.destination_port());
-        if (it == IPv4Socket::sockets_by_tcp_port().resource().end())
+        if (it == IPv4Socket::sockets_by_tcp_port().resource().end()) {
+            kprintf("handle_tcp: No TCP socket for port %u\n", tcp_packet.destination_port());
             return;
+        }
         ASSERT((*it).value);
         socket = *(*it).value;
     }
@@ -291,15 +293,18 @@ void handle_tcp(const EthernetFrameHeader& eth, int frame_size)
     ASSERT(socket->type() == SOCK_STREAM);
     ASSERT(socket->source_port() == tcp_packet.destination_port());
 
-    size_t payload_size = ipv4_packet.payload_size() - sizeof(TCPPacket);
+    size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
 
     if (tcp_packet.has_syn() && tcp_packet.has_ack()) {
         socket->set_tcp_ack_number(socket->tcp_sequence_number() + payload_size + 1);
         socket->send_tcp_packet(*adapter, TCPFlags::ACK);
+        socket->set_connected(true);
         kprintf("Connected!\n");
         socket->set_tcp_state(Connected);
         return;
     }
 
+    socket->send_tcp_packet(*adapter, TCPFlags::ACK);
+
     socket->did_receive(ByteBuffer::copy((const byte*)&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
 }

Kernel/Process.cpp

@@ -2329,6 +2329,7 @@ void Process::finalize()
             }
         }
     }
+    m_blocked_socket = nullptr;
 
     set_state(Dead);
 }
@@ -2511,10 +2512,10 @@ KResult Process::wait_for_connect(Socket& socket)
 {
     if (socket.is_connected())
         return KSuccess;
-    m_blocked_connecting_socket = socket;
+    m_blocked_socket = socket;
     block(BlockedConnect);
     Scheduler::yield();
-    m_blocked_connecting_socket = nullptr;
+    m_blocked_socket = nullptr;
     if (!socket.is_connected())
         return KResult(-ECONNREFUSED);
     return KSuccess;

Kernel/Process.h

@@ -372,7 +372,6 @@ private:
     dword m_times_scheduled { 0 };
     pid_t m_waitee_pid { -1 };
     int m_blocked_fd { -1 };
-    Socket* m_blocked_socket { nullptr };
     Vector<int> m_select_read_fds;
     Vector<int> m_select_write_fds;
     Vector<int> m_select_exceptional_fds;
@@ -382,7 +381,7 @@ private:
     SignalActionData m_signal_action_data[32];
     dword m_pending_signals { 0 };
     dword m_signal_mask { 0 };
-    RetainPtr<Socket> m_blocked_connecting_socket;
+    RetainPtr<Socket> m_blocked_socket;
 
     byte m_termination_status { 0 };
     byte m_termination_signal { 0 };

Kernel/Scheduler.cpp

@@ -95,8 +95,8 @@ bool Scheduler::pick_next()
         }
 
         if (process.state() == Process::BlockedConnect) {
-            ASSERT(process.m_blocked_connecting_socket);
-            if (process.m_blocked_connecting_socket->is_connected())
+            ASSERT(process.m_blocked_socket);
+            if (process.m_blocked_socket->is_connected())
                 process.unblock();
             return true;
         }

Kernel/Socket.cpp

@@ -22,6 +22,7 @@ Socket::Socket(int domain, int type, int protocol)
     : m_domain(domain)
     , m_type(type)
     , m_protocol(protocol)
+    , m_lock("Socket")
 {
     m_origin_pid = current->pid();
 }

Kernel/Socket.h

@@ -46,6 +46,10 @@ public:
     timeval receive_deadline() const { return m_receive_deadline; }
     timeval send_deadline() const { return m_send_deadline; }
 
+    void set_connected(bool connected) { m_connected = connected; }
+
+    Lock& lock() { return m_lock; }
+
 protected:
     Socket(int domain, int type, int protocol);
 

Kernel/TCP.h

@@ -18,6 +18,8 @@ public:
     TCPPacket() { }
     ~TCPPacket() { }
 
+    size_t header_size() const { return data_offset() * sizeof(dword); }
+
     word source_port() const { return m_source_port; }
     void set_source_port(word port) { m_source_port = port; }
 
@@ -48,8 +50,8 @@ public:
     word urgent() const { return m_urgent; }
     void set_urgent(word urgent) { m_urgent = urgent; }
 
-    const void* payload() const { return this + 1; }
-    void* payload() { return this + 1; }
+    const void* payload() const { return ((const byte*)this) + header_size(); }
+    void* payload() { return ((byte*)this) + header_size(); }
 
 private:
     NetworkOrdered<word> m_source_port;