1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 06:27:45 +00:00

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.
This commit is contained in:
Andreas Kling 2019-05-03 20:15:54 +02:00
parent 9f633a1871
commit 03da7046bd
14 changed files with 118 additions and 115 deletions

View file

@ -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) {

View file

@ -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; }

View file

@ -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();
}

View file

@ -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);

View file

@ -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*);

View file

@ -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;
}

View file

@ -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;

View file

@ -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;

View file

@ -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;
};