eliott/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2026-05-09 08:32:04 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
a706e81d41c76c9bee0943eb351bf4f250e3b420
serenity/Kernel/Net/NetworkTask.cpp
sdomi a706e81d41 Kernel/Net: Remove useless checks from handle_arp 
According to ARP.h, address lengths default to size of their
underlying types (IPv4Address and MACAddress respectively). We never
modify those values, and in reality, ARP never carries anything else.
Hence, those checks resolved to comparing sizeof to itself, which
probably gets optimized out of the compiler anyways.

This change removes the checks that will never fail, plus changes the
function definition to pass adapter directly, matching other handlers.
2024-10-04 12:04:17 +02:00

870 lines
38 KiB
C++
Raw Blame History

/*
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2024, sdomi <ja@sdomi.pl>
* Copyright (c) 2024, kleines Filmröllchen <filmroellchen@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/Debug.h>
#include <Kernel/Locking/Mutex.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Net/EtherType.h>
#include <Kernel/Net/EthernetFrameHeader.h>
#include <Kernel/Net/ICMP.h>
#include <Kernel/Net/ICMPv6.h>
#include <Kernel/Net/IP/ARP.h>
#include <Kernel/Net/IP/IP.h>
#include <Kernel/Net/IP/IPv4.h>
#include <Kernel/Net/IP/IPv6.h>
#include <Kernel/Net/IP/Socket.h>
#include <Kernel/Net/LoopbackAdapter.h>
#include <Kernel/Net/NetworkTask.h>
#include <Kernel/Net/NetworkingManagement.h>
#include <Kernel/Net/Routing.h>
#include <Kernel/Net/TCP.h>
#include <Kernel/Net/TCPSocket.h>
#include <Kernel/Net/UDP.h>
#include <Kernel/Net/UDPSocket.h>
#include <Kernel/Tasks/Process.h>
namespace Kernel {
static void handle_arp(EthernetFrameHeader const&, size_t frame_size, RefPtr<NetworkAdapter> adapter);
static void handle_ipv4(EthernetFrameHeader const&, size_t frame_size, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter);
static void handle_icmp(EthernetFrameHeader const&, IPv4Packet const&, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter);
static void handle_ipv6(EthernetFrameHeader const&, size_t frame_size, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter);
static void handle_icmpv6(EthernetFrameHeader const&, IPv6PacketHeader const&, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter);
static void handle_udp(IPv4Packet const&, UnixDateTime const& packet_timestamp);
static void handle_tcp(IPv4Packet const&, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter);
static void send_delayed_tcp_ack(TCPSocket& socket);
static void send_tcp_rst(IPv4Packet const& ipv4_packet, TCPPacket const& tcp_packet, RefPtr<NetworkAdapter> adapter);
static void flush_delayed_tcp_acks();
static void retransmit_tcp_packets();
static Thread* network_task = nullptr;
static HashTable<NonnullRefPtr<TCPSocket>>* delayed_ack_sockets;
[[noreturn]] static void NetworkTask_main(void*);
void NetworkTask::spawn()
{
auto [_, first_thread] = MUST(Process::create_kernel_process("Network Task"sv, NetworkTask_main, nullptr));
network_task = first_thread;
}
bool NetworkTask::is_current()
{
return Thread::current() == network_task;
}
void NetworkTask_main(void*)
{
delayed_ack_sockets = new HashTable<NonnullRefPtr<TCPSocket>>;
WaitQueue packet_wait_queue;
int pending_packets = 0;
NetworkingManagement::the().for_each([&](auto& adapter) {
dmesgln("NetworkTask: {} network adapter found: hw={}", adapter.class_name(), adapter.mac_address().to_string());
if (adapter.class_name() == "LoopbackAdapter"sv) {
adapter.set_ipv4_address({ 127, 0, 0, 1 });
adapter.set_ipv4_netmask({ 255, 0, 0, 0 });
}
adapter.on_receive = [&]() {
pending_packets++;
packet_wait_queue.wake_all();
};
});
size_t buffer_size = 64 * KiB;
auto region_or_error = MM.allocate_kernel_region(buffer_size, "Kernel Packet Buffer"sv, Memory::Region::Access::ReadWrite);
if (region_or_error.is_error())
TODO();
auto buffer_region = region_or_error.release_value();
struct {
u8* buffer;
UnixDateTime packet_timestamp;
RefPtr<NetworkAdapter> adapter;
} meta;
meta.buffer = (u8*)buffer_region->vaddr().get();
while (!Process::current().is_dying()) {
flush_delayed_tcp_acks();
retransmit_tcp_packets();
size_t packet_size = 0;
if (!pending_packets) {
auto timeout_time = Duration::from_milliseconds(500);
auto timeout = Thread::BlockTimeout { false, &timeout_time };
[[maybe_unused]] auto result = packet_wait_queue.wait_on(timeout, "NetworkTask"sv);
continue;
} else {
NetworkingManagement::the().for_each([&](auto& adapter) {
if (packet_size || !adapter.has_queued_packets()) {
return;
}
packet_size = adapter.dequeue_packet(meta.buffer, buffer_size, meta.packet_timestamp);
pending_packets--;
dbgln_if(NETWORK_TASK_DEBUG, "NetworkTask: Dequeued packet from {} ({} bytes)", adapter.name(), packet_size);
meta.adapter = adapter;
});
}
if (packet_size < sizeof(EthernetFrameHeader)) {
dbgln("NetworkTask: Packet is too small to be an Ethernet packet! ({})", packet_size);
continue;
}
auto& eth = *(EthernetFrameHeader const*)meta.buffer;
dbgln_if(ETHERNET_DEBUG, "NetworkTask: From {} to {}, ether_type={:#04x}, packet_size={}", eth.source().to_string(), eth.destination().to_string(), eth.ether_type(), packet_size);
switch (eth.ether_type()) {
case EtherType::ARP:
handle_arp(eth, packet_size, meta.adapter);
break;
case EtherType::IPv4:
handle_ipv4(eth, packet_size, meta.packet_timestamp, meta.adapter);
break;
case EtherType::IPv6:
handle_ipv6(eth, packet_size, meta.packet_timestamp, meta.adapter);
break;
default:
dbgln_if(ETHERNET_DEBUG, "NetworkTask: Unknown ethernet type {:#04x}", eth.ether_type());
}
}
Process::current().sys$exit(0);
VERIFY_NOT_REACHED();
}
void handle_arp(EthernetFrameHeader const& eth, size_t frame_size, RefPtr<NetworkAdapter> adapter)
{
constexpr size_t minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
if (frame_size < minimum_arp_frame_size) {
dbgln("handle_arp: Frame too small ({}, need {})", frame_size, minimum_arp_frame_size);
return;
}
auto& packet = *static_cast<ARPPacket const*>(eth.payload());
dbgln_if(ARP_DEBUG, "handle_arp: operation={:#04x}, sender={}/{}, target={}/{}",
packet.operation(),
packet.sender_hardware_address().to_string(),
packet.sender_protocol_address().to_string(),
packet.target_hardware_address().to_string(),
packet.target_protocol_address().to_string());
if (!packet.sender_hardware_address().is_zero() && !packet.sender_protocol_address().is_zero()) {
// Someone has this IPv4 address. I guess we can try to remember that.
// FIXME: Protect against ARP spamming.
update_arp_table(packet.sender_protocol_address(), packet.sender_hardware_address(), UpdateTable::Set);
}
if (packet.target_protocol_address() != adapter->ipv4_address()) {
dbgln_if(ARP_DEBUG, "handle_arp: Received a packet for {} on {}, discarding",
packet.target_protocol_address(),
adapter->name());
return;
}
if (packet.operation() == ARPOperation::Request) {
dbgln("handle_arp: Responding to ARP request for my IPv4 address ({})", adapter->ipv4_address());
ARPPacket response;
response.set_operation(ARPOperation::Response);
response.set_target_hardware_address(packet.sender_hardware_address());
response.set_target_protocol_address(packet.sender_protocol_address());
response.set_sender_hardware_address(adapter->mac_address());
response.set_sender_protocol_address(adapter->ipv4_address());
adapter->send(packet.sender_hardware_address(), response);
return;
}
}
void handle_ipv4(EthernetFrameHeader const& eth, size_t frame_size, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter)
{
constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
if (frame_size < minimum_ipv4_frame_size) {
dbgln("handle_ipv4: Frame too small ({}, need {})", frame_size, minimum_ipv4_frame_size);
return;
}
auto& packet = *static_cast<IPv4Packet const*>(eth.payload());
if (packet.length() < sizeof(IPv4Packet)) {
dbgln("handle_ipv4: IPv4 packet too short ({}, need {})", packet.length(), sizeof(IPv4Packet));
return;
}
size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader);
if (packet.length() > actual_ipv4_packet_length) {
dbgln("handle_ipv4: IPv4 packet claims to be longer than it is ({}, actually {})", packet.length(), actual_ipv4_packet_length);
return;
}
if (adapter->ipv4_address() != packet.destination() && adapter->ipv4_broadcast() != packet.destination()) {
dbgln_if(IPV4_DEBUG, "handle_ipv4: Received a packet for {}, discarding", packet.destination());
return;
}
dbgln_if(IPV4_DEBUG, "handle_ipv4: source={}, destination={}", packet.source(), packet.destination());
auto my_net = adapter->ipv4_address().to_u32() & adapter->ipv4_netmask().to_u32();
auto their_net = packet.source().to_u32() & adapter->ipv4_netmask().to_u32();
// FIXME: we probably shouldn't update the ARP table on every received packet...
if (my_net == their_net)
update_arp_table(packet.source(), eth.source(), UpdateTable::Set);
switch ((TransportProtocol)packet.protocol()) {
case TransportProtocol::ICMP:
return handle_icmp(eth, packet, packet_timestamp, adapter);
case TransportProtocol::UDP:
return handle_udp(packet, packet_timestamp);
case TransportProtocol::TCP:
return handle_tcp(packet, packet_timestamp, adapter);
default:
dbgln_if(IPV4_DEBUG, "handle_ipv4: Unhandled protocol {:#02x}", packet.protocol());
break;
}
}
void handle_ipv6(EthernetFrameHeader const& eth, size_t frame_size, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter)
{
(void)packet_timestamp;
constexpr size_t minimum_ipv6_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv6PacketHeader);
if (frame_size < minimum_ipv6_frame_size) {
dbgln("handle_ipv6: Frame too small ({}, need {})", frame_size, minimum_ipv6_frame_size);
return;
}
auto& packet = *static_cast<IPv6PacketHeader const*>(eth.payload());
size_t const actual_ipv6_packet_length = frame_size - adapter->layer3_payload_offset();
size_t const payload_length = frame_size - adapter->ipv6_payload_offset();
if (packet.length() < payload_length) {
dbgln("handle_ipv6: IPv6 packet too short ({}, need {})", packet.length(), sizeof(IPv6PacketHeader));
return;
}
if (packet.length() > payload_length) {
dbgln("handle_ipv6: IPv6 packet claims to be longer than it is ({}, actually {})", packet.length(), actual_ipv6_packet_length);
return;
}
dbgln_if(IPV6_DEBUG, "handle_ipv6: source={}, destination={}", packet.source(), packet.destination());
// TODO: Update ARP tables.
// TODO: skip or handle next headers that are not the next layer protocol header.
switch (static_cast<TransportProtocol>(packet.next_header())) {
case TransportProtocol::UDP:
dbgln_if(IPV6_DEBUG, "handle_ipv6: TODO: got UDP packet, what to do with it?");
break;
case TransportProtocol::TCP:
dbgln_if(IPV6_DEBUG, "handle_ipv6: TODO: got TCP packet, what to do with it?");
break;
case TransportProtocol::ICMPv6:
return handle_icmpv6(eth, packet, packet_timestamp, adapter);
default:
dbgln_if(IPV6_DEBUG, "handle_ipv6: Unhandled protocol {:#02x}", packet.next_header());
break;
}
}
void handle_icmpv6(EthernetFrameHeader const& eth, IPv6PacketHeader const& ipv6_packet, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter)
{
// TODO: Hand ICMPv6 packets to listening user sockets, once those exist.
// TODO: pass through packet_timestamp to raw sockets (see above)
(void)packet_timestamp;
auto& icmpv6_header = *static_cast<ICMPv6Header const*>(ipv6_packet.payload());
auto const ipv6_payload_offset = adapter->ipv6_payload_offset();
dbgln_if(ICMPV6_DEBUG, "handle_icmp6: source={}, destination={}, type={:#02x}, code={:#02x}", ipv6_packet.source().to_string(), ipv6_packet.destination().to_string(), icmpv6_header.type(), icmpv6_header.code());
RefPtr<PacketWithTimestamp> packet;
size_t icmp_packet_size = ipv6_packet.payload_size();
if (icmpv6_header.type() == ICMPv6Type::NeighborSolicitation) {
dbgln_if(ICMPV6_DEBUG, "handle_icmp6: got neighbor solicitation");
if (icmp_packet_size < sizeof(ICMPv6NeighborSolicitation)) {
dbgln_if(ICMPV6_DEBUG, "handle_icmp6: Neighbor solicitation packet too small, ignoring.");
return;
}
auto& request = *bit_cast<ICMPv6NeighborSolicitation const*>(&icmpv6_header);
if (request.target_address != adapter->ipv6_address()) {
dbgln_if(ICMPV6_DEBUG, "handle_icmp6: Got a packet, but not for us. Dropping.");
return;
}
struct [[gnu::packed]] advertisement_with_option {
ICMPv6NeighborAdvertisement base;
ICMPv6OptionLinkLayerAddress option;
};
icmp_packet_size = sizeof(advertisement_with_option);
packet = adapter->acquire_packet_buffer(ipv6_payload_offset + icmp_packet_size);
if (!packet) {
dbgln("Could not allocate packet buffer while sending ICMPv6 packet");
return;
}
adapter->fill_in_ipv6_header(*packet, adapter->ipv6_address(), eth.source(), ipv6_packet.source(), TransportProtocol::ICMPv6, icmp_packet_size, 255);
memset(packet->buffer->data() + ipv6_payload_offset, 0, icmp_packet_size);
auto& response = *(advertisement_with_option*)(packet->buffer->data() + ipv6_payload_offset);
response.base.header.set_type(ICMPv6Type::NeighborAdvertisement);
response.base.set_solicited(1);
response.base.set_override(1);
response.base.target_address = adapter->ipv6_address();
response.option.type = 2;
response.option.length = 1;
response.option.address = adapter->mac_address();
IPv6PseudoHeader header;
header.source_address = adapter->ipv6_address();
header.target_address = ipv6_packet.source();
header.packet_length = icmp_packet_size;
header.next_header = TransportProtocol::ICMPv6;
InternetChecksum checksum;
checksum.add({ &header, sizeof(IPv6PseudoHeader) });
checksum.add({ &response, sizeof(advertisement_with_option) });
response.base.header.set_checksum(checksum.finish());
} else if (icmpv6_header.type() == ICMPv6Type::EchoRequest) {
dbgln_if(ICMPV6_DEBUG, "handle_icmp6: got echo request");
if (icmp_packet_size < sizeof(ICMPv6Echo)) {
dbgln("handle_icmp6: echo request packet too small, ignoring.");
return;
}
auto& request = *bit_cast<ICMPv6Echo const*>(&icmpv6_header);
auto ipv6_payload_offset = adapter->ipv6_payload_offset();
packet = adapter->acquire_packet_buffer(ipv6_payload_offset + icmp_packet_size);
if (!packet) {
dbgln("Could not allocate packet buffer while sending ICMPv6 packet");
return;
}
adapter->fill_in_ipv6_header(*packet, adapter->ipv6_address(), eth.source(), ipv6_packet.source(), TransportProtocol::ICMPv6, icmp_packet_size, 64);
memset(packet->buffer->data() + ipv6_payload_offset, 0, sizeof(ICMPv6Echo));
auto& response = *(ICMPv6Echo*)(packet->buffer->data() + ipv6_payload_offset);
response.header.set_type(ICMPv6Type::EchoReply);
response.identifier = request.identifier;
response.sequence_number = request.sequence_number;
IPv6PseudoHeader header;
header.source_address = adapter->ipv6_address();
header.target_address = ipv6_packet.source();
header.packet_length = icmp_packet_size;
header.next_header = TransportProtocol::ICMPv6;
if (icmp_packet_size > sizeof(ICMPv6Echo))
memcpy(response.payload(), request.payload(), icmp_packet_size - sizeof(ICMPv6Echo));
InternetChecksum checksum;
checksum.add({ &header, sizeof(IPv6PseudoHeader) });
checksum.add({ &response, icmp_packet_size });
response.header.set_checksum(checksum.finish());
} else {
dbgln_if(ICMPV6_DEBUG, "handle_icmp6: got unknown ICMPv6 type {:#02x}", icmpv6_header.type());
return;
}
adapter->send_packet(packet->bytes());
adapter->release_packet_buffer(*packet);
return;
}
void handle_icmp(EthernetFrameHeader const& eth, IPv4Packet const& ipv4_packet, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter)
{
auto& icmp_header = *static_cast<ICMPHeader const*>(ipv4_packet.payload());
size_t const icmp_packet_size = ipv4_packet.payload_size();
size_t const icmp_header_size = sizeof(ICMPEchoPacket);
dbgln_if(ICMP_DEBUG, "handle_icmp: source={}, destination={}, type={:#02x}, code={:#02x}", ipv4_packet.source().to_string(), ipv4_packet.destination().to_string(), static_cast<u8>(icmp_header.type), icmp_header.code);
{
Vector<NonnullRefPtr<IPv4Socket>> icmp_sockets;
IPv4Socket::all_sockets().with_exclusive([&](auto& sockets) {
for (auto& socket : sockets) {
if (socket.protocol() == (unsigned)TransportProtocol::ICMP)
icmp_sockets.append(socket);
}
});
for (auto& socket : icmp_sockets)
socket->did_receive(ipv4_packet.source(), 0, { &ipv4_packet, sizeof(IPv4Packet) + icmp_packet_size }, packet_timestamp);
}
if (icmp_header.type == ICMPType::EchoRequest) {
auto& request = reinterpret_cast<ICMPEchoPacket const&>(icmp_header);
dbgln_if(ICMP_DEBUG, "handle_icmp: EchoRequest from {}: id={}, seq={}", ipv4_packet.source(), request.identifier, request.sequence_number);
if (icmp_packet_size < icmp_header_size) {
dbgln_if(ICMP_DEBUG, "handle_icmp: EchoRequest packet is too small, ignoring.");
return;
}
auto ipv4_payload_offset = adapter->ipv4_payload_offset();
auto packet = adapter->acquire_packet_buffer(ipv4_payload_offset + icmp_packet_size);
if (!packet) {
dbgln("Could not allocate packet buffer while sending ICMP packet");
return;
}
adapter->fill_in_ipv4_header(*packet, adapter->ipv4_address(), eth.source(), ipv4_packet.source(), TransportProtocol::ICMP, icmp_packet_size, 0, 64);
memset(packet->buffer->data() + ipv4_payload_offset, 0, icmp_header_size);
auto& response = *reinterpret_cast<ICMPEchoPacket*>(packet->buffer->data() + ipv4_payload_offset);
response.header.type = ICMPType::EchoReply;
response.identifier = request.identifier;
response.sequence_number = request.sequence_number;
if (icmp_packet_size > icmp_header_size)
memcpy(response.payload, request.payload, icmp_packet_size - icmp_header_size);
InternetChecksum checksum;
checksum.add({ &response, icmp_packet_size });
response.header.checksum = checksum.finish();
adapter->send_packet(packet->bytes());
adapter->release_packet_buffer(*packet);
}
}
void handle_udp(IPv4Packet const& ipv4_packet, UnixDateTime const& packet_timestamp)
{
if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
dbgln("handle_udp: Packet too small ({}, need {})", ipv4_packet.payload_size(), sizeof(UDPPacket));
return;
}
auto& udp_packet = *static_cast<UDPPacket const*>(ipv4_packet.payload());
dbgln_if(UDP_DEBUG, "handle_udp: source={}:{}, destination={}:{}, length={}",
ipv4_packet.source(), udp_packet.source_port(),
ipv4_packet.destination(), udp_packet.destination_port(),
udp_packet.length());
auto socket = UDPSocket::from_port(udp_packet.destination_port());
if (!socket) {
dbgln_if(UDP_DEBUG, "handle_udp: No local UDP socket for {}:{}", ipv4_packet.destination(), udp_packet.destination_port());
return;
}
VERIFY(socket->type() == SOCK_DGRAM);
VERIFY(socket->local_port() == udp_packet.destination_port());
auto& destination = ipv4_packet.destination();
if (destination == IPv4Address(255, 255, 255, 255) || NetworkingManagement::the().from_ipv4_address(destination) || socket->multicast_memberships().contains_slow(destination))
socket->did_receive(ipv4_packet.source(), udp_packet.source_port(), { &ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size() }, packet_timestamp);
}
void send_delayed_tcp_ack(TCPSocket& socket)
{
VERIFY(socket.mutex().is_locked());
if (!socket.should_delay_next_ack()) {
[[maybe_unused]] auto result = socket.send_ack();
return;
}
delayed_ack_sockets->set(move(socket));
}
void flush_delayed_tcp_acks()
{
Vector<NonnullRefPtr<TCPSocket>, 32> remaining_sockets;
for (auto& socket : *delayed_ack_sockets) {
MutexLocker locker(socket->mutex());
if (socket->should_delay_next_ack()) {
MUST(remaining_sockets.try_append(*socket));
continue;
}
[[maybe_unused]] auto result = socket->send_ack();
}
if (remaining_sockets.size() != delayed_ack_sockets->size()) {
delayed_ack_sockets->clear();
if (remaining_sockets.size() > 0)
dbgln("flush_delayed_tcp_acks: {} sockets remaining", remaining_sockets.size());
for (auto&& socket : remaining_sockets)
delayed_ack_sockets->set(move(socket));
}
}
void send_tcp_rst(IPv4Packet const& ipv4_packet, TCPPacket const& tcp_packet, RefPtr<NetworkAdapter> adapter)
{
auto routing_decision = route_to(ipv4_packet.source(), ipv4_packet.destination(), adapter);
if (routing_decision.is_zero())
return;
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
size_t const options_size = 0;
size_t const tcp_header_size = sizeof(TCPPacket) + options_size;
size_t const buffer_size = ipv4_payload_offset + tcp_header_size;
auto packet = routing_decision.adapter->acquire_packet_buffer(buffer_size);
if (!packet)
return;
routing_decision.adapter->fill_in_ipv4_header(*packet, ipv4_packet.destination(),
routing_decision.next_hop, ipv4_packet.source(), TransportProtocol::TCP,
buffer_size - ipv4_payload_offset, 0, 64);
auto& rst_packet = *(TCPPacket*)(packet->buffer->data() + ipv4_payload_offset);
rst_packet = {};
rst_packet.set_source_port(tcp_packet.destination_port());
rst_packet.set_destination_port(tcp_packet.source_port());
rst_packet.set_window_size(0);
rst_packet.set_sequence_number(0);
rst_packet.set_ack_number(tcp_packet.sequence_number() + 1);
rst_packet.set_data_offset(tcp_header_size / sizeof(u32));
rst_packet.set_flags(TCPFlags::RST | TCPFlags::ACK);
rst_packet.set_checksum(TCPSocket::compute_tcp_checksum(ipv4_packet.source(), ipv4_packet.destination(), rst_packet, 0));
routing_decision.adapter->send_packet(packet->bytes());
routing_decision.adapter->release_packet_buffer(*packet);
}
void handle_tcp(IPv4Packet const& ipv4_packet, UnixDateTime const& packet_timestamp, RefPtr<NetworkAdapter> adapter)
{
if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
dbgln("handle_tcp: IPv4 payload is too small to be a TCP packet ({}, need {})", ipv4_packet.payload_size(), sizeof(TCPPacket));
return;
}
auto& tcp_packet = *static_cast<TCPPacket const*>(ipv4_packet.payload());
size_t minimum_tcp_header_size = 5 * sizeof(u32);
size_t maximum_tcp_header_size = 15 * sizeof(u32);
if (tcp_packet.header_size() < minimum_tcp_header_size || tcp_packet.header_size() > maximum_tcp_header_size) {
dbgln("handle_tcp: TCP packet header has invalid size {}", tcp_packet.header_size());
}
if (ipv4_packet.payload_size() < tcp_packet.header_size()) {
dbgln("handle_tcp: IPv4 payload is smaller than TCP header claims ({}, supposedly {})", ipv4_packet.payload_size(), tcp_packet.header_size());
return;
}
size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
dbgln_if(TCP_DEBUG, "handle_tcp: source={}:{}, destination={}:{}, seq_no={}, ack_no={}, flags={:#04x} ({}{}{}{}), window_size={}, payload_size={}",
ipv4_packet.source().to_string(),
tcp_packet.source_port(),
ipv4_packet.destination().to_string(),
tcp_packet.destination_port(),
tcp_packet.sequence_number(),
tcp_packet.ack_number(),
tcp_packet.flags(),
tcp_packet.has_syn() ? "SYN " : "",
tcp_packet.has_ack() ? "ACK " : "",
tcp_packet.has_fin() ? "FIN " : "",
tcp_packet.has_rst() ? "RST " : "",
tcp_packet.window_size(),
payload_size);
IPv4SocketTuple tuple(ipv4_packet.destination(), tcp_packet.destination_port(), ipv4_packet.source(), tcp_packet.source_port());
dbgln_if(TCP_DEBUG, "handle_tcp: looking for socket; tuple={}", tuple.to_string());
auto socket = TCPSocket::from_tuple(tuple);
if (!socket) {
if (!tcp_packet.has_rst()) {
dbgln("handle_tcp: No TCP socket for tuple {}. Sending RST.", tuple.to_string());
send_tcp_rst(ipv4_packet, tcp_packet, adapter);
}
return;
}
MutexLocker locker(socket->mutex());
VERIFY(socket->type() == SOCK_STREAM);
VERIFY(socket->local_port() == tcp_packet.destination_port());
dbgln_if(TCP_DEBUG, "handle_tcp: got socket {}; state={}", socket->tuple().to_string(), TCPSocket::to_string(socket->state()));
socket->receive_tcp_packet(tcp_packet, ipv4_packet.payload_size());
Optional<u8> send_window_scale;
if (tcp_packet.has_syn()) {
tcp_packet.for_each_option([&send_window_scale](auto const& option) {
if (option.kind() != TCPOptionKind::WindowScale)
return;
if (option.length() != sizeof(TCPOptionWindowScale))
return;
auto scale = static_cast<TCPOptionWindowScale const&>(option).value();
if (scale > 14)
return; // Maximum allowed as per RFC7323
send_window_scale = scale;
});
}
switch (socket->state()) {
case TCPSocket::State::Closed:
dbgln("handle_tcp: unexpected flags in Closed state ({:x}) for socket with tuple {}", tcp_packet.flags(), tuple.to_string());
if (tcp_packet.has_rst()) {
return;
}
socket->set_sequence_number(tcp_packet.has_ack() ? tcp_packet.ack_number() : 0);
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_tcp_packet(TCPFlags::RST | TCPFlags::ACK);
return;
case TCPSocket::State::TimeWait:
dbgln("handle_tcp: unexpected flags in TimeWait state ({:x}) for socket with tuple {}", tcp_packet.flags(), tuple.to_string());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
case TCPSocket::State::Listen:
switch (tcp_packet.flags()) {
case TCPFlags::SYN: {
dbgln_if(TCP_DEBUG, "handle_tcp: incoming connection");
auto& local_address = ipv4_packet.destination();
auto& peer_address = ipv4_packet.source();
auto client_or_error = socket->try_create_client(local_address, tcp_packet.destination_port(), peer_address, tcp_packet.source_port());
if (client_or_error.is_error()) {
dmesgln("handle_tcp: couldn't create client socket: {}", client_or_error.error());
return;
}
auto client = client_or_error.release_value();
MutexLocker locker(client->mutex());
dbgln_if(TCP_DEBUG, "handle_tcp: created new client socket with tuple {}", client->tuple().to_string());
client->set_sequence_number(1000);
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
[[maybe_unused]] auto rc2 = client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
client->set_state(TCPSocket::State::SynReceived);
if (send_window_scale.has_value())
client->set_send_window_scale(*send_window_scale);
return;
}
default:
dbgln("handle_tcp: unexpected flags in Listen state ({:x})", tcp_packet.flags());
// socket->send_tcp_packet(TCPFlags::RST);
return;
}
case TCPSocket::State::SynSent:
switch (tcp_packet.flags()) {
case TCPFlags::SYN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
socket->set_state(TCPSocket::State::SynReceived);
if (send_window_scale.has_value())
socket->set_send_window_scale(*send_window_scale);
return;
case TCPFlags::ACK | TCPFlags::SYN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
(void)socket->send_ack(true);
socket->set_state(TCPSocket::State::Established);
socket->set_setup_state(Socket::SetupState::Completed);
socket->set_connected(true);
if (send_window_scale.has_value())
socket->set_send_window_scale(*send_window_scale);
return;
case TCPFlags::ACK | TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
send_delayed_tcp_ack(*socket);
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::FINDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
return;
case TCPFlags::ACK | TCPFlags::RST:
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::RSTDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
return;
default:
dbgln("handle_tcp: unexpected flags in SynSent state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
return;
}
case TCPSocket::State::SynReceived:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
switch (socket->direction()) {
case TCPSocket::Direction::Incoming:
if (!socket->has_originator()) {
dbgln("handle_tcp: connection doesn't have an originating socket; maybe it went away?");
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
socket->set_state(TCPSocket::State::Established);
socket->set_setup_state(Socket::SetupState::Completed);
socket->release_to_originator();
return;
case TCPSocket::Direction::Outgoing:
socket->set_state(TCPSocket::State::Established);
socket->set_setup_state(Socket::SetupState::Completed);
socket->set_connected(true);
return;
default:
dbgln("handle_tcp: got ACK in SynReceived state but direction is invalid ({})", TCPSocket::to_string(socket->direction()));
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
VERIFY_NOT_REACHED();
case TCPFlags::SYN:
dbgln("handle_tcp: ignoring SYN for partially established connection");
return;
default:
dbgln("handle_tcp: unexpected flags in SynReceived state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::CloseWait:
switch (tcp_packet.flags()) {
default:
dbgln("handle_tcp: unexpected flags in CloseWait state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::LastAck:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
socket->set_state(TCPSocket::State::Closed);
return;
default:
dbgln("handle_tcp: unexpected flags in LastAck state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::FinWait1:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
socket->set_state(TCPSocket::State::FinWait2);
return;
case TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->set_state(TCPSocket::State::Closing);
(void)socket->send_ack(true);
return;
case TCPFlags::FIN | TCPFlags::ACK:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->set_state(TCPSocket::State::TimeWait);
(void)socket->send_ack(true);
return;
default:
dbgln("handle_tcp: unexpected flags in FinWait1 state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::FinWait2:
switch (tcp_packet.flags()) {
case TCPFlags::FIN | TCPFlags::ACK: // Fallthrough
case TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->set_state(TCPSocket::State::TimeWait);
(void)socket->send_ack(true);
return;
case TCPFlags::ACK | TCPFlags::RST:
// FIXME: Verify that this transition is legitimate.
socket->set_state(TCPSocket::State::Closed);
return;
case TCPFlags::ACK:
if (payload_size) {
if (socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), { &ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size() }, packet_timestamp)) {
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
dbgln_if(TCP_DEBUG, "Got packet with ack_no={}, seq_no={}, payload_size={}, acking it with new ack_no={}, seq_no={}",
tcp_packet.ack_number(), tcp_packet.sequence_number(), payload_size, socket->ack_number(), socket->sequence_number());
send_delayed_tcp_ack(*socket);
}
}
return;
default:
dbgln("handle_tcp: unexpected flags in FinWait2 state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::Closing:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
socket->set_state(TCPSocket::State::TimeWait);
return;
default:
dbgln("handle_tcp: unexpected flags in Closing state ({:x})", tcp_packet.flags());
(void)socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::Established:
if (tcp_packet.has_rst()) {
socket->set_state(TCPSocket::State::Closed);
return;
}
if (tcp_packet.sequence_number() != socket->ack_number()) {
dbgln_if(TCP_DEBUG, "Discarding out of order packet: seq {} vs. ack {}", tcp_packet.sequence_number(), socket->ack_number());
if (socket->duplicate_acks() < TCPSocket::maximum_duplicate_acks) {
dbgln_if(TCP_DEBUG, "Sending ACK with same ack number to trigger fast retransmission");
socket->set_duplicate_acks(socket->duplicate_acks() + 1);
[[maybe_unused]] auto result = socket->send_ack(true);
}
return;
}
socket->set_duplicate_acks(0);
if (tcp_packet.has_fin()) {
if (payload_size != 0)
socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), { &ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size() }, packet_timestamp);
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
send_delayed_tcp_ack(*socket);
socket->set_state(TCPSocket::State::CloseWait);
socket->set_connected(false);
return;
}
if (payload_size) {
if (socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), { &ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size() }, packet_timestamp)) {
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
dbgln_if(TCP_DEBUG, "Got packet with ack_no={}, seq_no={}, payload_size={}, acking it with new ack_no={}, seq_no={}",
tcp_packet.ack_number(), tcp_packet.sequence_number(), payload_size, socket->ack_number(), socket->sequence_number());
send_delayed_tcp_ack(*socket);
}
}
}
}
void retransmit_tcp_packets()
{
// We must keep the sockets alive until after we've unlocked the hash table
// in case retransmit_packets() realizes that it wants to close the socket.
Vector<NonnullRefPtr<TCPSocket>, 16> sockets;
TCPSocket::sockets_for_retransmit().for_each_shared([&](auto const& socket) {
// We ignore allocation failures above the first 16 guaranteed socket slots, as
// we will just retransmit their packets the next time around
(void)sockets.try_append(socket);
});
for (auto& socket : sockets) {
MutexLocker socket_locker(socket->mutex());
socket->retransmit_packets();
}
}
}
Reference in New Issue View Git Blame Copy Permalink