Kernel: Prepare Socket for becoming a File.

Make the Socket functions take a FileDescriptor& rather than a socket role
throughout the code. Also change threads to block on a FileDescriptor,
rather than either an fd index or a Socket.

Kernel/Net/IPv4Socket.cpp

@@ -66,7 +66,7 @@ KResult IPv4Socket::bind(const sockaddr* address, socklen_t address_size)
     ASSERT_NOT_REACHED();
 }
 
-KResult IPv4Socket::connect(const sockaddr* address, socklen_t address_size, ShouldBlock should_block)
+KResult IPv4Socket::connect(FileDescriptor& descriptor, const sockaddr* address, socklen_t address_size, ShouldBlock should_block)
 {
     ASSERT(!m_bound);
     if (address_size != sizeof(sockaddr_in))
@@ -78,37 +78,37 @@ KResult IPv4Socket::connect(const sockaddr* address, socklen_t address_size, Sho
     m_destination_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
     m_destination_port = ntohs(ia.sin_port);
 
-    return protocol_connect(should_block);
+    return protocol_connect(descriptor, should_block);
 }
 
-void IPv4Socket::attach_fd(SocketRole)
+void IPv4Socket::attach(FileDescriptor&)
 {
     ++m_attached_fds;
 }
 
-void IPv4Socket::detach_fd(SocketRole)
+void IPv4Socket::detach(FileDescriptor&)
 {
     --m_attached_fds;
 }
 
-bool IPv4Socket::can_read(SocketRole) const
+bool IPv4Socket::can_read(FileDescriptor&) const
 {
     if (protocol_is_disconnected())
         return true;
     return m_can_read;
 }
 
-ssize_t IPv4Socket::read(SocketRole, byte* buffer, ssize_t size)
+ssize_t IPv4Socket::read(FileDescriptor& descriptor, byte* buffer, ssize_t size)
 {
-    return recvfrom(buffer, size, 0, nullptr, 0);
+    return recvfrom(descriptor, buffer, size, 0, nullptr, 0);
 }
 
-ssize_t IPv4Socket::write(SocketRole, const byte* data, ssize_t size)
+ssize_t IPv4Socket::write(FileDescriptor& descriptor, const byte* data, ssize_t size)
 {
-    return sendto(data, size, 0, nullptr, 0);
+    return sendto(descriptor, data, size, 0, nullptr, 0);
 }
 
-bool IPv4Socket::can_write(SocketRole) const
+bool IPv4Socket::can_write(FileDescriptor&) const
 {
     return is_connected();
 }
@@ -124,7 +124,7 @@ int IPv4Socket::allocate_source_port_if_needed()
     return port;
 }
 
-ssize_t IPv4Socket::sendto(const void* data, size_t data_length, int flags, const sockaddr* addr, socklen_t addr_length)
+ssize_t IPv4Socket::sendto(FileDescriptor&, const void* data, size_t data_length, int flags, const sockaddr* addr, socklen_t addr_length)
 {
     (void)flags;
     if (addr && addr_length != sizeof(sockaddr_in))
@@ -159,7 +159,7 @@ ssize_t IPv4Socket::sendto(const void* data, size_t data_length, int flags, cons
     return protocol_send(data, data_length);
 }
 
-ssize_t IPv4Socket::recvfrom(void* buffer, size_t buffer_length, int flags, sockaddr* addr, socklen_t* addr_length)
+ssize_t IPv4Socket::recvfrom(FileDescriptor& descriptor, void* buffer, size_t buffer_length, int flags, sockaddr* addr, socklen_t* addr_length)
 {
     (void)flags;
     if (addr_length && *addr_length < sizeof(sockaddr_in))
@@ -186,9 +186,8 @@ ssize_t IPv4Socket::recvfrom(void* buffer, size_t buffer_length, int flags, sock
             return 0;
         }
 
-        current->set_blocked_socket(this);
         load_receive_deadline();
-        current->block(Thread::BlockedReceive);
+        current->block(Thread::BlockedReceive, descriptor);
 
         LOCKER(lock());
         if (!m_can_read) {

Kernel/Net/IPv4Socket.h

@@ -21,16 +21,16 @@ public:
     static Lockable<HashTable<IPv4Socket*>>& all_sockets();
 
     virtual KResult bind(const sockaddr*, socklen_t) override;
-    virtual KResult connect(const sockaddr*, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
+    virtual KResult connect(FileDescriptor&, const sockaddr*, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
     virtual bool get_address(sockaddr*, socklen_t*) override;
-    virtual void attach_fd(SocketRole) override;
-    virtual void detach_fd(SocketRole) override;
-    virtual bool can_read(SocketRole) const override;
-    virtual ssize_t read(SocketRole, byte*, ssize_t) override;
-    virtual ssize_t write(SocketRole, const byte*, ssize_t) override;
-    virtual bool can_write(SocketRole) const override;
-    virtual ssize_t sendto(const void*, size_t, int, const sockaddr*, socklen_t) override;
-    virtual ssize_t recvfrom(void*, size_t, int flags, sockaddr*, socklen_t*) override;
+    virtual void attach(FileDescriptor&) override;
+    virtual void detach(FileDescriptor&) override;
+    virtual bool can_read(FileDescriptor&) const override;
+    virtual ssize_t read(FileDescriptor&, byte*, ssize_t) override;
+    virtual ssize_t write(FileDescriptor&, const byte*, ssize_t) override;
+    virtual bool can_write(FileDescriptor&) const override;
+    virtual ssize_t sendto(FileDescriptor&, const void*, size_t, int, const sockaddr*, socklen_t) override;
+    virtual ssize_t recvfrom(FileDescriptor&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
 
     void did_receive(ByteBuffer&&);
 
@@ -49,7 +49,7 @@ protected:
 
     virtual int protocol_receive(const ByteBuffer&, void*, size_t, int, sockaddr*, socklen_t*) { return -ENOTIMPL; }
     virtual int protocol_send(const void*, int) { return -ENOTIMPL; }
-    virtual KResult protocol_connect(ShouldBlock) { return KSuccess; }
+    virtual KResult protocol_connect(FileDescriptor&, ShouldBlock) { return KSuccess; }
     virtual int protocol_allocate_source_port() { return 0; }
     virtual bool protocol_is_disconnected() const { return false; }
 

Kernel/Net/LocalSocket.cpp

@@ -66,7 +66,7 @@ KResult LocalSocket::bind(const sockaddr* address, socklen_t address_size)
     return KSuccess;
 }
 
-KResult LocalSocket::connect(const sockaddr* address, socklen_t address_size, ShouldBlock)
+KResult LocalSocket::connect(FileDescriptor& descriptor, const sockaddr* address, socklen_t address_size, ShouldBlock)
 {
     ASSERT(!m_bound);
     if (address_size != sizeof(sockaddr_un))
@@ -98,36 +98,45 @@ KResult LocalSocket::connect(const sockaddr* address, socklen_t address_size, Sh
     if (result.is_error())
         return result;
 
-    return current->wait_for_connect(*this);
+    return current->wait_for_connect(descriptor);
 }
 
-void LocalSocket::attach_fd(SocketRole role)
+void LocalSocket::attach(FileDescriptor& descriptor)
 {
-    if (role == SocketRole::Accepted) {
+    switch (descriptor.socket_role()) {
+    case SocketRole::Accepted:
         ++m_accepted_fds_open;
-    } else if (role == SocketRole::Connected) {
+        break;
+    case SocketRole::Connected:
         ++m_connected_fds_open;
-    } else if (role == SocketRole::Connecting) {
+        break;
+    case SocketRole::Connecting:
         ++m_connecting_fds_open;
+        break;
     }
 }
 
-void LocalSocket::detach_fd(SocketRole role)
+void LocalSocket::detach(FileDescriptor& descriptor)
 {
-    if (role == SocketRole::Accepted) {
+    switch (descriptor.socket_role()) {
+    case SocketRole::Accepted:
         ASSERT(m_accepted_fds_open);
         --m_accepted_fds_open;
-    } else if (role == SocketRole::Connected) {
+        break;
+    case SocketRole::Connected:
         ASSERT(m_connected_fds_open);
         --m_connected_fds_open;
-    } else if (role == SocketRole::Connecting) {
+        break;
+    case SocketRole::Connecting:
         ASSERT(m_connecting_fds_open);
         --m_connecting_fds_open;
+        break;
     }
 }
 
-bool LocalSocket::can_read(SocketRole role) const
+bool LocalSocket::can_read(FileDescriptor& descriptor) const
 {
+    auto role = descriptor.socket_role();
     if (role == SocketRole::Listener)
         return can_accept();
     if (role == SocketRole::Accepted)
@@ -137,8 +146,9 @@ bool LocalSocket::can_read(SocketRole role) const
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::read(SocketRole role, byte* buffer, ssize_t size)
+ssize_t LocalSocket::read(FileDescriptor& descriptor, byte* buffer, ssize_t size)
 {
+    auto role = descriptor.socket_role();
     if (role == SocketRole::Accepted)
         return m_for_server.read(buffer, size);
     if (role == SocketRole::Connected)
@@ -146,14 +156,14 @@ ssize_t LocalSocket::read(SocketRole role, byte* buffer, ssize_t size)
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::write(SocketRole role, const byte* data, ssize_t size)
+ssize_t LocalSocket::write(FileDescriptor& descriptor, const byte* data, ssize_t size)
 {
-    if (role == SocketRole::Accepted) {
+    if (descriptor.socket_role() == SocketRole::Accepted) {
         if (!m_accepted_fds_open)
             return -EPIPE;
         return m_for_client.write(data, size);
     }
-    if (role == SocketRole::Connected) {
+    if (descriptor.socket_role() == SocketRole::Connected) {
         if (!m_connected_fds_open && !m_connecting_fds_open)
             return -EPIPE;
         return m_for_server.write(data, size);
@@ -161,21 +171,21 @@ ssize_t LocalSocket::write(SocketRole role, const byte* data, ssize_t size)
     ASSERT_NOT_REACHED();
 }
 
-bool LocalSocket::can_write(SocketRole role) const
+bool LocalSocket::can_write(FileDescriptor& descriptor) const
 {
-    if (role == SocketRole::Accepted)
+    if (descriptor.socket_role() == SocketRole::Accepted)
         return (!m_connected_fds_open && !m_connecting_fds_open) || m_for_client.bytes_in_write_buffer() < 4096;
-    if (role == SocketRole::Connected)
+    if (descriptor.socket_role() == SocketRole::Connected)
         return !m_accepted_fds_open || m_for_server.bytes_in_write_buffer() < 4096;
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::sendto(const void*, size_t, int, const sockaddr*, socklen_t)
+ssize_t LocalSocket::sendto(FileDescriptor&, const void*, size_t, int, const sockaddr*, socklen_t)
 {
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::recvfrom(void*, size_t, int flags, sockaddr*, socklen_t*)
+ssize_t LocalSocket::recvfrom(FileDescriptor&, void*, size_t, int flags, sockaddr*, socklen_t*)
 {
     ASSERT_NOT_REACHED();
 }

Kernel/Net/LocalSocket.h

@@ -11,16 +11,16 @@ public:
     virtual ~LocalSocket() override;
 
     virtual KResult bind(const sockaddr*, socklen_t) override;
-    virtual KResult connect(const sockaddr*, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
+    virtual KResult connect(FileDescriptor&, const sockaddr*, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
     virtual bool get_address(sockaddr*, socklen_t*) override;
-    virtual void attach_fd(SocketRole) override;
-    virtual void detach_fd(SocketRole) override;
-    virtual bool can_read(SocketRole) const override;
-    virtual ssize_t read(SocketRole, byte*, ssize_t) override;
-    virtual ssize_t write(SocketRole, const byte*, ssize_t) override;
-    virtual bool can_write(SocketRole) const override;
-    virtual ssize_t sendto(const void*, size_t, int, const sockaddr*, socklen_t) override;
-    virtual ssize_t recvfrom(void*, size_t, int flags, sockaddr*, socklen_t*) override;
+    virtual void attach(FileDescriptor&) override;
+    virtual void detach(FileDescriptor&) override;
+    virtual bool can_read(FileDescriptor&) const override;
+    virtual ssize_t read(FileDescriptor&, byte*, ssize_t) override;
+    virtual ssize_t write(FileDescriptor&, const byte*, ssize_t) override;
+    virtual bool can_write(FileDescriptor&) const override;
+    virtual ssize_t sendto(FileDescriptor&, const void*, size_t, int, const sockaddr*, socklen_t) override;
+    virtual ssize_t recvfrom(FileDescriptor&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
 
 private:
     explicit LocalSocket(int type);

Kernel/Net/Socket.h

@@ -11,6 +11,8 @@
 enum class SocketRole { None, Listener, Accepted, Connected, Connecting };
 enum class ShouldBlock { No = 0, Yes = 1 };
 
+class FileDescriptor;
+
 class Socket : public Retainable<Socket> {
 public:
     static KResultOr<Retained<Socket>> create(int domain, int type, int protocol);
@@ -26,18 +28,18 @@ public:
     KResult listen(int backlog);
 
     virtual KResult bind(const sockaddr*, socklen_t) = 0;
-    virtual KResult connect(const sockaddr*, socklen_t, ShouldBlock) = 0;
+    virtual KResult connect(FileDescriptor&, const sockaddr*, socklen_t, ShouldBlock) = 0;
     virtual bool get_address(sockaddr*, socklen_t*) = 0;
     virtual bool is_local() const { return false; }
     virtual bool is_ipv4() const { return false; }
-    virtual void attach_fd(SocketRole) = 0;
-    virtual void detach_fd(SocketRole) = 0;
-    virtual bool can_read(SocketRole) const = 0;
-    virtual ssize_t read(SocketRole, byte*, ssize_t) = 0;
-    virtual ssize_t write(SocketRole, const byte*, ssize_t) = 0;
-    virtual bool can_write(SocketRole) const = 0;
-    virtual ssize_t sendto(const void*, size_t, int flags, const sockaddr*, socklen_t) = 0;
-    virtual ssize_t recvfrom(void*, size_t, int flags, sockaddr*, socklen_t*) = 0;
+    virtual void attach(FileDescriptor&) = 0;
+    virtual void detach(FileDescriptor&) = 0;
+    virtual bool can_read(FileDescriptor&) const = 0;
+    virtual ssize_t read(FileDescriptor&, byte*, ssize_t) = 0;
+    virtual ssize_t write(FileDescriptor&, const byte*, ssize_t) = 0;
+    virtual bool can_write(FileDescriptor&) const = 0;
+    virtual ssize_t sendto(FileDescriptor&, const void*, size_t, int flags, const sockaddr*, socklen_t) = 0;
+    virtual ssize_t recvfrom(FileDescriptor&, void*, size_t, int flags, sockaddr*, socklen_t*) = 0;
 
     KResult setsockopt(int level, int option, const void*, socklen_t);
     KResult getsockopt(int level, int option, void*, socklen_t*);

Kernel/Net/TCPSocket.cpp

@@ -152,7 +152,7 @@ NetworkOrdered<word> TCPSocket::compute_tcp_checksum(const IPv4Address& source,
     return ~(checksum & 0xffff);
 }
 
-KResult TCPSocket::protocol_connect(ShouldBlock should_block)
+KResult TCPSocket::protocol_connect(FileDescriptor& descriptor, ShouldBlock should_block)
 {
     auto* adapter = adapter_for_route_to(destination_address());
     if (!adapter)
@@ -167,8 +167,7 @@ KResult TCPSocket::protocol_connect(ShouldBlock should_block)
     m_state = State::Connecting;
 
     if (should_block == ShouldBlock::Yes) {
-        current->set_blocked_socket(this);
-        current->block(Thread::BlockedConnect);
+        current->block(Thread::BlockedConnect, descriptor);
         ASSERT(is_connected());
         return KSuccess;
     }

Kernel/Net/TCPSocket.h

@@ -34,7 +34,7 @@ private:
 
     virtual int protocol_receive(const ByteBuffer&, void* buffer, size_t buffer_size, int flags, sockaddr* addr, socklen_t* addr_length) override;
     virtual int protocol_send(const void*, int) override;
-    virtual KResult protocol_connect(ShouldBlock) override;
+    virtual KResult protocol_connect(FileDescriptor&, ShouldBlock) override;
     virtual int protocol_allocate_source_port() override;
     virtual bool protocol_is_disconnected() const override;
 

Kernel/Net/UDPSocket.cpp

@@ -81,11 +81,6 @@ int UDPSocket::protocol_send(const void* data, int data_length)
     return data_length;
 }
 
-KResult UDPSocket::protocol_connect(ShouldBlock)
-{
-    return KSuccess;
-}
-
 int UDPSocket::protocol_allocate_source_port()
 {
     static const word first_ephemeral_port = 32768;

Kernel/Net/UDPSocket.h

@@ -17,7 +17,7 @@ private:
 
     virtual int protocol_receive(const ByteBuffer&, void* buffer, size_t buffer_size, int flags, sockaddr* addr, socklen_t* addr_length) override;
     virtual int protocol_send(const void*, int) override;
-    virtual KResult protocol_connect(ShouldBlock) override;
+    virtual KResult protocol_connect(FileDescriptor&, ShouldBlock) override { return KSuccess; }
     virtual int protocol_allocate_source_port() override;
 };