LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-11 09:18:05 +03:00
Code Issues Packages Projects Releases Wiki Activity
cb2c8f71f4
ladybird/Kernel/Net/NetworkTask.cpp

578 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 11:38:21 +03: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 12:43:58 +03: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 20:54:38 +03: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 12:43:58 +03:00
#include <Kernel/Net/LoopbackAdapter.h>
Kernel: Move NetworkTask startup into NetworkTask::spawn()
2020-04-09 14:31:05 +03:00
#include <Kernel/Net/NetworkTask.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 14:53:01 +03:00
#include <Kernel/Net/Routing.h>
Kernel: Run clang-format on everything.
2019-06-07 12:43:58 +03:00
#include <Kernel/Net/TCP.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 20:54:38 +03:00
#include <Kernel/Net/TCPSocket.h>
Kernel: Run clang-format on everything.
2019-06-07 12:43:58 +03:00
#include <Kernel/Net/UDP.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 20:54:38 +03: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 14:43:45 +03: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-12 01:21:38 +03: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 14:53:01 +03: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 06:11:20 +03: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 16:40:38 +03: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 14:58:01 +03: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 11:04:06 +03:00
//#define IPV4_DEBUG
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03: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 11:04:06 +03: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 06:11:20 +03:00
Kernel: Move all code into the Kernel namespace
2020-02-16 03:27:42 +03:00
namespace Kernel {
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 11:42:01 +03:00
static void handle_arp(const EthernetFrameHeader&, size_t frame_size);
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
static void handle_ipv4(const EthernetFrameHeader&, size_t frame_size, const timeval& packet_timestamp);
static void handle_icmp(const EthernetFrameHeader&, const IPv4Packet&, const timeval& packet_timestamp);
static void handle_udp(const IPv4Packet&, const timeval& packet_timestamp);
static void handle_tcp(const IPv4Packet&, const timeval& packet_timestamp);
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 14:43:45 +03:00
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 06:51:34 +03:00
[[noreturn]] static void NetworkTask_main(void*);
Kernel: Move NetworkTask startup into NetworkTask::spawn()
2020-04-09 14:31:05 +03:00
void NetworkTask::spawn()
{
Kernel: Make Thread refcounted Similar to Process, we need to make Thread refcounted. This will solve problems that will appear once we schedule threads on more than one processor. This allows us to hold onto threads without necessarily holding the scheduler lock for the entire duration.
2020-09-27 17:53:35 +03:00
RefPtr<Thread> thread;
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 06:51:34 +03:00
Process::create_kernel_process(thread, "NetworkTask", NetworkTask_main, nullptr);
Kernel: Move NetworkTask startup into NetworkTask::spawn()
2020-04-09 14:31:05 +03:00
}
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 06:51:34 +03:00
void NetworkTask_main(void*)
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 14:43:45 +03:00
{
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 18:47:49 +03: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 14:53:01 +03:00
u8 octet = 15;
int pending_packets = 0;
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 18:47:49 +03: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 14:53:01 +03: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 16:46:44 +03:00
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
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();
NetworkTask: Don't crash on startup if there's no E1000 NIC present.
2019-05-18 01:22:08 +03:00
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 18:47:49 +03: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 14:53:01 +03:00
pending_packets++;
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 18:47:49 +03:00
packet_wait_queue.wake_all();
Kernel: Use a public member for NetworkAdapter on_receive
2019-08-28 15:14:38 +03: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 14:53:01 +03: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 14:43:45 +03:00
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
auto dequeue_packet = [&pending_packets](u8* buffer, size_t buffer_size, timeval& packet_timestamp) -> size_t {
Kernel: Use a WaitQueue in NetworkTask
2019-12-01 18:47:49 +03: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 13:07:37 +03: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 14:53:01 +03:00
return;
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
packet_size = adapter.dequeue_packet(buffer, buffer_size, packet_timestamp);
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 14:53:01 +03:00
pending_packets--;
#ifdef NETWORK_TASK_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "NetworkTask: Dequeued packet from " << adapter.name().characters() << " (" << packet_size << " bytes)";
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 14:53:01 +03: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 13:07:37 +03: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 16:46:44 +03:00
};
AK: Rename KB, MB, GB to KiB, MiB, GiB The SI prefixes "k", "M", "G" mean "10^3", "10^6", "10^9". The IEC prefixes "Ki", "Mi", "Gi" mean "2^10", "2^20", "2^30". Let's use the correct name, at least in code. Only changes the name of the constants, no other behavior change.
2020-08-15 20:55:00 +03:00
size_t buffer_size = 64 * KiB;
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-28 02:07:56 +03:00
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: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
timeval packet_timestamp;
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-28 02:07:56 +03:00
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "NetworkTask: Enter main loop.";
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 14:43:45 +03:00
for (;;) {
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
size_t packet_size = dequeue_packet(buffer, buffer_size, packet_timestamp);
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 13:07:37 +03:00
if (!packet_size) {
Kernel: Fix some issues related to fixes and block conditions Fix some problems with join blocks where the joining thread block condition was added twice, which lead to a crash when trying to unblock that condition a second time. Deferred block condition evaluation by File objects were also not properly keeping the File object alive, which lead to some random crashes and corruption problems. Other problems were caused by the fact that the Queued state didn't handle signals/interruptions consistently. To solve these issues we remove this state entirely, along with Thread::wait_on and change the WaitQueue into a BlockCondition instead. Also, deliver signals even if there isn't going to be a context switch to another thread. Fixes #4336 and #4330
2020-12-08 07:29:41 +03:00
packet_wait_queue.wait_on(nullptr, "NetworkTask");
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 14:43:45 +03: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 13:07:37 +03:00
if (packet_size < sizeof(EthernetFrameHeader)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "NetworkTask: Packet is too small to be an Ethernet packet! (" << 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 14:43:45 +03:00
continue;
}
Kernel: Move incoming packet buffer off the NetworkTask stack
2019-12-28 02:07:56 +03: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 06:11:20 +03:00
#ifdef ETHERNET_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "NetworkTask: From " << eth.source().to_string().characters() << " to " << eth.destination().to_string().characters() << ", ether_type=" << String::format("%w", eth.ether_type()) << ", packet_length=" << 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 06:11:20 +03: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-12 01:21:38 +03: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 16:40:38 +03: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 13:07:37 +03:00
for (size_t i = 0; i < packet_size; i++) {
AK: Remove custom %b format string specifier This was a non-standard specifier alias for %02x. This patch replaces all uses of it with new-style formatting functions instead.
2020-12-25 18:45:35 +03:00
klog() << String::format("%#02x", 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 16:40:38 +03:00
switch (i % 16) {
case 7:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << " ";
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 16:40:38 +03:00
break;
case 15:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "";
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 16:40:38 +03:00
break;
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << " ";
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 16:40:38 +03:00
break;
}
}
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "";
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 16:40:38 +03: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-12 01:21:38 +03: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 13:07:37 +03: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-12 01:21:38 +03:00
break;
case EtherType::IPv4:
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
handle_ipv4(eth, packet_size, packet_timestamp);
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-12 01:21:38 +03:00
break;
Kernel: Ignore IPv6 packets; log unknown Ethernet payload types
2019-08-28 03:53:12 +03:00
case EtherType::IPv6:
// ignore
break;
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "NetworkTask: Unknown ethernet type 0x" << String::format("%x", 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-12 01:21:38 +03: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 14:43:45 +03: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-12 01:21:38 +03: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 11:42:01 +03: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-12 01:21:38 +03: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 11:42:01 +03: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-12 01:21:38 +03:00
if (frame_size < minimum_arp_frame_size) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_arp: Frame too small (" << frame_size << ", need " << minimum_arp_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-12 01:21:38 +03:00
return;
}
Kernel: Cache MAC<->IP mappings (from ARP responses) seen on the wire.
2019-03-12 02:56:33 +03:00
auto& packet = *static_cast<const ARPPacket*>(eth.payload());
Kernel: Minor style cleanup in NetworkTask.
2019-03-12 02:01:07 +03:00
if (packet.hardware_type() != 1 || packet.hardware_address_length() != sizeof(MACAddress)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_arp: Hardware type not ethernet (" << String::format("%w", packet.hardware_type()) << ", len=" << 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-12 01:21:38 +03:00
return;
}
Kernel: Minor style cleanup in NetworkTask.
2019-03-12 02:01:07 +03:00
if (packet.protocol_type() != EtherType::IPv4 || packet.protocol_address_length() != sizeof(IPv4Address)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_arp: Protocol type not IPv4 (" << String::format("%w", packet.hardware_type()) << ", len=" << 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-12 01:21:38 +03:00
return;
}
#ifdef ARP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_arp: operation=" << String::format("%w", packet.operation()) << ", sender=" << packet.sender_hardware_address().to_string().characters() << "/" << packet.sender_protocol_address().to_string().characters() << ", target=" << packet.target_hardware_address().to_string().characters() << "/" << 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-12 01:21:38 +03: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 10:26:21 +03: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.
Kernel: Move block condition evaluation out of the Scheduler This makes the Scheduler a lot leaner by not having to evaluate block conditions every time it is invoked. Instead evaluate them as the states change, and unblock threads at that point. This also implements some more waitid/waitpid/wait features and behavior. For example, WUNTRACED and WNOWAIT are now supported. And wait will now not return EINTR when SIGCHLD is delivered at the same time.
2020-11-30 02:05:27 +03:00
update_arp_table(packet.sender_protocol_address(), packet.sender_hardware_address());
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 10:26:21 +03:00
}
Kernel: Tidy up networking code with some named constants.
2019-03-12 03:30:49 +03: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-12 01:21:38 +03:00
// Who has this IP address?
Kernel: Use WeakPtr<NetworkAdapter> instead of NetworkAdapter* in net code
2019-08-09 05:34:32 +03: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-12 01:21:38 +03:00
// We do!
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_arp: Responding to ARP request for my IPv4 address (" << 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-12 01:21:38 +03:00
ARPPacket response;
Kernel: Tidy up networking code with some named constants.
2019-03-12 03:30:49 +03:00
response.set_operation(ARPOperation::Response);
Kernel: Minor style cleanup in NetworkTask.
2019-03-12 02:01:07 +03: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 15:30:36 +03: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-12 01:21:38 +03:00
Kernel: Add a way to look up NetworkAdapters by IPv4 address.
2019-03-12 15:30:36 +03: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-12 01:21:38 +03:00
}
Kernel: Cache MAC<->IP mappings (from ARP responses) seen on the wire.
2019-03-12 02:56:33 +03: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-12 01:21:38 +03:00
}
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size, const timeval& packet_timestamp)
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-12 01:21:38 +03: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 11:42:01 +03: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 06:11:20 +03:00
if (frame_size < minimum_ipv4_frame_size) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_ipv4: Frame too small (" << frame_size << ", need " << minimum_ipv4_frame_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 06:11:20 +03:00
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-12 01:21:38 +03: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 10:36:06 +03:00
if (packet.length() < sizeof(IPv4Packet)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_ipv4: IPv4 packet too short (" << packet.length() << ", need " << sizeof(IPv4Packet) << ")";
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 10:36:06 +03:00
return;
}
size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader);
if (packet.length() > actual_ipv4_packet_length) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_ipv4: IPv4 packet claims to be longer than it is (" << packet.length() << ", actually " << actual_ipv4_packet_length << ")";
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 10:36:06 +03:00
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 06:11:20 +03:00
#ifdef IPV4_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_ipv4: source=" << packet.source().to_string().characters() << ", target=" << 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 06:11:20 +03:00
#endif
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 14:43:30 +03: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 06:11:20 +03:00
case IPv4Protocol::ICMP:
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
return handle_icmp(eth, packet, packet_timestamp);
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
case IPv4Protocol::UDP:
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
return handle_udp(packet, packet_timestamp);
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03:00
case IPv4Protocol::TCP:
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
return handle_tcp(packet, packet_timestamp);
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 06:11:20 +03:00
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_ipv4: Unhandled protocol " << 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 06:11:20 +03:00
break;
}
}
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
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 06:11:20 +03: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 13:44:38 +03:00
#ifdef ICMP_DEBUG
AK: Remove custom %b format string specifier This was a non-standard specifier alias for %02x. This patch replaces all uses of it with new-style formatting functions instead.
2020-12-25 18:45:35 +03:00
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());
Kernel: Fix up the ICMP implementation to generate correct Echo replies. Serenity now responds to ping. :^)
2019-03-12 13:44:38 +03:00
#endif
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 14:43:30 +03: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 19:27:07 +03:00
{
LOCKER(IPv4Socket::all_sockets().lock());
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 19:37:47 +03: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 19:27:07 +03:00
LOCKER(socket->lock());
if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
continue;
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
socket->did_receive(ipv4_packet.source(), 0, KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp);
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 19:27:07 +03:00
}
}
Kernel: Use WeakPtr<NetworkAdapter> instead of NetworkAdapter* in net code
2019-08-09 05:34:32 +03:00
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
Kernel: Add a way to look up NetworkAdapters by IPv4 address.
2019-03-12 15:30:36 +03:00
if (!adapter)
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 14:43:30 +03:00
return;
if (icmp_header.type() == ICMPType::EchoRequest) {
auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_icmp: EchoRequest from " << ipv4_packet.source().to_string().characters() << ": id=" << (u16)request.identifier << ", seq=" << (u16)request.sequence_number;
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 14:43:30 +03:00
size_t icmp_packet_size = ipv4_packet.payload_size();
ICMP: Check that incoming ICMP echo requests are large enough Otherwise, just ignore them.
2020-10-20 18:53:11 +03:00
if (icmp_packet_size < sizeof(ICMPEchoPacket)) {
klog() << "handle_icmp: EchoRequest packet is too small, ignoring.";
return;
}
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 14:43:30 +03:00
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 09:57:01 +03:00
auto& response = *(ICMPEchoPacket*)buffer.data();
Kernel: More work on the ICMP and IPv4 support.
2019-03-12 14:43:30 +03: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 22:40:06 +03:00
// FIXME: What is the right TTL value here? Is 64 ok? Should we use the same TTL as the echo request?
Kernel: Make copy_to/from_user safe and remove unnecessary checks Since the CPU already does almost all necessary validation steps for us, we don't really need to attempt to do this. Doing it ourselves doesn't really work very reliably, because we'd have to account for other processors modifying virtual memory, and we'd have to account for e.g. pages not being able to be allocated due to insufficient resources. So change the copy_to/from_user (and associated helper functions) to use the new safe_memcpy, which will return whether it succeeded or not. The only manual validation step needed (which the CPU can't perform for us) is making sure the pointers provided by user mode aren't pointing to kernel mappings. To make it easier to read/write from/to either kernel or user mode data add the UserOrKernelBuffer helper class, which will internally either use copy_from/to_user or directly memcpy, or pass the data through directly using a temporary buffer on the stack. Last but not least we need to keep syscall params trivial as we need to copy them from/to user mode using copy_from/to_user.
2020-09-12 06:11:07 +03:00
auto response_buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&response);
adapter->send_ipv4(eth.source(), ipv4_packet.source(), IPv4Protocol::ICMP, response_buffer, 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 06:11:20 +03: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-12 01:21:38 +03:00
}
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
void handle_udp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03: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 11:42:01 +03:00
if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_udp: Packet too small (" << ipv4_packet.payload_size() << ", need " << sizeof(UDPPacket) << ")";
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 11:42:01 +03:00
return;
}
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
Kernel: Use WeakPtr<NetworkAdapter> instead of NetworkAdapter* in net code
2019-08-09 05:34:32 +03:00
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
Kernel: Do not reject broadcast UDP packets right away This patch relaxes how we think about UDP packets being "for us" a bit; the proper way to handle this would be to also check if the matched socket has SO_BROADCAST set, but we don't have that :)
2020-04-04 13:03:47 +03:00
if (!adapter && ipv4_packet.destination() != IPv4Address(255, 255, 255, 255)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_udp: this packet is not for me, it's for " << ipv4_packet.destination().to_string().characters();
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
return;
}
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
#ifdef UDP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
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();
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
#endif
IPv4: Factor out UDP parts of IPv4Socket into a UDPSocket class.
2019-03-14 14:43:18 +03: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 11:19:24 +03:00
if (!socket) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_udp: No UDP socket for 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 11:19:24 +03:00
return;
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
}
IPv4: Use the UDP-to-socket map to handle incoming UDP packets.
2019-03-13 18:23:22 +03: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 17:40:34 +03:00
ASSERT(socket->local_port() == udp_packet.destination_port());
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
socket->did_receive(ipv4_packet.source(), udp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp);
Kernel: Start fleshing out an UDP implementation.
2019-03-13 16:22:27 +03:00
}
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03:00
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
void handle_tcp(const IPv4Packet& ipv4_packet, const timeval& packet_timestamp)
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03: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 11:42:01 +03:00
if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: IPv4 payload is too small to be a TCP packet (" << ipv4_packet.payload_size() << ", need " << sizeof(TCPPacket) << ")";
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03: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 11:42:01 +03: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) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: TCP packet header has invalid size " << tcp_packet.header_size();
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 11:42:01 +03:00
}
if (ipv4_packet.payload_size() < tcp_packet.header_size()) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: IPv4 payload is smaller than TCP header claims (" << ipv4_packet.payload_size() << ", supposedly " << tcp_packet.header_size() << ")";
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 11:42:01 +03:00
return;
}
IPv4: Last burst of TCP hacking for today. Connecting to a test server and exchanging data back and forth works.
2019-03-14 03:42:29 +03:00
size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03:00
#ifdef TCP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: source=" << ipv4_packet.source().to_string().characters() << ":" << tcp_packet.source_port() << ", destination=" << ipv4_packet.destination().to_string().characters() << ":" << tcp_packet.destination_port() << " seq_no=" << tcp_packet.sequence_number() << ", ack_no=" << tcp_packet.ack_number() << ", flags=" << String::format("%w", tcp_packet.flags()) << " (" << (tcp_packet.has_syn() ? "SYN " : "") << (tcp_packet.has_ack() ? "ACK " : "") << (tcp_packet.has_fin() ? "FIN " : "") << (tcp_packet.has_rst() ? "RST " : "") << "), window_size=" << tcp_packet.window_size() << ", payload_size=" << payload_size;
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03: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 11:42:01 +03:00
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
if (!adapter) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: this packet is not for me, it's for " << ipv4_packet.destination().to_string().characters();
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 11:42:01 +03: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 16:40:38 +03: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 05:35:56 +03:00
#ifdef TCP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: looking for socket; tuple=" << tuple.to_string().characters();
Kernel: Improve some network-related log messages
2019-08-09 05:35:56 +03:00
#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 16:40:38 +03: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 11:19:24 +03:00
if (!socket) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: No TCP socket for tuple " << tuple.to_string().characters();
klog() << "handle_tcp: source=" << ipv4_packet.source().to_string().characters() << ":" << tcp_packet.source_port() << ", destination=" << ipv4_packet.destination().to_string().characters() << ":" << tcp_packet.destination_port() << " seq_no=" << tcp_packet.sequence_number() << ", ack_no=" << tcp_packet.ack_number() << ", flags=" << String::format("%w", tcp_packet.flags()) << " (" << (tcp_packet.has_syn() ? "SYN " : "") << (tcp_packet.has_ack() ? "ACK " : "") << (tcp_packet.has_fin() ? "FIN " : "") << (tcp_packet.has_rst() ? "RST " : "") << "), window_size=" << tcp_packet.window_size() << ", payload_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 11:19:24 +03:00
return;
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03:00
}
IPv4: Take the socket lock more (fixes TCP connection to localhost) This fixes an issue where making a TCP connection to localhost didn't work correctly since the loopback interface is currently synchronous. (Sending something to localhost would enqueue a packet on the same interface and then immediately wake the network task to process that packet.) This was preventing the TCP handshake from working correctly with localhost since we'd send out the SYN packet before moving to the SynSent state. The lock is now held long enough for this operation to be atomic.
2020-10-21 21:51:02 +03:00
LOCKER(socket->lock());
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03: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 17:40:34 +03: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-14 01:14:30 +03:00
Kernel: Improve some network-related log messages
2019-08-09 05:35:56 +03:00
#ifdef TCP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: got socket; state=" << socket->tuple().to_string().characters() << " " << TCPSocket::to_string(socket->state());
Kernel: Improve some network-related log messages
2019-08-09 05:35:56 +03:00
#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 10:38:08 +03: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 05:32:35 +03:00
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
[[maybe_unused]] int unused_rc {};
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 16:40:38 +03:00
switch (socket->state()) {
case TCPSocket::State::Closed:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in Closed state";
Kernel: Prevent RST spam when we get an unexpected packet
2019-08-08 05:29:34 +03: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 17:23:32 +03: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 16:40:38 +03:00
case TCPSocket::State::TimeWait:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in TimeWait state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
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 05:48:28 +03:00
case TCPFlags::SYN: {
Kernel: Put some network log messages behind debug flags
2019-09-08 12:13:50 +03:00
#ifdef TCP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: incoming connection";
Kernel: Put some network log messages behind debug flags
2019-09-08 12:13:50 +03:00
#endif
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 05:48:28 +03: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) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: couldn't create client socket";
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 05:48:28 +03:00
return;
}
IPv4: Take the socket lock more (fixes TCP connection to localhost) This fixes an issue where making a TCP connection to localhost didn't work correctly since the loopback interface is currently synchronous. (Sending something to localhost would enqueue a packet on the same interface and then immediately wake the network task to process that packet.) This was preventing the TCP handshake from working correctly with localhost since we'd send out the SYN packet before moving to the SynSent state. The lock is now held long enough for this operation to be atomic.
2020-10-21 21:51:02 +03:00
LOCKER(client->lock());
Kernel: Put some network log messages behind debug flags
2019-09-08 12:13:50 +03:00
#ifdef TCP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: created new client socket with tuple " << client->tuple().to_string().characters();
Kernel: Put some network log messages behind debug flags
2019-09-08 12:13:50 +03:00
#endif
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 05:48:28 +03:00
client->set_sequence_number(1000);
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
[[maybe_unused]] auto rc2 = client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 05:48:28 +03:00
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 16:40:38 +03:00
return;
Kernel: Implement TCP listening sockets and incoming connections
2019-08-09 05:48:28 +03: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 16:40:38 +03:00
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in Listen state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
// socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
return;
}
case TCPSocket::State::SynSent:
switch (tcp_packet.flags()) {
case TCPFlags::SYN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = 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 16:40:38 +03:00
socket->set_state(TCPSocket::State::SynReceived);
return;
Kernel: Detect some outgoing TCP connection failures
2019-08-10 06:18:18 +03: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 16:40:38 +03:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = 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 16:40:38 +03:00
socket->set_state(TCPSocket::State::Established);
Kernel: Use a more detailed state machine for socket setup
2019-08-10 06:17:00 +03: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 16:40:38 +03:00
socket->set_connected(true);
return;
Kernel: Detect some outgoing TCP connection failures
2019-08-10 06:18:18 +03:00
case TCPFlags::ACK | TCPFlags::FIN:
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
Kernel: Detect some outgoing TCP connection failures
2019-08-10 06:18:18 +03:00
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 10:02:40 +03:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
Kernel: Detect some outgoing TCP connection failures
2019-08-10 06:18:18 +03:00
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 16:40:38 +03:00
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in SynSent state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
socket->set_state(TCPSocket::State::Closed);
Kernel: Detect some outgoing TCP connection failures
2019-08-10 06:18:18 +03:00
socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect);
Kernel: Use a more detailed state machine for socket setup
2019-08-10 06:17:00 +03: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 16:40:38 +03: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 10:02:40 +03:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
Kernel: Handle listening socket disappearing during incoming handshake
2019-09-08 12:37:05 +03:00
switch (socket->direction()) {
case TCPSocket::Direction::Incoming:
if (!socket->has_originator()) {
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: connection doesn't have an originating socket; maybe it went away?";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
Kernel: Handle listening socket disappearing during incoming handshake
2019-09-08 12:37:05 +03:00
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 05:48:28 +03:00
socket->set_connected(true);
Kernel: Handle listening socket disappearing during incoming handshake
2019-09-08 12:37:05 +03:00
return;
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: got ACK in SynReceived state but direction is invalid (" << TCPSocket::to_string(socket->direction()) << ")";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
Kernel: Handle listening socket disappearing during incoming handshake
2019-09-08 12:37:05 +03:00
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 16:40:38 +03:00
return;
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in SynReceived state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::CloseWait:
switch (tcp_packet.flags()) {
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in CloseWait state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
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 10:02:40 +03: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 16:40:38 +03:00
socket->set_state(TCPSocket::State::Closed);
return;
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in LastAck state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
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 10:02:40 +03: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 16:40:38 +03: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:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in FinWait1 state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
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;
IPv4: Basic implementation of TCP socket shutdown We can now participate in the TCP connection closing handshake. :^) This implementation is definitely not complete and needs to handle a bunch of other cases. But it's a huge improvement over not being able to close connections at all. Note that we hold on to pending-close sockets indefinitely, until they are moved into the Closed state. This should also have a timeout but that's still a FIXME. :^) Fixes #428.
2020-02-08 17:52:32 +03:00
case TCPFlags::ACK | 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 16:40:38 +03:00
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in FinWait2 state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
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 10:02:40 +03: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 16:40:38 +03:00
socket->set_state(TCPSocket::State::TimeWait);
return;
default:
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
klog() << "handle_tcp: unexpected flags in Closing state";
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::RST);
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 16:40:38 +03:00
socket->set_state(TCPSocket::State::Closed);
return;
}
case TCPSocket::State::Established:
if (tcp_packet.has_fin()) {
if (payload_size != 0)
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp);
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 16:40:38 +03:00
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
IPv4: Basic implementation of TCP socket shutdown We can now participate in the TCP connection closing handshake. :^) This implementation is definitely not complete and needs to handle a bunch of other cases. But it's a huge improvement over not being able to close connections at all. Note that we hold on to pending-close sockets indefinitely, until they are moved into the Closed state. This should also have a timeout but that's still a FIXME. :^) Fixes #428.
2020-02-08 17:52:32 +03:00
socket->set_state(TCPSocket::State::CloseWait);
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 16:40:38 +03: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 17:23:32 +03: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 11:04:06 +03:00
#ifdef TCP_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 22:45:39 +03:00
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();
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 11:04:06 +03: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-14 02:20:44 +03:00
IPv4: Don't ACK empty TCP packets Wireshark was complaining about duplicate ACK's and this was why.
2020-02-08 16:09:02 +03:00
if (payload_size) {
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 19:25:06 +03:00
if (socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()), packet_timestamp))
Everywhere: Switch from (void) to [[maybe_unused]] (#4473) Problem: - `(void)` simply casts the expression to void. This is understood to indicate that it is ignored, but this is really a compiler trick to get the compiler to not generate a warning. Solution: - Use the `[[maybe_unused]]` attribute to indicate the value is unused. Note: - Functions taking a `(void)` argument list have also been changed to `()` because this is not needed and shows up in the same grep command.
2020-12-21 02:09:48 +03:00
unused_rc = socket->send_tcp_packet(TCPFlags::ACK);
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 16:03:14 +03: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 16:40:38 +03:00
}
IPv4: Begin fleshing out TCP support.
2019-03-13 19:17:07 +03:00
}
Kernel: Move all code into the Kernel namespace
2020-02-16 03:27:42 +03:00
}
Reference in New Issue Copy Permalink