beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/Net/IPv4Socket.cpp

902 lines
31 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
Kernel: Switch singletons to use new Singleton class MemoryManager cannot use the Singleton class because MemoryManager::initialize is called before the global constructors are run. That caused the Singleton to be re-initialized, causing it to create another MemoryManager instance. Fixes #3226
2020-08-25 01:35:19 +00:00
#include <AK/Singleton.h>
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
#include <AK/StringBuilder.h>
Kernel/Net: Implement SIOCGIFINDEX and SIOCGIFNAME for sockets These ioctls exist on Linux and can be used to implement libc functions if_indextoname and if_nametoindex (without needing to parse any JSON).
2023-01-13 21:05:18 +00:00
#include <AK/StringView.h>
Kernel+Userland: Move LibC/sys/ioctl_numbers to Kernel/API/Ioctl.h This header has always been fundamentally a Kernel API file. Move it where it belongs. Include it directly in Kernel files, and make Userland applications include it via sys/ioctl.h rather than directly.
2023-01-07 20:52:06 +00:00
#include <Kernel/API/Ioctl.h>
Kernel+LibC: Move errno definitions to Kernel/API/POSIX This fixes at least half of our LibC includes in the kernel. The source of truth for errno codes and their description strings now lives in Kernel/API/POSIX/errno.h as an enumeration, which LibC includes.
2021-09-12 11:29:28 +00:00
#include <Kernel/API/POSIX/errno.h>
Meta: Split debug defines into multiple headers. The following script was used to make these changes: #!/bin/bash set -e tmp=$(mktemp -d) echo "tmp=$tmp" find Kernel \( -name '*.cpp' -o -name '*.h' \) | sort > $tmp/Kernel.files find . \( -path ./Toolchain -prune -o -path ./Build -prune -o -path ./Kernel -prune \) -o \( -name '*.cpp' -o -name '*.h' \) -print | sort > $tmp/EverythingExceptKernel.files cat $tmp/Kernel.files | xargs grep -Eho '[A-Z0-9_]+_DEBUG' | sort | uniq > $tmp/Kernel.macros cat $tmp/EverythingExceptKernel.files | xargs grep -Eho '[A-Z0-9_]+_DEBUG' | sort | uniq > $tmp/EverythingExceptKernel.macros comm -23 $tmp/Kernel.macros $tmp/EverythingExceptKernel.macros > $tmp/Kernel.unique comm -1 $tmp/Kernel.macros $tmp/EverythingExceptKernel.macros > $tmp/EverythingExceptKernel.unique cat $tmp/Kernel.unique | awk '{ print "#cmakedefine01 "$1 }' > $tmp/Kernel.header cat $tmp/EverythingExceptKernel.unique | awk '{ print "#cmakedefine01 "$1 }' > $tmp/EverythingExceptKernel.header for macro in $(cat $tmp/Kernel.unique) do cat $tmp/Kernel.files | xargs grep -l $macro >> $tmp/Kernel.new-includes ||: done cat $tmp/Kernel.new-includes | sort > $tmp/Kernel.new-includes.sorted for macro in $(cat $tmp/EverythingExceptKernel.unique) do cat $tmp/Kernel.files | xargs grep -l $macro >> $tmp/Kernel.old-includes ||: done cat $tmp/Kernel.old-includes | sort > $tmp/Kernel.old-includes.sorted comm -23 $tmp/Kernel.new-includes.sorted $tmp/Kernel.old-includes.sorted > $tmp/Kernel.includes.new comm -13 $tmp/Kernel.new-includes.sorted $tmp/Kernel.old-includes.sorted > $tmp/Kernel.includes.old comm -12 $tmp/Kernel.new-includes.sorted $tmp/Kernel.old-includes.sorted > $tmp/Kernel.includes.mixed for file in $(cat $tmp/Kernel.includes.new) do sed -i -E 's/#include <AK\/Debug\.h>/#include <Kernel\/Debug\.h>/' $file done for file in $(cat $tmp/Kernel.includes.mixed) do echo "mixed include in $file, requires manual editing." done
2021-01-25 15:07:10 +00:00
#include <Kernel/Debug.h>
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
#include <Kernel/FileSystem/OpenFileDescription.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/ARP.h>
#include <Kernel/Net/ICMP.h>
#include <Kernel/Net/IPv4.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/IPv4Socket.h>
#include <Kernel/Net/NetworkAdapter.h>
Kernel: Introduce the NetworkingManagement singleton Instead of initializing network adapters in init.cpp, let's move that logic into a separate class to handle this. Also, it seems like a good idea to shift responsiblity on enumeration of network adapters after the boot process, so this singleton will take care of finding the appropriate network adapter when asked to with an IPv4 address or interface name. With this change being merged, we simplify the creation logic of NetworkAdapter derived classes, so we enumerate the PCI bus only once, searching for driver candidates when doing so, and we let each driver to test if it is resposible for the specified PCI device.
2021-06-04 04:43:16 +00:00
#include <Kernel/Net/NetworkingManagement.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/Routing.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/TCP.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/TCPSocket.h>
Kernel: Move networking related files into Kernel/Net/.
2019-04-02 17:54:38 +00:00
#include <Kernel/Net/UDP.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/UDPSocket.h>
Kernel: Move all tasks-related code to the Tasks subdirectory
2023-02-24 17:45:37 +00:00
#include <Kernel/Tasks/Process.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/UnixTypes.h>
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
namespace Kernel {
Kernel: Rename ProtectedValue<T> => MutexProtected<T> Let's make it obvious what we're protecting it with.
2021-08-21 21:31:15 +00:00
static Singleton<MutexProtected<IPv4Socket::List>> s_all_sockets;
Kernel: Switch singletons to use new Singleton class MemoryManager cannot use the Singleton class because MemoryManager::initialize is called before the global constructors are run. That caused the Singleton to be re-initialized, causing it to create another MemoryManager instance. Fixes #3226
2020-08-25 01:35:19 +00:00
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
using BlockFlags = Thread::OpenFileDescriptionBlocker::BlockFlags;
Kernel: Add bitwise operators for Thread::FileBlocker::BlockFlags enum Switch to using type-safe bitwise operators for the BlockFlags class, this cleans up a lot of boilerplate casts which are necessary when the enum is declared as `enum class`.
2021-03-07 11:01:11 +00:00
Kernel: Rename ProtectedValue<T> => MutexProtected<T> Let's make it obvious what we're protecting it with.
2021-08-21 21:31:15 +00:00
MutexProtected<IPv4Socket::List>& IPv4Socket::all_sockets()
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
{
Kernel: Convert IPv4 socket list from HashTable to IntrusiveList There was no reason whatsoever to use a HashTable here. IntrusiveList removes all the heap allocations and does everything more efficiently.
2021-08-15 13:46:35 +00:00
return *s_all_sockets;
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<NonnullOwnPtr<DoubleBuffer>> IPv4Socket::try_create_receive_buffer()
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
{
Kernel: Annotate all `KBuffer` and `DoubleBuffer` with a custom name
2022-04-10 22:08:07 +00:00
return DoubleBuffer::try_create("IPv4Socket: Receive buffer"sv, 256 * KiB);
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
}
Kernel: Use RefPtr instead of LockRefPtr for File and subclasses This was mostly straightforward, as all the storage locations are guarded by some related mutex. The use of old-school associated mutexes instead of MutexProtected is unfortunate, but the process to modernize such code is ongoing.
2023-03-10 06:53:02 +00:00
ErrorOr<NonnullRefPtr<Socket>> IPv4Socket::create(int type, int protocol)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Kernel: Make DoubleBuffer::try() return KResultOr This tidies up error propagation in a number of places.
2021-09-07 11:46:11 +00:00
auto receive_buffer = TRY(IPv4Socket::try_create_receive_buffer());
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
Kernel: Use TRY() in IPv4Socket
2021-09-05 12:16:08 +00:00
if (type == SOCK_STREAM)
Kernel: Make DoubleBuffer::try() return KResultOr This tidies up error propagation in a number of places.
2021-09-07 11:46:11 +00:00
return TRY(TCPSocket::try_create(protocol, move(receive_buffer)));
Kernel: Use TRY() in IPv4Socket
2021-09-05 12:16:08 +00:00
if (type == SOCK_DGRAM)
Kernel: Make DoubleBuffer::try() return KResultOr This tidies up error propagation in a number of places.
2021-09-07 11:46:11 +00:00
return TRY(UDPSocket::try_create(protocol, move(receive_buffer)));
Kernel: Make IPv4Socket::create API for SOCK_RAW OOM safe
2021-05-13 08:24:44 +00:00
if (type == SOCK_RAW) {
Kernel: Use RefPtr instead of LockRefPtr for File and subclasses This was mostly straightforward, as all the storage locations are guarded by some related mutex. The use of old-school associated mutexes instead of MutexProtected is unfortunate, but the process to modernize such code is ongoing.
2023-03-10 06:53:02 +00:00
auto raw_socket = adopt_ref_if_nonnull(new (nothrow) IPv4Socket(type, protocol, move(receive_buffer), {}));
Kernel: Make IPv4Socket::create API for SOCK_RAW OOM safe
2021-05-13 08:24:44 +00:00
if (raw_socket)
return raw_socket.release_nonnull();
return ENOMEM;
}
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return EINVAL;
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Kernel: Handle OOM when allocating IPv4Socket optional scratch buffer
2021-08-01 12:11:05 +00:00
IPv4Socket::IPv4Socket(int type, int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer, OwnPtr<KBuffer> optional_scratch_buffer)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
: Socket(AF_INET, type, protocol)
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
, m_receive_buffer(move(receive_buffer))
Kernel: Handle OOM when allocating IPv4Socket optional scratch buffer
2021-08-01 12:11:05 +00:00
, m_scratch_buffer(move(optional_scratch_buffer))
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 12:03:24 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket({}) created with type={}, protocol={}", this, type, protocol);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
m_buffer_mode = type == SOCK_STREAM ? BufferMode::Bytes : BufferMode::Packets;
if (m_buffer_mode == BufferMode::Bytes) {
Kernel: Handle OOM when allocating IPv4Socket optional scratch buffer
2021-08-01 12:11:05 +00:00
VERIFY(m_scratch_buffer);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
}
Kernel: Migrate IPv4 socket table locking to ProtectedValue
2021-07-18 09:59:25 +00:00
all_sockets().with_exclusive([&](auto& table) {
Kernel: Convert IPv4 socket list from HashTable to IntrusiveList There was no reason whatsoever to use a HashTable here. IntrusiveList removes all the heap allocations and does everything more efficiently.
2021-08-15 13:46:35 +00:00
table.append(*this);
Kernel: Migrate IPv4 socket table locking to ProtectedValue
2021-07-18 09:59:25 +00:00
});
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
IPv4Socket::~IPv4Socket()
{
Kernel: Migrate IPv4 socket table locking to ProtectedValue
2021-07-18 09:59:25 +00:00
all_sockets().with_exclusive([&](auto& table) {
Kernel: Convert IPv4 socket list from HashTable to IntrusiveList There was no reason whatsoever to use a HashTable here. IntrusiveList removes all the heap allocations and does everything more efficiently.
2021-08-15 13:46:35 +00:00
table.remove(*this);
Kernel: Migrate IPv4 socket table locking to ProtectedValue
2021-07-18 09:59:25 +00:00
});
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Kernel: Truncate addresses stored by getsockname() and getpeername() If there's not enough space in the output buffer for the whole sockaddr we now simply truncate the address instead of returning EINVAL. This patch also makes getpeername() actually return the peer address rather than the local address.. :^)
2020-02-07 22:42:28 +00:00
void IPv4Socket::get_local_address(sockaddr* address, socklen_t* address_size)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Kernel: Truncate addresses stored by getsockname() and getpeername() If there's not enough space in the output buffer for the whole sockaddr we now simply truncate the address instead of returning EINVAL. This patch also makes getpeername() actually return the peer address rather than the local address.. :^)
2020-02-07 22:42:28 +00:00
sockaddr_in local_address = { AF_INET, htons(m_local_port), { m_local_address.to_in_addr_t() }, { 0 } };
memcpy(address, &local_address, min(static_cast<size_t>(*address_size), sizeof(sockaddr_in)));
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
*address_size = sizeof(sockaddr_in);
}
Kernel: Truncate addresses stored by getsockname() and getpeername() If there's not enough space in the output buffer for the whole sockaddr we now simply truncate the address instead of returning EINVAL. This patch also makes getpeername() actually return the peer address rather than the local address.. :^)
2020-02-07 22:42:28 +00:00
void IPv4Socket::get_peer_address(sockaddr* address, socklen_t* address_size)
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
{
Kernel: Truncate addresses stored by getsockname() and getpeername() If there's not enough space in the output buffer for the whole sockaddr we now simply truncate the address instead of returning EINVAL. This patch also makes getpeername() actually return the peer address rather than the local address.. :^)
2020-02-07 22:42:28 +00:00
sockaddr_in peer_address = { AF_INET, htons(m_peer_port), { m_peer_address.to_in_addr_t() }, { 0 } };
memcpy(address, &peer_address, min(static_cast<size_t>(*address_size), sizeof(sockaddr_in)));
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
*address_size = sizeof(sockaddr_in);
}
Kernel/Net: Rework ephemeral port allocation Currently, ephemeral port allocation is handled by the allocate_local_port_if_needed() and protocol_allocate_local_port() methods. Actually binding the socket to an address (which means inserting the socket/address pair into a global map) is performed either in protocol_allocate_local_port() (for ephemeral ports) or in protocol_listen() (for non-ephemeral ports); the latter will fail with EADDRINUSE if the address is already used by an existing pair present in the map. There used to be a bug where for listen() without an explicit bind(), the port allocation would conflict with itself: first an ephemeral port would get allocated and inserted into the map, and then protocol_listen() would check again for the port being free, find the just-created map entry, and error out. This was fixed in commit 01e5af487f9513696dbcacab15d3e0036446f586 by passing an additional flag did_allocate_port into protocol_listen() which specifies whether the port was just allocated, and skipping the check in protocol_listen() if the flag is set. However, this only helps if the socket is bound to an ephemeral port inside of this very listen() call. But calling bind(sin_port = 0) from userspace should succeed and bind to an allocated ephemeral port, in the same was as using an unbound socket for connect() does. The port number can then be retrieved from userspace by calling getsockname (), and it should be possible to either connect() or listen() on this socket, keeping the allocated port number. Also, calling bind() when already bound (either explicitly or implicitly) should always result in EINVAL. To untangle this, introduce an explicit m_bound state in IPv4Socket, just like LocalSocket has already. Once a socket is bound, further attempt to bind it fail. Some operations cause the socket to implicitly get bound to an (ephemeral) address; this is implemented by the new ensure_bound() method. The protocol_allocate_local_port() method is gone; it is now up to a protocol to assign a port to the socket inside protocol_bind() if it finds that the socket has local_port() == 0. protocol_bind() is now called in more cases, such as inside listen() if the socket wasn't bound before that.
2023-07-23 12:43:45 +00:00
ErrorOr<void> IPv4Socket::ensure_bound()
{
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket::ensure_bound() m_bound {}", m_bound);
if (m_bound)
return {};
auto result = protocol_bind();
if (!result.is_error())
m_bound = true;
return result;
}
Kernel: Make Socket::bind() take credentials as input
2022-08-21 14:33:09 +00:00
ErrorOr<void> IPv4Socket::bind(Credentials const& credentials, Userspace<sockaddr const*> user_address, socklen_t address_size)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Kernel/Net: Rework ephemeral port allocation Currently, ephemeral port allocation is handled by the allocate_local_port_if_needed() and protocol_allocate_local_port() methods. Actually binding the socket to an address (which means inserting the socket/address pair into a global map) is performed either in protocol_allocate_local_port() (for ephemeral ports) or in protocol_listen() (for non-ephemeral ports); the latter will fail with EADDRINUSE if the address is already used by an existing pair present in the map. There used to be a bug where for listen() without an explicit bind(), the port allocation would conflict with itself: first an ephemeral port would get allocated and inserted into the map, and then protocol_listen() would check again for the port being free, find the just-created map entry, and error out. This was fixed in commit 01e5af487f9513696dbcacab15d3e0036446f586 by passing an additional flag did_allocate_port into protocol_listen() which specifies whether the port was just allocated, and skipping the check in protocol_listen() if the flag is set. However, this only helps if the socket is bound to an ephemeral port inside of this very listen() call. But calling bind(sin_port = 0) from userspace should succeed and bind to an allocated ephemeral port, in the same was as using an unbound socket for connect() does. The port number can then be retrieved from userspace by calling getsockname (), and it should be possible to either connect() or listen() on this socket, keeping the allocated port number. Also, calling bind() when already bound (either explicitly or implicitly) should always result in EINVAL. To untangle this, introduce an explicit m_bound state in IPv4Socket, just like LocalSocket has already. Once a socket is bound, further attempt to bind it fail. Some operations cause the socket to implicitly get bound to an (ephemeral) address; this is implemented by the new ensure_bound() method. The protocol_allocate_local_port() method is gone; it is now up to a protocol to assign a port to the socket inside protocol_bind() if it finds that the socket has local_port() == 0. protocol_bind() is now called in more cases, such as inside listen() if the socket wasn't bound before that.
2023-07-23 12:43:45 +00:00
if (m_bound)
return set_so_error(EINVAL);
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(setup_state() == SetupState::Unstarted);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
if (address_size != sizeof(sockaddr_in))
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINVAL);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
sockaddr_in address {};
SOCKET_TRY(copy_from_user(&address, user_address, sizeof(sockaddr_in)));
Kernel: Remove SmapDisabler in bind()
2020-01-11 11:07:45 +00:00
if (address.sin_family != AF_INET)
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINVAL);
Kernel: Don't allow non-superusers to bind TCP/UDP ports < 1024
2019-09-02 16:49:54 +00:00
Kernel: Remove SmapDisabler in bind()
2020-01-11 11:07:45 +00:00
auto requested_local_port = ntohs(address.sin_port);
Kernel: Make Socket::bind() take credentials as input
2022-08-21 14:33:09 +00:00
if (!credentials.is_superuser()) {
Kernel: Stop treating port 0 (ephemeral auto bind) as a privileged port Binding to port 0 is used to signal to listen() to bind to any port that is available. (in serenity's case, to the port range of 32768 to 60999, which are not privileged ports)
2021-04-19 21:12:56 +00:00
if (requested_local_port > 0 && requested_local_port < 1024) {
Kernel: Make Socket::bind() take credentials as input
2022-08-21 14:33:09 +00:00
dbgln("UID {} attempted to bind {} to port {}", credentials.uid(), class_name(), requested_local_port);
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EACCES);
Kernel: Don't allow non-superusers to bind TCP/UDP ports < 1024
2019-09-02 16:49:54 +00:00
}
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
m_local_address = IPv4Address((u8 const*)&address.sin_addr.s_addr);
Kernel: Don't allow non-superusers to bind TCP/UDP ports < 1024
2019-09-02 16:49:54 +00:00
m_local_port = requested_local_port;
IPv4: Implement bind() for TCP and UDP sockets. We can't accept connections just yet, but this patch makes it possible to bind() to a given source address/port.
2019-05-03 19:51:40 +00:00
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 12:03:24 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket::bind {}({}) to {}:{}", class_name(), this, m_local_address, m_local_port);
IPv4: Implement bind() for TCP and UDP sockets. We can't accept connections just yet, but this patch makes it possible to bind() to a given source address/port.
2019-05-03 19:51:40 +00:00
Kernel/Net: Rework ephemeral port allocation Currently, ephemeral port allocation is handled by the allocate_local_port_if_needed() and protocol_allocate_local_port() methods. Actually binding the socket to an address (which means inserting the socket/address pair into a global map) is performed either in protocol_allocate_local_port() (for ephemeral ports) or in protocol_listen() (for non-ephemeral ports); the latter will fail with EADDRINUSE if the address is already used by an existing pair present in the map. There used to be a bug where for listen() without an explicit bind(), the port allocation would conflict with itself: first an ephemeral port would get allocated and inserted into the map, and then protocol_listen() would check again for the port being free, find the just-created map entry, and error out. This was fixed in commit 01e5af487f9513696dbcacab15d3e0036446f586 by passing an additional flag did_allocate_port into protocol_listen() which specifies whether the port was just allocated, and skipping the check in protocol_listen() if the flag is set. However, this only helps if the socket is bound to an ephemeral port inside of this very listen() call. But calling bind(sin_port = 0) from userspace should succeed and bind to an allocated ephemeral port, in the same was as using an unbound socket for connect() does. The port number can then be retrieved from userspace by calling getsockname (), and it should be possible to either connect() or listen() on this socket, keeping the allocated port number. Also, calling bind() when already bound (either explicitly or implicitly) should always result in EINVAL. To untangle this, introduce an explicit m_bound state in IPv4Socket, just like LocalSocket has already. Once a socket is bound, further attempt to bind it fail. Some operations cause the socket to implicitly get bound to an (ephemeral) address; this is implemented by the new ensure_bound() method. The protocol_allocate_local_port() method is gone; it is now up to a protocol to assign a port to the socket inside protocol_bind() if it finds that the socket has local_port() == 0. protocol_bind() is now called in more cases, such as inside listen() if the socket wasn't bound before that.
2023-07-23 12:43:45 +00:00
return ensure_bound();
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> IPv4Socket::listen(size_t backlog)
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
{
Kernel: Rename Socket::lock() => Socket::mutex() "lock" is ambiguous (verb vs noun) while "mutex" is not.
2021-08-29 11:10:55 +00:00
MutexLocker locker(mutex());
Kernel/Net: Rework ephemeral port allocation Currently, ephemeral port allocation is handled by the allocate_local_port_if_needed() and protocol_allocate_local_port() methods. Actually binding the socket to an address (which means inserting the socket/address pair into a global map) is performed either in protocol_allocate_local_port() (for ephemeral ports) or in protocol_listen() (for non-ephemeral ports); the latter will fail with EADDRINUSE if the address is already used by an existing pair present in the map. There used to be a bug where for listen() without an explicit bind(), the port allocation would conflict with itself: first an ephemeral port would get allocated and inserted into the map, and then protocol_listen() would check again for the port being free, find the just-created map entry, and error out. This was fixed in commit 01e5af487f9513696dbcacab15d3e0036446f586 by passing an additional flag did_allocate_port into protocol_listen() which specifies whether the port was just allocated, and skipping the check in protocol_listen() if the flag is set. However, this only helps if the socket is bound to an ephemeral port inside of this very listen() call. But calling bind(sin_port = 0) from userspace should succeed and bind to an allocated ephemeral port, in the same was as using an unbound socket for connect() does. The port number can then be retrieved from userspace by calling getsockname (), and it should be possible to either connect() or listen() on this socket, keeping the allocated port number. Also, calling bind() when already bound (either explicitly or implicitly) should always result in EINVAL. To untangle this, introduce an explicit m_bound state in IPv4Socket, just like LocalSocket has already. Once a socket is bound, further attempt to bind it fail. Some operations cause the socket to implicitly get bound to an (ephemeral) address; this is implemented by the new ensure_bound() method. The protocol_allocate_local_port() method is gone; it is now up to a protocol to assign a port to the socket inside protocol_bind() if it finds that the socket has local_port() == 0. protocol_bind() is now called in more cases, such as inside listen() if the socket wasn't bound before that.
2023-07-23 12:43:45 +00:00
TRY(ensure_bound());
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
set_backlog(backlog);
Kernel: Add Socket::set_role() and use it everywhere Instead of having Socket subclasses write their role into Socket::m_role directly, add a setter to do this.
2021-08-29 00:04:30 +00:00
set_role(Role::Listener);
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-29 23:05:27 +00:00
evaluate_block_conditions();
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 12:03:24 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket({}) listening with backlog={}", this, backlog);
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
Kernel/Net: Rework ephemeral port allocation Currently, ephemeral port allocation is handled by the allocate_local_port_if_needed() and protocol_allocate_local_port() methods. Actually binding the socket to an address (which means inserting the socket/address pair into a global map) is performed either in protocol_allocate_local_port() (for ephemeral ports) or in protocol_listen() (for non-ephemeral ports); the latter will fail with EADDRINUSE if the address is already used by an existing pair present in the map. There used to be a bug where for listen() without an explicit bind(), the port allocation would conflict with itself: first an ephemeral port would get allocated and inserted into the map, and then protocol_listen() would check again for the port being free, find the just-created map entry, and error out. This was fixed in commit 01e5af487f9513696dbcacab15d3e0036446f586 by passing an additional flag did_allocate_port into protocol_listen() which specifies whether the port was just allocated, and skipping the check in protocol_listen() if the flag is set. However, this only helps if the socket is bound to an ephemeral port inside of this very listen() call. But calling bind(sin_port = 0) from userspace should succeed and bind to an allocated ephemeral port, in the same was as using an unbound socket for connect() does. The port number can then be retrieved from userspace by calling getsockname (), and it should be possible to either connect() or listen() on this socket, keeping the allocated port number. Also, calling bind() when already bound (either explicitly or implicitly) should always result in EINVAL. To untangle this, introduce an explicit m_bound state in IPv4Socket, just like LocalSocket has already. Once a socket is bound, further attempt to bind it fail. Some operations cause the socket to implicitly get bound to an (ephemeral) address; this is implemented by the new ensure_bound() method. The protocol_allocate_local_port() method is gone; it is now up to a protocol to assign a port to the socket inside protocol_bind() if it finds that the socket has local_port() == 0. protocol_bind() is now called in more cases, such as inside listen() if the socket wasn't bound before that.
2023-07-23 12:43:45 +00:00
return protocol_listen();
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
}
Kernel: Make Socket::connect() take credentials as input
2022-08-21 14:35:03 +00:00
ErrorOr<void> IPv4Socket::connect(Credentials const&, OpenFileDescription& description, Userspace<sockaddr const*> address, socklen_t address_size)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
if (address_size != sizeof(sockaddr_in))
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINVAL);
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 03:11:07 +00:00
u16 sa_family_copy;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
auto* user_address = reinterpret_cast<sockaddr const*>(address.unsafe_userspace_ptr());
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
SOCKET_TRY(copy_from_user(&sa_family_copy, &user_address->sa_family, sizeof(u16)));
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 03:11:07 +00:00
if (sa_family_copy != AF_INET)
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINVAL);
Kernel: Move socket role tracking to the Socket class itself This is more logical and allows us to solve the problem of non-blocking TCP sockets getting stuck in SocketRole::None. The only complication is that a single LocalSocket may be shared between two file descriptions (on the connect and accept sides), and should have two different roles depending from which side you look at it. To deal with it, Socket::role() is made a virtual method that accepts a file description, and LocalSocket internally tracks which FileDescription is the which one and returns a correct role.
2019-08-11 13:38:20 +00:00
if (m_role == Role::Connected)
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EISCONN);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
sockaddr_in safe_address {};
SOCKET_TRY(copy_from_user(&safe_address, (sockaddr_in const*)user_address, sizeof(sockaddr_in)));
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 03:11:07 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
m_peer_address = IPv4Address((u8 const*)&safe_address.sin_addr.s_addr);
Kernel: Treat 0.0.0.0 as a loopback address This matches what other operating systems like Linux do: $ ip route get 0.0.0.0 local 0.0.0.0 dev lo src 127.0.0.1 uid 1000 cache <local> $ ssh 0.0.0.0 gunnar@0.0.0.0's password: $ ss -na | grep :22 | grep ESTAB tcp ESTAB 0 0 127.0.0.1:43118 127.0.0.1:22 tcp ESTAB 0 0 127.0.0.1:22 127.0.0.1:43118
2021-05-12 10:14:03 +00:00
if (m_peer_address == IPv4Address { 0, 0, 0, 0 })
m_peer_address = IPv4Address { 127, 0, 0, 1 };
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 03:11:07 +00:00
m_peer_port = ntohs(safe_address.sin_port);
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
Kernel: Remove the Socket::{protocol,}connect ShouldBlock argument This argument is always set to description.is_blocking(), but description is also given as a separate argument, so there's no point to piping it through separately.
2022-07-13 06:31:24 +00:00
return protocol_connect(description);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
bool IPv4Socket::can_read(OpenFileDescription const&, u64) const
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Kernel: Move socket role tracking to the Socket class itself This is more logical and allows us to solve the problem of non-blocking TCP sockets getting stuck in SocketRole::None. The only complication is that a single LocalSocket may be shared between two file descriptions (on the connect and accept sides), and should have two different roles depending from which side you look at it. To deal with it, Socket::role() is made a virtual method that accepts a file description, and LocalSocket internally tracks which FileDescription is the which one and returns a correct role.
2019-08-11 13:38:20 +00:00
if (m_role == Role::Listener)
IPv4: Implement bind() for TCP and UDP sockets. We can't accept connections just yet, but this patch makes it possible to bind() to a given source address/port.
2019-05-03 19:51:40 +00:00
return can_accept();
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
if (protocol_is_disconnected())
return true;
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
return m_can_read;
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
bool IPv4Socket::can_write(OpenFileDescription const&, u64) const
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Kernel: Return EPIPE when trying to write to an unconnected socket When attempting to write to a socket that is not connected or - for connection-less protocols - doesn't have a peer address set we should return EPIPE instead of blocking the thread.
2021-06-05 11:03:06 +00:00
return true;
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<size_t> IPv4Socket::sendto(OpenFileDescription&, UserOrKernelBuffer const& data, size_t data_length, [[maybe_unused]] int flags, Userspace<sockaddr const*> addr, socklen_t addr_length)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
{
Kernel: Rename Socket::lock() => Socket::mutex() "lock" is ambiguous (verb vs noun) while "mutex" is not.
2021-08-29 11:10:55 +00:00
MutexLocker locker(mutex());
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 18:51:02 +00:00
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
if (addr && addr_length != sizeof(sockaddr_in))
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINVAL);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
if (addr) {
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
sockaddr_in ia {};
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
SOCKET_TRY(copy_from_user(&ia, Userspace<sockaddr_in const*>(addr.ptr())));
Kernel: Use Userspace<T> for the sendto syscall, and Socket implementation Note that the data member is of type ImmutableBufferArgument, which has no Userspace<T> usage. I left it alone for now, to be fixed in a future change holistically for all usages.
2020-08-18 06:49:35 +00:00
if (ia.sin_family != AF_INET) {
Kernel: Convert klog() => dmesgln() in IPv4Socket
2021-03-09 21:25:09 +00:00
dmesgln("sendto: Bad address family: {} is not AF_INET", ia.sin_family);
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EAFNOSUPPORT);
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
m_peer_address = IPv4Address((u8 const*)&ia.sin_addr.s_addr);
IPv4: Rename source/destination in socket classes to local/peer. It was way too ambiguous who's the source and who's the destination, and it didn't really follow a logical pattern. "Local port" vs "Peer port" is super obvious, so let's call it that.
2019-05-04 14:40:34 +00:00
m_peer_port = ntohs(ia.sin_port);
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
}
IPv4: More work on UDP support. I'm now able to connect to a simple UDP server on my host machine and exchange some data. Very cool! :^)
2019-03-13 14:40:30 +00:00
Kernel: Return EPIPE when trying to write to an unconnected socket When attempting to write to a socket that is not connected or - for connection-less protocols - doesn't have a peer address set we should return EPIPE instead of blocking the thread.
2021-06-05 11:03:06 +00:00
if (!is_connected() && m_peer_address.is_zero())
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EPIPE);
Kernel: Return EPIPE when trying to write to an unconnected socket When attempting to write to a socket that is not connected or - for connection-less protocols - doesn't have a peer address set we should return EPIPE instead of blocking the thread.
2021-06-05 11:03:06 +00:00
Kernel: Implement the SO_DONTROUTE SOL_SOCKET-level option
2021-12-01 23:01:02 +00:00
auto allow_using_gateway = ((flags & MSG_DONTROUTE) || m_routing_disabled) ? AllowUsingGateway::No : AllowUsingGateway::Yes;
Kernel/Net: Iron out the locking mechanism across the subsystem There is a big mix of LockRefPtrs all over the Networking subsystem, as well as lots of room for improvements with our locking patterns, which this commit will not pursue, but will give a good start for such work. To deal with this situation, we change the following things: - Creating instances of NetworkAdapter should always yield a non-locking NonnullRefPtr. Acquiring an instance from the NetworkingManagement should give a simple RefPtr,as giving LockRefPtr does not really protect from concurrency problems in such case. - Since NetworkingManagement works with normal RefPtrs we should protect all instances of RefPtr<NetworkAdapter> with SpinlockProtected to ensure references are gone unexpectedly. - Protect the so_error class member with a proper spinlock. This happens to be important because the clear_so_error() method lacked any proper locking measures. It also helps preventing a possible TOCTOU when we might do a more fine-grained locking in the Socket code, so this could be definitely a start for this. - Change unnecessary LockRefPtr<PacketWithTimestamp> in the structure of OutgoingPacket to a simple RefPtr<PacketWithTimestamp> as the whole list should be MutexProtected.
2023-04-11 00:50:15 +00:00
auto adapter = bound_interface().with([](auto& bound_device) -> RefPtr<NetworkAdapter> { return bound_device; });
auto routing_decision = route_to(m_peer_address, m_local_address, adapter, allow_using_gateway);
Kernel: Implement is_zero for RoutingDecision
2019-08-29 01:18:38 +00:00
if (routing_decision.is_zero())
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EHOSTUNREACH);
Kernel: Add a LoopbackAdapter for talking to yourself via 127.0.0.1. Choosing adapter for transmit is done by adapter_for_route_to(IPv4Address). This is just hard-coded logic right now but can be expanded to support a proper routing table. Also start moving kernel networking code into Kernel/Net/.
2019-04-02 13:46:44 +00:00
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
if (m_local_address.to_u32() == 0)
Kernel: Add simple ARP routing layer This replaces the previous placeholder routing layer with a real one! It's still very primitive, doesn't deal with things like timeouts very well, and will probably need several more iterations to support more normal networking things. I haven't confirmed that this works with anything other than the QEMU user networking layer, but I suspect that's what nearly everybody is using at this point, so that's the important target to keep working.
2019-08-28 11:58:01 +00:00
m_local_address = routing_decision.adapter->ipv4_address();
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
Kernel/Net: Rework ephemeral port allocation Currently, ephemeral port allocation is handled by the allocate_local_port_if_needed() and protocol_allocate_local_port() methods. Actually binding the socket to an address (which means inserting the socket/address pair into a global map) is performed either in protocol_allocate_local_port() (for ephemeral ports) or in protocol_listen() (for non-ephemeral ports); the latter will fail with EADDRINUSE if the address is already used by an existing pair present in the map. There used to be a bug where for listen() without an explicit bind(), the port allocation would conflict with itself: first an ephemeral port would get allocated and inserted into the map, and then protocol_listen() would check again for the port being free, find the just-created map entry, and error out. This was fixed in commit 01e5af487f9513696dbcacab15d3e0036446f586 by passing an additional flag did_allocate_port into protocol_listen() which specifies whether the port was just allocated, and skipping the check in protocol_listen() if the flag is set. However, this only helps if the socket is bound to an ephemeral port inside of this very listen() call. But calling bind(sin_port = 0) from userspace should succeed and bind to an allocated ephemeral port, in the same was as using an unbound socket for connect() does. The port number can then be retrieved from userspace by calling getsockname (), and it should be possible to either connect() or listen() on this socket, keeping the allocated port number. Also, calling bind() when already bound (either explicitly or implicitly) should always result in EINVAL. To untangle this, introduce an explicit m_bound state in IPv4Socket, just like LocalSocket has already. Once a socket is bound, further attempt to bind it fail. Some operations cause the socket to implicitly get bound to an (ephemeral) address; this is implemented by the new ensure_bound() method. The protocol_allocate_local_port() method is gone; it is now up to a protocol to assign a port to the socket inside protocol_bind() if it finds that the socket has local_port() == 0. protocol_bind() is now called in more cases, such as inside listen() if the socket wasn't bound before that.
2023-07-23 12:43:45 +00:00
TRY(ensure_bound());
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
Kernel: Convert klog() => dmesgln() in IPv4Socket
2021-03-09 21:25:09 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "sendto: destination={}:{}", m_peer_address, m_peer_port);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
IPv4: More work on UDP support. I'm now able to connect to a simple UDP server on my host machine and exchange some data. Very cool! :^)
2019-03-13 14:40:30 +00:00
if (type() == SOCK_RAW) {
Kernel: Avoid allocations when sending IP packets Previously we'd allocate buffers when sending packets. This patch avoids these allocations by using the NetworkAdapter's packet queue. At the same time this also avoids copying partially constructed packets in order to prepend Ethernet and/or IPv4 headers. It also properly truncates UDP and raw IP packets.
2021-05-26 03:35:05 +00:00
auto ipv4_payload_offset = routing_decision.adapter->ipv4_payload_offset();
data_length = min(data_length, routing_decision.adapter->mtu() - ipv4_payload_offset);
auto packet = routing_decision.adapter->acquire_packet_buffer(ipv4_payload_offset + data_length);
if (!packet)
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(ENOMEM);
Kernel: Avoid allocations when sending IP packets Previously we'd allocate buffers when sending packets. This patch avoids these allocations by using the NetworkAdapter's packet queue. At the same time this also avoids copying partially constructed packets in order to prepend Ethernet and/or IPv4 headers. It also properly truncates UDP and raw IP packets.
2021-05-26 03:35:05 +00:00
routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(), routing_decision.next_hop,
Kernel+LibC: Add support for the IPv4 TOS field via the IP_TOS sockopt
2021-10-27 20:20:24 +00:00
m_peer_address, (IPv4Protocol)protocol(), data_length, m_type_of_service, m_ttl);
Kernel: Make UserOrKernelBuffer return KResult from read/write/memset This allows us to simplify a whole bunch of call sites with TRY(). :^)
2021-09-07 10:09:52 +00:00
if (auto result = data.read(packet->buffer->data() + ipv4_payload_offset, data_length); result.is_error()) {
Kernel: Avoid allocations when sending IP packets Previously we'd allocate buffers when sending packets. This patch avoids these allocations by using the NetworkAdapter's packet queue. At the same time this also avoids copying partially constructed packets in order to prepend Ethernet and/or IPv4 headers. It also properly truncates UDP and raw IP packets.
2021-05-26 03:35:05 +00:00
routing_decision.adapter->release_packet_buffer(*packet);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return set_so_error(result.release_error());
Kernel: Avoid allocations when sending IP packets Previously we'd allocate buffers when sending packets. This patch avoids these allocations by using the NetworkAdapter's packet queue. At the same time this also avoids copying partially constructed packets in order to prepend Ethernet and/or IPv4 headers. It also properly truncates UDP and raw IP packets.
2021-05-26 03:35:05 +00:00
}
Kernel: Handle OOM when allocating Packet KBuffers
2021-08-01 12:11:49 +00:00
routing_decision.adapter->send_packet(packet->bytes());
Kernel: Avoid allocations when sending IP packets Previously we'd allocate buffers when sending packets. This patch avoids these allocations by using the NetworkAdapter's packet queue. At the same time this also avoids copying partially constructed packets in order to prepend Ethernet and/or IPv4 headers. It also properly truncates UDP and raw IP packets.
2021-05-26 03:35:05 +00:00
routing_decision.adapter->release_packet_buffer(*packet);
IPv4: More work on UDP support. I'm now able to connect to a simple UDP server on my host machine and exchange some data. Very cool! :^)
2019-03-13 14:40:30 +00:00
return data_length;
}
Kernel: Make File::write() and File::read() return KResultOr<size_t> Instead of returning a ssize_t where negative values mean error, we now return KResultOr<size_t> and use the error state to report errors exclusively.
2020-08-04 16:02:23 +00:00
auto nsent_or_error = protocol_send(data, data_length);
if (!nsent_or_error.is_error())
Thread::current()->did_ipv4_socket_write(nsent_or_error.value());
return nsent_or_error;
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
Kernel: Make sys$recvfrom() with MSG_DONTWAIT not so racy Instead of temporary changing the open file description's "blocking" flag while doing a non-waiting recvfrom, we instead plumb the currently wanted blocking behavior all the way through to the underlying socket.
2022-08-21 14:45:42 +00:00
ErrorOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, bool blocking)
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
{
Kernel: Rename Socket::lock() => Socket::mutex() "lock" is ambiguous (verb vs noun) while "mutex" is not.
2021-08-29 11:10:55 +00:00
MutexLocker locker(mutex());
Kernel: Drop the receive buffer when socket enters the TimeWait state The TimeWait state is intended to prevent another socket from taking the address tuple in case any packets are still in transit after the final close. Since this state never delivers packets to userspace, it doesn't make sense to keep the receive buffer around.
2021-09-16 00:15:36 +00:00
VERIFY(m_receive_buffer);
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
if (m_receive_buffer->is_empty()) {
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
if (protocol_is_disconnected())
return 0;
Kernel: Make sys$recvfrom() with MSG_DONTWAIT not so racy Instead of temporary changing the open file description's "blocking" flag while doing a non-waiting recvfrom, we instead plumb the currently wanted blocking behavior all the way through to the underlying socket.
2022-08-21 14:45:42 +00:00
if (!blocking)
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EAGAIN);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
IPv4: Keep IPv4 socket locked during receive operations We unlock/relock around blocking, but outside of that we now keep the socket locked. This fixes an intermittent ASSERT(m_can_read) failure.
2020-03-07 10:26:17 +00:00
locker.unlock();
Kernel: Add bitwise operators for Thread::FileBlocker::BlockFlags enum Switch to using type-safe bitwise operators for the BlockFlags class, this cleans up a lot of boilerplate casts which are necessary when the enum is declared as `enum class`.
2021-03-07 11:01:11 +00:00
auto unblocked_flags = BlockFlags::None;
AK: Simplify constructors and conversions from nullptr_t Problem: - Many constructors are defined as `{}` rather than using the ` = default` compiler-provided constructor. - Some types provide an implicit conversion operator from `nullptr_t` instead of requiring the caller to default construct. This violates the C++ Core Guidelines suggestion to declare single-argument constructors explicit (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c46-by-default-declare-single-argument-constructors-explicit). Solution: - Change default constructors to use the compiler-provided default constructor. - Remove implicit conversion operators from `nullptr_t` and change usage to enforce type consistency without conversion.
2021-01-10 23:29:28 +00:00
auto res = Thread::current()->block<Thread::ReadBlocker>({}, description, unblocked_flags);
IPv4: Keep IPv4 socket locked during receive operations We unlock/relock around blocking, but outside of that we now keep the socket locked. This fixes an intermittent ASSERT(m_can_read) failure.
2020-03-07 10:26:17 +00:00
locker.lock();
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
Kernel: Add bitwise operators for Thread::FileBlocker::BlockFlags enum Switch to using type-safe bitwise operators for the BlockFlags class, this cleans up a lot of boilerplate casts which are necessary when the enum is declared as `enum class`.
2021-03-07 11:01:11 +00:00
if (!has_flag(unblocked_flags, BlockFlags::Read)) {
Kernel: Fix checking BlockResult We now have BlockResult::WokeNormally and BlockResult::NotBlocked, both of which indicate no error. We can no longer just check for BlockResult::WokeNormally and assume anything else must be an interruption.
2020-07-06 23:10:52 +00:00
if (res.was_interrupted())
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINTR);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
// Unblocked due to timeout.
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EAGAIN);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
}
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
}
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<size_t> nreceived_or_error { 0 };
Kernel: Add MSG_PEEK support for the IPv4Socket This commit will add MSG_PEEK support, which allows a package to be seen without taking it from the buffer, so that a subsequent recv() without the MSG_PEEK flag can pick it up.
2021-04-28 21:22:55 +00:00
if (flags & MSG_PEEK)
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
nreceived_or_error = m_receive_buffer->peek(buffer, buffer_length);
Kernel: Add MSG_PEEK support for the IPv4Socket This commit will add MSG_PEEK support, which allows a package to be seen without taking it from the buffer, so that a subsequent recv() without the MSG_PEEK flag can pick it up.
2021-04-28 21:22:55 +00:00
else
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
nreceived_or_error = m_receive_buffer->read(buffer, buffer_length);
Kernel: Add MSG_PEEK support for the IPv4Socket This commit will add MSG_PEEK support, which allows a package to be seen without taking it from the buffer, so that a subsequent recv() without the MSG_PEEK flag can pick it up.
2021-04-28 21:22:55 +00:00
Kernel: Use KResultOr<size_t> for the DoubleBuffer class
2021-06-16 13:33:14 +00:00
if (!nreceived_or_error.is_error() && nreceived_or_error.value() > 0 && !(flags & MSG_PEEK))
Thread::current()->did_ipv4_socket_read(nreceived_or_error.value());
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
set_can_read(!m_receive_buffer->is_empty());
Kernel: Use KResultOr<size_t> for the DoubleBuffer class
2021-06-16 13:33:14 +00:00
return nreceived_or_error;
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
}
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
Kernel: Use UnixDateTime wherever applicable "Wherever applicable" = most places, actually :^), especially for networking and filesystem timestamps. This includes changes to unzip, which uses DOSPackedTime, since that is changed for the FAT file systems.
2023-03-13 21:11:13 +00:00
ErrorOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, UnixDateTime& packet_timestamp, bool blocking)
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
{
Kernel: Rename Socket::lock() => Socket::mutex() "lock" is ambiguous (verb vs noun) while "mutex" is not.
2021-08-29 11:10:55 +00:00
MutexLocker locker(mutex());
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
ReceivedPacket taken_packet;
ReceivedPacket* packet { nullptr };
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
{
IPv4: Disconnected non-blocking sockets were not signalling EOF After a socket has disconnected, we shouldn't return -EAGAIN. Instead we should allow userspace to read/recvfrom the socket until its packet queue has been exhausted. At that point, we now return 0, signalling EOF. It might be even better to start returning -ENOTCONN after signalling EOF once. I'm not sure how that should work, needs looking into.
2019-11-18 16:30:45 +00:00
if (m_receive_queue.is_empty()) {
Kernel: Fix handful of remaining "return -EFOO" mistakes Now that all KResult and KResultOr are used consistently throughout the kernel, it's no longer necessary to return negative error codes. However, we were still doing that in some places, so let's fix all those (bugs) by removing the minuses. :^)
2021-08-05 22:35:27 +00:00
// FIXME: Shouldn't this return ENOTCONN instead of EOF?
IPv4: Disconnected non-blocking sockets were not signalling EOF After a socket has disconnected, we shouldn't return -EAGAIN. Instead we should allow userspace to read/recvfrom the socket until its packet queue has been exhausted. At that point, we now return 0, signalling EOF. It might be even better to start returning -ENOTCONN after signalling EOF once. I'm not sure how that should work, needs looking into.
2019-11-18 16:30:45 +00:00
// But if so, we still need to deliver at least one EOF read to userspace.. right?
if (protocol_is_disconnected())
return 0;
Kernel: Make sys$recvfrom() with MSG_DONTWAIT not so racy Instead of temporary changing the open file description's "blocking" flag while doing a non-waiting recvfrom, we instead plumb the currently wanted blocking behavior all the way through to the underlying socket.
2022-08-21 14:45:42 +00:00
if (!blocking)
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EAGAIN);
IPv4: Disconnected non-blocking sockets were not signalling EOF After a socket has disconnected, we shouldn't return -EAGAIN. Instead we should allow userspace to read/recvfrom the socket until its packet queue has been exhausted. At that point, we now return 0, signalling EOF. It might be even better to start returning -ENOTCONN after signalling EOF once. I'm not sure how that should work, needs looking into.
2019-11-18 16:30:45 +00:00
}
IPv4: Non-blocking IPv4 sockets should return -EAGAIN in recvfrom() ...if there are no packets in the receive queue.
2019-11-04 12:41:36 +00:00
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
if (!m_receive_queue.is_empty()) {
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
if (flags & MSG_PEEK) {
packet = &m_receive_queue.first();
} else {
taken_packet = m_receive_queue.take_first();
packet = &taken_packet;
}
Kernel: Add MSG_PEEK support for the IPv4Socket This commit will add MSG_PEEK support, which allows a package to be seen without taking it from the buffer, so that a subsequent recv() without the MSG_PEEK flag can pick it up.
2021-04-28 21:22:55 +00:00
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-29 23:05:27 +00:00
set_can_read(!m_receive_queue.is_empty());
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 12:03:24 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket({}): recvfrom without blocking {} bytes, packets in queue: {}",
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
this,
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
packet->data->size(),
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
m_receive_queue.size());
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
}
Kernel: Fix null dereference in IPv4Socket::receive_packet_buffered() This was a mistake in the move away from KBuffer-as-a-value type. We need to check `packet` here, not `packet->data`. Regressed in b300f9aa2fd11796e63b5029008b33a1ae735928. Fixes #9888.
2021-09-10 01:06:32 +00:00
if (!packet) {
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
if (protocol_is_disconnected()) {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("IPv4Socket({}) is protocol-disconnected, returning 0 in recvfrom!", this);
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
return 0;
}
IPv4: Keep IPv4 socket locked during receive operations We unlock/relock around blocking, but outside of that we now keep the socket locked. This fixes an intermittent ASSERT(m_can_read) failure.
2020-03-07 10:26:17 +00:00
locker.unlock();
Kernel: Add bitwise operators for Thread::FileBlocker::BlockFlags enum Switch to using type-safe bitwise operators for the BlockFlags class, this cleans up a lot of boilerplate casts which are necessary when the enum is declared as `enum class`.
2021-03-07 11:01:11 +00:00
auto unblocked_flags = BlockFlags::None;
AK: Simplify constructors and conversions from nullptr_t Problem: - Many constructors are defined as `{}` rather than using the ` = default` compiler-provided constructor. - Some types provide an implicit conversion operator from `nullptr_t` instead of requiring the caller to default construct. This violates the C++ Core Guidelines suggestion to declare single-argument constructors explicit (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c46-by-default-declare-single-argument-constructors-explicit). Solution: - Change default constructors to use the compiler-provided default constructor. - Remove implicit conversion operators from `nullptr_t` and change usage to enforce type consistency without conversion.
2021-01-10 23:29:28 +00:00
auto res = Thread::current()->block<Thread::ReadBlocker>({}, description, unblocked_flags);
IPv4: Keep IPv4 socket locked during receive operations We unlock/relock around blocking, but outside of that we now keep the socket locked. This fixes an intermittent ASSERT(m_can_read) failure.
2020-03-07 10:26:17 +00:00
locker.lock();
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
Kernel: Add bitwise operators for Thread::FileBlocker::BlockFlags enum Switch to using type-safe bitwise operators for the BlockFlags class, this cleans up a lot of boilerplate casts which are necessary when the enum is declared as `enum class`.
2021-03-07 11:01:11 +00:00
if (!has_flag(unblocked_flags, BlockFlags::Read)) {
Kernel: Fix checking BlockResult We now have BlockResult::WokeNormally and BlockResult::NotBlocked, both of which indicate no error. We can no longer just check for BlockResult::WokeNormally and assume anything else must be an interruption.
2020-07-06 23:10:52 +00:00
if (res.was_interrupted())
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINTR);
Thread: Return a result from block() indicating why the block terminated And use this to return EINTR in various places; some of which we were not handling properly before. This might expose a few bugs in userspace, but should be more compatible with other POSIX systems, and is certainly a little cleaner.
2019-07-20 09:05:52 +00:00
Add support for socket send/receive timeouts. Only the receive timeout is hooked up yet. You can change the timeout by calling setsockopt(..., SOL_SOCKET, SO_RCVTIMEO, ...). Use this mechanism to make /bin/ping report timeouts.
2019-03-13 12:13:23 +00:00
// Unblocked due to timeout.
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EAGAIN);
Add support for socket send/receive timeouts. Only the receive timeout is hooked up yet. You can change the timeout by calling setsockopt(..., SOL_SOCKET, SO_RCVTIMEO, ...). Use this mechanism to make /bin/ping report timeouts.
2019-03-13 12:13:23 +00:00
}
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(m_can_read);
VERIFY(!m_receive_queue.is_empty());
Kernel: Add MSG_PEEK support for the IPv4Socket This commit will add MSG_PEEK support, which allows a package to be seen without taking it from the buffer, so that a subsequent recv() without the MSG_PEEK flag can pick it up.
2021-04-28 21:22:55 +00:00
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
if (flags & MSG_PEEK) {
packet = &m_receive_queue.first();
} else {
taken_packet = m_receive_queue.take_first();
packet = &taken_packet;
}
Kernel: Add MSG_PEEK support for the IPv4Socket This commit will add MSG_PEEK support, which allows a package to be seen without taking it from the buffer, so that a subsequent recv() without the MSG_PEEK flag can pick it up.
2021-04-28 21:22:55 +00:00
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-29 23:05:27 +00:00
set_can_read(!m_receive_queue.is_empty());
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 12:03:24 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "IPv4Socket({}): recvfrom with blocking {} bytes, packets in queue: {}",
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
this,
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
packet->data->size(),
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
m_receive_queue.size());
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
VERIFY(packet->data);
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
packet_timestamp = packet->timestamp;
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 16:25:06 +00:00
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
if (addr) {
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "Incoming packet is from: {}:{}", packet->peer_address, packet->peer_port);
Kernel: Use Userspace<T> for the recvfrom syscall, and Socket implementation This fixes a bunch of unchecked kernel reads and writes, seems like they would might exploitable :). Write of sockaddr_in size to any address you please...
2020-08-18 07:25:23 +00:00
sockaddr_in out_addr {};
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
memcpy(&out_addr.sin_addr, &packet->peer_address, sizeof(IPv4Address));
out_addr.sin_port = htons(packet->peer_port);
Kernel: Use Userspace<T> for the recvfrom syscall, and Socket implementation This fixes a bunch of unchecked kernel reads and writes, seems like they would might exploitable :). Write of sockaddr_in size to any address you please...
2020-08-18 07:25:23 +00:00
out_addr.sin_family = AF_INET;
Userspace<sockaddr_in*> dest_addr = addr.ptr();
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
SOCKET_TRY(copy_to_user(dest_addr, &out_addr));
Kernel: Use Userspace<T> for the recvfrom syscall, and Socket implementation This fixes a bunch of unchecked kernel reads and writes, seems like they would might exploitable :). Write of sockaddr_in size to any address you please...
2020-08-18 07:25:23 +00:00
socklen_t out_length = sizeof(sockaddr_in);
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(addr_length);
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
SOCKET_TRY(copy_to_user(addr_length, &out_length));
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
}
Kernel: recvfrom() should treat the address arguments as outparams.
2019-03-13 13:47:21 +00:00
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
if (type() == SOCK_RAW) {
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
size_t bytes_written = min(packet->data->size(), buffer_length);
SOCKET_TRY(buffer.write(packet->data->data(), bytes_written));
IPv4: Truncate raw socket reads past buffer length In addition to being the proper POSIX etiquette, it seems like a bad idea for issues like the one seen in #3428 to result in a kernel crash. This patch replaces the current behavior of failing on insufficient buffer size to truncating SOCK_RAW messages to the buffer size. This will have to change if/when MSG_PEEK is implemented, but for now this behavior is more compliant and logical than just bailing.
2020-09-10 04:12:50 +00:00
return bytes_written;
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
}
Kernel: Add KBuffer::bytes() and use it (Instead of hand-wrapping { data(), size() } in a bunch of places.)
2021-09-08 16:29:52 +00:00
return protocol_receive(packet->data->bytes(), buffer, buffer_length, flags);
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
}
Kernel: Use UnixDateTime wherever applicable "Wherever applicable" = most places, actually :^), especially for networking and filesystem timestamps. This includes changes to unzip, which uses DOSPackedTime, since that is changed for the FAT file systems.
2023-03-13 21:11:13 +00:00
ErrorOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, UnixDateTime& packet_timestamp, bool blocking)
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
{
Kernel: Use Userspace<T> for the recvfrom syscall, and Socket implementation This fixes a bunch of unchecked kernel reads and writes, seems like they would might exploitable :). Write of sockaddr_in size to any address you please...
2020-08-18 07:25:23 +00:00
if (user_addr_length) {
socklen_t addr_length;
Kernel/Net: Add a special SOCKET_TRY() and use it in socket code Sockets remember their last error code in the SO_ERROR field, so we need to take special care to remember this when returning an error. This patch adds a SOCKET_TRY() that works like TRY() but also calls set_so_error() on the failure path. There's probably a lot more code that should be using this, but that's outside the scope of this patch.
2021-09-07 13:05:51 +00:00
SOCKET_TRY(copy_from_user(&addr_length, user_addr_length.unsafe_userspace_ptr()));
Kernel: Use Userspace<T> for the recvfrom syscall, and Socket implementation This fixes a bunch of unchecked kernel reads and writes, seems like they would might exploitable :). Write of sockaddr_in size to any address you please...
2020-08-18 07:25:23 +00:00
if (addr_length < sizeof(sockaddr_in))
Kernel: Add so_error to keep track of the socket's error state This sets the m_so_error variable every time the socket returns an error.
2021-08-01 15:27:23 +00:00
return set_so_error(EINVAL);
Kernel: Use Userspace<T> for the recvfrom syscall, and Socket implementation This fixes a bunch of unchecked kernel reads and writes, seems like they would might exploitable :). Write of sockaddr_in size to any address you please...
2020-08-18 07:25:23 +00:00
}
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
Kernel: Convert klog() => dmesgln() in IPv4Socket
2021-03-09 21:25:09 +00:00
dbgln_if(IPV4_SOCKET_DEBUG, "recvfrom: type={}, local_port={}", type(), local_port());
IPv4: Split IPv4Socket::recvfrom() into packet/byte buffered functions This code was really hard to follow since it handles two separate modes of buffering the data.
2020-02-08 12:09:37 +00:00
Kernel: Add support for the MSG_WAITALL sys$recvmsg flag
2021-12-01 22:39:50 +00:00
ErrorOr<size_t> total_nreceived = 0;
do {
auto offset_buffer = buffer.offset(total_nreceived.value());
auto offset_buffer_length = buffer_length - total_nreceived.value();
ErrorOr<size_t> nreceived = 0;
if (buffer_mode() == BufferMode::Bytes)
Kernel: Make sys$recvfrom() with MSG_DONTWAIT not so racy Instead of temporary changing the open file description's "blocking" flag while doing a non-waiting recvfrom, we instead plumb the currently wanted blocking behavior all the way through to the underlying socket.
2022-08-21 14:45:42 +00:00
nreceived = receive_byte_buffered(description, offset_buffer, offset_buffer_length, flags, user_addr, user_addr_length, blocking);
Kernel: Add support for the MSG_WAITALL sys$recvmsg flag
2021-12-01 22:39:50 +00:00
else
Kernel: Make sys$recvfrom() with MSG_DONTWAIT not so racy Instead of temporary changing the open file description's "blocking" flag while doing a non-waiting recvfrom, we instead plumb the currently wanted blocking behavior all the way through to the underlying socket.
2022-08-21 14:45:42 +00:00
nreceived = receive_packet_buffered(description, offset_buffer, offset_buffer_length, flags, user_addr, user_addr_length, packet_timestamp, blocking);
Kernel: Add support for the MSG_WAITALL sys$recvmsg flag
2021-12-01 22:39:50 +00:00
if (nreceived.is_error())
Everywhere: Remove needless copies of Error / ErrorOr instances Either take the underlying objects with release_* methods or move() the instances around.
2023-02-09 18:26:53 +00:00
total_nreceived = move(nreceived);
Kernel: Add support for the MSG_WAITALL sys$recvmsg flag
2021-12-01 22:39:50 +00:00
else
total_nreceived.value() += nreceived.value();
} while ((flags & MSG_WAITALL) && !total_nreceived.is_error() && total_nreceived.value() < buffer_length);
if (!total_nreceived.is_error())
Thread::current()->did_ipv4_socket_read(total_nreceived.value());
return total_nreceived;
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
Kernel: Use UnixDateTime wherever applicable "Wherever applicable" = most places, actually :^), especially for networking and filesystem timestamps. This includes changes to unzip, which uses DOSPackedTime, since that is changed for the FAT file systems.
2023-03-13 21:11:13 +00:00
bool IPv4Socket::did_receive(IPv4Address const& source_address, u16 source_port, ReadonlyBytes packet, UnixDateTime const& 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 16:27:07 +00:00
{
Kernel: Rename Socket::lock() => Socket::mutex() "lock" is ambiguous (verb vs noun) while "mutex" is not.
2021-08-29 11:10:55 +00:00
MutexLocker locker(mutex());
IPv4: Drop incoming packets on sockets that are shut down for reading
2020-02-07 23:58:11 +00:00
if (is_shut_down_for_reading())
return false;
Kernel: Make KBuffer a value-type wrapper around a KBufferImpl A KBuffer always contains a valid KBufferImpl. If you need a "null" state buffer, use Optional<KBuffer>. This makes KBuffer very easy to work with and pass around, just like ByteBuffer before it.
2019-08-05 09:06:21 +00:00
auto packet_size = packet.size();
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
if (buffer_mode() == BufferMode::Bytes) {
Kernel: Drop the receive buffer when socket enters the TimeWait state The TimeWait state is intended to prevent another socket from taking the address tuple in case any packets are still in transit after the final close. Since this state never delivers packets to userspace, it doesn't make sense to keep the receive buffer around.
2021-09-16 00:15:36 +00:00
VERIFY(m_receive_buffer);
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
size_t space_in_receive_buffer = m_receive_buffer->space_for_writing();
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
if (packet_size > space_in_receive_buffer) {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("IPv4Socket({}): did_receive refusing packet since buffer is full.", this);
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY(m_can_read);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
return false;
}
Kernel: Handle OOM when allocating IPv4Socket optional scratch buffer
2021-08-01 12:11:05 +00:00
auto scratch_buffer = UserOrKernelBuffer::for_kernel_buffer(m_scratch_buffer->data());
auto nreceived_or_error = protocol_receive(packet, scratch_buffer, m_scratch_buffer->size(), 0);
Kernel: Make File::write() and File::read() return KResultOr<size_t> Instead of returning a ssize_t where negative values mean error, we now return KResultOr<size_t> and use the error state to report errors exclusively.
2020-08-04 16:02:23 +00:00
if (nreceived_or_error.is_error())
return false;
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
auto nwritten_or_error = m_receive_buffer->write(scratch_buffer, nreceived_or_error.value());
Kernel: Use KResultOr<size_t> for the DoubleBuffer class
2021-06-16 13:33:14 +00:00
if (nwritten_or_error.is_error())
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 03:11:07 +00:00
return false;
Kernel: Handle OOM from DoubleBuffer usage in IPv4Socket The IPv4Socket requires a DoubleBuffer for storage of any data it received on the socket. However it was previously using the default constructor which can not observe allocation failure. Address this by plumbing the receive buffer through the various derived classes.
2021-08-01 09:42:03 +00:00
set_can_read(!m_receive_buffer->is_empty());
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
} else {
Kernel: Switch IPv4Socket receive queue to SinglyLinkedListWithCount<T> Avoid walking the packet queue, instead use a linked list with a count.
2020-08-05 04:35:30 +00:00
if (m_receive_queue.size() > 2000) {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything:
2021-01-10 14:17:54 +00:00
dbgln("IPv4Socket({}): did_receive refusing packet since queue is full.", this);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
return false;
}
Kernel: Annotate all `KBuffer` and `DoubleBuffer` with a custom name
2022-04-10 22:08:07 +00:00
auto data_or_error = KBuffer::try_create_with_bytes("IPv4Socket: Packet buffer"sv, packet);
Kernel: Convert KBuffer::copy() => KBuffer::try_copy() This was a weird KBuffer API that assumed failure was impossible. This patch converts it to a modern KResultOr<NonnullOwnPtr<KBuffer>> API and updates the two clients to the new style.
2021-09-07 13:36:39 +00:00
if (data_or_error.is_error()) {
dbgln("IPv4Socket: did_receive unable to allocate storage for incoming packet.");
return false;
}
AK+Kernel: Handle some allocation failures in IPv4Socket and TCPSocket This adds try_* methods to AK::SinglyLinkedList and AK::SinglyLinkedListWithCount and updates the network stack to use those to gracefully handle allocation failures. Refs #6369.
2022-11-01 09:04:13 +00:00
auto result = m_receive_queue.try_append({ source_address, source_port, packet_timestamp, data_or_error.release_value() });
if (result.is_error()) {
dbgln("IPv4Socket: Dropped incoming packet because appending to the receive queue failed.");
return false;
}
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-29 23:05:27 +00:00
set_can_read(true);
IPv4: Only buffer payload bytes for SOCK_STREAM sockets Since stream sockets don't actually need to deliver packets-at-a-time data in recvfrom(), they can just buffer the payload bytes instead. This avoids keeping one KBuffer per incoming packet in the receive queue, which was a big performance issue in ProtocolServer. This code is definitely not perfect and is something we should keep improving over time.
2019-12-14 08:43:31 +00:00
}
TCP: Collect the payload if present in a packet with FIN set.
2019-03-14 14:28:23 +00:00
m_bytes_received += packet_size;
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
Everywhere: Debug macros instead of constexpr. This was done with the following script: find . \( -name '*.cpp' -o -name '*.h' -o -name '*.in' \) -not -path './Toolchain/*' -not -path './Build/*' -exec sed -i -E 's/dbgln<debug_([a-z_]+)>/dbgln<\U\1_DEBUG>/' {} \; find . \( -name '*.cpp' -o -name '*.h' -o -name '*.in' \) -not -path './Toolchain/*' -not -path './Build/*' -exec sed -i -E 's/if constexpr \(debug_([a-z0-9_]+)/if constexpr \(\U\1_DEBUG/' {} \;
2021-01-23 22:59:27 +00:00
if constexpr (IPV4_SOCKET_DEBUG) {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-13 23:21:21 +00:00
if (buffer_mode() == BufferMode::Bytes)
dbgln("IPv4Socket({}): did_receive {} bytes, total_received={}", this, packet_size, m_bytes_received);
else
dbgln("IPv4Socket({}): did_receive {} bytes, total_received={}, packets in queue: {}",
this,
packet_size,
m_bytes_received,
m_receive_queue.size());
}
Kernel: Make File's can_read/can_write take a const FileDescription& Asking a File if we could possibly read or write it will never mutate the asking FileDescription&, so it should be const.
2019-11-04 13:03:14 +00:00
return true;
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(OpenFileDescription const&) const
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
{
if (m_role == Role::None)
Kernel: Clarify ambiguous {File,Description}::absolute_path Found due to smelly code in InodeFile::absolute_path. In particular, this replaces the following misleading methods: File::absolute_path This method *never* returns an actual path, and if called on an InodeFile (which is impossible), it would VERIFY_NOT_REACHED(). OpenFileDescription::try_serialize_absolute_path OpenFileDescription::absolute_path These methods do not guarantee to return an actual path (just like the other method), and just like Custody::absolute_path they do not guarantee accuracy. In particular, just renaming the method made a TOCTOU bug obvious. The new method signatures use KResultOr, just like try_serialize_absolute_path() already did.
2021-10-29 22:45:23 +00:00
return KString::try_create("socket"sv);
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
StringBuilder builder;
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(builder.try_append("socket:"sv));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
Kernel: AK: Fix ignored .to_string() errors in IPv4Socket
2023-01-12 22:14:35 +00:00
TRY(builder.try_appendff("{}:{}", TRY(m_local_address.to_string()), m_local_port));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
if (m_role == Role::Accepted || m_role == Role::Connected)
Kernel: AK: Fix ignored .to_string() errors in IPv4Socket
2023-01-12 22:14:35 +00:00
TRY(builder.try_appendff(" / {}:{}", TRY(m_peer_address.to_string()), m_peer_port));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
switch (m_role) {
case Role::Listener:
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(builder.try_append(" (listening)"sv));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
break;
case Role::Accepted:
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(builder.try_append(" (accepted)"sv));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
break;
case Role::Connected:
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(builder.try_append(" (connected)"sv));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
break;
case Role::Connecting:
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
TRY(builder.try_append(" (connecting)"sv));
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
break;
default:
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_NOT_REACHED();
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
}
Kernel+AK: Eliminate a couple of temporary String allocations
2021-12-30 12:43:45 +00:00
return KString::try_create(builder.string_view());
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
}
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<void const*> user_value, socklen_t user_value_size)
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
{
if (level != IPPROTO_IP)
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
return Socket::setsockopt(level, option, user_value, user_value_size);
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
Kernel: Lock socket mutex across {get,set}sockopt() and SO_ERROR updates Since a socket can be accessed by multiple threads concurrently, we need to protect shared data behind the socket mutex. There's very likely more places where we need to fix this, the purpose of this patch is to fix a VERIFY() failure in getsockopt() seen on CI.
2021-12-28 14:16:57 +00:00
MutexLocker locker(mutex());
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
switch (option) {
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
case IP_TTL: {
if (user_value_size < sizeof(int))
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return EINVAL;
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
int value;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
TRY(copy_from_user(&value, static_ptr_cast<int const*>(user_value)));
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
if (value < 0 || value > 255)
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return EINVAL;
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
m_ttl = value;
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
}
Kernel+LibC: Add support for the IPv4 TOS field via the IP_TOS sockopt
2021-10-27 20:20:24 +00:00
case IP_TOS: {
if (user_value_size < sizeof(int))
return EINVAL;
int value;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
TRY(copy_from_user(&value, static_ptr_cast<int const*>(user_value)));
Kernel+LibC: Add support for the IPv4 TOS field via the IP_TOS sockopt
2021-10-27 20:20:24 +00:00
if (value < 0 || value > 255)
return EINVAL;
m_type_of_service = value;
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel+LibC: Add support for the IPv4 TOS field via the IP_TOS sockopt
2021-10-27 20:20:24 +00:00
}
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
case IP_MULTICAST_LOOP: {
if (user_value_size != 1)
return EINVAL;
u8 value;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
TRY(copy_from_user(&value, static_ptr_cast<u8 const*>(user_value)));
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
if (value != 0 && value != 1)
return EINVAL;
m_multicast_loop = value;
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
}
case IP_ADD_MEMBERSHIP: {
if (user_value_size != sizeof(ip_mreq))
return EINVAL;
ip_mreq mreq;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
TRY(copy_from_user(&mreq, static_ptr_cast<ip_mreq const*>(user_value)));
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
if (mreq.imr_interface.s_addr != INADDR_ANY)
return ENOTSUP;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
IPv4Address address { (u8 const*)&mreq.imr_multiaddr.s_addr };
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
if (!m_multicast_memberships.contains_slow(address))
m_multicast_memberships.append(address);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
}
case IP_DROP_MEMBERSHIP: {
if (user_value_size != sizeof(ip_mreq))
return EINVAL;
ip_mreq mreq;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
TRY(copy_from_user(&mreq, static_ptr_cast<ip_mreq const*>(user_value)));
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
if (mreq.imr_interface.s_addr != INADDR_ANY)
return ENOTSUP;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
IPv4Address address { (u8 const*)&mreq.imr_multiaddr.s_addr };
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
m_multicast_memberships.remove_first_matching([&address](auto& a) { return a == address; });
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
}
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
default:
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return ENOPROTOOPT;
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
}
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> IPv4Socket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
{
if (level != IPPROTO_IP)
Kernel: Add getsockopt(SO_PEERCRED) for local sockets This sockopt gives you a struct with the PID, UID and GID of a socket's peer process.
2019-12-06 17:38:36 +00:00
return Socket::getsockopt(description, level, option, value, value_size);
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
Kernel: Lock socket mutex across {get,set}sockopt() and SO_ERROR updates Since a socket can be accessed by multiple threads concurrently, we need to protect shared data behind the socket mutex. There's very likely more places where we need to fix this, the purpose of this patch is to fix a VERIFY() failure in getsockopt() seen on CI.
2021-12-28 14:16:57 +00:00
MutexLocker locker(mutex());
Kernel: Use Userspace<T> for the getsockopt syscall and Socket interface The way getsockopt is implemented for socket types requires us to push down Userspace<T> using into those interfaces. This change does so, and utilizes proper copy implementations instead of the kind of haphazard pointer dereferencing that was occurring there before.
2020-08-07 09:29:05 +00:00
socklen_t size;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
TRY(copy_from_user(&size, value_size.unsafe_userspace_ptr()));
Kernel: Use Userspace<T> for the getsockopt syscall and Socket interface The way getsockopt is implemented for socket types requires us to push down Userspace<T> using into those interfaces. This change does so, and utilizes proper copy implementations instead of the kind of haphazard pointer dereferencing that was occurring there before.
2020-08-07 09:29:05 +00:00
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
switch (option) {
Kernel: Fix accidental memory over-read in getsockopt(IP_TTL) We were accidentally casting the pointer to m_ttl from an u8* to an int* which resulted in copying of 3 extra unrelated bytes (which turned out to be padding in this case).
2021-10-27 20:17:35 +00:00
case IP_TTL: {
Kernel: Use Userspace<T> for the getsockopt syscall and Socket interface The way getsockopt is implemented for socket types requires us to push down Userspace<T> using into those interfaces. This change does so, and utilizes proper copy implementations instead of the kind of haphazard pointer dereferencing that was occurring there before.
2020-08-07 09:29:05 +00:00
if (size < sizeof(int))
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return EINVAL;
Kernel: Fix accidental memory over-read in getsockopt(IP_TTL) We were accidentally casting the pointer to m_ttl from an u8* to an int* which resulted in copying of 3 extra unrelated bytes (which turned out to be padding in this case).
2021-10-27 20:17:35 +00:00
int ttl = m_ttl;
TRY(copy_to_user(static_ptr_cast<int*>(value), (int*)&ttl));
Kernel: Use Userspace<T> for the getsockopt syscall and Socket interface The way getsockopt is implemented for socket types requires us to push down Userspace<T> using into those interfaces. This change does so, and utilizes proper copy implementations instead of the kind of haphazard pointer dereferencing that was occurring there before.
2020-08-07 09:29:05 +00:00
size = sizeof(int);
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(value_size, &size);
Kernel: Fix accidental memory over-read in getsockopt(IP_TTL) We were accidentally casting the pointer to m_ttl from an u8* to an int* which resulted in copying of 3 extra unrelated bytes (which turned out to be padding in this case).
2021-10-27 20:17:35 +00:00
}
Kernel+LibC: Add support for the IPv4 TOS field via the IP_TOS sockopt
2021-10-27 20:20:24 +00:00
case IP_TOS: {
if (size < sizeof(int))
return EINVAL;
int type_of_service = m_type_of_service;
TRY(copy_to_user(static_ptr_cast<int*>(value), (int*)&type_of_service));
size = sizeof(int);
return copy_to_user(value_size, &size);
}
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
case IP_MULTICAST_LOOP: {
if (size < 1)
return EINVAL;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
TRY(copy_to_user(static_ptr_cast<u8*>(value), (u8 const*)&m_multicast_loop));
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
size = 1;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(value_size, &size);
Kernel: Implement IP multicast support An IP socket can now join a multicast group by using the IP_ADD_MEMBERSHIP sockopt, which will cause it to start receiving packets sent to the multicast address, even though this address does not belong to this host.
2021-05-04 11:42:47 +00:00
}
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
default:
Kernel+LibC: Turn errno codes into a strongly typed enum ..and allow implicit creation of KResult and KResultOr from ErrnoCode. This means that kernel functions that return those types can finally do "return EINVAL;" and it will just work. There's a handful of functions that still deal with signed integers that should be converted to return KResults.
2021-01-20 22:11:17 +00:00
return ENOPROTOOPT;
IPv4: Support overriding the default TTL (64) Made getsockopt() and setsockopt() virtual so we can handle them in the various Socket subclasses. The subclasses map kinda nicely to "levels". This will allow us to implement things like "traceroute", although.. I spent some time trying to do that, but then hit a wall when it turned out that the user-mode networking in QEMU doesn't preserve TTL in the ICMP packets passing through.
2019-09-19 19:40:06 +00:00
}
}
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
{
Kernel: Handle promise violations in the syscall handler Previously we would crash the process immediately when a promise violation was found during a syscall. This is error prone, as we don't unwind the stack. This means that in certain cases we can leak resources, like an OwnPtr / RefPtr tracked on the stack. Or even leak a lock acquired in a ScopeLockLocker. To remedy this situation we move the promise violation handling to the syscall handler, right before we return to user space. This allows the code to follow the normal unwind path, and grantees there is no longer any cleanup that needs to occur. The Process::require_promise() and Process::require_no_promises() functions were modified to return ErrorOr<void> so we enforce that the errors are always propagated by the caller.
2021-12-29 09:11:45 +00:00
TRY(Process::current().require_promise(Pledge::inet));
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
Kernel: Lock socket Mutex when servicing IPv4Socket ioctls This prevents a kernel panic found in CI when m_receive_queue's size is queried and found to be non-zero, then a different thread clears the queue, and finally the first thread continues into the if block and calls the queue's first() method, which then fails an assertion that the queue's size is non-zero.
2022-02-17 22:19:08 +00:00
MutexLocker locker(mutex());
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
auto ioctl_route = [request, arg]() -> ErrorOr<void> {
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
auto user_route = static_ptr_cast<rtentry*>(arg);
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 03:11:07 +00:00
rtentry route;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
TRY(copy_from_user(&route, user_route));
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
Kernel: Remove char* versions of path argument / kstring copy methods The only two paths for copying strings in the kernel should be going through the existing Userspace<char const*>, or StringArgument methods. Lets enforce this by removing the option for using the raw cstring APIs that were previously available.
2021-08-13 05:04:31 +00:00
Userspace<const char*> user_rt_dev((FlatPtr)route.rt_dev);
Kernel: Use FixedStringBuffer for fixed-length strings in syscalls Using the kernel stack is preferable, especially when the examined strings should be limited to a reasonable length. This is a small improvement, because if we don't actually move these strings then we don't need to own heap allocations for them during the syscall handler function scope. In addition to that, some kernel strings are known to be limited, like the hostname string, for these strings we also can use FixedStringBuffer to store and copy to and from these buffers, without using any heap allocations at all.
2023-07-17 16:22:01 +00:00
auto ifname = TRY(Process::get_syscall_name_string_fixed_buffer<IFNAMSIZ>(user_rt_dev));
auto adapter = NetworkingManagement::the().lookup_by_name(ifname.representable_view());
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
if (!adapter)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return ENODEV;
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
switch (request) {
Kernel: Add a global routing table Previously the system had no concept of assigning different routes for different destination addresses as the default gateway IP address was directly assigned to a network adapter. This default gateway was statically assigned and any update would remove the previously existing route. This patch is a beginning step towards implementing #180. It implements a simple global routing table that is referenced during the routing process. With this implementation it is now possible for a user or service (i.e. DHCP) to dynamically add routes to the table. The routing table will select the most specific route when possible. It will select any direct match between the destination and routing entry addresses. If the destination address overlaps between multiple entries, the Kernel will use the longest prefix match, or the longest number of matching bits between the destination address and the routing address. In the event that there is no entries found for a specific destination address, this implementation supports entries for a default route to be set for any specified interface. This is a small first step towards enhancing the system's routing capabilities. Future enhancements would include referencing a configuration file at boot to load pre-defined static routes.
2022-03-12 19:16:13 +00:00
case SIOCADDRT: {
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
auto current_process_credentials = Process::current().credentials();
if (!current_process_credentials->is_superuser())
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EPERM;
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 03:11:07 +00:00
if (route.rt_gateway.sa_family != AF_INET)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EAFNOSUPPORT;
Kernel: Add support for route flags Previously the routing table did not store the route flags. This adds basic support and exposes them in the /proc directory so that a userspace caller can query the route and identify the type of each route.
2022-05-09 11:23:02 +00:00
if (!(route.rt_flags & RTF_UP))
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EINVAL; // FIXME: Find the correct value to return
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
Kernel: Add a global routing table Previously the system had no concept of assigning different routes for different destination addresses as the default gateway IP address was directly assigned to a network adapter. This default gateway was statically assigned and any update would remove the previously existing route. This patch is a beginning step towards implementing #180. It implements a simple global routing table that is referenced during the routing process. With this implementation it is now possible for a user or service (i.e. DHCP) to dynamically add routes to the table. The routing table will select the most specific route when possible. It will select any direct match between the destination and routing entry addresses. If the destination address overlaps between multiple entries, the Kernel will use the longest prefix match, or the longest number of matching bits between the destination address and the routing address. In the event that there is no entries found for a specific destination address, this implementation supports entries for a default route to be set for any specified interface. This is a small first step towards enhancing the system's routing capabilities. Future enhancements would include referencing a configuration file at boot to load pre-defined static routes.
2022-03-12 19:16:13 +00:00
auto destination = IPv4Address(((sockaddr_in&)route.rt_dst).sin_addr.s_addr);
auto gateway = IPv4Address(((sockaddr_in&)route.rt_gateway).sin_addr.s_addr);
auto genmask = IPv4Address(((sockaddr_in&)route.rt_genmask).sin_addr.s_addr);
Kernel: Add support for route flags Previously the routing table did not store the route flags. This adds basic support and exposes them in the /proc directory so that a userspace caller can query the route and identify the type of each route.
2022-05-09 11:23:02 +00:00
return update_routing_table(destination, gateway, genmask, route.rt_flags, adapter, UpdateTable::Set);
Kernel: Add a global routing table Previously the system had no concept of assigning different routes for different destination addresses as the default gateway IP address was directly assigned to a network adapter. This default gateway was statically assigned and any update would remove the previously existing route. This patch is a beginning step towards implementing #180. It implements a simple global routing table that is referenced during the routing process. With this implementation it is now possible for a user or service (i.e. DHCP) to dynamically add routes to the table. The routing table will select the most specific route when possible. It will select any direct match between the destination and routing entry addresses. If the destination address overlaps between multiple entries, the Kernel will use the longest prefix match, or the longest number of matching bits between the destination address and the routing address. In the event that there is no entries found for a specific destination address, this implementation supports entries for a default route to be set for any specified interface. This is a small first step towards enhancing the system's routing capabilities. Future enhancements would include referencing a configuration file at boot to load pre-defined static routes.
2022-03-12 19:16:13 +00:00
}
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
case SIOCDELRT:
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
auto current_process_credentials = Process::current().credentials();
if (!current_process_credentials->is_superuser())
Kernel+route: Support global routing table deletion
2022-04-30 01:49:00 +00:00
return EPERM;
if (route.rt_gateway.sa_family != AF_INET)
return EAFNOSUPPORT;
auto destination = IPv4Address(((sockaddr_in&)route.rt_dst).sin_addr.s_addr);
auto gateway = IPv4Address(((sockaddr_in&)route.rt_gateway).sin_addr.s_addr);
auto genmask = IPv4Address(((sockaddr_in&)route.rt_genmask).sin_addr.s_addr);
Kernel: Add support for route flags Previously the routing table did not store the route flags. This adds basic support and exposes them in the /proc directory so that a userspace caller can query the route and identify the type of each route.
2022-05-09 11:23:02 +00:00
return update_routing_table(destination, gateway, genmask, route.rt_flags, adapter, UpdateTable::Delete);
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
}
Userland: Set the mask of a network adapter with ifconfig (#1388) A new IP address or a new network mask can be specified in the command line arguments of ifconfig to replace the old values of a given network adapter. Additionally, more information is being printed for each adapter.
2020-03-11 20:30:41 +00:00
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EINVAL;
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
};
Kernel: Add SIOCGIFHWADDR ioctl to get the MAC address of an adapter
2019-10-02 16:20:11 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
auto ioctl_arp = [request, arg]() -> ErrorOr<void> {
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
auto user_req = static_ptr_cast<arpreq*>(arg);
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
arpreq arp_req;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
TRY(copy_from_user(&arp_req, user_req));
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
auto current_process_credentials = Process::current().credentials();
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
switch (request) {
case SIOCSARP:
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
if (!current_process_credentials->is_superuser())
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EPERM;
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
if (arp_req.arp_pa.sa_family != AF_INET)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EAFNOSUPPORT;
Kernel: Generalize the UpdateArp table to UpdateTable We can use the same enum cases to apply to updates on different networking tables within the Kernel (i.e. a routing table)
2022-03-12 18:56:23 +00:00
update_arp_table(IPv4Address(((sockaddr_in&)arp_req.arp_pa).sin_addr.s_addr), *(MACAddress*)&arp_req.arp_ha.sa_data[0], UpdateTable::Set);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
case SIOCDARP:
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
if (!current_process_credentials->is_superuser())
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EPERM;
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
if (arp_req.arp_pa.sa_family != AF_INET)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EAFNOSUPPORT;
Kernel: Generalize the UpdateArp table to UpdateTable We can use the same enum cases to apply to updates on different networking tables within the Kernel (i.e. a routing table)
2022-03-12 18:56:23 +00:00
update_arp_table(IPv4Address(((sockaddr_in&)arp_req.arp_pa).sin_addr.s_addr), *(MACAddress*)&arp_req.arp_ha.sa_data[0], UpdateTable::Delete);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
}
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EINVAL;
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
};
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
auto ioctl_interface = [request, arg]() -> ErrorOr<void> {
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
auto user_ifr = static_ptr_cast<ifreq*>(arg);
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 03:11:07 +00:00
ifreq ifr;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
TRY(copy_from_user(&ifr, user_ifr));
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
Kernel/Net: Implement SIOCGIFINDEX and SIOCGIFNAME for sockets These ioctls exist on Linux and can be used to implement libc functions if_indextoname and if_nametoindex (without needing to parse any JSON).
2023-01-13 21:05:18 +00:00
if (request == SIOCGIFNAME) {
// NOTE: Network devices are 1-indexed since index 0 denotes an invalid device
if (ifr.ifr_index == 0)
return EINVAL;
size_t index = 1;
Optional<StringView> result {};
NetworkingManagement::the().for_each([&ifr, &index, &result](auto& adapter) {
if (index == ifr.ifr_index)
result = adapter.name();
++index;
});
if (result.has_value()) {
auto name = result.release_value();
auto succ = name.copy_characters_to_buffer(ifr.ifr_name, IFNAMSIZ);
if (!succ) {
return EFAULT;
}
return copy_to_user(user_ifr, &ifr);
}
return ENODEV;
}
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
char namebuf[IFNAMSIZ + 1];
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 03:11:07 +00:00
memcpy(namebuf, ifr.ifr_name, IFNAMSIZ);
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
namebuf[sizeof(namebuf) - 1] = '\0';
Kernel/Net: Implement SIOCGIFINDEX and SIOCGIFNAME for sockets These ioctls exist on Linux and can be used to implement libc functions if_indextoname and if_nametoindex (without needing to parse any JSON).
2023-01-13 21:05:18 +00:00
if (request == SIOCGIFINDEX) {
StringView name { namebuf, strlen(namebuf) };
size_t index = 1;
Optional<size_t> result {};
NetworkingManagement::the().for_each([&name, &index, &result](auto& adapter) {
if (adapter.name() == name)
result = index;
++index;
});
if (result.has_value()) {
ifr.ifr_index = result.release_value();
return copy_to_user(user_ifr, &ifr);
}
return ENODEV;
}
Everywhere: Explicitly specify the size in StringView constructors This commit moves the length calculations out to be directly on the StringView users. This is an important step towards the goal of removing StringView(char const*), as it moves the responsibility of calculating the size of the string to the user of the StringView (which will prevent naive uses causing OOB access).
2022-07-11 19:53:29 +00:00
auto adapter = NetworkingManagement::the().lookup_by_name({ namebuf, strlen(namebuf) });
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
if (!adapter)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return ENODEV;
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
auto current_process_credentials = Process::current().credentials();
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
switch (request) {
case SIOCSIFADDR:
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
if (!current_process_credentials->is_superuser())
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EPERM;
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 03:11:07 +00:00
if (ifr.ifr_addr.sa_family != AF_INET)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EAFNOSUPPORT;
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 03:11:07 +00:00
adapter->set_ipv4_address(IPv4Address(((sockaddr_in&)ifr.ifr_addr).sin_addr.s_addr));
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
case SIOCSIFNETMASK:
Kernel: Use Process::credentials() and remove user ID/group ID helpers Move away from using the group ID/user ID helpers in the process to allow for us to take advantage of the immutable credentials instead.
2022-08-20 22:21:01 +00:00
if (!current_process_credentials->is_superuser())
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EPERM;
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 03:11:07 +00:00
if (ifr.ifr_addr.sa_family != AF_INET)
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EAFNOSUPPORT;
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 03:11:07 +00:00
adapter->set_ipv4_netmask(IPv4Address(((sockaddr_in&)ifr.ifr_netmask).sin_addr.s_addr));
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
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 03:11:07 +00:00
case SIOCGIFADDR: {
auto ip4_addr = adapter->ipv4_address().to_u32();
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
auto& socket_address_in = reinterpret_cast<sockaddr_in&>(ifr.ifr_addr);
socket_address_in.sin_family = AF_INET;
socket_address_in.sin_addr.s_addr = ip4_addr;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(user_ifr, &ifr);
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 03:11:07 +00:00
}
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
case SIOCGIFNETMASK: {
auto ip4_netmask = adapter->ipv4_netmask().to_u32();
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
auto& socket_address_in = reinterpret_cast<sockaddr_in&>(ifr.ifr_addr);
socket_address_in.sin_family = AF_INET;
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
// NOTE: NOT ifr_netmask.
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
socket_address_in.sin_addr.s_addr = ip4_netmask;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(user_ifr, &ifr);
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
}
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 03:11:07 +00:00
case SIOCGIFHWADDR: {
auto mac_address = adapter->mac_address();
Kernel/Net: Get the correct interface type in SIOCGIFHWADDR ioctl When calling ioctl on a socket with SIOCGIFHWADDR, return the correct physical interface type. This value was previously hardcoded to ARPHRD_ETHER (Ethernet), and now can also return ARPHRD_LOOPBACK for the loopback adapter.
2023-01-13 08:46:31 +00:00
switch (adapter->adapter_type()) {
case NetworkAdapter::Type::Loopback:
ifr.ifr_hwaddr.sa_family = ARPHRD_LOOPBACK;
break;
case NetworkAdapter::Type::Ethernet:
ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
break;
default:
VERIFY_NOT_REACHED();
}
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
mac_address.copy_to(Bytes { ifr.ifr_hwaddr.sa_data, sizeof(ifr.ifr_hwaddr.sa_data) });
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(user_ifr, &ifr);
Kernel: Add SIOCGIFHWADDR ioctl to get the MAC address of an adapter
2019-10-02 16:20:11 +00:00
}
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
case SIOCGIFBRDADDR: {
// Broadcast address is basically the reverse of the netmask, i.e.
// instead of zeroing out the end, you OR with 1 instead.
auto ip4_netmask = adapter->ipv4_netmask().to_u32();
auto broadcast_addr = adapter->ipv4_address().to_u32() | ~ip4_netmask;
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
auto& socket_address_in = reinterpret_cast<sockaddr_in&>(ifr.ifr_addr);
socket_address_in.sin_family = AF_INET;
socket_address_in.sin_addr.s_addr = broadcast_addr;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(user_ifr, &ifr);
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
}
case SIOCGIFMTU: {
auto ip4_metric = adapter->mtu();
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
ifr.ifr_addr.sa_family = AF_INET;
ifr.ifr_metric = ip4_metric;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(user_ifr, &ifr);
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
}
case SIOCGIFFLAGS: {
// FIXME: stub!
Kernel: Utilize AK::Userspace<T> in the ioctl interface It's easy to forget the responsibility of validating and safely copying kernel parameters in code that is far away from syscalls. ioctl's are one such example, and bugs there are just as dangerous as at the root syscall level. To avoid this case, utilize the AK::Userspace<T> template in the ioctl kernel interface so that implementors have no choice but to properly validate and copy ioctl pointer arguments.
2021-07-26 09:47:00 +00:00
constexpr short flags = 1;
ifr.ifr_addr.sa_family = AF_INET;
ifr.ifr_flags = flags;
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
return copy_to_user(user_ifr, &ifr);
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
}
case SIOCGIFCONF: {
// FIXME: stub!
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EINVAL;
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
}
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 03:11:07 +00:00
}
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EINVAL;
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
};
switch (request) {
case SIOCSIFADDR:
case SIOCSIFNETMASK:
case SIOCGIFADDR:
case SIOCGIFHWADDR:
Kernel: Add some missing socket ioctls This patch adds a few missing ioctls which were required by Wine. SIOCGIFNETMASK, SIOCGIFBRDADDR and SIOCGIFMTU are fully implemented, while SIOCGIFFLAGS and SIOCGIFCONF are stubs.
2021-04-16 15:48:41 +00:00
case SIOCGIFNETMASK:
case SIOCGIFBRDADDR:
case SIOCGIFMTU:
case SIOCGIFFLAGS:
case SIOCGIFCONF:
Kernel/Net: Implement SIOCGIFINDEX and SIOCGIFNAME for sockets These ioctls exist on Linux and can be used to implement libc functions if_indextoname and if_nametoindex (without needing to parse any JSON).
2023-01-13 21:05:18 +00:00
case SIOCGIFNAME:
case SIOCGIFINDEX:
Userland: ifconfig can change the IP address of the default gateway ioctl can now perform a request for a specific route and change the address of it's default gateway.
2020-03-14 19:00:49 +00:00
return ioctl_interface();
case SIOCADDRT:
case SIOCDELRT:
return ioctl_route();
Kernel: Support ioctl SIOCSARP and SIOCDARP Creates ioctl calls necessary to set/delete an entry from the ARP table
2021-07-25 00:04:11 +00:00
case SIOCSARP:
case SIOCDARP:
return ioctl_arp();
Kernel+LibC: Implement FIONREAD ioctl FIONREAD gets the number of bytes availible to read from a file descriptor without blocking. I only implemented it for regular files and sockets
2021-07-27 05:06:22 +00:00
case FIONREAD: {
Kernel: Return the correct result for FIONREAD on datagram sockets Before this commit, we only checked the receive buffer on the socket, which is unused on datagram streams. Now we return the actual size of the datagram without the protocol headers, which required the protocol to tell us what the size of the payload is.
2021-09-11 19:38:05 +00:00
int readable = 0;
if (buffer_mode() == BufferMode::Bytes) {
readable = static_cast<int>(m_receive_buffer->immediately_readable());
} else {
if (m_receive_queue.size() != 0u) {
readable = static_cast<int>(TRY(protocol_size(m_receive_queue.first().data->bytes())));
}
}
Kernel: Use static_ptr_cast to convert between Userspace<T*> types Some calls of copy_to_user were converting Userspace<T*> to Userspace<U*> via the implicit conversion to FlatPtr. Change them to use the static_ptr_cast overload that is designed to express this conversion
2021-11-14 22:43:43 +00:00
return copy_to_user(static_ptr_cast<int*>(arg), &readable);
Kernel+LibC: Implement FIONREAD ioctl FIONREAD gets the number of bytes availible to read from a file descriptor without blocking. I only implemented it for regular files and sockets
2021-07-27 05:06:22 +00:00
}
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
}
Kernel: Modify the IOCTL API to return KResult The kernel has been gradually moving towards KResult from just bare int's, this change migrates the IOCTL paths.
2021-07-26 10:47:25 +00:00
return EINVAL;
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
}
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 14:52:32 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> IPv4Socket::close()
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 14:52:32 +00: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-20 23:09:48 +00:00
[[maybe_unused]] auto rc = shutdown(SHUT_RDWR);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
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 14:52:32 +00:00
}
IPv4: Sockets should say can_read() after reading is shut down This allows clients to get their EOF after shutting down reading.
2020-02-08 14:59:21 +00:00
void IPv4Socket::shut_down_for_reading()
{
Socket::shut_down_for_reading();
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-29 23:05:27 +00:00
set_can_read(true);
}
void IPv4Socket::set_can_read(bool value)
{
m_can_read = value;
if (value)
evaluate_block_conditions();
IPv4: Sockets should say can_read() after reading is shut down This allows clients to get their EOF after shutting down reading.
2020-02-08 14:59:21 +00:00
}
Kernel: Make copy_{from,to}_user() return KResult and use TRY() This makes EFAULT propagation flow much more naturally. :^)
2021-09-05 15:38:37 +00:00
Kernel: Drop the receive buffer when socket enters the TimeWait state The TimeWait state is intended to prevent another socket from taking the address tuple in case any packets are still in transit after the final close. Since this state never delivers packets to userspace, it doesn't make sense to keep the receive buffer around.
2021-09-16 00:15:36 +00:00
void IPv4Socket::drop_receive_buffer()
{
m_receive_buffer = nullptr;
}
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
}
Reference in a new issue Copy permalink