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>
|
2023-03-18 11:17:13 +00:00
|
|
|
#include <Kernel/Devices/Generic/RandomDevice.h>
|
2021-09-07 11:39:11 +00:00
|
|
|
#include <Kernel/FileSystem/OpenFileDescription.h>
|
2021-08-21 21:31:15 +00:00
|
|
|
#include <Kernel/Locking/MutexProtected.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>
|
2020-01-03 11:36:30 +00:00
|
|
|
#include <Kernel/Random.h>
|
2023-02-24 17:45:37 +00:00
|
|
|
#include <Kernel/Tasks/Process.h>
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2020-02-16 00:27:42 +00:00
|
|
|
namespace Kernel {
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
void TCPSocket::for_each(Function<void(TCPSocket const&)> callback)
|
2019-08-06 13:40:38 +00:00
|
|
|
{
|
2022-04-01 17:58:27 +00:00
|
|
|
sockets_by_tuple().for_each_shared([&](auto const& it) {
|
2019-08-09 10:26:29 +00:00
|
|
|
callback(*it.value);
|
2021-07-18 10:14:43 +00:00
|
|
|
});
|
2019-08-06 13:40:38 +00:00
|
|
|
}
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
ErrorOr<void> TCPSocket::try_for_each(Function<ErrorOr<void>(TCPSocket const&)> callback)
|
2022-02-24 18:05:24 +00:00
|
|
|
{
|
2022-04-01 17:58:27 +00:00
|
|
|
return sockets_by_tuple().with_shared([&](auto const& sockets) -> ErrorOr<void> {
|
2022-02-24 18:05:24 +00:00
|
|
|
for (auto& it : sockets)
|
|
|
|
TRY(callback(*it.value));
|
|
|
|
return {};
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-01-06 21:06:00 +00:00
|
|
|
bool TCPSocket::unref() const
|
|
|
|
{
|
|
|
|
bool did_hit_zero = sockets_by_tuple().with_exclusive([&](auto& table) {
|
|
|
|
if (deref_base())
|
|
|
|
return false;
|
|
|
|
table.remove(tuple());
|
2022-01-08 14:43:56 +00:00
|
|
|
const_cast<TCPSocket&>(*this).revoke_weak_ptrs();
|
2022-01-06 21:06:00 +00:00
|
|
|
return true;
|
|
|
|
});
|
|
|
|
if (did_hit_zero) {
|
|
|
|
const_cast<TCPSocket&>(*this).will_be_destroyed();
|
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
return did_hit_zero;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2021-08-12 02:49:18 +00:00
|
|
|
if (new_state == State::Established && m_direction == Direction::Outgoing) {
|
2021-08-29 00:04:30 +00:00
|
|
|
set_role(Role::Connected);
|
2021-11-07 23:51:39 +00:00
|
|
|
clear_so_error();
|
2021-08-12 02:49:18 +00:00
|
|
|
}
|
2020-02-08 14:52:32 +00:00
|
|
|
|
2021-09-16 00:15:36 +00:00
|
|
|
if (new_state == State::TimeWait) {
|
|
|
|
// Once we hit TimeWait, we are only holding the socket in case there
|
|
|
|
// are packets on the way which we wouldn't want a new socket to get hit
|
|
|
|
// with, so there's no point in keeping the receive buffer around.
|
|
|
|
drop_receive_buffer();
|
|
|
|
}
|
|
|
|
|
2020-02-08 14:52:32 +00:00
|
|
|
if (new_state == State::Closed) {
|
2021-07-18 10:14:43 +00:00
|
|
|
closing_sockets().with_exclusive([&](auto& table) {
|
|
|
|
table.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
|
|
|
}
|
|
|
|
|
2023-03-10 06:53:02 +00:00
|
|
|
static Singleton<MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>> s_socket_closing;
|
2020-08-25 01:35:19 +00:00
|
|
|
|
2023-03-10 06:53:02 +00:00
|
|
|
MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& TCPSocket::closing_sockets()
|
2020-02-08 14:52:32 +00:00
|
|
|
{
|
2020-08-25 01:35:19 +00:00
|
|
|
return *s_socket_closing;
|
2019-08-10 03:14:00 +00:00
|
|
|
}
|
|
|
|
|
2021-08-21 21:31:15 +00:00
|
|
|
static Singleton<MutexProtected<HashMap<IPv4SocketTuple, TCPSocket*>>> s_socket_tuples;
|
2020-08-25 01:35:19 +00:00
|
|
|
|
2021-08-21 21:31:15 +00:00
|
|
|
MutexProtected<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
|
|
|
}
|
|
|
|
|
2023-03-10 06:53:02 +00:00
|
|
|
RefPtr<TCPSocket> TCPSocket::from_tuple(IPv4SocketTuple const& tuple)
|
2019-03-14 11:28:30 +00:00
|
|
|
{
|
2023-03-10 06:53:02 +00:00
|
|
|
return sockets_by_tuple().with_shared([&](auto const& table) -> RefPtr<TCPSocket> {
|
2021-07-18 10:14:43 +00:00
|
|
|
auto exact_match = table.get(tuple);
|
|
|
|
if (exact_match.has_value())
|
|
|
|
return { *exact_match.value() };
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
auto address_tuple = IPv4SocketTuple(tuple.local_address(), tuple.local_port(), IPv4Address(), 0);
|
|
|
|
auto address_match = table.get(address_tuple);
|
|
|
|
if (address_match.has_value())
|
|
|
|
return { *address_match.value() };
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
auto wildcard_tuple = IPv4SocketTuple(IPv4Address(), tuple.local_port(), IPv4Address(), 0);
|
|
|
|
auto wildcard_match = table.get(wildcard_tuple);
|
|
|
|
if (wildcard_match.has_value())
|
|
|
|
return { *wildcard_match.value() };
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
return {};
|
|
|
|
});
|
2019-03-14 11:28:30 +00:00
|
|
|
}
|
2023-03-10 06:53:02 +00:00
|
|
|
ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create_client(IPv4Address const& new_local_address, u16 new_local_port, IPv4Address const& 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);
|
2023-03-10 06:53:02 +00:00
|
|
|
return sockets_by_tuple().with_exclusive([&](auto& table) -> ErrorOr<NonnullRefPtr<TCPSocket>> {
|
2021-07-18 10:14:43 +00:00
|
|
|
if (table.contains(tuple))
|
2021-09-07 12:44:29 +00:00
|
|
|
return EEXIST;
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-09-07 12:44:29 +00:00
|
|
|
auto receive_buffer = TRY(try_create_receive_buffer());
|
|
|
|
auto client = TRY(TCPSocket::try_create(protocol(), move(receive_buffer)));
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
client->set_setup_state(SetupState::InProgress);
|
|
|
|
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);
|
|
|
|
client->set_originator(*this);
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
m_pending_release_for_accept.set(tuple, client);
|
|
|
|
table.set(tuple, client);
|
2019-08-09 02:48:28 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
return { move(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);
|
2022-04-09 19:25:39 +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
|
|
|
}
|
|
|
|
|
2023-03-10 06:53:02 +00:00
|
|
|
void TCPSocket::release_for_accept(NonnullRefPtr<TCPSocket> socket)
|
2019-09-08 07:18:28 +00:00
|
|
|
{
|
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?
|
2022-04-09 19:25:39 +00:00
|
|
|
[[maybe_unused]] auto rc = queue_connection_from(move(socket));
|
2019-09-08 07:18:28 +00:00
|
|
|
}
|
|
|
|
|
2021-09-07 13:11:49 +00:00
|
|
|
TCPSocket::TCPSocket(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer, NonnullOwnPtr<KBuffer> scratch_buffer)
|
2021-08-01 12:11:05 +00:00
|
|
|
: 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-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
|
|
|
}
|
|
|
|
|
2023-03-10 06:53:02 +00:00
|
|
|
ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_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.
|
2022-04-10 22:08:07 +00:00
|
|
|
auto scratch_buffer = TRY(KBuffer::try_create_with_size("TCPSocket: Scratch buffer"sv, 65536));
|
2023-03-10 06:53:02 +00:00
|
|
|
return adopt_nonnull_ref_or_enomem(new (nothrow) TCPSocket(protocol, move(receive_buffer), move(scratch_buffer)));
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
|
|
|
|
2021-09-11 19:38:05 +00:00
|
|
|
ErrorOr<size_t> TCPSocket::protocol_size(ReadonlyBytes raw_ipv4_packet)
|
|
|
|
{
|
2022-04-01 17:58:27 +00:00
|
|
|
auto& ipv4_packet = *reinterpret_cast<IPv4Packet const*>(raw_ipv4_packet.data());
|
|
|
|
auto& tcp_packet = *static_cast<TCPPacket const*>(ipv4_packet.payload());
|
2021-09-11 19:38:05 +00:00
|
|
|
return raw_ipv4_packet.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
|
|
|
|
}
|
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
ErrorOr<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
|
|
|
{
|
2022-04-01 17:58:27 +00:00
|
|
|
auto& ipv4_packet = *reinterpret_cast<IPv4Packet const*>(raw_ipv4_packet.data());
|
|
|
|
auto& tcp_packet = *static_cast<TCPPacket const*>(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);
|
2021-09-07 13:05:51 +00:00
|
|
|
SOCKET_TRY(buffer.write(tcp_packet.payload(), payload_size));
|
2019-03-14 11:20:38 +00:00
|
|
|
return payload_size;
|
|
|
|
}
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
ErrorOr<size_t> TCPSocket::protocol_send(UserOrKernelBuffer const& data, size_t data_length)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2023-04-11 00:50:15 +00:00
|
|
|
auto adapter = bound_interface().with([](auto& bound_device) -> RefPtr<NetworkAdapter> { return bound_device; });
|
|
|
|
RoutingDecision routing_decision = route_to(peer_address(), local_address(), adapter);
|
2021-05-25 19:29:37 +00:00
|
|
|
if (routing_decision.is_zero())
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(EHOSTUNREACH);
|
2021-05-25 19:29:37 +00:00
|
|
|
size_t mss = routing_decision.adapter->mtu() - sizeof(IPv4Packet) - sizeof(TCPPacket);
|
|
|
|
data_length = min(data_length, mss);
|
2022-03-17 13:24:21 +00:00
|
|
|
TRY(send_tcp_packet(TCPFlags::PSH | TCPFlags::ACK, &data, data_length, &routing_decision));
|
2019-03-14 11:20:38 +00:00
|
|
|
return data_length;
|
|
|
|
}
|
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
ErrorOr<void> TCPSocket::send_ack(bool allow_duplicate)
|
2021-05-12 07:14:37 +00:00
|
|
|
{
|
|
|
|
if (!allow_duplicate && m_last_ack_number_sent == m_ack_number)
|
2021-11-07 23:51:39 +00:00
|
|
|
return {};
|
2021-05-12 07:14:37 +00:00
|
|
|
return send_tcp_packet(TCPFlags::ACK);
|
|
|
|
}
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
ErrorOr<void> TCPSocket::send_tcp_packet(u16 flags, UserOrKernelBuffer const* payload, size_t payload_size, RoutingDecision* user_routing_decision)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2023-04-11 00:50:15 +00:00
|
|
|
auto adapter = bound_interface().with([](auto& bound_device) -> RefPtr<NetworkAdapter> { return bound_device; });
|
|
|
|
RoutingDecision routing_decision = user_routing_decision ? *user_routing_decision : route_to(peer_address(), local_address(), adapter);
|
2021-05-26 03:35:05 +00:00
|
|
|
if (routing_decision.is_zero())
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(EHOSTUNREACH);
|
2021-05-26 03:35:05 +00:00
|
|
|
|
|
|
|
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
bool const has_mss_option = flags == TCPFlags::SYN;
|
2021-05-11 19:09:11 +00:00
|
|
|
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)
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(ENOMEM);
|
2021-05-26 03:35:05 +00:00
|
|
|
routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(),
|
|
|
|
routing_decision.next_hop, peer_address(), IPv4Protocol::TCP,
|
2021-10-27 20:20:24 +00:00
|
|
|
buffer_size - ipv4_payload_offset, type_of_service(), ttl());
|
2021-08-01 12:11:49 +00:00
|
|
|
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-09-07 10:09:52 +00:00
|
|
|
if (payload) {
|
|
|
|
if (auto result = payload->read(tcp_packet.payload(), payload_size); result.is_error()) {
|
|
|
|
routing_decision.adapter->release_packet_buffer(*packet);
|
2021-11-07 23:51:39 +00:00
|
|
|
return set_so_error(result.release_error());
|
2021-09-07 10:09:52 +00:00
|
|
|
}
|
2021-05-27 22:49:53 +00:00
|
|
|
}
|
2020-09-12 03:11:07 +00:00
|
|
|
|
2022-02-11 11:38:10 +00:00
|
|
|
if (flags & TCPFlags::ACK) {
|
|
|
|
m_last_ack_number_sent = m_ack_number;
|
|
|
|
m_last_ack_sent_time = kgettimeofday();
|
|
|
|
tcp_packet.set_ack_number(m_ack_number);
|
|
|
|
}
|
|
|
|
|
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-08-01 12:11:49 +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
|
|
|
|
2022-11-01 09:04:13 +00:00
|
|
|
bool expect_ack { tcp_packet.has_syn() || payload_size > 0 };
|
|
|
|
if (expect_ack) {
|
|
|
|
bool append_failed { false };
|
2021-08-07 13:42:11 +00:00
|
|
|
m_unacked_packets.with_exclusive([&](auto& unacked_packets) {
|
2022-11-01 09:04:13 +00:00
|
|
|
auto result = unacked_packets.packets.try_append({ m_sequence_number, packet, ipv4_payload_offset, *routing_decision.adapter });
|
|
|
|
if (result.is_error()) {
|
|
|
|
dbgln("TCPSocket: Dropped outbound packet because try_append() failed");
|
|
|
|
append_failed = true;
|
|
|
|
return;
|
|
|
|
}
|
2021-08-07 13:42:11 +00:00
|
|
|
unacked_packets.size += payload_size;
|
|
|
|
enqueue_for_retransmit();
|
|
|
|
});
|
2022-11-01 09:04:13 +00:00
|
|
|
if (append_failed)
|
|
|
|
return set_so_error(ENOMEM);
|
2021-05-13 08:49:10 +00:00
|
|
|
}
|
|
|
|
|
2022-11-01 09:04:13 +00:00
|
|
|
m_packets_out++;
|
|
|
|
m_bytes_out += buffer_size;
|
|
|
|
routing_decision.adapter->send_packet(packet->bytes());
|
|
|
|
if (!expect_ack)
|
|
|
|
routing_decision.adapter->release_packet_buffer(*packet);
|
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
return {};
|
2019-09-08 07:38:08 +00:00
|
|
|
}
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
void TCPSocket::receive_tcp_packet(TCPPacket const& 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-08-07 13:42:11 +00:00
|
|
|
m_unacked_packets.with_exclusive([&](auto& unacked_packets) {
|
|
|
|
while (!unacked_packets.packets.is_empty()) {
|
|
|
|
auto& packet = unacked_packets.packets.first();
|
|
|
|
|
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket: iterate: {}", packet.ack_number);
|
|
|
|
|
|
|
|
if (packet.ack_number <= ack_number) {
|
|
|
|
auto old_adapter = packet.adapter.strong_ref();
|
|
|
|
if (old_adapter)
|
|
|
|
old_adapter->release_packet_buffer(*packet.buffer);
|
|
|
|
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();
|
|
|
|
unacked_packets.size -= payload_size;
|
|
|
|
evaluate_block_conditions();
|
|
|
|
unacked_packets.packets.take_first();
|
|
|
|
removed++;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
2019-09-08 07:38:08 +00:00
|
|
|
}
|
|
|
|
|
2021-08-07 13:42:11 +00:00
|
|
|
if (unacked_packets.packets.is_empty()) {
|
|
|
|
m_retransmit_attempts = 0;
|
|
|
|
dequeue_for_retransmit();
|
|
|
|
}
|
2021-05-13 08:49:10 +00:00
|
|
|
|
2021-08-07 13:42:11 +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.
|
2023-03-13 15:30:34 +00:00
|
|
|
if (kgettimeofday() >= m_last_ack_sent_time + Duration::from_milliseconds(500))
|
2021-05-12 07:14:37 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(IPv4Address const& source, IPv4Address const& destination, TCPPacket const& packet, u16 payload_size)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2022-12-12 16:52:00 +00:00
|
|
|
union PseudoHeader {
|
|
|
|
struct [[gnu::packed]] {
|
|
|
|
IPv4Address source;
|
|
|
|
IPv4Address destination;
|
|
|
|
u8 zero;
|
|
|
|
u8 protocol;
|
|
|
|
NetworkOrdered<u16> payload_size;
|
|
|
|
} header;
|
|
|
|
u16 raw[6];
|
2019-03-14 11:20:38 +00:00
|
|
|
};
|
2022-12-12 16:52:00 +00:00
|
|
|
static_assert(sizeof(PseudoHeader) == 12);
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2022-12-13 11:39:52 +00:00
|
|
|
Checked<u16> packet_size = packet.header_size();
|
|
|
|
packet_size += payload_size;
|
|
|
|
VERIFY(!packet_size.has_overflow());
|
|
|
|
|
|
|
|
PseudoHeader pseudo_header { .header = { source, destination, 0, (u8)IPv4Protocol::TCP, packet_size.value() } };
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2019-07-03 19:17:35 +00:00
|
|
|
u32 checksum = 0;
|
2022-12-12 16:52:00 +00:00
|
|
|
auto* raw_pseudo_header = pseudo_header.raw;
|
2019-07-03 19:17:35 +00:00
|
|
|
for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(u16); ++i) {
|
2021-09-01 07:27:42 +00:00
|
|
|
checksum += AK::convert_between_host_and_network_endian(raw_pseudo_header[i]);
|
2019-03-14 11:20:38 +00:00
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
2022-12-12 16:52:00 +00:00
|
|
|
auto* raw_packet = bit_cast<u16*>(&packet);
|
2021-05-11 19:09:11 +00:00
|
|
|
for (size_t i = 0; i < packet.header_size() / sizeof(u16); ++i) {
|
2021-09-01 07:27:42 +00:00
|
|
|
checksum += AK::convert_between_host_and_network_endian(raw_packet[i]);
|
2019-03-14 11:20:38 +00:00
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
2021-05-11 19:09:11 +00:00
|
|
|
VERIFY(packet.data_offset() * 4 == packet.header_size());
|
2022-12-12 16:52:00 +00:00
|
|
|
auto* raw_payload = bit_cast<u16*>(packet.payload());
|
2019-07-03 19:17:35 +00:00
|
|
|
for (size_t i = 0; i < payload_size / sizeof(u16); ++i) {
|
2021-09-01 07:27:42 +00:00
|
|
|
checksum += AK::convert_between_host_and_network_endian(raw_payload[i]);
|
2019-03-14 11:20:38 +00:00
|
|
|
if (checksum > 0xffff)
|
|
|
|
checksum = (checksum >> 16) + (checksum & 0xffff);
|
|
|
|
}
|
|
|
|
if (payload_size & 1) {
|
2022-04-01 17:58:27 +00:00
|
|
|
u16 expanded_byte = ((u8 const*)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);
|
|
|
|
}
|
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
ErrorOr<void> TCPSocket::protocol_bind()
|
2019-08-06 13:40:38 +00:00
|
|
|
{
|
2023-04-11 00:50:15 +00:00
|
|
|
return m_adapter.with([this](auto& adapter) -> ErrorOr<void> {
|
|
|
|
if (has_specific_local_address() && !adapter) {
|
|
|
|
adapter = NetworkingManagement::the().from_ipv4_address(local_address());
|
|
|
|
if (!adapter)
|
|
|
|
return set_so_error(EADDRNOTAVAIL);
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
});
|
2019-08-06 13:40:38 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
ErrorOr<void> 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-18 10:14:43 +00:00
|
|
|
bool ok = sockets_by_tuple().with_exclusive([&](auto& table) -> bool {
|
|
|
|
if (table.contains(tuple()))
|
|
|
|
return false;
|
|
|
|
table.set(tuple(), this);
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
if (!ok)
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(EADDRINUSE);
|
2021-05-31 23:11:14 +00:00
|
|
|
}
|
|
|
|
|
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);
|
2021-11-07 23:51:39 +00:00
|
|
|
return {};
|
2019-08-06 13:40:38 +00:00
|
|
|
}
|
|
|
|
|
2022-07-13 06:31:24 +00:00
|
|
|
ErrorOr<void> TCPSocket::protocol_connect(OpenFileDescription& description)
|
2019-03-14 11:20:38 +00:00
|
|
|
{
|
2021-08-29 11:10:55 +00:00
|
|
|
MutexLocker locker(mutex());
|
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-08-01 15:27:23 +00:00
|
|
|
return set_so_error(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())
|
2021-11-07 23:51:39 +00:00
|
|
|
return result.error_or_port.release_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);
|
2021-09-05 13:48:40 +00:00
|
|
|
TRY(send_tcp_packet(TCPFlags::SYN));
|
2019-08-06 13:40:38 +00:00
|
|
|
m_state = State::SynSent;
|
2021-08-29 00:04:30 +00:00
|
|
|
set_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();
|
|
|
|
|
2022-07-13 06:31:24 +00:00
|
|
|
if (description.is_blocking()) {
|
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-08-01 15:27:23 +00:00
|
|
|
return set_so_error(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
|
2021-08-29 00:04:30 +00:00
|
|
|
set_role(Role::None);
|
2021-05-13 08:49:10 +00:00
|
|
|
if (error() == TCPSocket::Error::RetransmitTimeout)
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(ETIMEDOUT);
|
2021-05-13 08:49:10 +00:00
|
|
|
else
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(ECONNREFUSED);
|
2019-08-11 13:38:20 +00:00
|
|
|
}
|
2021-11-07 23:51:39 +00:00
|
|
|
return {};
|
2019-04-08 02:52:21 +00:00
|
|
|
}
|
2019-03-14 11:20:38 +00:00
|
|
|
|
2021-08-01 15:27:23 +00:00
|
|
|
return set_so_error(EINPROGRESS);
|
2019-03-14 11:20:38 +00:00
|
|
|
}
|
2019-03-14 11:28:30 +00:00
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
ErrorOr<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-11-07 23:51:39 +00:00
|
|
|
return sockets_by_tuple().with_exclusive([&](auto& table) -> ErrorOr<u16> {
|
2021-07-18 10:14:43 +00:00
|
|
|
for (u16 port = first_scan_port;;) {
|
|
|
|
IPv4SocketTuple proposed_tuple(local_address(), port, peer_address(), peer_port());
|
2019-08-06 13:40:38 +00:00
|
|
|
|
2021-07-18 10:14:43 +00:00
|
|
|
auto it = table.find(proposed_tuple);
|
|
|
|
if (it == table.end()) {
|
|
|
|
set_local_port(port);
|
|
|
|
table.set(proposed_tuple, this);
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
++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-08-01 15:27:23 +00:00
|
|
|
return set_so_error(EADDRINUSE);
|
2021-07-18 10:14:43 +00:00
|
|
|
});
|
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) {
|
2022-02-06 16:28:58 +00:00
|
|
|
dbgln_if(TCP_SOCKET_DEBUG, " Sending FIN from Established and moving into FinWait1");
|
|
|
|
(void)send_tcp_packet(TCPFlags::FIN);
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-07 23:51:39 +00:00
|
|
|
ErrorOr<void> TCPSocket::close()
|
2020-02-08 14:52:32 +00:00
|
|
|
{
|
2021-08-29 11:10:55 +00:00
|
|
|
MutexLocker locker(mutex());
|
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-07-18 10:14:43 +00:00
|
|
|
if (state() != State::Closed && state() != State::Listen)
|
|
|
|
closing_sockets().with_exclusive([&](auto& table) {
|
|
|
|
table.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-08-21 21:31:15 +00:00
|
|
|
static Singleton<MutexProtected<TCPSocket::RetransmitList>> s_sockets_for_retransmit;
|
2021-05-13 08:49:10 +00:00
|
|
|
|
2021-08-21 21:31:15 +00:00
|
|
|
MutexProtected<TCPSocket::RetransmitList>& TCPSocket::sockets_for_retransmit()
|
2021-05-13 08:49:10 +00:00
|
|
|
{
|
|
|
|
return *s_sockets_for_retransmit;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::enqueue_for_retransmit()
|
|
|
|
{
|
2021-08-15 14:37:45 +00:00
|
|
|
sockets_for_retransmit().with_exclusive([&](auto& list) {
|
|
|
|
list.append(*this);
|
2021-07-18 10:14:43 +00:00
|
|
|
});
|
2021-05-13 08:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TCPSocket::dequeue_for_retransmit()
|
|
|
|
{
|
2021-08-15 14:37:45 +00:00
|
|
|
sockets_for_retransmit().with_exclusive([&](auto& list) {
|
|
|
|
list.remove(*this);
|
2021-07-18 10:14:43 +00:00
|
|
|
});
|
2021-05-13 08:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2023-03-13 15:30:34 +00:00
|
|
|
if (m_last_retransmit_time > now - Duration::from_seconds(retransmit_interval))
|
2021-05-13 08:49:10 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2023-04-11 00:50:15 +00:00
|
|
|
auto adapter = bound_interface().with([](auto& bound_device) -> RefPtr<NetworkAdapter> { return bound_device; });
|
|
|
|
auto routing_decision = route_to(peer_address(), local_address(), adapter);
|
2021-05-13 09:34:38 +00:00
|
|
|
if (routing_decision.is_zero())
|
|
|
|
return;
|
|
|
|
|
2021-08-07 13:42:11 +00:00
|
|
|
m_unacked_packets.with_exclusive([&](auto& unacked_packets) {
|
|
|
|
for (auto& packet : unacked_packets.packets) {
|
|
|
|
packet.tx_counter++;
|
|
|
|
|
|
|
|
if constexpr (TCP_SOCKET_DEBUG) {
|
|
|
|
auto& tcp_packet = *(const TCPPacket*)(packet.buffer->buffer->data() + packet.ipv4_payload_offset);
|
|
|
|
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-13 09:34:38 +00:00
|
|
|
|
2021-08-07 13:42:11 +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-08-01 12:11:49 +00:00
|
|
|
|
2021-08-07 13:42:11 +00:00
|
|
|
auto packet_buffer = packet.buffer->bytes();
|
2021-08-01 12:11:49 +00:00
|
|
|
|
2021-08-07 13:42:11 +00:00
|
|
|
routing_decision.adapter->fill_in_ipv4_header(*packet.buffer,
|
|
|
|
local_address(), routing_decision.next_hop, peer_address(),
|
2021-10-27 20:20:24 +00:00
|
|
|
IPv4Protocol::TCP, packet_buffer.size() - ipv4_payload_offset, type_of_service(), ttl());
|
2021-08-07 13:42:11 +00:00
|
|
|
routing_decision.adapter->send_packet(packet_buffer);
|
|
|
|
m_packets_out++;
|
|
|
|
m_bytes_out += packet_buffer.size();
|
|
|
|
}
|
|
|
|
});
|
2021-05-13 08:49:10 +00:00
|
|
|
}
|
|
|
|
|
2022-04-01 17:58:27 +00:00
|
|
|
bool TCPSocket::can_write(OpenFileDescription const& file_description, u64 size) const
|
2021-05-26 04:26:20 +00:00
|
|
|
{
|
|
|
|
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-08-07 13:42:11 +00:00
|
|
|
return m_unacked_packets.with_shared([&](auto& unacked_packets) {
|
|
|
|
return unacked_packets.size + size <= m_send_window_size;
|
|
|
|
});
|
2021-05-26 04:26:20 +00:00
|
|
|
}
|
2020-02-16 00:27:42 +00:00
|
|
|
}
|