system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-09-06 17:06:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
serenity/Kernel/Net/NetworkTask.cpp

629 lines
26 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Lock.h>
#include <Kernel/Net/ARP.h>
#include <Kernel/Net/EtherType.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/EthernetFrameHeader.h>
#include <Kernel/Net/ICMP.h>
#include <Kernel/Net/IPv4.h>
#include <Kernel/Net/IPv4Socket.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/LoopbackAdapter.h>
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
#include <Kernel/Net/Routing.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/TCP.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/TCPSocket.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/UDP.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/UDPSocket.h>
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
#include <Kernel/Process.h>
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
//#define NETWORK_TASK_DEBUG
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
//#define ETHERNET_DEBUG
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
//#define ETHERNET_VERY_DEBUG
Kernel: Add simple ARP routing layer This replaces the previous placeholder routing layer with a real one! It's still very primitive, doesn't deal with things like timeouts very well, and will probably need several more iterations to support more normal networking things. I haven't confirmed that this works with anything other than the QEMU user networking layer, but I suspect that's what nearly everybody is using at this point, so that's the important target to keep working.
2019-08-28 11:58:01 +00:00
//#define ARP_DEBUG
Kernel: Put IPv4 and TCP related debug spam behind flags ...and turn those flags off for now, to make it possible to write some networking code without being spammed to death.
2019-08-04 08:04:06 +00:00
//#define IPV4_DEBUG
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
//#define ICMP_DEBUG
Kernel: Put IPv4 and TCP related debug spam behind flags ...and turn those flags off for now, to make it possible to write some networking code without being spammed to death.
2019-08-04 08:04:06 +00:00
//#define UDP_DEBUG
//#define TCP_DEBUG
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
static void handle_arp(const EthernetFrameHeader&, size_t frame_size);
static void handle_ipv4(const EthernetFrameHeader&, size_t frame_size);
static void handle_icmp(const EthernetFrameHeader&, const IPv4Packet&);
static void handle_udp(const IPv4Packet&);
static void handle_tcp(const IPv4Packet&);
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
void NetworkTask_main()
{
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 15:47:49 +00:00
WaitQueue packet_wait_queue;
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
u8 octet = 15;
int pending_packets = 0;
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 15:47:49 +00:00
NetworkAdapter::for_each([&](auto& adapter) {
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
if (String(adapter.class_name()) == "LoopbackAdapter") {
adapter.set_ipv4_address({ 127, 0, 0, 1 });
adapter.set_ipv4_netmask({ 255, 0, 0, 0 });
adapter.set_ipv4_gateway({ 0, 0, 0, 0 });
} else {
adapter.set_ipv4_address({ 10, 0, 2, octet++ });
adapter.set_ipv4_netmask({ 255, 255, 255, 0 });
adapter.set_ipv4_gateway({ 10, 0, 2, 2 });
}
Kernel: Add a LoopbackAdapter for talking to yourself via 127.0.0.1. Choosing adapter for transmit is done by adapter_for_route_to(IPv4Address). This is just hard-coded logic right now but can be expanded to support a proper routing table. Also start moving kernel networking code into Kernel/Net/.
2019-04-02 13:46:44 +00:00
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
kprintf("NetworkTask: %s network adapter found: hw=%s address=%s netmask=%s gateway=%s\n",
adapter.class_name(),
adapter.mac_address().to_string().characters(),
adapter.ipv4_address().to_string().characters(),
adapter.ipv4_netmask().to_string().characters(),
adapter.ipv4_gateway().to_string().characters());
NetworkTask: Don't crash on startup if there's no E1000 NIC present.
2019-05-17 22:22:08 +00:00
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 15:47:49 +00:00
adapter.on_receive = [&]() {
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
pending_packets++;
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 15:47:49 +00:00
packet_wait_queue.wake_all();
Kernel: Use a public member for NetworkAdapter on_receive
2019-08-28 12:14:38 +00:00
};
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
});
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
auto dequeue_packet = [&pending_packets](u8* buffer, size_t buffer_size) -> size_t {
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 15:47:49 +00:00
if (pending_packets == 0)
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
return 0;
size_t packet_size = 0;
NetworkAdapter::for_each([&](auto& adapter) {
if (packet_size || !adapter.has_queued_packets())
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
return;
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
packet_size = adapter.dequeue_packet(buffer, buffer_size);
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
pending_packets--;
#ifdef NETWORK_TASK_DEBUG
Kernel: Fix code locked behind NETWORK_TASK_DEBUG
2019-12-28 00:19:07 +00:00
kprintf("NetworkTask: Dequeued packet from %s (%d bytes)\n", adapter.name().characters(), packet_size);
Kernel: Remove specific devices from network code By setting up the devices in init() and looping over the registered network adapters in NetworkTask_main, we can remove the remaining hard-coded adapter references from the network code. This also assigns IPs according to the default range supplied by QEMU in its slirp networking mode.
2019-08-28 11:53:01 +00:00
#endif
});
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
return packet_size;
Kernel: Add a LoopbackAdapter for talking to yourself via 127.0.0.1. Choosing adapter for transmit is done by adapter_for_route_to(IPv4Address). This is just hard-coded logic right now but can be expanded to support a proper routing table. Also start moving kernel networking code into Kernel/Net/.
2019-04-02 13:46:44 +00:00
};
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-27 23:07:56 +00:00
size_t buffer_size = 64 * KB;
auto buffer_region = MM.allocate_kernel_region(buffer_size, "Kernel Packet Buffer", Region::Access::Read | Region::Access::Write, false, true);
auto buffer = (u8*)buffer_region->vaddr().get();
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
kprintf("NetworkTask: Enter main loop.\n");
for (;;) {
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-27 23:07:56 +00:00
size_t packet_size = dequeue_packet(buffer, buffer_size);
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
if (!packet_size) {
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 15:47:49 +00:00
current->wait_on(packet_wait_queue);
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
continue;
}
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
if (packet_size < sizeof(EthernetFrameHeader)) {
kprintf("NetworkTask: Packet is too small to be an Ethernet packet! (%zu)\n", packet_size);
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
continue;
}
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-27 23:07:56 +00:00
auto& eth = *(const EthernetFrameHeader*)buffer;
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
#ifdef ETHERNET_DEBUG
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
kprintf("NetworkTask: From %s to %s, ether_type=%w, packet_length=%u\n",
eth.source().to_string().characters(),
eth.destination().to_string().characters(),
eth.ether_type(),
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
packet_size);
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
#endif
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
#ifdef ETHERNET_VERY_DEBUG
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
for (size_t i = 0; i < packet_size; i++) {
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-27 23:07:56 +00:00
kprintf("%b", buffer[i]);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
switch (i % 16) {
case 7:
kprintf(" ");
break;
case 15:
kprintf("\n");
break;
default:
kprintf(" ");
break;
}
}
kprintf("\n");
#endif
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
switch (eth.ether_type()) {
case EtherType::ARP:
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
handle_arp(eth, packet_size);
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
break;
case EtherType::IPv4:
Net: Try to reuse incoming packet buffers to avoid allocation churn The majority of the time in NetworkTask was being spent in allocating and deallocating KBuffers for each incoming packet. We'll now keep up to 100 buffers around and reuse them for new packets if the next incoming packet fits in an old buffer. This is pretty naively implemented but definitely cuts down on time spent here.
2019-12-14 10:07:37 +00:00
handle_ipv4(eth, packet_size);
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
break;
Kernel: Ignore IPv6 packets; log unknown Ethernet payload types
2019-08-28 00:53:12 +00:00
case EtherType::IPv6:
// ignore
break;
default:
kprintf("NetworkTask: Unknown ethernet type %#04x\n", eth.ether_type());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
}
Kernel: Add a NetworkTask and a received network packet queue. It will be easier to deal with incoming packets in a separate task.
2019-03-11 11:43:45 +00:00
}
}
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
void handle_arp(const EthernetFrameHeader& eth, size_t frame_size)
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
{
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
constexpr size_t minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
if (frame_size < minimum_arp_frame_size) {
kprintf("handle_arp: Frame too small (%d, need %d)\n", frame_size, minimum_arp_frame_size);
return;
}
Kernel: Cache MAC<->IP mappings (from ARP responses) seen on the wire.
2019-03-11 23:56:33 +00:00
auto& packet = *static_cast<const ARPPacket*>(eth.payload());
Kernel: Minor style cleanup in NetworkTask.
2019-03-11 23:01:07 +00:00
if (packet.hardware_type() != 1 || packet.hardware_address_length() != sizeof(MACAddress)) {
kprintf("handle_arp: Hardware type not ethernet (%w, len=%u)\n",
packet.hardware_type(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
packet.hardware_address_length());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
return;
}
Kernel: Minor style cleanup in NetworkTask.
2019-03-11 23:01:07 +00:00
if (packet.protocol_type() != EtherType::IPv4 || packet.protocol_address_length() != sizeof(IPv4Address)) {
kprintf("handle_arp: Protocol type not IPv4 (%w, len=%u)\n",
packet.hardware_type(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
packet.protocol_address_length());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
return;
}
#ifdef ARP_DEBUG
kprintf("handle_arp: operation=%w, sender=%s/%s, target=%s/%s\n",
Kernel: Minor style cleanup in NetworkTask.
2019-03-11 23:01:07 +00:00
packet.operation(),
packet.sender_hardware_address().to_string().characters(),
packet.sender_protocol_address().to_string().characters(),
packet.target_hardware_address().to_string().characters(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
packet.target_protocol_address().to_string().characters());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
#endif
Kernel: Remember all ARP replies, even ones we didn't request This allows us to take advantage of unsolicited ARP replies, such as those that are emitted by many systems after their network interfaces are enabled, or after their DHCP client sets their IP. This also makes us a bit more vulnerable to ARP flooding, but we need some kind of eviction strategy anyway, so we can deal with that later.
2019-09-08 07:26:21 +00:00
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.
// FIXME: Support static ARP table entries.
LOCKER(arp_table().lock());
arp_table().resource().set(packet.sender_protocol_address(), packet.sender_hardware_address());
kprintf("ARP table (%d entries):\n", arp_table().resource().size());
for (auto& it : arp_table().resource()) {
kprintf("%s :: %s\n", it.value.to_string().characters(), it.key.to_string().characters());
}
}
Kernel: Tidy up networking code with some named constants.
2019-03-12 00:30:49 +00:00
if (packet.operation() == ARPOperation::Request) {
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
// Who has this IP address?
Kernel: Use WeakPtr<NetworkAdapter> instead of NetworkAdapter* in net code
2019-08-09 02:34:32 +00:00
if (auto adapter = NetworkAdapter::from_ipv4_address(packet.target_protocol_address())) {
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
// We do!
Kernel: Minor style cleanup in NetworkTask.
2019-03-11 23:01:07 +00:00
kprintf("handle_arp: Responding to ARP request for my IPv4 address (%s)\n",
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
adapter->ipv4_address().to_string().characters());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
ARPPacket response;
Kernel: Tidy up networking code with some named constants.
2019-03-12 00:30:49 +00:00
response.set_operation(ARPOperation::Response);
Kernel: Minor style cleanup in NetworkTask.
2019-03-11 23:01:07 +00:00
response.set_target_hardware_address(packet.sender_hardware_address());
response.set_target_protocol_address(packet.sender_protocol_address());
Kernel: Add a way to look up NetworkAdapters by IPv4 address.
2019-03-12 12:30:36 +00:00
response.set_sender_hardware_address(adapter->mac_address());
response.set_sender_protocol_address(adapter->ipv4_address());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
Kernel: Add a way to look up NetworkAdapters by IPv4 address.
2019-03-12 12:30:36 +00:00
adapter->send(packet.sender_hardware_address(), response);
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
}
Kernel: Cache MAC<->IP mappings (from ARP responses) seen on the wire.
2019-03-11 23:56:33 +00:00
return;
}
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
}
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size)
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
{
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
if (frame_size < minimum_ipv4_frame_size) {
kprintf("handle_ipv4: Frame too small (%d, need %d)\n", frame_size, minimum_ipv4_frame_size);
return;
}
auto& packet = *static_cast<const IPv4Packet*>(eth.payload());
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
Kernel: Do some basic sanity checking on IPv4 packet headers Ignore packets that are too small, or not as large as they claim to be.
2019-08-09 07:36:06 +00:00
if (packet.length() < sizeof(IPv4Packet)) {
kprintf("handle_ipv4: IPv4 packet too short (%u, need %u)\n", packet.length(), sizeof(IPv4Packet));
return;
}
size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader);
if (packet.length() > actual_ipv4_packet_length) {
kprintf("handle_ipv4: IPv4 packet claims to be longer than it is (%u, actually %zu)\n", packet.length(), actual_ipv4_packet_length);
return;
}
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
#ifdef IPV4_DEBUG
kprintf("handle_ipv4: source=%s, target=%s\n",
packet.source().to_string().characters(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
packet.destination().to_string().characters());
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
#endif
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 11:43:30 +00:00
switch ((IPv4Protocol)packet.protocol()) {
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
case IPv4Protocol::ICMP:
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
return handle_icmp(eth, packet);
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
case IPv4Protocol::UDP:
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
return handle_udp(packet);
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
case IPv4Protocol::TCP:
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
return handle_tcp(packet);
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
default:
kprintf("handle_ipv4: Unhandled protocol %u\n", packet.protocol());
break;
}
}
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet)
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
{
auto& icmp_header = *static_cast<const ICMPHeader*>(ipv4_packet.payload());
Kernel: Fix up the ICMP implementation to generate correct Echo replies. Serenity now responds to ping. :^)
2019-03-12 10:44:38 +00:00
#ifdef ICMP_DEBUG
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
kprintf("handle_icmp: source=%s, destination=%s, type=%b, code=%b\n",
Kernel: Fix up the ICMP implementation to generate correct Echo replies. Serenity now responds to ping. :^)
2019-03-12 10:44:38 +00:00
ipv4_packet.source().to_string().characters(),
ipv4_packet.destination().to_string().characters(),
icmp_header.type(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
icmp_header.code());
Kernel: Fix up the ICMP implementation to generate correct Echo replies. Serenity now responds to ping. :^)
2019-03-12 10:44:38 +00:00
#endif
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 11:43:30 +00:00
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
{
LOCKER(IPv4Socket::all_sockets().lock());
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
for (RefPtr<IPv4Socket> socket : IPv4Socket::all_sockets().resource()) {
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
LOCKER(socket->lock());
if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
continue;
IPv4: Use KBuffer instead of ByteBuffer for socket receive queues This drastically reduces the pressure on the kernel heap when receiving data from IPv4 sockets.
2019-08-04 19:07:50 +00:00
socket->did_receive(ipv4_packet.source(), 0, KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
}
Kernel: Use WeakPtr<NetworkAdapter> instead of NetworkAdapter* in net code
2019-08-09 02:34:32 +00:00
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
Kernel: Add a way to look up NetworkAdapters by IPv4 address.
2019-03-12 12:30:36 +00:00
if (!adapter)
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 11:43:30 +00:00
return;
if (icmp_header.type() == ICMPType::EchoRequest) {
auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
kprintf("handle_icmp: EchoRequest from %s: id=%u, seq=%u\n",
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
ipv4_packet.source().to_string().characters(),
AK: Rename the common integer typedefs to make it obvious what they are. These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
2019-07-03 19:17:35 +00:00
(u16)request.identifier,
(u16)request.sequence_number);
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 11:43:30 +00:00
size_t icmp_packet_size = ipv4_packet.payload_size();
auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
ByteBuffer: Remove pointer() in favor of data() We had two ways to get the data inside a ByteBuffer. That was silly.
2019-09-30 06:57:01 +00:00
auto& response = *(ICMPEchoPacket*)buffer.data();
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 11:43:30 +00:00
response.header.set_type(ICMPType::EchoReply);
response.header.set_code(0);
response.identifier = request.identifier;
response.sequence_number = request.sequence_number;
if (size_t icmp_payload_size = icmp_packet_size - sizeof(ICMPEchoPacket))
memcpy(response.payload(), request.payload(), icmp_payload_size);
response.header.set_checksum(internet_checksum(&response, icmp_packet_size));
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
// FIXME: What is the right TTL value here? Is 64 ok? Should we use the same TTL as the echo request?
adapter->send_ipv4(eth.source(), ipv4_packet.source(), IPv4Protocol::ICMP, buffer.data(), buffer.size(), 64);
Kernel: Start adding IPv4 support, starting with ICMP echo messages. This doesn't work correctly yet, but it's getting nice enough to commit.
2019-03-12 03:11:20 +00:00
}
Kernel: Bring up enough networking code that we can respond to ARP requests. This is all pretty rickety but we can now respond to "arping" from the host while running inside QEMU. Very cool. :^)
2019-03-11 22:21:38 +00:00
}
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
void handle_udp(const IPv4Packet& ipv4_packet)
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
{
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
kprintf("handle_udp: Packet too small (%u, need %zu)\n", ipv4_packet.payload_size());
return;
}
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
Kernel: Use WeakPtr<NetworkAdapter> instead of NetworkAdapter* in net code
2019-08-09 02:34:32 +00:00
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
if (!adapter) {
kprintf("handle_udp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
return;
}
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
#ifdef UDP_DEBUG
kprintf("handle_udp: source=%s:%u, destination=%s:%u length=%u\n",
ipv4_packet.source().to_string().characters(),
udp_packet.source_port(),
ipv4_packet.destination().to_string().characters(),
udp_packet.destination_port(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
udp_packet.length());
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
#endif
IPv4: Factor out UDP parts of IPv4Socket into a UDPSocket class.
2019-03-14 11:43:18 +00:00
auto socket = UDPSocket::from_port(udp_packet.destination_port());
Kernel: Add SocketHandle helper class that wraps locked sockets. This allows us to have a comfy IPv4Socket::from_tcp_port() API that returns a socket that's locked and safe to access. No need to worry about locking at the client site.
2019-03-14 08:19:24 +00:00
if (!socket) {
kprintf("handle_udp: No UDP socket for port %u\n", udp_packet.destination_port());
return;
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
}
IPv4: Use the UDP-to-socket map to handle incoming UDP packets.
2019-03-13 15:23:22 +00:00
ASSERT(socket->type() == SOCK_DGRAM);
IPv4: Rename source/destination in socket classes to local/peer. It was way too ambiguous who's the source and who's the destination, and it didn't really follow a logical pattern. "Local port" vs "Peer port" is super obvious, so let's call it that.
2019-05-04 14:40:34 +00:00
ASSERT(socket->local_port() == udp_packet.destination_port());
IPv4: Use KBuffer instead of ByteBuffer for socket receive queues This drastically reduces the pressure on the kernel heap when receiving data from IPv4 sockets.
2019-08-04 19:07:50 +00:00
socket->did_receive(ipv4_packet.source(), udp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
}
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
void handle_tcp(const IPv4Packet& ipv4_packet)
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
{
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
kprintf("handle_tcp: IPv4 payload is too small to be a TCP packet (%u, need %zu)\n", ipv4_packet.payload_size(), sizeof(TCPPacket));
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
return;
}
auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
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) {
kprintf("handle_tcp: TCP packet header has invalid size %zu\n", tcp_packet.header_size());
}
if (ipv4_packet.payload_size() < tcp_packet.header_size()) {
kprintf("handle_tcp: IPv4 payload is smaller than TCP header claims (%u, supposedly %u)\n", ipv4_packet.payload_size(), tcp_packet.header_size());
return;
}
IPv4: Last burst of TCP hacking for today. Connecting to a test server and exchanging data back and forth works.
2019-03-14 00:42:29 +00:00
size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
#ifdef TCP_DEBUG
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
kprintf("handle_tcp: source=%s:%u, destination=%s:%u seq_no=%u, ack_no=%u, flags=%w (%s%s%s%s), window_size=%u, payload_size=%u\n",
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
ipv4_packet.source().to_string().characters(),
tcp_packet.source_port(),
ipv4_packet.destination().to_string().characters(),
tcp_packet.destination_port(),
tcp_packet.sequence_number(),
tcp_packet.ack_number(),
tcp_packet.flags(),
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
tcp_packet.has_syn() ? "SYN " : "",
tcp_packet.has_ack() ? "ACK " : "",
tcp_packet.has_fin() ? "FIN " : "",
tcp_packet.has_rst() ? "RST " : "",
IPv4: Last burst of TCP hacking for today. Connecting to a test server and exchanging data back and forth works.
2019-03-14 00:42:29 +00:00
tcp_packet.window_size(),
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
payload_size);
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
#endif
Kernel: Clean up and sanitize incoming packet handling a bit more Once we've converted from an Ethernet frame to an IPv4 packet, we can pass the IPv4Packet around instead of the EthernetFrameHeader. Also add some more code to ignore invalid-looking packets.
2019-08-09 08:42:01 +00:00
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
if (!adapter) {
kprintf("handle_tcp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
return;
}
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
IPv4SocketTuple tuple(ipv4_packet.destination(), tcp_packet.destination_port(), ipv4_packet.source(), tcp_packet.source_port());
Kernel: Improve some network-related log messages
2019-08-09 02:35:56 +00:00
#ifdef TCP_DEBUG
kprintf("handle_tcp: looking for socket; tuple=%s\n", tuple.to_string().characters());
#endif
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
auto socket = TCPSocket::from_tuple(tuple);
Kernel: Add SocketHandle helper class that wraps locked sockets. This allows us to have a comfy IPv4Socket::from_tcp_port() API that returns a socket that's locked and safe to access. No need to worry about locking at the client site.
2019-03-14 08:19:24 +00:00
if (!socket) {
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
kprintf("handle_tcp: No TCP socket for tuple %s\n", tuple.to_string().characters());
TCP: Log packet metadata when receiving a TCP packet with no socket
2019-12-14 12:03:26 +00:00
kprintf("handle_tcp: source=%s:%u, destination=%s:%u seq_no=%u, ack_no=%u, flags=%w (%s%s%s%s), window_size=%u, payload_size=%u\n",
ipv4_packet.source().to_string().characters(),
tcp_packet.source_port(),
ipv4_packet.destination().to_string().characters(),
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);
Kernel: Add SocketHandle helper class that wraps locked sockets. This allows us to have a comfy IPv4Socket::from_tcp_port() API that returns a socket that's locked and safe to access. No need to worry about locking at the client site.
2019-03-14 08:19:24 +00:00
return;
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
}
ASSERT(socket->type() == SOCK_STREAM);
IPv4: Rename source/destination in socket classes to local/peer. It was way too ambiguous who's the source and who's the destination, and it didn't really follow a logical pattern. "Local port" vs "Peer port" is super obvious, so let's call it that.
2019-05-04 14:40:34 +00:00
ASSERT(socket->local_port() == tcp_packet.destination_port());
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
Kernel: Improve some network-related log messages
2019-08-09 02:35:56 +00:00
#ifdef TCP_DEBUG
kprintf("handle_tcp: got socket; state=%s\n", socket->tuple().to_string().characters(), TCPSocket::to_string(socket->state()));
#endif
Kernel: Implement outgoing TCP retransmission and better ACK handling This approach is a bit naiive - whenever we send a packet out, we check to see if there are any other packets we should try to send. This works well enough for a busy connection but not very well for a quiet one. Ideally we would check for not-acked packets on some kind of timer, and use the length of this not-acked list as feedback to throttle the writes coming from userspace.
2019-09-08 07:38:08 +00:00
socket->receive_tcp_packet(tcp_packet, ipv4_packet.payload_size());
Kernel: Record network statistics and expose as JSON This is comprised of five small changes: * Keep a counter for tx/rx packets/bytes per TCP socket * Keep a counter for tx/rx packets/bytes per network adapter * Expose that data in /proc/net_tcp and /proc/netadapters * Convert /proc/netadapters to JSON * Fix up ifconfig to read the JSON from netadapters
2019-08-08 02:32:35 +00:00
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
switch (socket->state()) {
case TCPSocket::State::Closed:
kprintf("handle_tcp: unexpected flags in Closed state\n");
Kernel: Prevent RST spam when we get an unexpected packet
2019-08-08 02:29:34 +00:00
// TODO: we may want to send an RST here, maybe as a configurable option
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
return;
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
case TCPSocket::State::TimeWait:
kprintf("handle_tcp: unexpected flags in TimeWait state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
case TCPSocket::State::Listen:
switch (tcp_packet.flags()) {
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
case TCPFlags::SYN: {
Kernel: Put some network log messages behind debug flags
2019-09-08 09:13:50 +00:00
#ifdef TCP_DEBUG
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
kprintf("handle_tcp: incoming connection\n");
Kernel: Put some network log messages behind debug flags
2019-09-08 09:13:50 +00:00
#endif
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
auto& local_address = ipv4_packet.destination();
auto& peer_address = ipv4_packet.source();
auto client = socket->create_client(local_address, tcp_packet.destination_port(), peer_address, tcp_packet.source_port());
if (!client) {
kprintf("handle_tcp: couldn't create client socket\n");
return;
}
Kernel: Put some network log messages behind debug flags
2019-09-08 09:13:50 +00:00
#ifdef TCP_DEBUG
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
kprintf("handle_tcp: created new client socket with tuple %s\n", client->tuple().to_string().characters());
Kernel: Put some network log messages behind debug flags
2019-09-08 09:13:50 +00:00
#endif
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
client->set_sequence_number(1000);
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
client->set_state(TCPSocket::State::SynReceived);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
return;
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
}
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
default:
kprintf("handle_tcp: unexpected flags in Listen state\n");
// 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);
socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::SynReceived);
return;
Kernel: Detect some outgoing TCP connection failures
2019-08-10 03:18:18 +00:00
case TCPFlags::ACK | TCPFlags::SYN:
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::Established);
Kernel: Use a more detailed state machine for socket setup
2019-08-10 03:17:00 +00:00
socket->set_setup_state(Socket::SetupState::Completed);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
socket->set_connected(true);
return;
Kernel: Detect some outgoing TCP connection failures
2019-08-10 03:18:18 +00:00
case TCPFlags::ACK | TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->send_tcp_packet(TCPFlags::ACK);
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:
Kernel: Don't increment ACK number without SYN, FIN, or data
2019-09-08 07:02:40 +00:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Kernel: Detect some outgoing TCP connection failures
2019-08-10 03:18:18 +00:00
socket->send_tcp_packet(TCPFlags::ACK);
socket->set_state(TCPSocket::State::Closed);
socket->set_error(TCPSocket::Error::RSTDuringConnect);
socket->set_setup_state(Socket::SetupState::Completed);
return;
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
default:
kprintf("handle_tcp: unexpected flags in SynSent state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
Kernel: Detect some outgoing TCP connection failures
2019-08-10 03:18:18 +00:00
socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect);
Kernel: Use a more detailed state machine for socket setup
2019-08-10 03:17:00 +00:00
socket->set_setup_state(Socket::SetupState::Completed);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
return;
}
case TCPSocket::State::SynReceived:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
Kernel: Don't increment ACK number without SYN, FIN, or data
2019-09-08 07:02:40 +00:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Kernel: Handle listening socket disappearing during incoming handshake
2019-09-08 09:37:05 +00:00
switch (socket->direction()) {
case TCPSocket::Direction::Incoming:
if (!socket->has_originator()) {
kprintf("handle_tcp: connection doesn't have an originating socket; maybe it went away?\n");
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);
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 02:48:28 +00:00
socket->set_connected(true);
Kernel: Handle listening socket disappearing during incoming handshake
2019-09-08 09:37:05 +00:00
return;
default:
kprintf("handle_tcp: got ACK in SynReceived state but direction is invalid (%s)\n", TCPSocket::to_string(socket->direction()));
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
return;
default:
kprintf("handle_tcp: unexpected flags in SynReceived state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::CloseWait:
switch (tcp_packet.flags()) {
default:
kprintf("handle_tcp: unexpected flags in CloseWait state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::LastAck:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
Kernel: Don't increment ACK number without SYN, FIN, or data
2019-09-08 07:02:40 +00:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
socket->set_state(TCPSocket::State::Closed);
return;
default:
kprintf("handle_tcp: unexpected flags in LastAck state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::FinWait1:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
Kernel: Don't increment ACK number without SYN, FIN, or data
2019-09-08 07:02:40 +00:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
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);
return;
default:
kprintf("handle_tcp: unexpected flags in FinWait1 state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::FinWait2:
switch (tcp_packet.flags()) {
case TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
socket->set_state(TCPSocket::State::TimeWait);
return;
default:
kprintf("handle_tcp: unexpected flags in FinWait2 state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::Closing:
switch (tcp_packet.flags()) {
case TCPFlags::ACK:
Kernel: Don't increment ACK number without SYN, FIN, or data
2019-09-08 07:02:40 +00:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
socket->set_state(TCPSocket::State::TimeWait);
return;
default:
kprintf("handle_tcp: unexpected flags in Closing state\n");
socket->send_tcp_packet(TCPFlags::RST);
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::Established:
if (tcp_packet.has_fin()) {
if (payload_size != 0)
socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
Kernel: Send ACK/FIN in response to FIN packets on active connections This is to work around our lack of a shutdown() implementation.
2019-09-08 07:42:19 +00:00
// TODO: We should only send a FIN packet out once we're shutting
// down our side of the socket, so we should change this back to
// just being an ACK and a transition to CloseWait once we have a
// shutdown() implementation.
socket->send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
socket->set_state(TCPSocket::State::Closing);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
socket->set_connected(false);
return;
}
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
Kernel: Put IPv4 and TCP related debug spam behind flags ...and turn those flags off for now, to make it possible to write some networking code without being spammed to death.
2019-08-04 08:04:06 +00:00
#ifdef TCP_DEBUG
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
kprintf("Got packet with ack_no=%u, seq_no=%u, payload_size=%u, acking it with new ack_no=%u, seq_no=%u\n",
tcp_packet.ack_number(),
tcp_packet.sequence_number(),
payload_size,
socket->ack_number(),
socket->sequence_number());
Kernel: Put IPv4 and TCP related debug spam behind flags ...and turn those flags off for now, to make it possible to write some networking code without being spammed to death.
2019-08-04 08:04:06 +00:00
#endif
IPv4: More work on the TCP implementation. I can now establish a connection to my little test server on the host.
2019-03-13 23:20:44 +00:00
Kernel: Make File's can_read/can_write take a const FileDescription& Asking a File if we could possibly read or write it will never mutate the asking FileDescription&, so it should be const.
2019-11-04 13:03:14 +00:00
bool should_ack = true;
if (payload_size != 0) {
should_ack = socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
}
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
Kernel: Make File's can_read/can_write take a const FileDescription& Asking a File if we could possibly read or write it will never mutate the asking FileDescription&, so it should be const.
2019-11-04 13:03:14 +00:00
if (should_ack)
socket->send_tcp_packet(TCPFlags::ACK);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
}
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
}
Reference in a new issue Copy permalink