1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:47:36 +00:00

IPv4: Basic implementation of TCP socket shutdown

We can now participate in the TCP connection closing handshake. :^)
This implementation is definitely not complete and needs to handle a
bunch of other cases. But it's a huge improvement over not being able
to close connections at all.

Note that we hold on to pending-close sockets indefinitely, until they
are moved into the Closed state. This should also have a timeout but
that's still a FIXME. :^)

Fixes #428.
This commit is contained in:
Andreas Kling 2020-02-08 15:52:32 +01:00
parent 8325662186
commit 228a1e9099
7 changed files with 69 additions and 8 deletions

View file

@ -500,3 +500,8 @@ int IPv4Socket::ioctl(FileDescription&, unsigned request, unsigned arg)
return -EINVAL; return -EINVAL;
} }
void IPv4Socket::close()
{
shutdown(SHUT_RDWR);
}

View file

@ -46,6 +46,7 @@ public:
static Lockable<HashTable<IPv4Socket*>>& all_sockets(); static Lockable<HashTable<IPv4Socket*>>& all_sockets();
virtual void close() override;
virtual KResult bind(const sockaddr*, socklen_t) override; virtual KResult bind(const sockaddr*, socklen_t) override;
virtual KResult connect(FileDescription&, const sockaddr*, socklen_t, ShouldBlock = ShouldBlock::Yes) override; virtual KResult connect(FileDescription&, const sockaddr*, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
virtual KResult listen(int) override; virtual KResult listen(int) override;

View file

@ -572,6 +572,9 @@ void handle_tcp(const IPv4Packet& ipv4_packet)
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1); socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->set_state(TCPSocket::State::TimeWait); socket->set_state(TCPSocket::State::TimeWait);
return; return;
case TCPFlags::ACK | TCPFlags::RST:
socket->set_state(TCPSocket::State::Closed);
return;
default: default:
kprintf("handle_tcp: unexpected flags in FinWait2 state\n"); kprintf("handle_tcp: unexpected flags in FinWait2 state\n");
socket->send_tcp_packet(TCPFlags::RST); socket->send_tcp_packet(TCPFlags::RST);
@ -596,12 +599,8 @@ void handle_tcp(const IPv4Packet& ipv4_packet)
socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size())); socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1); socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
// TODO: We should only send a FIN packet out once we're shutting socket->send_tcp_packet(TCPFlags::ACK);
// down our side of the socket, so we should change this back to socket->set_state(TCPSocket::State::CloseWait);
// just being an ACK and a transition to CloseWait once we have a
// shutdown() implementation.
socket->send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
socket->set_state(TCPSocket::State::Closing);
socket->set_connected(false); socket->set_connected(false);
return; return;
} }

View file

@ -165,7 +165,13 @@ KResult Socket::shutdown(int how)
{ {
if (type() == SOCK_STREAM && !is_connected()) if (type() == SOCK_STREAM && !is_connected())
return KResult(-ENOTCONN); return KResult(-ENOTCONN);
m_shut_down_for_reading |= how & SHUT_RD; if (m_role == Role::Listener)
m_shut_down_for_writing |= how & SHUT_WR; return KResult(-ENOTCONN);
if (!m_shut_down_for_writing && (how & SHUT_WR))
shut_down_for_writing();
if (!m_shut_down_for_reading && (how & SHUT_RD))
shut_down_for_reading();
m_shut_down_for_reading |= (how & SHUT_RD) != 0;
m_shut_down_for_writing |= (how & SHUT_WR) != 0;
return KSuccess; return KSuccess;
} }

View file

@ -141,6 +141,9 @@ protected:
virtual const char* class_name() const override { return "Socket"; } virtual const char* class_name() const override { return "Socket"; }
virtual void shut_down_for_reading() {}
virtual void shut_down_for_writing() {}
Role m_role { Role::None }; Role m_role { Role::None };
protected: protected:

View file

@ -55,6 +55,19 @@ void TCPSocket::set_state(State new_state)
if (new_state == State::Established && m_direction == Direction::Outgoing) if (new_state == State::Established && m_direction == Direction::Outgoing)
m_role = Role::Connected; m_role = Role::Connected;
if (new_state == State::Closed) {
LOCKER(closing_sockets().lock());
closing_sockets().resource().remove(tuple());
}
}
Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& TCPSocket::closing_sockets()
{
static Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>* s_map;
if (!s_map)
s_map = new Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>;
return *s_map;
} }
Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple() Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
@ -137,6 +150,10 @@ TCPSocket::~TCPSocket()
{ {
LOCKER(sockets_by_tuple().lock()); LOCKER(sockets_by_tuple().lock());
sockets_by_tuple().resource().remove(tuple()); sockets_by_tuple().resource().remove(tuple());
#ifdef TCP_SOCKET_DEBUG
dbg() << "~TCPSocket in state " << to_string(state());
#endif
} }
NonnullRefPtr<TCPSocket> TCPSocket::create(int protocol) NonnullRefPtr<TCPSocket> TCPSocket::create(int protocol)
@ -420,3 +437,27 @@ bool TCPSocket::protocol_is_disconnected() const
return false; return false;
} }
} }
void TCPSocket::shut_down_for_writing()
{
if (state() == State::Established) {
dbg() << " Sending FIN/ACK from Established and moving into FinWait1";
send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
set_state(State::FinWait1);
} else {
dbg() << " Shutting down TCPSocket for writing but not moving to FinWait1 since state is " << to_string(state());
}
}
void TCPSocket::close()
{
IPv4Socket::close();
if (state() == State::CloseWait) {
dbg() << " Sending FIN from CloseWait and moving into LastAck";
send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
set_state(State::LastAck);
}
LOCKER(closing_sockets().lock());
closing_sockets().resource().set(tuple(), *this);
}

View file

@ -155,12 +155,16 @@ public:
static RefPtr<TCPSocket> from_tuple(const IPv4SocketTuple& tuple); static RefPtr<TCPSocket> from_tuple(const IPv4SocketTuple& tuple);
static RefPtr<TCPSocket> from_endpoints(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port); static RefPtr<TCPSocket> from_endpoints(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port);
static Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& closing_sockets();
RefPtr<TCPSocket> create_client(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port); RefPtr<TCPSocket> create_client(const IPv4Address& local_address, u16 local_port, const IPv4Address& peer_address, u16 peer_port);
void set_originator(TCPSocket& originator) { m_originator = originator.make_weak_ptr(); } void set_originator(TCPSocket& originator) { m_originator = originator.make_weak_ptr(); }
bool has_originator() { return !!m_originator; } bool has_originator() { return !!m_originator; }
void release_to_originator(); void release_to_originator();
void release_for_accept(RefPtr<TCPSocket>); void release_for_accept(RefPtr<TCPSocket>);
virtual void close() override;
protected: protected:
void set_direction(Direction direction) { m_direction = direction; } void set_direction(Direction direction) { m_direction = direction; }
@ -170,6 +174,8 @@ private:
static NetworkOrdered<u16> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, u16 payload_size); static NetworkOrdered<u16> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, u16 payload_size);
virtual void shut_down_for_writing() override;
virtual int protocol_receive(const KBuffer&, void* buffer, size_t buffer_size, int flags) override; virtual int protocol_receive(const KBuffer&, void* buffer, size_t buffer_size, int flags) override;
virtual int protocol_send(const void*, size_t) override; virtual int protocol_send(const void*, size_t) override;
virtual KResult protocol_connect(FileDescription&, ShouldBlock) override; virtual KResult protocol_connect(FileDescription&, ShouldBlock) override;