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

631 lines
21 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
Kernel: Switch singletons to use new Singleton class MemoryManager cannot use the Singleton class because MemoryManager::initialize is called before the global constructors are run. That caused the Singleton to be re-initialized, causing it to create another MemoryManager instance. Fixes #3226
2020-08-25 01:35:19 +00:00
#include <AK/Singleton.h>
Kernel: Customize absolute_path() for more file types
2019-08-10 16:10:36 +00:00
#include <AK/StringBuilder.h>
Kernel: 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: 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: Put IPv4 and TCP related debug spam behind flags ...and turn those flags off for now, to make it possible to write some networking code without being spammed to death.
2019-08-04 08:04:06 +00:00
//#define IPV4_SOCKET_DEBUG
Kernel: Start fleshing out an UDP implementation.
2019-03-13 13:22:27 +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+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: 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: Factor out TCP parts of IPv4Socket into a TCPSocket class.
2019-03-14 11:20:38 +00:00
if (type == SOCK_STREAM)
return TCPSocket::create(protocol);
IPv4: Factor out UDP parts of IPv4Socket into a UDPSocket class.
2019-03-14 11:43:18 +00:00
if (type == SOCK_DGRAM)
return UDPSocket::create(protocol);
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
if (type == SOCK_RAW)
return adopt(*new IPv4Socket(type, protocol));
return KResult(-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
}
IPv4Socket::IPv4Socket(int type, int protocol)
: Socket(AF_INET, type, protocol)
{
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#ifdef IPV4_SOCKET_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 19:45:39 +00:00
dbg() << "IPv4Socket{" << this << "} created with type=" << type << ", protocol=" << protocol;
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#endif
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) {
m_scratch_buffer = KBuffer::create_with_size(65536);
}
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
LOCKER(all_sockets().lock());
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()
{
IPv4: Factor out UDP parts of IPv4Socket into a UDPSocket class.
2019-03-14 11:43:18 +00:00
LOCKER(all_sockets().lock());
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
{
Kernel: Use a more detailed state machine for socket setup
2019-08-10 03:17:00 +00:00
ASSERT(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))
return KResult(-EINVAL);
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)))
return KResult(-EFAULT);
Kernel: Remove SmapDisabler in bind()
2020-01-11 11:07:45 +00:00
if (address.sin_family != AF_INET)
return KResult(-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: Don't allow non-superusers to bind TCP/UDP ports < 1024
2019-09-02 16:49:54 +00:00
if (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: Don't allow non-superusers to bind TCP/UDP ports < 1024
2019-09-02 16:49:54 +00:00
return KResult(-EACCES);
}
}
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
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#ifdef IPV4_SOCKET_DEBUG
Kernel: Remove some unnecessary .characters() when doing dbg()<<String
2020-03-01 12:23:26 +00:00
dbg() << "IPv4Socket::bind " << class_name() << "{" << this << "} to " << m_local_address << ":" << m_local_port;
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#endif
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
{
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
LOCKER(lock());
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
int rc = allocate_local_port_if_needed();
if (rc < 0)
return KResult(-EADDRINUSE);
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
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#ifdef IPV4_SOCKET_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 19:45:39 +00:00
dbg() << "IPv4Socket{" << this << "} listening with backlog=" << backlog;
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#endif
Kernel: Refactor TCP/IP stack This has several significant changes to the networking stack. * Significant refactoring of the TCP state machine. Right now it's probably more fragile than it used to be, but handles quite a lot more of the handshake process. * `TCPSocket` holds a `NetworkAdapter*`, assigned during `connect()` or `bind()`, whichever comes first. * `listen()` is now virtual in `Socket` and intended to be implemented in its child classes * `listen()` no longer works without `bind()` - this is a bit of a regression, but listening sockets didn't work at all before, so it's not possible to observe the regression. * A file is exposed at `/proc/net_tcp`, which is a JSON document listing the current TCP sockets with a bit of metadata. * There's an `ETHERNET_VERY_DEBUG` flag for dumping packet's content out to `kprintf`. It is, indeed, _very debug_.
2019-08-06 13:40:38 +00:00
return protocol_listen();
}
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))
return KResult(-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)))
return KResult(-EFAULT);
if (sa_family_copy != AF_INET)
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
return KResult(-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)
return KResult(-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)))
return KResult(-EFAULT);
m_peer_address = IPv4Address((const u8*)&safe_address.sin_addr.s_addr);
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: Support non-blocking connect(). If connect() is called on a non-blocking socket, it will "fail" immediately with -EINPROGRESS. After that, you select() on the socket and wait for it to become writable.
2019-04-08 02:52:21 +00:00
return is_connected();
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: 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
int IPv4Socket::allocate_local_port_if_needed()
IPv4: Dynamically allocate the UDP source port if needed.
2019-03-13 15:05:56 +00:00
{
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)
return m_local_port;
int port = protocol_allocate_local_port();
IPv4: Add simple pseudorandom ephemeral port allocators for TCP and UDP.
2019-03-18 03:03:44 +00:00
if (port < 0)
return port;
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_local_port = (u16)port;
IPv4: Add simple pseudorandom ephemeral port allocators for TCP and UDP.
2019-03-18 03:03:44 +00:00
return port;
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
{
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
LOCKER(lock());
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: 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
return KResult(-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: 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
return KResult(-EFAULT);
if (ia.sin_family != AF_INET) {
klog() << "sendto: Bad address family: " << ia.sin_family << " is not AF_INET!";
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
return KResult(-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: 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: 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
return KResult(-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
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
int rc = allocate_local_port_if_needed();
IPv4: Add simple pseudorandom ephemeral port allocators for TCP and UDP.
2019-03-18 03:03:44 +00:00
if (rc < 0)
return rc;
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: Put some network log messages behind debug flags
2019-09-08 09:13:50 +00:00
#ifdef IPV4_SOCKET_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 19:45:39 +00:00
klog() << "sendto: destination=" << m_peer_address.to_string().characters() << ":" << m_peer_port;
Kernel: Put some network log messages behind debug flags
2019-09-08 09:13:50 +00:00
#endif
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: 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
int err = routing_decision.adapter->send_ipv4(routing_decision.next_hop, m_peer_address, (IPv4Protocol)protocol(), data, data_length, m_ttl);
if (err < 0)
return KResult(err);
IPv4: More work on UDP support. I'm now able to connect to a simple UDP server on my host machine and exchange some data. Very cool! :^)
2019-03-13 14:40:30 +00:00
return data_length;
}
Kernel: Make File::write() and File::read() return KResultOr<size_t> Instead of returning a ssize_t where negative values mean error, we now return KResultOr<size_t> and use the error state to report errors exclusively.
2020-08-04 16:02:23 +00:00
auto nsent_or_error = protocol_send(data, data_length);
if (!nsent_or_error.is_error())
Thread::current()->did_ipv4_socket_write(nsent_or_error.value());
return nsent_or_error;
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
Kernel: Make 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
KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int, 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
{
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 locker(lock());
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 (m_receive_buffer.is_empty()) {
if (protocol_is_disconnected())
return 0;
if (!description.is_blocking())
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
return KResult(-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: 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
auto unblocked_flags = Thread::FileDescriptionBlocker::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: 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
if (!((u32)unblocked_flags & (u32)Thread::FileDescriptionBlocker::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: 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
return KResult(-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: 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
return KResult(-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
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
ASSERT(!m_receive_buffer.is_empty());
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
int nreceived = m_receive_buffer.read(buffer, buffer_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
if (nreceived > 0)
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
Thread::current()->did_ipv4_socket_read((size_t)nreceived);
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: 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_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
return nreceived;
}
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: 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
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, timeval& 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
{
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 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: 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
return KResult(-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()) {
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
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());
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
#ifdef IPV4_SOCKET_DEBUG
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
dbg() << "IPv4Socket(" << this << "): recvfrom without blocking " << packet.data.value().size() << " bytes, packets in queue: " << m_receive_queue.size();
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
#endif
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: 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
auto unblocked_flags = Thread::FileDescriptionBlocker::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: 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
if (!((u32)unblocked_flags & (u32)Thread::FileDescriptionBlocker::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: 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
return KResult(-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: 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
return KResult(-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
}
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
ASSERT(m_can_read);
ASSERT(!m_receive_queue.is_empty());
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
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());
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
#ifdef IPV4_SOCKET_DEBUG
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
dbg() << "IPv4Socket(" << this << "): recvfrom with blocking " << packet.data.value().size() << " bytes, packets in queue: " << m_receive_queue.size();
TCP: Start working on auto-closing connections when we get FIN.
2019-03-14 14:23:32 +00:00
#endif
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
ASSERT(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) {
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#ifdef IPV4_SOCKET_DEBUG
Kernel: Remove some unnecessary .characters() when doing dbg()<<String
2020-03-01 12:23:26 +00:00
dbg() << "Incoming packet is from: " << packet.peer_address << ":" << packet.peer_port;
Net: Put a bunch of socket debug logging behind FOO_DEBUG Also remove an unused Socket::listen() implementation.
2019-10-18 14:47:29 +00:00
#endif
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))
return KResult(-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);
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
ASSERT(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))
return KResult(-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: 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 KResult(-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: 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
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, timeval& 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: 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
return KResult(-EFAULT);
if (addr_length < sizeof(sockaddr_in))
return KResult(-EINVAL);
}
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
#ifdef IPV4_SOCKET_DEBUG
Kernel: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 19:45:39 +00:00
klog() << "recvfrom: type=" << type() << ", local_port=" << 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
#endif
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: 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
bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, KBuffer&& packet, const timeval& 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
{
IPv4: More work on the TCP implementation. I can now establish a connection to my little test server on the host.
2019-03-13 23:20:44 +00:00
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: Make DoubleBuffer use a KBuffer instead of kmalloc()ing Background: DoubleBuffer is a handy buffer class in the kernel that allows you to keep writing to it from the "outside" while the "inside" reads from it. It's used for things like LocalSocket and TTY's. Internally, it has a read buffer and a write buffer, but the two will swap places when the read buffer is exhausted (by reading from it.) Before this patch, it was internally implemented as two Vector<u8> that we would swap between when the reader side had exhausted the data in the read buffer. Now instead we preallocate a large KBuffer (64KB*2) on DoubleBuffer construction and use that throughout its lifetime. This removes all the kmalloc heap traffic caused by DoubleBuffers :^)
2020-01-20 15:08:49 +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);
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
ASSERT(m_can_read);
return false;
}
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 scratch_buffer = UserOrKernelBuffer::for_kernel_buffer(m_scratch_buffer.value().data());
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
auto nreceived_or_error = protocol_receive(ReadonlyBytes { packet.data(), packet.size() }, scratch_buffer, m_scratch_buffer.value().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: 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
ssize_t nwritten = m_receive_buffer.write(scratch_buffer, nreceived_or_error.value());
if (nwritten < 0)
return false;
Kernel: Move block condition evaluation out of the Scheduler This makes the Scheduler a lot leaner by not having to evaluate block conditions every time it is invoked. Instead evaluate them as the states change, and unblock threads at that point. This also implements some more waitid/waitpid/wait features and behavior. For example, WUNTRACED and WNOWAIT are now supported. And wait will now not return EINTR when SIGCHLD is delivered at the same time.
2020-11-29 23:05:27 +00:00
set_can_read(!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: 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
m_receive_queue.append({ source_address, source_port, packet_timestamp, move(packet) });
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;
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
#ifdef IPV4_SOCKET_DEBUG
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: Use klog() instead of kprintf() Also, duplicate data in dbg() and klog() calls were removed. In addition, leakage of virtual address to kernel log is prevented. This is done by replacing kprintf() calls to dbg() calls with the leaked data instead. Also, other kprintf() calls were replaced with klog().
2020-03-01 19:45:39 +00:00
dbg() << "IPv4Socket(" << this << "): did_receive " << packet_size << " bytes, total_received=" << m_bytes_received;
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
dbg() << "IPv4Socket(" << this << "): did_receive " << packet_size << " bytes, total_received=" << m_bytes_received << ", packets in queue: " << m_receive_queue.size();
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
#endif
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:");
builder.appendf("%s:%d", m_local_address.to_string().characters(), m_local_port);
if (m_role == Role::Accepted || m_role == Role::Connected)
builder.appendf(" / %s:%d", m_peer_address.to_string().characters(), m_peer_port);
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:
ASSERT_NOT_REACHED();
}
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))
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 KResult(-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: Remove SmapDisabler in sys$setsockopt()
2020-07-30 22:26:33 +00:00
return KResult(-EFAULT);
if (value < 0 || value > 255)
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 KResult(-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
}
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:
return KResult(-ENOPROTOOPT);
}
}
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: 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
return KResult(-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
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))
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 KResult(-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))
return KResult(-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))
return KResult(-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;
default:
return KResult(-ENOPROTOOPT);
}
}
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: Use a FlatPtr for the "argument" to ioctl() Since it's often used to pass pointers, it should really be a FlatPtr.
2020-05-23 11:17:58 +00:00
int IPv4Socket::ioctl(FileDescription&, unsigned request, FlatPtr 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
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
auto ioctl_route = [request, 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;
if (!copy_from_user(&route, (rtentry*)arg))
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 -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())
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: 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 adapter = NetworkAdapter::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)
return -ENODEV;
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())
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 -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)
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 -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))
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 -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));
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 0;
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
return 0;
}
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
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 -EINVAL;
};
Kernel: Add SIOCGIFHWADDR ioctl to get the MAC address of an adapter
2019-10-02 16:20:11 +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
auto ioctl_interface = [request, 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* user_ifr = (ifreq*)arg;
ifreq ifr;
if (!copy_from_user(&ifr, user_ifr))
Kernel: Add SIOCGIFHWADDR ioctl to get the MAC address of an adapter
2019-10-02 16:20:11 +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';
auto adapter = NetworkAdapter::lookup_by_name(namebuf);
if (!adapter)
return -ENODEV;
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())
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 -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)
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 -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));
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 0;
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())
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 -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)
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 -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));
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 0;
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: {
u16 sa_family = AF_INET;
if (!copy_to_user(&user_ifr->ifr_addr.sa_family, &sa_family))
return -EFAULT;
auto ip4_addr = adapter->ipv4_address().to_u32();
if (!copy_to_user(&((sockaddr_in&)user_ifr->ifr_addr).sin_addr.s_addr, &ip4_addr, sizeof(ip4_addr)))
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 -EFAULT;
return 0;
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: 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: {
u16 sa_family = AF_INET;
if (!copy_to_user(&user_ifr->ifr_hwaddr.sa_family, &sa_family))
return -EFAULT;
auto mac_address = adapter->mac_address();
if (!copy_to_user(ifr.ifr_hwaddr.sa_data, &mac_address, sizeof(MACAddress)))
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 -EFAULT;
return 0;
Kernel: Add SIOCGIFHWADDR ioctl to get the MAC address of an adapter
2019-10-02 16:20:11 +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
return -EINVAL;
};
switch (request) {
case SIOCSIFADDR:
case SIOCSIFNETMASK:
case SIOCGIFADDR:
case SIOCGIFHWADDR:
return ioctl_interface();
case SIOCADDRT:
case SIOCDELRT:
return ioctl_route();
IPv4: Implement socket ioctls SIOCGIFADDR and SIOCSIFADDR This allows userspace programs to get and set (superuser-only) the IPv4 address of a network adapter. :^)
2019-09-23 17:06:03 +00:00
}
return -EINVAL;
}
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