RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-24 03:45:07 +00:00
Code Issues Activity Actions

Kernel: Convert klog() => AK::Format in NetworkTask

Browse source
This commit is contained in:
Andreas Kling 2021-03-12 11:59:41 +01:00
parent 201d35e70f
commit f9aace29ec
1 changed files with 53 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

142
Kernel/Net/NetworkTask.cpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org> * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -73,7 +73,12 @@ void NetworkTask_main(void*)
adapter.set_ipv4_gateway({ 10, 0, 2, 2 }); adapter.set_ipv4_gateway({ 10, 0, 2, 2 });
} }
klog() << "NetworkTask: " << adapter.class_name() << " network adapter found: hw=" << adapter.mac_address().to_string().characters() << " address=" << adapter.ipv4_address().to_string().characters() << " netmask=" << adapter.ipv4_netmask().to_string().characters() << " gateway=" << adapter.ipv4_gateway().to_string().characters(); dmesgln("NetworkTask: {} network adapter found: hw={}, ipv4_address={}, ipv4_netmask={}, ipv4_gateway={}",
adapter.class_name(),
adapter.mac_address().to_string(),
adapter.ipv4_address(),
adapter.ipv4_netmask(),
adapter.ipv4_gateway());
adapter.on_receive = [&]() { adapter.on_receive = [&]() {
pending_packets++; pending_packets++;
@ -90,9 +95,7 @@ void NetworkTask_main(void*)
return; return;
packet_size = adapter.dequeue_packet(buffer, buffer_size, packet_timestamp); packet_size = adapter.dequeue_packet(buffer, buffer_size, packet_timestamp);
pending_packets--; pending_packets--;
#if NETWORK_TASK_DEBUG dbgln_if(NETWORK_TASK_DEBUG, "NetworkTask: Dequeued packet from {} ({} bytes)", adapter.name(), packet_size);
klog() << "NetworkTask: Dequeued packet from " << adapter.name().characters() << " (" << packet_size << " bytes)";
#endif
}); });
return packet_size; return packet_size;
}; };
@ -102,7 +105,6 @@ void NetworkTask_main(void*)
auto buffer = (u8*)buffer_region->vaddr().get(); auto buffer = (u8*)buffer_region->vaddr().get();
Time packet_timestamp; Time packet_timestamp;
klog() << "NetworkTask: Enter main loop.";
for (;;) { for (;;) {
size_t packet_size = dequeue_packet(buffer, buffer_size, packet_timestamp); size_t packet_size = dequeue_packet(buffer, buffer_size, packet_timestamp);
if (!packet_size) { if (!packet_size) {
@ -110,33 +112,11 @@ void NetworkTask_main(void*)
continue; continue;
} }
if (packet_size < sizeof(EthernetFrameHeader)) { if (packet_size < sizeof(EthernetFrameHeader)) {
klog() << "NetworkTask: Packet is too small to be an Ethernet packet! (" << packet_size << ")"; dbgln("NetworkTask: Packet is too small to be an Ethernet packet! ({})", packet_size);
continue; continue;
} }
auto& eth = *(const EthernetFrameHeader*)buffer; auto& eth = *(const EthernetFrameHeader*)buffer;
#if ETHERNET_DEBUG 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);
dbgln("NetworkTask: From {} to {}, ether_type={:#04x}, packet_size={}", eth.source().to_string(), eth.destination().to_string(), eth.ether_type(), packet_size);
#endif
#if ETHERNET_VERY_DEBUG
for (size_t i = 0; i < packet_size; i++) {
klog() << String::format("%#02x", buffer[i]);
switch (i % 16) {
case 7:
klog() << " ";
break;
case 15:
klog() << "";
break;
default:
klog() << " ";
break;
}
}
klog() << "";
#endif
switch (eth.ether_type()) { switch (eth.ether_type()) {
case EtherType::ARP: case EtherType::ARP:
@ -149,7 +129,7 @@ void NetworkTask_main(void*)
// ignore // ignore
break; break;
default: default:
klog() << "NetworkTask: Unknown ethernet type 0x" << String::format("%x", eth.ether_type()); dbgln("NetworkTask: Unknown ethernet type {:#04x}", eth.ether_type());
} }
} }
} }
@ -158,7 +138,7 @@ void handle_arp(const EthernetFrameHeader& eth, size_t frame_size)
{ {
constexpr size_t minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket); constexpr size_t minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
if (frame_size < minimum_arp_frame_size) { if (frame_size < minimum_arp_frame_size) {
klog() << "handle_arp: Frame too small (" << frame_size << ", need " << minimum_arp_frame_size << ")"; dbgln("handle_arp: Frame too small ({}, need {})", frame_size, minimum_arp_frame_size);
return; return;
} }
auto& packet = *static_cast<const ARPPacket*>(eth.payload()); auto& packet = *static_cast<const ARPPacket*>(eth.payload());
@ -171,14 +151,12 @@ void handle_arp(const EthernetFrameHeader& eth, size_t frame_size)
return; return;
} }
#if ARP_DEBUG dbgln_if(ARP_DEBUG, "handle_arp: operation={:#04x}, sender={}/{}, target={}/{}",
dbgln("handle_arp: operation={:#04x}, sender={}/{}, target={}/{}",
packet.operation(), packet.operation(),
packet.sender_hardware_address().to_string(), packet.sender_hardware_address().to_string(),
packet.sender_protocol_address().to_string(), packet.sender_protocol_address().to_string(),
packet.target_hardware_address().to_string(), packet.target_hardware_address().to_string(),
packet.target_protocol_address().to_string()); packet.target_protocol_address().to_string());
#endif
if (!packet.sender_hardware_address().is_zero() && !packet.sender_protocol_address().is_zero()) { 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. // Someone has this IPv4 address. I guess we can try to remember that.
@ -191,7 +169,7 @@ void handle_arp(const EthernetFrameHeader& eth, size_t frame_size)
// Who has this IP address? // Who has this IP address?
if (auto adapter = NetworkAdapter::from_ipv4_address(packet.target_protocol_address())) { if (auto adapter = NetworkAdapter::from_ipv4_address(packet.target_protocol_address())) {
// We do! // We do!
klog() << "handle_arp: Responding to ARP request for my IPv4 address (" << adapter->ipv4_address().to_string().characters() << ")"; dbgln("handle_arp: Responding to ARP request for my IPv4 address ({})", adapter->ipv4_address());
ARPPacket response; ARPPacket response;
response.set_operation(ARPOperation::Response); response.set_operation(ARPOperation::Response);
response.set_target_hardware_address(packet.sender_hardware_address()); response.set_target_hardware_address(packet.sender_hardware_address());
@ -209,25 +187,23 @@ void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size, const Time&
{ {
constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet); constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
if (frame_size < minimum_ipv4_frame_size) { if (frame_size < minimum_ipv4_frame_size) {
klog() << "handle_ipv4: Frame too small (" << frame_size << ", need " << minimum_ipv4_frame_size << ")"; dbgln("handle_ipv4: Frame too small ({}, need {})", frame_size, minimum_ipv4_frame_size);
return; return;
} }
auto& packet = *static_cast<const IPv4Packet*>(eth.payload()); auto& packet = *static_cast<const IPv4Packet*>(eth.payload());
if (packet.length() < sizeof(IPv4Packet)) { if (packet.length() < sizeof(IPv4Packet)) {
klog() << "handle_ipv4: IPv4 packet too short (" << packet.length() << ", need " << sizeof(IPv4Packet) << ")"; dbgln("handle_ipv4: IPv4 packet too short ({}, need {})", packet.length(), sizeof(IPv4Packet));
return; return;
} }
size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader); size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader);
if (packet.length() > actual_ipv4_packet_length) { if (packet.length() > actual_ipv4_packet_length) {
klog() << "handle_ipv4: IPv4 packet claims to be longer than it is (" << packet.length() << ", actually " << actual_ipv4_packet_length << ")"; dbgln("handle_ipv4: IPv4 packet claims to be longer than it is ({}, actually {})", packet.length(), actual_ipv4_packet_length);
return; return;
} }
#if IPV4_DEBUG dbgln_if(IPV4_DEBUG, "handle_ipv4: source={}, destination={}", packet.source(), packet.destination());
klog() << "handle_ipv4: source=" << packet.source().to_string().characters() << ", target=" << packet.destination().to_string().characters();
#endif
switch ((IPv4Protocol)packet.protocol()) { switch ((IPv4Protocol)packet.protocol()) {
case IPv4Protocol::ICMP: case IPv4Protocol::ICMP:
@ -237,7 +213,7 @@ void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size, const Time&
case IPv4Protocol::TCP: case IPv4Protocol::TCP:
return handle_tcp(packet, packet_timestamp); return handle_tcp(packet, packet_timestamp);
default: default:
klog() << "handle_ipv4: Unhandled protocol " << packet.protocol(); dbgln("handle_ipv4: Unhandled protocol {:#02x}", packet.protocol());
break; break;
} }
} }
@ -245,9 +221,7 @@ void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size, const Time&
void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet, const Time& packet_timestamp) void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
{ {
auto& icmp_header = *static_cast<const ICMPHeader*>(ipv4_packet.payload()); auto& icmp_header = *static_cast<const ICMPHeader*>(ipv4_packet.payload());
#if ICMP_DEBUG dbgln_if(ICMP_DEBUG, "handle_icmp: source={}, destination={}, type={:#02x}, code={:#02x}", ipv4_packet.source().to_string(), ipv4_packet.destination().to_string(), icmp_header.type(), icmp_header.code());
dbgln("handle_icmp: source={}, destination={}, type={:#02x}, code={:#02x}", ipv4_packet.source().to_string(), ipv4_packet.destination().to_string(), icmp_header.type(), icmp_header.code());
#endif
{ {
NonnullRefPtrVector<IPv4Socket> icmp_sockets; NonnullRefPtrVector<IPv4Socket> icmp_sockets;
@ -269,10 +243,10 @@ void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet,
if (icmp_header.type() == ICMPType::EchoRequest) { if (icmp_header.type() == ICMPType::EchoRequest) {
auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header); auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
klog() << "handle_icmp: EchoRequest from " << ipv4_packet.source().to_string().characters() << ": id=" << (u16)request.identifier << ", seq=" << (u16)request.sequence_number; dbgln("handle_icmp: EchoRequest from {}: id={}, seq={}", ipv4_packet.source(), (u16)request.identifier, (u16)request.sequence_number);
size_t icmp_packet_size = ipv4_packet.payload_size(); size_t icmp_packet_size = ipv4_packet.payload_size();
if (icmp_packet_size < sizeof(ICMPEchoPacket)) { if (icmp_packet_size < sizeof(ICMPEchoPacket)) {
klog() << "handle_icmp: EchoRequest packet is too small, ignoring."; dbgln("handle_icmp: EchoRequest packet is too small, ignoring.");
return; return;
} }
auto buffer = ByteBuffer::create_zeroed(icmp_packet_size); auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
@ -293,24 +267,25 @@ void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet,
void handle_udp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp) void handle_udp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
{ {
if (ipv4_packet.payload_size() < sizeof(UDPPacket)) { if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
klog() << "handle_udp: Packet too small (" << ipv4_packet.payload_size() << ", need " << sizeof(UDPPacket) << ")"; dbgln("handle_udp: Packet too small ({}, need {})", ipv4_packet.payload_size(), sizeof(UDPPacket));
return; return;
} }
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination()); auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
if (!adapter && ipv4_packet.destination() != IPv4Address(255, 255, 255, 255)) { if (!adapter && ipv4_packet.destination() != IPv4Address(255, 255, 255, 255)) {
klog() << "handle_udp: this packet is not for me, it's for " << ipv4_packet.destination().to_string().characters(); dbgln("handle_udp: this packet is not for me, it's for {}", ipv4_packet.destination());
return; return;
} }
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload()); auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
#if UDP_DEBUG dbgln_if(UDP_DEBUG, "handle_udp: source={}:{}, destination={}:{}, length={}",
klog() << "handle_udp: source=" << ipv4_packet.source().to_string().characters() << ":" << udp_packet.source_port() << ", destination=" << ipv4_packet.destination().to_string().characters() << ":" << udp_packet.destination_port() << " length=" << udp_packet.length(); ipv4_packet.source(), udp_packet.source_port(),
#endif ipv4_packet.destination(), udp_packet.destination_port(),
udp_packet.length());
auto socket = UDPSocket::from_port(udp_packet.destination_port()); auto socket = UDPSocket::from_port(udp_packet.destination_port());
if (!socket) { if (!socket) {
klog() << "handle_udp: No UDP socket for port " << udp_packet.destination_port(); dbgln("handle_udp: No local UDP socket for {}:{}", ipv4_packet.destination(), udp_packet.destination_port());
return; return;
} }
@ -322,7 +297,7 @@ void handle_udp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp) void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
{ {
if (ipv4_packet.payload_size() < sizeof(TCPPacket)) { if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
klog() << "handle_tcp: IPv4 payload is too small to be a TCP packet (" << ipv4_packet.payload_size() << ", need " << sizeof(TCPPacket) << ")"; dbgln("handle_tcp: IPv4 payload is too small to be a TCP packet ({}, need {})", ipv4_packet.payload_size(), sizeof(TCPPacket));
return; return;
} }
@ -331,18 +306,17 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
size_t minimum_tcp_header_size = 5 * sizeof(u32); size_t minimum_tcp_header_size = 5 * sizeof(u32);
size_t maximum_tcp_header_size = 15 * 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) { if (tcp_packet.header_size() < minimum_tcp_header_size || tcp_packet.header_size() > maximum_tcp_header_size) {
klog() << "handle_tcp: TCP packet header has invalid size " << tcp_packet.header_size(); dbgln("handle_tcp: TCP packet header has invalid size {}", tcp_packet.header_size());
} }
if (ipv4_packet.payload_size() < tcp_packet.header_size()) { if (ipv4_packet.payload_size() < tcp_packet.header_size()) {
klog() << "handle_tcp: IPv4 payload is smaller than TCP header claims (" << ipv4_packet.payload_size() << ", supposedly " << 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; return;
} }
size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size(); size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
#if TCP_DEBUG dbgln_if(TCP_DEBUG, "handle_tcp: source={}:{}, destination={}:{}, seq_no={}, ack_no={}, flags={:#04x} ({}{}{}{}), window_size={}, payload_size={}",
dbgln("handle_tcp: source={}:{}, destination={}:{}, seq_no={}, ack_no={}, flags={:#04x} ({}{}{}{}), window_size={}, payload_size={}",
ipv4_packet.source().to_string(), ipv4_packet.source().to_string(),
tcp_packet.source_port(), tcp_packet.source_port(),
ipv4_packet.destination().to_string(), ipv4_packet.destination().to_string(),
@ -356,19 +330,16 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
tcp_packet.has_rst() ? "RST " : "", tcp_packet.has_rst() ? "RST " : "",
tcp_packet.window_size(), tcp_packet.window_size(),
payload_size); payload_size);
#endif
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination()); auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
if (!adapter) { if (!adapter) {
klog() << "handle_tcp: this packet is not for me, it's for " << ipv4_packet.destination().to_string().characters(); dbgln("handle_tcp: this packet is not for me, it's for {}", ipv4_packet.destination());
return; return;
} }
IPv4SocketTuple tuple(ipv4_packet.destination(), tcp_packet.destination_port(), ipv4_packet.source(), tcp_packet.source_port()); IPv4SocketTuple tuple(ipv4_packet.destination(), tcp_packet.destination_port(), ipv4_packet.source(), tcp_packet.source_port());
#if TCP_DEBUG dbgln_if(TCP_DEBUG, "handle_tcp: looking for socket; tuple={}", tuple.to_string());
klog() << "handle_tcp: looking for socket; tuple=" << tuple.to_string().characters();
#endif
auto socket = TCPSocket::from_tuple(tuple); auto socket = TCPSocket::from_tuple(tuple);
if (!socket) { if (!socket) {
@ -394,40 +365,34 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
VERIFY(socket->type() == SOCK_STREAM); VERIFY(socket->type() == SOCK_STREAM);
VERIFY(socket->local_port() == tcp_packet.destination_port()); VERIFY(socket->local_port() == tcp_packet.destination_port());
#if TCP_DEBUG dbgln_if(TCP_DEBUG, "handle_tcp: got socket {}; state={}", socket->tuple().to_string(), TCPSocket::to_string(socket->state()));
klog() << "handle_tcp: got socket; state=" << socket->tuple().to_string().characters() << " " << TCPSocket::to_string(socket->state());
#endif
socket->receive_tcp_packet(tcp_packet, ipv4_packet.payload_size()); socket->receive_tcp_packet(tcp_packet, ipv4_packet.payload_size());
[[maybe_unused]] int unused_rc {}; [[maybe_unused]] int unused_rc {};
switch (socket->state()) { switch (socket->state()) {
case TCPSocket::State::Closed: case TCPSocket::State::Closed:
klog() << "handle_tcp: unexpected flags in Closed state"; dbgln("handle_tcp: unexpected flags in Closed state");
// TODO: we may want to send an RST here, maybe as a configurable option // TODO: we may want to send an RST here, maybe as a configurable option
return; return;
case TCPSocket::State::TimeWait: case TCPSocket::State::TimeWait:
klog() << "handle_tcp: unexpected flags in TimeWait state"; dbgln("handle_tcp: unexpected flags in TimeWait state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
case TCPSocket::State::Listen: case TCPSocket::State::Listen:
switch (tcp_packet.flags()) { switch (tcp_packet.flags()) {
case TCPFlags::SYN: { case TCPFlags::SYN: {
#if TCP_DEBUG dbgln_if(TCP_DEBUG, "handle_tcp: incoming connection");
klog() << "handle_tcp: incoming connection";
#endif
auto& local_address = ipv4_packet.destination(); auto& local_address = ipv4_packet.destination();
auto& peer_address = ipv4_packet.source(); auto& peer_address = ipv4_packet.source();
auto client = socket->create_client(local_address, tcp_packet.destination_port(), peer_address, tcp_packet.source_port()); auto client = socket->create_client(local_address, tcp_packet.destination_port(), peer_address, tcp_packet.source_port());
if (!client) { if (!client) {
klog() << "handle_tcp: couldn't create client socket"; dmesgln("handle_tcp: couldn't create client socket");
return; return;
} }
LOCKER(client->lock()); LOCKER(client->lock());
#if TCP_DEBUG dbgln_if(TCP_DEBUG, "handle_tcp: created new client socket with tuple {}", client->tuple().to_string());
klog() << "handle_tcp: created new client socket with tuple " << client->tuple().to_string().characters();
#endif
client->set_sequence_number(1000); client->set_sequence_number(1000);
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1); client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
[[maybe_unused]] auto rc2 = client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK); [[maybe_unused]] auto rc2 = client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
@ -435,7 +400,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
return; return;
} }
default: default:
klog() << "handle_tcp: unexpected flags in Listen state"; dbgln("handle_tcp: unexpected flags in Listen state");
// socket->send_tcp_packet(TCPFlags::RST); // socket->send_tcp_packet(TCPFlags::RST);
return; return;
} }
@ -468,7 +433,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_setup_state(Socket::SetupState::Completed); socket->set_setup_state(Socket::SetupState::Completed);
return; return;
default: default:
klog() << "handle_tcp: unexpected flags in SynSent state"; dbgln("handle_tcp: unexpected flags in SynSent state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect); socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect);
@ -483,7 +448,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
switch (socket->direction()) { switch (socket->direction()) {
case TCPSocket::Direction::Incoming: case TCPSocket::Direction::Incoming:
if (!socket->has_originator()) { if (!socket->has_originator()) {
klog() << "handle_tcp: connection doesn't have an originating socket; maybe it went away?"; dbgln("handle_tcp: connection doesn't have an originating socket; maybe it went away?");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -499,7 +464,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_connected(true); socket->set_connected(true);
return; return;
default: default:
klog() << "handle_tcp: got ACK in SynReceived state but direction is invalid (" << TCPSocket::to_string(socket->direction()) << ")"; dbgln("handle_tcp: got ACK in SynReceived state but direction is invalid ({})", TCPSocket::to_string(socket->direction()));
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -507,7 +472,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
return; return;
default: default:
klog() << "handle_tcp: unexpected flags in SynReceived state"; dbgln("handle_tcp: unexpected flags in SynReceived state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -515,7 +480,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
case TCPSocket::State::CloseWait: case TCPSocket::State::CloseWait:
switch (tcp_packet.flags()) { switch (tcp_packet.flags()) {
default: default:
klog() << "handle_tcp: unexpected flags in CloseWait state"; dbgln("handle_tcp: unexpected flags in CloseWait state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -527,7 +492,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
default: default:
klog() << "handle_tcp: unexpected flags in LastAck state"; dbgln("handle_tcp: unexpected flags in LastAck state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -543,7 +508,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_state(TCPSocket::State::Closing); socket->set_state(TCPSocket::State::Closing);
return; return;
default: default:
klog() << "handle_tcp: unexpected flags in FinWait1 state"; dbgln("handle_tcp: unexpected flags in FinWait1 state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -558,7 +523,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
default: default:
klog() << "handle_tcp: unexpected flags in FinWait2 state"; dbgln("handle_tcp: unexpected flags in FinWait2 state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -570,7 +535,7 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_state(TCPSocket::State::TimeWait); socket->set_state(TCPSocket::State::TimeWait);
return; return;
default: default:
klog() << "handle_tcp: unexpected flags in Closing state"; dbgln("handle_tcp: unexpected flags in Closing state");
unused_rc = socket->send_tcp_packet(TCPFlags::RST); unused_rc = socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed); socket->set_state(TCPSocket::State::Closed);
return; return;
@ -589,9 +554,8 @@ void handle_tcp(const IPv4Packet& ipv4_packet, const Time& packet_timestamp)
socket->set_ack_number(tcp_packet.sequence_number() + payload_size); socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
#if TCP_DEBUG dbgln_if(TCP_DEBUG, "Got packet with ack_no={}, seq_no={}, payload_size={}, acking it with new ack_no={}, seq_no={}",
klog() << "Got packet with ack_no=" << tcp_packet.ack_number() << ", seq_no=" << tcp_packet.sequence_number() << ", payload_size=" << payload_size << ", acking it with new ack_no=" << socket->ack_number() << ", seq_no=" << socket->sequence_number(); tcp_packet.ack_number(), tcp_packet.sequence_number(), payload_size, socket->ack_number(), socket->sequence_number());
#endif
if (payload_size) { if (payload_size) {
if (socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp)) if (socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp))