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

794 lines
27 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>
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: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/FileSystem/FileDescription.h>
#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>
#include <Kernel/Process.h>
#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
#include <LibC/errno_numbers.h>
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
#include <LibC/sys/ioctl_numbers.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: 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
static AK::Singleton<Lockable<HashTable<IPv4Socket*>>> s_table;
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
using BlockFlags = Thread::FileDescriptionBlocker::BlockFlags;
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
Lockable<HashTable<IPv4Socket*>>& IPv4Socket::all_sockets()
{
return *s_table;
}
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
OwnPtr<DoubleBuffer> IPv4Socket::create_receive_buffer()
{
return DoubleBuffer::try_create(256 * KiB);
}
Kernel: Allow Socket subclasses to fail construction For example, socket(AF_INET) should only succeed for valid SOCK_TYPEs.
2020-01-23 17:11:14 +00:00
KResultOr<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: 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 receive_buffer = IPv4Socket::create_receive_buffer();
if (!receive_buffer)
return ENOMEM;
Kernel: Make TCPSocket::create API OOM safe Note that the changes to IPv4Socket::create are unfortunately needed as the return type of TCPSocket::create and IPv4Socket::create don't match. - KResultOr<NonnullRefPtr<TcpSocket>>> vs - KResultOr<NonnullRefPtr<Socket>>> To handle this we are forced to manually decompose the KResultOr<T> and return the value() and error() separately.
2021-05-13 08:01:38 +00:00
if (type == SOCK_STREAM) {
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 tcp_socket = TCPSocket::create(protocol, receive_buffer.release_nonnull());
Kernel: Make TCPSocket::create API OOM safe Note that the changes to IPv4Socket::create are unfortunately needed as the return type of TCPSocket::create and IPv4Socket::create don't match. - KResultOr<NonnullRefPtr<TcpSocket>>> vs - KResultOr<NonnullRefPtr<Socket>>> To handle this we are forced to manually decompose the KResultOr<T> and return the value() and error() separately.
2021-05-13 08:01:38 +00:00
if (tcp_socket.is_error())
return tcp_socket.error();
return tcp_socket.release_value();
}
Kernel: Make UDPSocket::create() API OOM safe
2021-05-13 08:34:04 +00:00
if (type == SOCK_DGRAM) {
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 udp_socket = UDPSocket::create(protocol, receive_buffer.release_nonnull());
Kernel: Make UDPSocket::create() API OOM safe
2021-05-13 08:34:04 +00:00
if (udp_socket.is_error())
return udp_socket.error();
return udp_socket.release_value();
}
Kernel: Make IPv4Socket::create API for SOCK_RAW OOM safe
2021-05-13 08:24:44 +00:00
if (type == SOCK_RAW) {
Kernel: Handle OOM when allocating IPv4Socket optional scratch buffer
2021-08-01 12:11:05 +00:00
auto raw_socket = adopt_ref_if_nonnull(new (nothrow) IPv4Socket(type, protocol, receive_buffer.release_nonnull(), {}));
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: Rename Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(all_sockets().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
all_sockets().resource().set(this);
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: Rename Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(all_sockets().lock());
IPv4: Factor out UDP parts of IPv4Socket into a UDPSocket class.
2019-03-14 11:43:18 +00:00
all_sockets().resource().remove(this);
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: Use Userspace<T> for the bind syscall, and implementation
2020-08-09 22:13:43 +00:00
KResult IPv4Socket::bind(Userspace<const sockaddr*> 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
{
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+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: Remove SmapDisabler in bind()
2020-01-11 11:07:45 +00:00
sockaddr_in address;
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 (!copy_from_user(&address, user_address, sizeof(sockaddr_in)))
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 EFAULT;
Kernel: Remove SmapDisabler in bind()
2020-01-11 11:07:45 +00:00
if (address.sin_family != AF_INET)
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: 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: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
if (!Process::current()->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) {
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("UID {} attempted to bind {} to port {}", Process::current()->uid(), class_name(), requested_local_port);
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 EACCES;
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
m_local_address = IPv4Address((const u8*)&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
return protocol_bind();
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
}
AK: Make Vector use size_t for its size and capacity
2020-02-25 13:49:47 +00:00
KResult 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 Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(lock());
Kernel: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
auto result = allocate_local_port_if_needed();
if (result.error_or_port.is_error() && result.error_or_port.error() != -ENOPROTOOPT)
return result.error_or_port.error();
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: Make sure IPv4Socket is marked as listening in listen()
2019-09-08 07:03:03 +00:00
m_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: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
return protocol_listen(result.did_allocate);
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 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
KResult IPv4Socket::connect(FileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock should_block)
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+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: 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;
auto* user_address = reinterpret_cast<const sockaddr*>(address.unsafe_userspace_ptr());
if (!copy_from_user(&sa_family_copy, &user_address->sa_family, sizeof(u16)))
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 EFAULT;
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+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: 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+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 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: 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
sockaddr_in safe_address;
if (!copy_from_user(&safe_address, (const sockaddr_in*)user_address, sizeof(sockaddr_in)))
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 EFAULT;
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_address = IPv4Address((const u8*)&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: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return protocol_connect(description, should_block);
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: Add explicit offset parameter to File::read etc
2020-04-10 09:44:42 +00:00
bool IPv4Socket::can_read(const FileDescription&, size_t) 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
}
Kernel: Add explicit offset parameter to File::read etc
2020-04-10 09:44:42 +00:00
bool IPv4Socket::can_write(const FileDescription&, size_t) 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
}
Kernel: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
PortAllocationResult IPv4Socket::allocate_local_port_if_needed()
IPv4: Dynamically allocate the UDP source port if needed.
2019-03-13 15:05:56 +00:00
{
Kernel: Rename Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(lock());
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
if (m_local_port)
Kernel: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
return { m_local_port, false };
Kernel/IPv4: Propagate errors from local port allocation Remove hacks and assumptions and make the EADDRINUSE propagate all the way from the point of failure to the syscall layer.
2021-04-30 10:26:25 +00:00
auto port_or_error = protocol_allocate_local_port();
if (port_or_error.is_error())
Kernel: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
return { port_or_error.error(), false };
Kernel/IPv4: Propagate errors from local port allocation Remove hacks and assumptions and make the EADDRINUSE propagate all the way from the point of failure to the syscall layer.
2021-04-30 10:26:25 +00:00
m_local_port = port_or_error.value();
Kernel: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
return { m_local_port, true };
IPv4: Dynamically allocate the UDP source port if needed.
2019-03-13 15:05:56 +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
KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> 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 Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(lock());
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+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
IPv4: Begin fleshing out TCP support.
2019-03-13 16:17:07 +00:00
if (addr) {
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
sockaddr_in ia;
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 (!copy_from_user(&ia, Userspace<const sockaddr_in*>(addr.ptr())))
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 EFAULT;
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+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 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
}
AK: Rename the common integer typedefs to make it obvious what they are. These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
2019-07-03 19:17:35 +00:00
m_peer_address = IPv4Address((const u8*)&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())
return EPIPE;
Kernel: Add the SO_BINDTODEVICE socket option This patch adds a way for a socket to ask to be routed through a specific interface. Currently, this option only applies to sending, however, it should also apply to receiving...somehow :^)
2020-04-04 20:46:45 +00:00
auto routing_decision = route_to(m_peer_address, m_local_address, bound_interface());
Kernel: Implement is_zero for RoutingDecision
2019-08-29 01:18:38 +00:00
if (routing_decision.is_zero())
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 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: Dont try to register ephemeral TCP ports twice
2021-05-31 23:11:14 +00:00
if (auto result = allocate_local_port_if_needed(); result.error_or_port.is_error() && result.error_or_port.error() != -ENOPROTOOPT)
return result.error_or_port.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: 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)
return ENOMEM;
routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(), routing_decision.next_hop,
m_peer_address, (IPv4Protocol)protocol(), data_length, m_ttl);
if (!data.read(packet->buffer.data() + ipv4_payload_offset, data_length)) {
routing_decision.adapter->release_packet_buffer(*packet);
return EFAULT;
}
Kernel: Make sure we increment the TX counter This was broken by b436dd1.
2021-06-04 15:58:55 +00:00
routing_decision.adapter->send_packet({ packet->buffer.data(), packet->buffer.size() });
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: 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
KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>)
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 Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(lock());
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;
if (!description.is_blocking())
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 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+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 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+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 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: Use KResultOr<size_t> for the DoubleBuffer class
2021-06-16 13:33:14 +00:00
KResultOr<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: Make sockets use AK::Time
2021-02-28 01:48:45 +00:00
KResultOr<size_t> IPv4Socket::receive_packet_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp)
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 Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(lock());
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
ReceivedPacket packet;
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()) {
// FIXME: Shouldn't this return -ENOTCONN instead of EOF?
// But if so, we still need to deliver at least one EOF read to userspace.. right?
if (protocol_is_disconnected())
return 0;
if (!description.is_blocking())
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 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: 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)
packet = m_receive_queue.first();
else
packet = m_receive_queue.take_first();
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,
packet.data.value().size(),
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: 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
if (!packet.data.has_value()) {
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+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 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+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 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
if (flags & MSG_PEEK)
packet = m_receive_queue.first();
else
packet = m_receive_queue.take_first();
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,
packet.data.value().size(),
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
}
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(packet.data.has_value());
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +00:00
Kernel: Plumb packet receive timestamp from NetworkAdapter to Socket::recvfrom Since the receiving socket isn't yet known at packet receive time, keep timestamps for all packets. This is useful for keeping statistics about in-kernel queue latencies in the future, and it can be used to implement SO_TIMESTAMP.
2020-09-16 16:25:06 +00:00
packet_timestamp = packet.timestamp;
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) {
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, "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 {};
memcpy(&out_addr.sin_addr, &packet.peer_address, sizeof(IPv4Address));
out_addr.sin_port = htons(packet.peer_port);
out_addr.sin_family = AF_INET;
Userspace<sockaddr_in*> dest_addr = addr.ptr();
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 (!copy_to_user(dest_addr, &out_addr))
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 EFAULT;
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: 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 (!copy_to_user(addr_length, &out_length))
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 EFAULT;
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) {
IPv4: Include IP headers when receiving from a raw socket We were stripping the L3 headers from packets received on raw sockets. This didn't match what other systems do, so let's adjust our behavior. Thanks to @SpencerCDixon for noticing this! :^)
2020-10-31 10:32:33 +00:00
size_t bytes_written = min(packet.data.value().size(), buffer_length);
if (!buffer.write(packet.data.value().data(), bytes_written))
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 EFAULT;
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/Net: Make IPv4Socket::protocol_receive() take a ReadonlyBytes The overrides of this function don't need to know how the original packet was stored, so let's just give them a ReadonlyBytes view of the raw packet data.
2020-12-18 15:13:23 +00:00
return protocol_receive(ReadonlyBytes { packet.data.value().data(), packet.data.value().size() }, 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: Make sockets use AK::Time
2021-02-28 01:48:45 +00:00
KResultOr<size_t> IPv4Socket::recvfrom(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Time& packet_timestamp)
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: 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 (!copy_from_user(&addr_length, user_addr_length.unsafe_userspace_ptr()))
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 EFAULT;
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+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: 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: 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
KResultOr<size_t> nreceived = 0;
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 (buffer_mode() == BufferMode::Bytes)
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
nreceived = receive_byte_buffered(description, buffer, buffer_length, flags, user_addr, user_addr_length);
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
else
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
nreceived = receive_packet_buffered(description, buffer, buffer_length, flags, user_addr, user_addr_length, packet_timestamp);
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: 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.is_error())
Thread::current()->did_ipv4_socket_read(nreceived.value());
Kernel+SystemMonitor: Log amounts of I/O per thread This patch adds these I/O counters to each thread: - (Inode) file read bytes - (Inode) file write bytes - Unix socket read bytes - Unix socket write bytes - IPv4 socket read bytes - IPv4 socket write bytes These are then exposed in /proc/all and seen in SystemMonitor.
2019-12-01 16:36:06 +00:00
return 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: Avoid allocating KBuffers for TCP packets This avoids allocating a KBuffer for each incoming TCP packet.
2021-05-11 17:47:40 +00:00
bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, ReadonlyBytes packet, const Time& 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 Locker => MutexLocker
2021-07-17 23:13:34 +00:00
MutexLocker locker(lock());
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: 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: Avoid allocating KBuffers for TCP packets This avoids allocating a KBuffer for each incoming TCP packet.
2021-05-11 17:47:40 +00:00
m_receive_queue.append({ source_address, source_port, packet_timestamp, KBuffer::copy(packet.data(), packet.size()) });
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
String IPv4Socket::absolute_path(const FileDescription&) const
{
if (m_role == Role::None)
return "socket";
StringBuilder builder;
builder.append("socket:");
Kernel: Convert all *Builder::appendf() => appendff()
2021-02-09 15:08:43 +00:00
builder.appendff("{}:{}", 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: Convert all *Builder::appendf() => appendff()
2021-02-09 15:08:43 +00:00
builder.appendff(" / {}:{}", 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:
builder.append(" (listening)");
break;
case Role::Accepted:
builder.append(" (accepted)");
break;
case Role::Connected:
builder.append(" (connected)");
break;
case Role::Connecting:
builder.append(" (connecting)");
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
}
return builder.to_string();
}
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: Use Userspace<T> for the setsockopt syscall
2020-08-07 07:18:20 +00:00
KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> 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
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;
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 (!copy_from_user(&value, static_ptr_cast<const int*>(user_value)))
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 EFAULT;
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;
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
return KSuccess;
Kernel: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +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;
if (!copy_from_user(&value, static_ptr_cast<const u8*>(user_value)))
return EFAULT;
if (value != 0 && value != 1)
return EINVAL;
m_multicast_loop = value;
return KSuccess;
}
case IP_ADD_MEMBERSHIP: {
if (user_value_size != sizeof(ip_mreq))
return EINVAL;
ip_mreq mreq;
if (!copy_from_user(&mreq, static_ptr_cast<const ip_mreq*>(user_value)))
return EFAULT;
if (mreq.imr_interface.s_addr != INADDR_ANY)
return ENOTSUP;
IPv4Address address { (const u8*)&mreq.imr_multiaddr.s_addr };
if (!m_multicast_memberships.contains_slow(address))
m_multicast_memberships.append(address);
return KSuccess;
}
case IP_DROP_MEMBERSHIP: {
if (user_value_size != sizeof(ip_mreq))
return EINVAL;
ip_mreq mreq;
if (!copy_from_user(&mreq, static_ptr_cast<const ip_mreq*>(user_value)))
return EFAULT;
if (mreq.imr_interface.s_addr != INADDR_ANY)
return ENOTSUP;
IPv4Address address { (const u8*)&mreq.imr_multiaddr.s_addr };
m_multicast_memberships.remove_first_matching([&address](auto& a) { return a == address; });
return KSuccess;
}
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: 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
KResult IPv4Socket::getsockopt(FileDescription& 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: 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_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 (!copy_from_user(&size, value_size.unsafe_userspace_ptr()))
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 EFAULT;
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) {
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: 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 (!copy_to_user(static_ptr_cast<int*>(value), (int*)&m_ttl))
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 EFAULT;
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_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 (!copy_to_user(value_size, &size))
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 EFAULT;
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
return KSuccess;
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;
if (!copy_to_user(static_ptr_cast<u8*>(value), (const u8*)&m_multicast_loop))
return EFAULT;
size = 1;
if (!copy_to_user(value_size, &size))
return EFAULT;
return KSuccess;
}
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: 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
KResult IPv4Socket::ioctl(FileDescription&, 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
{
IPv4: Require "inet" promise for ioctl() on an IPv4Socket
2020-01-12 12:28:07 +00:00
REQUIRE_PROMISE(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: 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
auto ioctl_route = [request, arg]() -> KResult {
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: 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
if (!copy_from_user(&route, user_route))
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 EFAULT;
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: 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
auto copied_ifname = copy_string_from_user(route.rt_dev, IFNAMSIZ);
if (copied_ifname.is_null())
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 EFAULT;
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: 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
auto adapter = NetworkingManagement::the().lookup_by_name(copied_ifname);
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) {
case SIOCADDRT:
Kernel: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
if (!Process::current()->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: 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_flags & (RTF_UP | RTF_GATEWAY)) != (RTF_UP | RTF_GATEWAY))
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
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_gateway(IPv4Address(((sockaddr_in&)route.rt_gateway).sin_addr.s_addr));
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 KSuccess;
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
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:
// FIXME: Support gateway deletion
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 KSuccess;
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: 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
auto ioctl_arp = [request, arg]() -> KResult {
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: 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
if (!copy_from_user(&arp_req, user_req))
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 EFAULT;
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:
if (!Process::current()->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: 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
update_arp_table(IPv4Address(((sockaddr_in&)arp_req.arp_pa).sin_addr.s_addr), *(MACAddress*)&arp_req.arp_ha.sa_data[0], UpdateArp::Set);
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 KSuccess;
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:
if (!Process::current()->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: 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
update_arp_table(IPv4Address(((sockaddr_in&)arp_req.arp_pa).sin_addr.s_addr), *(MACAddress*)&arp_req.arp_ha.sa_data[0], UpdateArp::Delete);
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 KSuccess;
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: 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
auto ioctl_interface = [request, arg]() -> KResult {
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;
if (!copy_from_user(&ifr, user_ifr))
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 EFAULT;
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: 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
auto adapter = NetworkingManagement::the().lookup_by_name(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
switch (request) {
case SIOCSIFADDR:
Kernel: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
if (!Process::current()->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: 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 KSuccess;
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: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
if (!Process::current()->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: 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 KSuccess;
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;
if (!copy_to_user(user_ifr, &ifr))
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 EFAULT;
return KSuccess;
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;
if (!copy_to_user(user_ifr, &ifr))
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 EFAULT;
return KSuccess;
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: 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_hwaddr.sa_family = AF_INET;
mac_address.copy_to(Bytes { ifr.ifr_hwaddr.sa_data, sizeof(ifr.ifr_hwaddr.sa_data) });
if (!copy_to_user(user_ifr, &ifr))
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 EFAULT;
return KSuccess;
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;
if (!copy_to_user(user_ifr, &ifr))
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 EFAULT;
return KSuccess;
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;
if (!copy_to_user(user_ifr, &ifr))
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 EFAULT;
return KSuccess;
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;
if (!copy_to_user(user_ifr, &ifr))
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 EFAULT;
return KSuccess;
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:
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();
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: Allow File::close() to fail And pass the result through to sys$close() return value. Fixes https://github.com/SerenityOS/serenity/issues/427
2020-06-02 16:20:05 +00:00
KResult 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: Allow File::close() to fail And pass the result through to sys$close() return value. Fixes https://github.com/SerenityOS/serenity/issues/427
2020-06-02 16:20:05 +00:00
return KSuccess;
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: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
}
Reference in a new issue Copy permalink