2020-01-18 08:38:21 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
|
|
*
|
2021-04-22 08:24:48 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2020-01-18 08:38:21 +00:00
|
|
|
*/
|
|
|
|
|
2020-08-25 01:35:19 +00:00
|
|
|
#include <AK/Singleton.h>
|
2019-09-08 09:40:26 +00:00
|
|
|
#include <AK/Time.h>
|
2021-01-25 15:07:10 +00:00
|
|
|
#include <Kernel/Debug.h>
|
2019-06-07 09:43:58 +00:00
|
|
|
#include <Kernel/Devices/RandomDevice.h>
|
2019-08-06 13:40:38 +00:00
|
|
|
#include <Kernel/FileSystem/FileDescription.h>
|
2021-05-25 19:29:37 +00:00
|
|
|
#include <Kernel/Net/EthernetFrameHeader.h>
|
2021-05-11 19:09:11 +00:00
|
|
|
#include <Kernel/Net/IPv4.h>
|
2019-04-02 17:54:38 +00:00
|
|
|
#include <Kernel/Net/NetworkAdapter.h>
|
2021-06-04 04:43:16 +00:00
|
|
|
#include <Kernel/Net/NetworkingManagement.h>
|
2019-04-02 13:46:44 +00:00
|
|
|
#include <Kernel/Net/Routing.h>
|
2019-06-07 09:43:58 +00:00
|
|
|
#include <Kernel/Net/TCP.h>
|
|
|
|
#include <Kernel/Net/TCPSocket.h>
|
2019-04-02 17:54:38 +00:00
|
|
|
#include <Kernel/Process.h>
|
2020-01-03 11:36:30 +00:00
|
|
|
#include <Kernel/Random.h>
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2020-02-16 00:27:42 +00:00
|
|
|
namespace Kernel {
|
|
|
|
|
2020-04-18 09:50:35 +00:00
|
|
|
void TCPSocket::for_each(Function<void(const TCPSocket&)> callback)
|
2019-08-06 13:40:38 +00:00
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
2019-08-06 13:40:38 +00:00
|
|
|
for (auto& it : sockets_by_tuple().resource())
|
2019-08-09 10:26:29 +00:00
|
|
|
callback(*it.value);
|
2019-08-06 13:40:38 +00:00
|
|
|
}
|
|
|
|
|
2019-08-10 03:14:00 +00:00
|
|
|
void TCPSocket::set_state(State new_state)
|
|
|
|
{
|
2021-02-07 12:03:24 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket({}) state moving from {} to {}", this, to_string(m_state), to_string(new_state));
|
2019-08-10 03:14:00 +00:00
|
|
|
|
2020-11-29 23:05:27 +00:00
|
|
|
auto was_disconnected = protocol_is_disconnected();
|
|
|
|
auto previous_role = m_role;
|
|
|
|
|
2019-08-10 03:14:00 +00:00
|
|
|
m_state = new_state;
|
2019-08-11 13:38:20 +00:00
|
|
|
|
|
|
|
if (new_state == State::Established && m_direction == Direction::Outgoing)
|
|
|
|
m_role = Role::Connected;
|
2020-02-08 14:52:32 +00:00
|
|
|
|
|
|
|
if (new_state == State::Closed) {
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(closing_sockets().lock());
|
2020-02-08 14:52:32 +00:00
|
|
|
closing_sockets().resource().remove(tuple());
|
2021-04-30 19:43:37 +00:00
|
|
|
|
|
|
|
if (m_originator)
|
|
|
|
release_to_originator();
|
2020-02-08 14:52:32 +00:00
|
|
|
}
|
2020-11-29 23:05:27 +00:00
|
|
|
|
|
|
|
if (previous_role != m_role || was_disconnected != protocol_is_disconnected())
|
|
|
|
evaluate_block_conditions();
|
2020-02-08 14:52:32 +00:00
|
|
|
}
|
|
|
|
|
2020-08-25 01:35:19 +00:00
|
|
|
static AK::Singleton<Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>> s_socket_closing;
|
|
|
|
|
2020-02-08 14:52:32 +00:00
|
|
|
Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& TCPSocket::closing_sockets()
|
|
|
|
{
|
2020-08-25 01:35:19 +00:00
|
|
|
return *s_socket_closing;
|
2019-08-10 03:14:00 +00:00
|
|
|
}
|
|
|
|
|
2020-08-25 01:35:19 +00:00
|
|
|
static AK::Singleton<Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>> s_socket_tuples;
|
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
|
2019-03-14 11:28:30 +00:00
|
|
|
{
|
2020-08-25 01:35:19 +00:00
|
|
|
return *s_socket_tuples;
|
2019-03-14 11:28:30 +00:00
|
|
|
}
|
|
|
|
|
2019-09-08 07:16:40 +00:00
|
|
|
RefPtr<TCPSocket> TCPSocket::from_tuple(const IPv4SocketTuple& tuple)
|
2019-03-14 11:28:30 +00:00
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
2019-08-09 02:48:28 +00:00
|
|
|
|
|
|
|
auto exact_match = sockets_by_tuple().resource().get(tuple);
|
|
|
|
if (exact_match.has_value())
|
2019-08-09 07:16:12 +00:00
|
|
|
return { *exact_match.value() };
|
2019-08-09 02:48:28 +00:00
|
|
|
|
|
|
|
auto address_tuple = IPv4SocketTuple(tuple.local_address(), tuple.local_port(), IPv4Address(), 0);
|
|
|
|
auto address_match = sockets_by_tuple().resource().get(address_tuple);
|
|
|
|
if (address_match.has_value())
|
2019-08-09 07:16:12 +00:00
|
|
|
return { *address_match.value() };
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2019-08-09 02:38:56 +00:00
|
|
|
auto wildcard_tuple = IPv4SocketTuple(IPv4Address(), tuple.local_port(), IPv4Address(), 0);
|
|
|
|
auto wildcard_match = sockets_by_tuple().resource().get(wildcard_tuple);
|
|
|
|
if (wildcard_match.has_value())
|
2019-08-09 07:16:12 +00:00
|
|
|
return { *wildcard_match.value() };
|
2019-08-09 02:38:56 +00:00
|
|
|
|
2019-08-09 02:48:28 +00:00
|
|
|
return {};
|
2019-03-14 11:28:30 +00:00
|
|
|
}
|
2019-09-08 07:16:40 +00:00
|
|
|
RefPtr<TCPSocket> TCPSocket::create_client(const IPv4Address& new_local_address, u16 new_local_port, const IPv4Address& new_peer_address, u16 new_peer_port)
|
2019-08-09 02:48:28 +00:00
|
|
|
{
|
|
|
|
auto tuple = IPv4SocketTuple(new_local_address, new_local_port, new_peer_address, new_peer_port);
|
|
|
|
|
2021-05-13 09:50:01 +00:00
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_by_tuple().lock(), Mutex::Mode::Shared);
|
2021-05-13 09:50:01 +00:00
|
|
|
if (sockets_by_tuple().resource().contains(tuple))
|
|
|
|
return {};
|
|
|
|
}
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-08-01 09:42:03 +00:00
|
|
|
auto receive_buffer = create_receive_buffer();
|
|
|
|
if (!receive_buffer)
|
|
|
|
return {};
|
|
|
|
auto result = TCPSocket::create(protocol(), receive_buffer.release_nonnull());
|
2021-05-13 08:01:38 +00:00
|
|
|
if (result.is_error())
|
|
|
|
return {};
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-05-13 08:01:38 +00:00
|
|
|
auto client = result.release_value();
|
2019-08-10 03:17:00 +00:00
|
|
|
client->set_setup_state(SetupState::InProgress);
|
2019-08-09 02:48:28 +00:00
|
|
|
client->set_local_address(new_local_address);
|
|
|
|
client->set_local_port(new_local_port);
|
|
|
|
client->set_peer_address(new_peer_address);
|
|
|
|
client->set_peer_port(new_peer_port);
|
|
|
|
client->set_direction(Direction::Incoming);
|
2019-09-08 07:18:28 +00:00
|
|
|
client->set_originator(*this);
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_by_tuple().lock());
|
2019-09-08 07:18:28 +00:00
|
|
|
m_pending_release_for_accept.set(tuple, client);
|
2019-08-09 02:48:28 +00:00
|
|
|
sockets_by_tuple().resource().set(tuple, client);
|
|
|
|
|
2021-05-13 09:50:01 +00:00
|
|
|
return client;
|
2019-08-09 02:48:28 +00:00
|
|
|
}
|
|
|
|
|
2019-09-08 07:18:28 +00:00
|
|
|
void TCPSocket::release_to_originator()
|
|
|
|
{
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY(!!m_originator);
|
AK: Make RefPtr, NonnullRefPtr, WeakPtr thread safe
This makes most operations thread safe, especially so that they
can safely be used in the Kernel. This includes obtaining a strong
reference from a weak reference, which now requires an explicit
call to WeakPtr::strong_ref(). Another major change is that
Weakable::make_weak_ref() may require the explicit target type.
Previously we used reinterpret_cast in WeakPtr, assuming that it
can be properly converted. But WeakPtr does not necessarily have
the knowledge to be able to do this. Instead, we now ask the class
itself to deliver a WeakPtr to the type that we want.
Also, WeakLink is no longer specific to a target type. The reason
for this is that we want to be able to safely convert e.g. WeakPtr<T>
to WeakPtr<U>, and before this we just reinterpret_cast the internal
WeakLink<T> to WeakLink<U>, which is a bold assumption that it would
actually produce the correct code. Instead, WeakLink now operates
on just a raw pointer and we only make those constructors/operators
available if we can verify that it can be safely cast.
In order to guarantee thread safety, we now use the least significant
bit in the pointer for locking purposes. This also means that only
properly aligned pointers can be used.
2020-09-29 22:26:13 +00:00
|
|
|
m_originator.strong_ref()->release_for_accept(this);
|
2021-04-30 19:43:37 +00:00
|
|
|
m_originator.clear();
|
2019-09-08 07:18:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::release_for_accept(RefPtr<TCPSocket> socket)
|
|
|
|
{
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY(m_pending_release_for_accept.contains(socket->tuple()));
|
2019-09-08 07:18:28 +00:00
|
|
|
m_pending_release_for_accept.remove(socket->tuple());
|
2020-08-05 09:13:30 +00:00
|
|
|
// FIXME: Should we observe this error somehow?
|
2020-12-20 23:09:48 +00:00
|
|
|
[[maybe_unused]] auto rc = queue_connection_from(*socket);
|
2019-09-08 07:18:28 +00:00
|
|
|
}
|
|
|
|
|
2021-08-01 12:11:05 +00:00
|
|
|
TCPSocket::TCPSocket(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer, OwnPtr<KBuffer> scratch_buffer)
|
|
|
|
: IPv4Socket(SOCK_STREAM, protocol, move(receive_buffer), move(scratch_buffer))
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2021-05-13 08:49:10 +00:00
|
|
|
m_last_retransmit_time = kgettimeofday();
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TCPSocket::~TCPSocket()
|
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_by_tuple().lock());
|
2019-08-06 13:40:38 +00:00
|
|
|
sockets_by_tuple().resource().remove(tuple());
|
2020-02-08 14:52:32 +00:00
|
|
|
|
2021-05-13 08:49:10 +00:00
|
|
|
dequeue_for_retransmit();
|
|
|
|
|
2021-02-07 12:03:24 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "~TCPSocket in state {}", to_string(state()));
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
|
|
|
|
2021-08-01 09:42:03 +00:00
|
|
|
KResultOr<NonnullRefPtr<TCPSocket>> TCPSocket::create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2021-08-01 12:11:05 +00:00
|
|
|
// Note: Scratch buffer is only used for SOCK_STREAM sockets.
|
|
|
|
auto scratch_buffer = KBuffer::try_create_with_size(65536);
|
|
|
|
if (!scratch_buffer)
|
|
|
|
return ENOMEM;
|
|
|
|
|
|
|
|
auto socket = adopt_ref_if_nonnull(new (nothrow) TCPSocket(protocol, move(receive_buffer), move(scratch_buffer)));
|
2021-05-13 08:01:38 +00:00
|
|
|
if (socket)
|
|
|
|
return socket.release_nonnull();
|
|
|
|
return ENOMEM;
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
|
|
|
|
2020-12-20 23:09:48 +00:00
|
|
|
KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2020-12-18 15:13:23 +00:00
|
|
|
auto& ipv4_packet = *reinterpret_cast<const IPv4Packet*>(raw_ipv4_packet.data());
|
2019-03-14 11:20:38 +00:00
|
|
|
auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
|
2020-12-18 15:13:23 +00:00
|
|
|
size_t payload_size = raw_ipv4_packet.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
|
2021-03-09 22:06:47 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "payload_size {}, will it fit in {}?", payload_size, buffer_size);
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY(buffer_size >= payload_size);
|
2020-09-12 03:11:07 +00:00
|
|
|
if (!buffer.write(tcp_packet.payload(), payload_size))
|
2021-01-20 22:11:17 +00:00
|
|
|
return EFAULT;
|
2019-03-14 11:20:38 +00:00
|
|
|
return payload_size;
|
|
|
|
}
|
|
|
|
|
2020-09-12 03:11:07 +00:00
|
|
|
KResultOr<size_t> TCPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2021-05-25 19:29:37 +00:00
|
|
|
RoutingDecision routing_decision = route_to(peer_address(), local_address(), bound_interface());
|
|
|
|
if (routing_decision.is_zero())
|
|
|
|
return EHOSTUNREACH;
|
|
|
|
size_t mss = routing_decision.adapter->mtu() - sizeof(IPv4Packet) - sizeof(TCPPacket);
|
|
|
|
data_length = min(data_length, mss);
|
|
|
|
int err = send_tcp_packet(TCPFlags::PUSH | TCPFlags::ACK, &data, data_length, &routing_decision);
|
2020-09-12 03:11:07 +00:00
|
|
|
if (err < 0)
|
2021-01-20 22:11:17 +00:00
|
|
|
return KResult((ErrnoCode)-err);
|
2019-03-14 11:20:38 +00:00
|
|
|
return data_length;
|
|
|
|
}
|
|
|
|
|
2021-05-12 07:14:37 +00:00
|
|
|
KResult TCPSocket::send_ack(bool allow_duplicate)
|
|
|
|
{
|
|
|
|
if (!allow_duplicate && m_last_ack_number_sent == m_ack_number)
|
|
|
|
return KSuccess;
|
|
|
|
return send_tcp_packet(TCPFlags::ACK);
|
|
|
|
}
|
|
|
|
|
2021-05-25 19:29:37 +00:00
|
|
|
KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload, size_t payload_size, RoutingDecision* user_routing_decision)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2021-05-26 03:35:05 +00:00
|
|
|
RoutingDecision routing_decision = user_routing_decision ? *user_routing_decision : route_to(peer_address(), local_address(), bound_interface());
|
|
|
|
if (routing_decision.is_zero())
|
|
|
|
return EHOSTUNREACH;
|
|
|
|
|
|
|
|
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
|
|
|
|
|
2021-05-11 19:09:11 +00:00
|
|
|
const bool has_mss_option = flags == TCPFlags::SYN;
|
|
|
|
const size_t options_size = has_mss_option ? sizeof(TCPOptionMSS) : 0;
|
2021-05-26 03:35:05 +00:00
|
|
|
const size_t tcp_header_size = sizeof(TCPPacket) + options_size;
|
|
|
|
const size_t buffer_size = ipv4_payload_offset + tcp_header_size + payload_size;
|
|
|
|
auto packet = routing_decision.adapter->acquire_packet_buffer(buffer_size);
|
|
|
|
if (!packet)
|
|
|
|
return ENOMEM;
|
|
|
|
routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(),
|
|
|
|
routing_decision.next_hop, peer_address(), IPv4Protocol::TCP,
|
|
|
|
buffer_size - ipv4_payload_offset, ttl());
|
|
|
|
memset(packet->buffer.data() + ipv4_payload_offset, 0, sizeof(TCPPacket));
|
|
|
|
auto& tcp_packet = *(TCPPacket*)(packet->buffer.data() + ipv4_payload_offset);
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY(local_port());
|
2019-05-04 14:40:34 +00:00
|
|
|
tcp_packet.set_source_port(local_port());
|
|
|
|
tcp_packet.set_destination_port(peer_port());
|
2021-05-11 14:18:33 +00:00
|
|
|
tcp_packet.set_window_size(NumericLimits<u16>::max());
|
2019-03-14 11:20:38 +00:00
|
|
|
tcp_packet.set_sequence_number(m_sequence_number);
|
2021-05-26 03:35:05 +00:00
|
|
|
tcp_packet.set_data_offset(tcp_header_size / sizeof(u32));
|
2019-03-14 11:20:38 +00:00
|
|
|
tcp_packet.set_flags(flags);
|
|
|
|
|
2021-05-12 07:14:37 +00:00
|
|
|
if (flags & TCPFlags::ACK) {
|
|
|
|
m_last_ack_number_sent = m_ack_number;
|
|
|
|
m_last_ack_sent_time = kgettimeofday();
|
2019-03-14 11:20:38 +00:00
|
|
|
tcp_packet.set_ack_number(m_ack_number);
|
2021-05-12 07:14:37 +00:00
|
|
|
}
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2021-05-27 22:49:53 +00:00
|
|
|
if (payload && !payload->read(tcp_packet.payload(), payload_size)) {
|
|
|
|
routing_decision.adapter->release_packet_buffer(*packet);
|
2021-01-31 11:13:16 +00:00
|
|
|
return EFAULT;
|
2021-05-27 22:49:53 +00:00
|
|
|
}
|
2020-09-12 03:11:07 +00:00
|
|
|
|
2019-08-09 02:48:28 +00:00
|
|
|
if (flags & TCPFlags::SYN) {
|
2019-03-14 11:20:38 +00:00
|
|
|
++m_sequence_number;
|
|
|
|
} else {
|
|
|
|
m_sequence_number += payload_size;
|
|
|
|
}
|
|
|
|
|
2021-05-11 19:09:11 +00:00
|
|
|
if (has_mss_option) {
|
|
|
|
u16 mss = routing_decision.adapter->mtu() - sizeof(IPv4Packet) - sizeof(TCPPacket);
|
|
|
|
TCPOptionMSS mss_option { mss };
|
2021-05-26 03:35:05 +00:00
|
|
|
VERIFY(packet->buffer.size() >= ipv4_payload_offset + sizeof(TCPPacket) + sizeof(mss_option));
|
|
|
|
memcpy(packet->buffer.data() + ipv4_payload_offset + sizeof(TCPPacket), &mss_option, sizeof(mss_option));
|
2021-05-11 19:09:11 +00:00
|
|
|
}
|
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
tcp_packet.set_checksum(compute_tcp_checksum(local_address(), peer_address(), tcp_packet, payload_size));
|
2019-09-08 07:38:08 +00:00
|
|
|
|
2021-06-04 15:58:55 +00:00
|
|
|
routing_decision.adapter->send_packet({ packet->buffer.data(), packet->buffer.size() });
|
2019-09-08 07:38:08 +00:00
|
|
|
|
2019-10-17 18:46:04 +00:00
|
|
|
m_packets_out++;
|
2020-12-18 18:18:19 +00:00
|
|
|
m_bytes_out += buffer_size;
|
2021-05-13 08:49:10 +00:00
|
|
|
if (tcp_packet.has_syn() || payload_size > 0) {
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(m_not_acked_lock);
|
2021-05-26 03:35:05 +00:00
|
|
|
m_not_acked.append({ m_sequence_number, move(packet), ipv4_payload_offset, *routing_decision.adapter });
|
2021-05-26 04:26:20 +00:00
|
|
|
m_not_acked_size += payload_size;
|
2021-05-13 08:49:10 +00:00
|
|
|
enqueue_for_retransmit();
|
2021-05-27 22:49:53 +00:00
|
|
|
} else {
|
|
|
|
routing_decision.adapter->release_packet_buffer(*packet);
|
2021-05-13 08:49:10 +00:00
|
|
|
}
|
|
|
|
|
2021-01-31 11:13:16 +00:00
|
|
|
return KSuccess;
|
2019-09-08 07:38:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::receive_tcp_packet(const TCPPacket& packet, u16 size)
|
2019-08-08 02:32:35 +00:00
|
|
|
{
|
2019-09-08 07:38:08 +00:00
|
|
|
if (packet.has_ack()) {
|
|
|
|
u32 ack_number = packet.ack_number();
|
|
|
|
|
2021-02-07 12:03:24 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket: receive_tcp_packet: {}", ack_number);
|
2019-09-08 07:38:08 +00:00
|
|
|
|
|
|
|
int removed = 0;
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(m_not_acked_lock);
|
2019-09-08 07:38:08 +00:00
|
|
|
while (!m_not_acked.is_empty()) {
|
|
|
|
auto& packet = m_not_acked.first();
|
|
|
|
|
2021-02-07 12:03:24 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket: iterate: {}", packet.ack_number);
|
2019-09-08 07:38:08 +00:00
|
|
|
|
|
|
|
if (packet.ack_number <= ack_number) {
|
2021-05-26 03:35:05 +00:00
|
|
|
auto old_adapter = packet.adapter.strong_ref();
|
|
|
|
if (old_adapter)
|
|
|
|
old_adapter->release_packet_buffer(*packet.buffer);
|
2021-05-26 04:26:20 +00:00
|
|
|
TCPPacket& tcp_packet = *(TCPPacket*)(packet.buffer->buffer.data() + packet.ipv4_payload_offset);
|
|
|
|
auto payload_size = packet.buffer->buffer.data() + packet.buffer->buffer.size() - (u8*)tcp_packet.payload();
|
|
|
|
m_not_acked_size -= payload_size;
|
|
|
|
evaluate_block_conditions();
|
2019-09-08 07:38:08 +00:00
|
|
|
m_not_acked.take_first();
|
|
|
|
removed++;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-13 08:49:10 +00:00
|
|
|
if (m_not_acked.is_empty()) {
|
|
|
|
m_retransmit_attempts = 0;
|
|
|
|
dequeue_for_retransmit();
|
|
|
|
}
|
|
|
|
|
2021-02-07 12:03:24 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket: receive_tcp_packet acknowledged {} packets", removed);
|
2019-09-08 07:38:08 +00:00
|
|
|
}
|
|
|
|
|
2019-08-08 02:32:35 +00:00
|
|
|
m_packets_in++;
|
2019-09-08 07:38:08 +00:00
|
|
|
m_bytes_in += packet.header_size() + size;
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
|
|
|
|
2021-05-12 07:14:37 +00:00
|
|
|
bool TCPSocket::should_delay_next_ack() const
|
|
|
|
{
|
|
|
|
// FIXME: We don't know the MSS here so make a reasonable guess.
|
|
|
|
const size_t mss = 1500;
|
|
|
|
|
|
|
|
// RFC 1122 says we should send an ACK for every two full-sized segments.
|
|
|
|
if (m_ack_number >= m_last_ack_number_sent + 2 * mss)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// RFC 1122 says we should not delay ACKs for more than 500 milliseconds.
|
|
|
|
if (kgettimeofday() >= m_last_ack_sent_time + Time::from_milliseconds(500))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-07-03 19:17:35 +00:00
|
|
|
NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, u16 payload_size)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2020-12-30 21:44:54 +00:00
|
|
|
struct [[gnu::packed]] PseudoHeader {
|
2019-03-14 11:20:38 +00:00
|
|
|
IPv4Address source;
|
|
|
|
IPv4Address destination;
|
2019-07-03 19:17:35 +00:00
|
|
|
u8 zero;
|
|
|
|
u8 protocol;
|
|
|
|
NetworkOrdered<u16> payload_size;
|
2019-03-14 11:20:38 +00:00
|
|
|
};
|
|
|
|
|
2021-05-11 19:09:11 +00:00
|
|
|
PseudoHeader pseudo_header { source, destination, 0, (u8)IPv4Protocol::TCP, packet.header_size() + payload_size };
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2019-07-03 19:17:35 +00:00
|
|
|
u32 checksum = 0;
|
|
|
|
auto* w = (const NetworkOrdered<u16>*)&pseudo_header;
|
|
|
|
for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(u16); ++i) {
|
2019-03-14 11:20:38 +00:00
|
|
|
checksum += w[i];
|
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
2019-07-03 19:17:35 +00:00
|
|
|
w = (const NetworkOrdered<u16>*)&packet;
|
2021-05-11 19:09:11 +00:00
|
|
|
for (size_t i = 0; i < packet.header_size() / sizeof(u16); ++i) {
|
2019-03-14 11:20:38 +00:00
|
|
|
checksum += w[i];
|
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
2021-05-11 19:09:11 +00:00
|
|
|
VERIFY(packet.data_offset() * 4 == packet.header_size());
|
2019-07-03 19:17:35 +00:00
|
|
|
w = (const NetworkOrdered<u16>*)packet.payload();
|
|
|
|
for (size_t i = 0; i < payload_size / sizeof(u16); ++i) {
|
2019-03-14 11:20:38 +00:00
|
|
|
checksum += w[i];
|
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
|
|
|
if (payload_size & 1) {
|
2019-07-03 19:17:35 +00:00
|
|
|
u16 expanded_byte = ((const u8*)packet.payload())[payload_size - 1] << 8;
|
2019-03-14 11:20:38 +00:00
|
|
|
checksum += expanded_byte;
|
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
|
|
|
return ~(checksum & 0xffff);
|
|
|
|
}
|
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
KResult TCPSocket::protocol_bind()
|
|
|
|
{
|
2019-08-09 02:38:56 +00:00
|
|
|
if (has_specific_local_address() && !m_adapter) {
|
2021-06-04 04:43:16 +00:00
|
|
|
m_adapter = NetworkingManagement::the().from_ipv4_address(local_address());
|
2019-08-06 13:40:38 +00:00
|
|
|
if (!m_adapter)
|
2021-01-20 22:11:17 +00:00
|
|
|
return EADDRNOTAVAIL;
|
2019-08-06 13:40:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return KSuccess;
|
|
|
|
}
|
|
|
|
|
2021-05-31 23:11:14 +00:00
|
|
|
KResult TCPSocket::protocol_listen(bool did_allocate_port)
|
2019-08-06 13:40:38 +00:00
|
|
|
{
|
2021-05-31 23:11:14 +00:00
|
|
|
if (!did_allocate_port) {
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker socket_locker(sockets_by_tuple().lock());
|
2021-05-31 23:11:14 +00:00
|
|
|
if (sockets_by_tuple().resource().contains(tuple()))
|
|
|
|
return EADDRINUSE;
|
|
|
|
sockets_by_tuple().resource().set(tuple(), this);
|
|
|
|
}
|
|
|
|
|
2019-08-09 02:48:28 +00:00
|
|
|
set_direction(Direction::Passive);
|
2019-08-06 13:40:38 +00:00
|
|
|
set_state(State::Listen);
|
2019-08-10 03:17:00 +00:00
|
|
|
set_setup_state(SetupState::Completed);
|
2019-08-06 13:40:38 +00:00
|
|
|
return KSuccess;
|
|
|
|
}
|
|
|
|
|
2019-06-13 20:03:04 +00:00
|
|
|
KResult TCPSocket::protocol_connect(FileDescription& description, ShouldBlock should_block)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(lock());
|
2020-10-21 18:51:02 +00:00
|
|
|
|
2019-08-28 11:58:01 +00:00
|
|
|
auto routing_decision = route_to(peer_address(), local_address());
|
2019-08-29 01:18:38 +00:00
|
|
|
if (routing_decision.is_zero())
|
2021-01-20 22:11:17 +00:00
|
|
|
return EHOSTUNREACH;
|
2019-08-28 11:58:01 +00:00
|
|
|
if (!has_specific_local_address())
|
|
|
|
set_local_address(routing_decision.adapter->ipv4_address());
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2021-05-31 23:11:14 +00:00
|
|
|
if (auto result = allocate_local_port_if_needed(); result.error_or_port.is_error())
|
|
|
|
return result.error_or_port.error();
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2020-01-08 15:03:01 +00:00
|
|
|
m_sequence_number = get_good_random<u32>();
|
2019-03-14 11:20:38 +00:00
|
|
|
m_ack_number = 0;
|
|
|
|
|
2019-08-10 03:17:00 +00:00
|
|
|
set_setup_state(SetupState::InProgress);
|
2020-09-12 03:11:07 +00:00
|
|
|
int err = send_tcp_packet(TCPFlags::SYN);
|
|
|
|
if (err < 0)
|
2021-01-20 22:11:17 +00:00
|
|
|
return KResult((ErrnoCode)-err);
|
2019-08-06 13:40:38 +00:00
|
|
|
m_state = State::SynSent;
|
2019-08-11 13:38:20 +00:00
|
|
|
m_role = Role::Connecting;
|
2019-08-09 02:48:28 +00:00
|
|
|
m_direction = Direction::Outgoing;
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2020-11-29 23:05:27 +00:00
|
|
|
evaluate_block_conditions();
|
|
|
|
|
2019-04-08 02:52:21 +00:00
|
|
|
if (should_block == ShouldBlock::Yes) {
|
2020-10-21 18:51:02 +00:00
|
|
|
locker.unlock();
|
2020-11-29 23:05:27 +00:00
|
|
|
auto unblock_flags = Thread::FileBlocker::BlockFlags::None;
|
2021-01-10 23:29:28 +00:00
|
|
|
if (Thread::current()->block<Thread::ConnectBlocker>({}, description, unblock_flags).was_interrupted())
|
2021-01-20 22:11:17 +00:00
|
|
|
return EINTR;
|
2020-10-21 18:51:02 +00:00
|
|
|
locker.lock();
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY(setup_state() == SetupState::Completed);
|
2020-11-29 23:05:27 +00:00
|
|
|
if (has_error()) { // TODO: check unblock_flags
|
2019-08-11 13:38:20 +00:00
|
|
|
m_role = Role::None;
|
2021-05-13 08:49:10 +00:00
|
|
|
if (error() == TCPSocket::Error::RetransmitTimeout)
|
|
|
|
return ETIMEDOUT;
|
|
|
|
else
|
|
|
|
return ECONNREFUSED;
|
2019-08-11 13:38:20 +00:00
|
|
|
}
|
2019-04-08 02:52:21 +00:00
|
|
|
return KSuccess;
|
|
|
|
}
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2021-01-20 22:11:17 +00:00
|
|
|
return EINPROGRESS;
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
2019-03-14 11:28:30 +00:00
|
|
|
|
2021-04-30 10:26:25 +00:00
|
|
|
KResultOr<u16> TCPSocket::protocol_allocate_local_port()
|
2019-03-14 11:28:30 +00:00
|
|
|
{
|
2021-05-19 14:35:09 +00:00
|
|
|
constexpr u16 first_ephemeral_port = 32768;
|
|
|
|
constexpr u16 last_ephemeral_port = 60999;
|
|
|
|
constexpr u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
|
2020-01-03 11:36:30 +00:00
|
|
|
u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
|
2019-03-18 03:03:44 +00:00
|
|
|
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_by_tuple().lock());
|
2019-07-03 19:17:35 +00:00
|
|
|
for (u16 port = first_scan_port;;) {
|
2019-08-06 13:40:38 +00:00
|
|
|
IPv4SocketTuple proposed_tuple(local_address(), port, peer_address(), peer_port());
|
|
|
|
|
|
|
|
auto it = sockets_by_tuple().resource().find(proposed_tuple);
|
|
|
|
if (it == sockets_by_tuple().resource().end()) {
|
2019-05-04 14:40:34 +00:00
|
|
|
set_local_port(port);
|
2019-08-06 13:40:38 +00:00
|
|
|
sockets_by_tuple().resource().set(proposed_tuple, this);
|
2019-03-18 03:03:44 +00:00
|
|
|
return port;
|
2019-03-14 11:28:30 +00:00
|
|
|
}
|
2019-03-18 03:03:44 +00:00
|
|
|
++port;
|
|
|
|
if (port > last_ephemeral_port)
|
|
|
|
port = first_ephemeral_port;
|
|
|
|
if (port == first_scan_port)
|
|
|
|
break;
|
2019-03-14 11:28:30 +00:00
|
|
|
}
|
2021-04-30 10:26:25 +00:00
|
|
|
return EADDRINUSE;
|
2019-03-14 11:28:30 +00:00
|
|
|
}
|
2019-03-14 14:23:32 +00:00
|
|
|
|
|
|
|
bool TCPSocket::protocol_is_disconnected() const
|
|
|
|
{
|
2019-08-06 13:40:38 +00:00
|
|
|
switch (m_state) {
|
|
|
|
case State::Closed:
|
|
|
|
case State::CloseWait:
|
|
|
|
case State::LastAck:
|
|
|
|
case State::FinWait1:
|
|
|
|
case State::FinWait2:
|
|
|
|
case State::Closing:
|
|
|
|
case State::TimeWait:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
2019-05-03 19:51:40 +00:00
|
|
|
}
|
2020-02-08 14:52:32 +00:00
|
|
|
|
|
|
|
void TCPSocket::shut_down_for_writing()
|
|
|
|
{
|
|
|
|
if (state() == State::Established) {
|
2021-05-01 19:10:08 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, " Sending FIN/ACK from Established and moving into FinWait1");
|
2020-12-20 23:09:48 +00:00
|
|
|
[[maybe_unused]] auto rc = send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
|
2020-02-08 14:52:32 +00:00
|
|
|
set_state(State::FinWait1);
|
|
|
|
} else {
|
2021-01-10 14:43:09 +00:00
|
|
|
dbgln(" Shutting down TCPSocket for writing but not moving to FinWait1 since state is {}", to_string(state()));
|
2020-02-08 14:52:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-02 16:20:05 +00:00
|
|
|
KResult TCPSocket::close()
|
2020-02-08 14:52:32 +00:00
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker socket_locker(lock());
|
2020-06-02 16:20:05 +00:00
|
|
|
auto result = IPv4Socket::close();
|
2020-02-08 14:52:32 +00:00
|
|
|
if (state() == State::CloseWait) {
|
2021-05-01 19:10:08 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, " Sending FIN from CloseWait and moving into LastAck");
|
2020-12-20 23:09:48 +00:00
|
|
|
[[maybe_unused]] auto rc = send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
|
2020-02-08 14:52:32 +00:00
|
|
|
set_state(State::LastAck);
|
|
|
|
}
|
|
|
|
|
2021-04-30 17:19:53 +00:00
|
|
|
if (state() != State::Closed && state() != State::Listen) {
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(closing_sockets().lock());
|
2021-04-30 17:19:53 +00:00
|
|
|
closing_sockets().resource().set(tuple(), *this);
|
|
|
|
}
|
2020-06-02 16:20:05 +00:00
|
|
|
return result;
|
2020-02-08 14:52:32 +00:00
|
|
|
}
|
2020-02-16 00:27:42 +00:00
|
|
|
|
2021-05-13 08:49:10 +00:00
|
|
|
static AK::Singleton<Lockable<HashTable<TCPSocket*>>> s_sockets_for_retransmit;
|
|
|
|
|
|
|
|
Lockable<HashTable<TCPSocket*>>& TCPSocket::sockets_for_retransmit()
|
|
|
|
{
|
|
|
|
return *s_sockets_for_retransmit;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::enqueue_for_retransmit()
|
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_for_retransmit().lock());
|
2021-05-13 08:49:10 +00:00
|
|
|
sockets_for_retransmit().resource().set(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::dequeue_for_retransmit()
|
|
|
|
{
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(sockets_for_retransmit().lock());
|
2021-05-13 08:49:10 +00:00
|
|
|
sockets_for_retransmit().resource().remove(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::retransmit_packets()
|
|
|
|
{
|
|
|
|
auto now = kgettimeofday();
|
|
|
|
|
|
|
|
// RFC6298 says we should have at least one second between retransmits. According to
|
|
|
|
// RFC1122 we must do exponential backoff - even for SYN packets.
|
|
|
|
i64 retransmit_interval = 1;
|
|
|
|
for (decltype(m_retransmit_attempts) i = 0; i < m_retransmit_attempts; i++)
|
|
|
|
retransmit_interval *= 2;
|
|
|
|
|
|
|
|
if (m_last_retransmit_time > now - Time::from_seconds(retransmit_interval))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket({}) handling retransmit", this);
|
|
|
|
|
|
|
|
m_last_retransmit_time = now;
|
|
|
|
++m_retransmit_attempts;
|
|
|
|
|
|
|
|
if (m_retransmit_attempts > maximum_retransmits) {
|
|
|
|
set_state(TCPSocket::State::Closed);
|
|
|
|
set_error(TCPSocket::Error::RetransmitTimeout);
|
|
|
|
set_setup_state(Socket::SetupState::Completed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-13 09:34:38 +00:00
|
|
|
auto routing_decision = route_to(peer_address(), local_address(), bound_interface());
|
|
|
|
if (routing_decision.is_zero())
|
|
|
|
return;
|
|
|
|
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker locker(m_not_acked_lock, Mutex::Mode::Shared);
|
2021-05-13 09:34:38 +00:00
|
|
|
for (auto& packet : m_not_acked) {
|
|
|
|
packet.tx_counter++;
|
|
|
|
|
|
|
|
if constexpr (TCP_SOCKET_DEBUG) {
|
2021-05-26 03:35:05 +00:00
|
|
|
auto& tcp_packet = *(const TCPPacket*)(packet.buffer->buffer.data() + packet.ipv4_payload_offset);
|
2021-05-13 09:34:38 +00:00
|
|
|
dbgln("Sending TCP packet from {}:{} to {}:{} with ({}{}{}{}) seq_no={}, ack_no={}, tx_counter={}",
|
|
|
|
local_address(), local_port(),
|
|
|
|
peer_address(), peer_port(),
|
|
|
|
(tcp_packet.has_syn() ? "SYN " : ""),
|
|
|
|
(tcp_packet.has_ack() ? "ACK " : ""),
|
|
|
|
(tcp_packet.has_fin() ? "FIN " : ""),
|
|
|
|
(tcp_packet.has_rst() ? "RST " : ""),
|
|
|
|
tcp_packet.sequence_number(),
|
|
|
|
tcp_packet.ack_number(),
|
|
|
|
packet.tx_counter);
|
|
|
|
}
|
|
|
|
|
2021-05-26 03:35:05 +00:00
|
|
|
size_t ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
|
|
|
|
if (ipv4_payload_offset != packet.ipv4_payload_offset) {
|
|
|
|
// FIXME: Add support for this. This can happen if after a route change
|
|
|
|
// we ended up on another adapter which doesn't have the same layer 2 type
|
|
|
|
// like the previous adapter.
|
|
|
|
VERIFY_NOT_REACHED();
|
2021-05-13 09:34:38 +00:00
|
|
|
}
|
2021-05-26 03:35:05 +00:00
|
|
|
routing_decision.adapter->fill_in_ipv4_header(*packet.buffer,
|
|
|
|
local_address(), routing_decision.next_hop, peer_address(),
|
|
|
|
IPv4Protocol::TCP, packet.buffer->buffer.size() - ipv4_payload_offset, ttl());
|
2021-06-04 15:58:55 +00:00
|
|
|
routing_decision.adapter->send_packet({ packet.buffer->buffer.data(), packet.buffer->buffer.size() });
|
2021-05-26 03:35:05 +00:00
|
|
|
m_packets_out++;
|
|
|
|
m_bytes_out += packet.buffer->buffer.size();
|
2021-05-13 09:34:38 +00:00
|
|
|
}
|
2021-05-13 08:49:10 +00:00
|
|
|
}
|
|
|
|
|
2021-05-26 04:26:20 +00:00
|
|
|
bool TCPSocket::can_write(const FileDescription& file_description, size_t size) const
|
|
|
|
{
|
|
|
|
if (!IPv4Socket::can_write(file_description, size))
|
|
|
|
return false;
|
|
|
|
|
2021-06-11 06:43:17 +00:00
|
|
|
if (m_state == State::SynSent || m_state == State::SynReceived)
|
|
|
|
return false;
|
|
|
|
|
2021-05-26 04:26:20 +00:00
|
|
|
if (!file_description.is_blocking())
|
|
|
|
return true;
|
|
|
|
|
2021-07-17 23:13:34 +00:00
|
|
|
MutexLocker lock(m_not_acked_lock);
|
2021-05-26 04:26:20 +00:00
|
|
|
return m_not_acked_size + size <= m_send_window_size;
|
|
|
|
}
|
|
|
|
|
2020-02-16 00:27:42 +00:00
|
|
|
}
|