mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-23 09:51:57 -05:00
Code Issues Projects Releases Packages Wiki Activity
serenity/Kernel/Net/LocalSocket.h

109 lines
4.2 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 09:38:21 +01:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
#pragma once
Kernel: Switch LocalSocket to IntrusiveList from InlineLinkedList
2021-05-26 02:38:32 -07:00
#include <AK/IntrusiveList.h>
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
#include <Kernel/DoubleBuffer.h>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 11:53:16 +02:00
#include <Kernel/Net/Socket.h>
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
Kernel: Move all code into the Kernel namespace
2020-02-16 01:27:42 +01:00
namespace Kernel {
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 09:36:51 +02:00
class FileDescription;
Kernel: More sockets work. Fleshing out accept().
2019-02-14 15:17:30 +01:00
Kernel+LibC: Implement the socketpair() syscall
2021-04-28 12:39:12 +02:00
struct SocketPair {
Kernel: Avoid file descriptor leak in Process::sys$socketpair on error Previously it was possible to leak the file descriptor if we error out after allocating the first descriptor. Now we perform both fd allocations back to back so we can handle the potential error when processing the second fd allocation.
2021-07-28 01:49:04 -07:00
NonnullRefPtr<FileDescription> description0;
Kernel+LibC: Implement the socketpair() syscall
2021-04-28 12:39:12 +02:00
NonnullRefPtr<FileDescription> description1;
};
Kernel: Switch LocalSocket to IntrusiveList from InlineLinkedList
2021-05-26 02:38:32 -07:00
class LocalSocket final : public Socket {
Kernel: More header dependency reduction work
2020-02-16 02:15:33 +01:00
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
public:
Kernel: Allow Socket subclasses to fail construction For example, socket(AF_INET) should only succeed for valid SOCK_TYPEs.
2020-01-23 18:11:14 +01:00
static KResultOr<NonnullRefPtr<Socket>> create(int type);
Kernel+LibC: Implement the socketpair() syscall
2021-04-28 12:39:12 +02:00
static KResultOr<SocketPair> create_connected_pair(int type);
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
virtual ~LocalSocket() override;
Kernel: Minor cleanups in sendfd/recvfd Applying some nice suggestions by @bugaevc. :^)
2020-06-25 10:51:30 +02:00
KResult sendfd(const FileDescription& socket_description, FileDescription& passing_description);
KResultOr<NonnullRefPtr<FileDescription>> recvfd(const FileDescription& socket_description);
Kernel+LibC: Add sys$recvfd() and sys$sendfd() for fd passing These new syscalls allow you to send and receive file descriptors over a local domain socket. This will enable various privilege separation techniques and other good stuff. :^)
2020-06-24 22:57:37 +02:00
Kernel: Use shared locking mode in some places The notable piece of code that remains to be converted is Ext2FS.
2020-04-18 12:50:35 +03:00
static void for_each(Function<void(const LocalSocket&)>);
Net: Add LocalSocket::socket_path() This is a little utility function to safely extract the path without manually dealing with sun_path and null-termination.
2019-08-10 18:55:54 +03:00
StringView socket_path() const;
Kernel: Customize absolute_path() for more file types
2019-08-10 19:10:36 +03:00
String absolute_path(const FileDescription& description) const override;
Net: Let Socket have read/write wrappers around sendto/recvfrom The situations in IPv4Socket and LocalSocket were mirrors of each other where one had implemented read/write as wrappers and the other had sendto/recvfrom as wrappers. Instead of this silliness, move read and write up to the Socket base. Then mark them final, so subclasses have no choice but to implement sendto and recvfrom.
2019-08-05 10:03:19 +02:00
// ^Socket
Kernel: Use Userspace<T> for the bind syscall, and implementation
2020-08-09 15:13:43 -07:00
virtual KResult bind(Userspace<const sockaddr*>, socklen_t) override;
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-11 21:11:07 -06:00
virtual KResult connect(FileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
AK: Make Vector use size_t for its size and capacity
2020-02-25 14:49:47 +01:00
virtual KResult listen(size_t) override;
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 23:42:28 +01:00
virtual void get_local_address(sockaddr*, socklen_t*) override;
virtual void get_peer_address(sockaddr*, socklen_t*) override;
Kernel: Improve ProcFS behavior in low memory conditions When ProcFS could no longer allocate KBuffer objects to serve calls to read, it would just return 0, indicating EOF. This then triggered parsing errors because code assumed it read the file. Because read isn't supposed to return ENOMEM, change ProcFS to populate the file data upon file open or seek to the beginning. This also means that calls to open can now return ENOMEM if needed. This allows the caller to either be able to successfully open the file and read it, or fail to open it in the first place.
2020-09-17 13:51:09 -06:00
virtual KResult attach(FileDescription&) override;
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 09:36:51 +02:00
virtual void detach(FileDescription&) override;
Kernel: Add explicit offset parameter to File::read etc
2020-04-10 19:44:42 +10:00
virtual bool can_read(const FileDescription&, size_t) const override;
virtual bool can_write(const FileDescription&, size_t) const override;
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-11 21:11:07 -06:00
virtual KResultOr<size_t> sendto(FileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
Kernel: Make sockets use AK::Time
2021-02-28 02:48:45 +01:00
virtual KResultOr<size_t> recvfrom(FileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
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 02:29:05 -07:00
virtual KResult getsockopt(FileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
Kernel: Pass a FileDescription to File::chmod() and File::chown() We're going to make use of it in the next commit. But the idea is we want to know how this File (more specifically, InodeFile) was opened in order to decide how chown()/chmod() should behave, in particular whether it should be allowed or not. Note that many other File operations, such as read(), write(), and ioctl(), already require the caller to pass a FileDescription.
2020-05-28 17:32:20 +03:00
virtual KResult chown(FileDescription&, uid_t, gid_t) override;
virtual KResult chmod(FileDescription&, mode_t) override;
Kernel: Actually send things between the socket endpoints.
2019-02-14 16:01:08 +01:00
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
private:
Kernel: Handle OOM from DoubleBuffer usage in Net/LocalSocket LocalSockets keep a DoubleBuffer for both client and server usage. This change converts the usage from using the default constructor which is unable to observe OOM, to the new try_create factory and plumb the result through the constructor.
2021-08-01 02:34:10 -07:00
explicit LocalSocket(int type, NonnullOwnPtr<DoubleBuffer> client_buffer, NonnullOwnPtr<DoubleBuffer> server_buffer);
Kernel: Make various T::class_name() and similar return StringView Instead of returning char const*, we can also give you a StringView.
2021-07-11 01:46:09 +02:00
virtual StringView class_name() const override { return "LocalSocket"; }
Kernel: More work on sockets. Fleshing out connect().
2019-02-14 15:55:19 +01:00
virtual bool is_local() const override { return true; }
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 09:36:51 +02:00
bool has_attached_peer(const FileDescription&) const;
Kernel: Don't assert when reading from a listening-mode local socket Instead just fail with EINVAL as a listening socket is never suitable for reading from. Fixes #4511.
2020-12-23 20:24:00 +01:00
DoubleBuffer* receive_buffer_for(FileDescription&);
DoubleBuffer* send_buffer_for(FileDescription&);
Kernel: Minor cleanups in sendfd/recvfd Applying some nice suggestions by @bugaevc. :^)
2020-06-25 10:51:30 +02:00
NonnullRefPtrVector<FileDescription>& sendfd_queue_for(const FileDescription&);
NonnullRefPtrVector<FileDescription>& recvfd_queue_for(const FileDescription&);
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01: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 16:05:27 -07:00
void set_connect_side_role(Role connect_side_role, bool force_evaluate_block_conditions = false)
{
auto previous = m_connect_side_role;
m_connect_side_role = connect_side_role;
if (previous != m_connect_side_role || force_evaluate_block_conditions)
evaluate_block_conditions();
}
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 16:38:20 +03:00
// An open socket file on the filesystem.
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 18:37:47 +02:00
RefPtr<FileDescription> m_file;
Kernel: More sockets work. Fleshing out accept().
2019-02-14 15:17:30 +01:00
Kernel: Allow fchmod() and fchown() on pre-bind() local sockets In order to ensure a specific owner and mode when the local socket filesystem endpoint is instantiated, we need to be able to call fchmod() and fchown() on a socket fd between socket() and bind(). This is because until we call bind(), there is no filesystem inode for the socket yet.
2020-01-03 20:14:56 +01:00
uid_t m_prebind_uid { 0 };
Kernel: Make LocalSocket pre-bind GID be gid_t (#1012)
2020-01-04 10:05:01 +01:00
gid_t m_prebind_gid { 0 };
Kernel: Allow fchmod() and fchown() on pre-bind() local sockets In order to ensure a specific owner and mode when the local socket filesystem endpoint is instantiated, we need to be able to call fchmod() and fchown() on a socket fd between socket() and bind(). This is because until we call bind(), there is no filesystem inode for the socket yet.
2020-01-03 20:14:56 +01:00
mode_t m_prebind_mode { 0 };
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 16:38:20 +03:00
// A single LocalSocket is shared between two file descriptions
// on the connect side and the accept side; so we need to store
// an additional role for the connect side and differentiate
// between them.
Role m_connect_side_role { Role::None };
FileDescription* m_connect_side_fd { nullptr };
virtual Role role(const FileDescription& description) const override
{
if (m_connect_side_fd == &description)
return m_connect_side_role;
return m_role;
}
Kernel: More sockets work. Fleshing out accept().
2019-02-14 15:17:30 +01:00
bool m_bound { false };
Net: Simplify how LocalSocket tracks open fds Now that there can't be multiple clones of the same fd, we only need to track whether or not an fd exists on each side. Also there's no point in tracking connecting fds.
2019-08-11 16:28:18 +03:00
bool m_accept_side_fd_open { false };
Kernel: Zero-initialize LocalSocket::m_address It was possible to read uninitialized kernel memory via getsockname(). Of course, kmalloc() is a good boy and scrubs new allocations with 0xBB so all you got was a bunch of 0xBB.
2020-01-26 09:33:47 +01:00
sockaddr_un m_address { 0, { 0 } };
Kernel: More sockets work. Fleshing out accept().
2019-02-14 15:17:30 +01:00
Kernel: Handle OOM from DoubleBuffer usage in Net/LocalSocket LocalSockets keep a DoubleBuffer for both client and server usage. This change converts the usage from using the default constructor which is unable to observe OOM, to the new try_create factory and plumb the result through the constructor.
2021-08-01 02:34:10 -07:00
NonnullOwnPtr<DoubleBuffer> m_for_client;
NonnullOwnPtr<DoubleBuffer> m_for_server;
Net: Store all the LocalSockets in an InlineLinkedList
2019-08-10 18:58:06 +03:00
Kernel+LibC: Add sys$recvfd() and sys$sendfd() for fd passing These new syscalls allow you to send and receive file descriptors over a local domain socket. This will enable various privilege separation techniques and other good stuff. :^)
2020-06-24 22:57:37 +02:00
NonnullRefPtrVector<FileDescription> m_fds_for_client;
NonnullRefPtrVector<FileDescription> m_fds_for_server;
Kernel: Switch LocalSocket to IntrusiveList from InlineLinkedList
2021-05-26 02:38:32 -07:00
IntrusiveListNode<LocalSocket> m_list_node;
public:
using List = IntrusiveList<LocalSocket, RawPtr<LocalSocket>, &LocalSocket::m_list_node>;
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 14:17:38 +01:00
};
Kernel: Move all code into the Kernel namespace
2020-02-16 01:27:42 +01:00
}
Reference in a new issue Copy permalink