Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibCore/Stream.h

957 lines
34 KiB
C
Raw Normal View History

LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
/*
* Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
Libraries: Use default constructors/destructors in LibCore https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-02-26 09:09:45 -07:00
* Copyright (c) 2022, the SerenityOS developers.
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/EnumBits.h>
#include <AK/Function.h>
#include <AK/IPv4Address.h>
LibCore: Rewrite BufferedStream::read_until_any_of() with memmem This function used to sometimes return the entire input instead of the value up to the delimiter, fix that and rewrite it to be a bit more readable.
2022-02-02 19:06:51 +03:30
#include <AK/MemMem.h>
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
#include <AK/Noncopyable.h>
#include <AK/Result.h>
#include <AK/Span.h>
#include <AK/String.h>
LibCore: Add a timeout option to UDPSocket::connect This allows us to set a timeout during connection and during receive and send operations. I didn't add this to the other connect calls as it's not used anywhere else for the time being.
2022-02-06 16:40:12 +00:00
#include <AK/Time.h>
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
#include <AK/Variant.h>
#include <LibCore/Notifier.h>
#include <LibCore/SocketAddress.h>
#include <errno.h>
#include <netdb.h>
namespace Core::Stream {
/// The base, abstract class for stream operations. This class defines the
/// operations one can perform on every stream in LibCore.
class Stream {
public:
virtual bool is_readable() const { return false; }
/// Reads into a buffer, with the maximum size being the size of the buffer.
/// The amount of bytes read can be smaller than the size of the buffer.
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
/// Returns either the bytes that were read, or an errno in the case of
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
/// failure.
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes) = 0;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
/// Tries to fill the entire buffer through reading. Returns whether the
/// buffer was filled without an error.
virtual bool read_or_error(Bytes);
LibCore: Add documentation to Stream functions + make parameter clearer file_size was not very clear about what it was being used for, so I switched it to say expected_file_size to make it clear that it's just a heuristic.
2022-09-14 19:44:53 +00:00
/// Reads the stream until EOF, storing the contents into a ByteBuffer which
/// is returned once EOF is encountered. The block size determines the size
/// of newly allocated chunks while reading.
LibCore: Avoid some successive allocations in Stream::read_all() For the general case, allocations will always have the size of a block. In case of a smaller read a block will be filled entirely before another allocation appends. It also adds a specialization for Stream::File::read_all() that tries to detect the size of the file with fstat to perform a single allocation.
2022-02-27 12:57:31 +01:00
virtual ErrorOr<ByteBuffer> read_all(size_t block_size = 4096);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual bool is_writable() const { return false; }
/// Tries to write the entire contents of the buffer. It is possible for
/// less than the full buffer to be written. Returns either the amount of
/// bytes written into the stream, or an errno in the case of failure.
virtual ErrorOr<size_t> write(ReadonlyBytes) = 0;
/// Same as write, but does not return until either the entire buffer
/// contents are written or an error occurs. Returns whether the entire
/// contents were written without an error.
virtual bool write_or_error(ReadonlyBytes);
/// Returns whether the stream has reached the end of file. For sockets,
/// this most likely means that the protocol has disconnected (in the case
/// of TCP). For seekable streams, this means the end of the file. Note that
/// is_eof will only return true _after_ a read with 0 length, so this
/// method should be called after a read.
virtual bool is_eof() const = 0;
virtual bool is_open() const = 0;
virtual void close() = 0;
virtual ~Stream()
{
}
LibCore: Avoid some successive allocations in Stream::read_all() For the general case, allocations will always have the size of a block. In case of a smaller read a block will be filled entirely before another allocation appends. It also adds a specialization for Stream::File::read_all() that tries to detect the size of the file with fstat to perform a single allocation.
2022-02-27 12:57:31 +01:00
protected:
LibCore: Add documentation to Stream functions + make parameter clearer file_size was not very clear about what it was being used for, so I switched it to say expected_file_size to make it clear that it's just a heuristic.
2022-09-14 19:44:53 +00:00
/// Provides a default implementation of read_all that works for streams
/// that behave like POSIX file descriptors. expected_file_size can be
/// passed as a heuristic for what the Stream subclass expects the file
/// content size to be in order to reduce allocations (does not affect
/// actual reading).
ErrorOr<ByteBuffer> read_all_impl(size_t block_size, size_t expected_file_size = 0);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
};
enum class SeekMode {
SetPosition,
FromCurrentPosition,
FromEndPosition,
};
/// Adds seekability to Core::Stream. Classes inheriting from SeekableStream
/// will be seekable to any point in the stream.
class SeekableStream : public Stream {
public:
/// Seeks to the given position in the given mode. Returns either the
/// current position of the file, or an errno in the case of an error.
virtual ErrorOr<off_t> seek(i64 offset, SeekMode) = 0;
/// Returns the current position of the file, or an errno in the case of
/// an error.
virtual ErrorOr<off_t> tell() const;
/// Returns the total size of the stream, or an errno in the case of an
/// error. May not preserve the original position on the stream on failure.
virtual ErrorOr<off_t> size();
LibCore+Tests: Add SeekableStream::truncate()
2022-02-03 19:21:51 +00:00
/// Shrinks or extends the stream to the given size. Returns an errno in
/// the case of an error.
virtual ErrorOr<void> truncate(off_t length) = 0;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
};
/// The Socket class is the base class for all concrete BSD-style socket
/// classes. Sockets are non-seekable streams which can be read byte-wise.
class Socket : public Stream {
public:
Socket(Socket&&) = default;
Socket& operator=(Socket&&) = default;
/// Checks how many bytes of data are currently available to read on the
/// socket. For datagram-based socket, this is the size of the first
/// datagram that can be read. Returns either the amount of bytes, or an
/// errno in the case of failure.
virtual ErrorOr<size_t> pending_bytes() const = 0;
/// Returns whether there's any data that can be immediately read, or an
/// errno on failure.
virtual ErrorOr<bool> can_read_without_blocking(int timeout = 0) const = 0;
// Sets the blocking mode of the socket. If blocking mode is disabled, reads
// will fail with EAGAIN when there's no data available to read, and writes
// will fail with EAGAIN when the data cannot be written without blocking
// (due to the send buffer being full, for example).
virtual ErrorOr<void> set_blocking(bool enabled) = 0;
// Sets the close-on-exec mode of the socket. If close-on-exec mode is
// enabled, then the socket will be automatically closed by the kernel when
// an exec call happens.
virtual ErrorOr<void> set_close_on_exec(bool enabled) = 0;
LibCore: Add Core::Stream::Socket::set_notifications_enabled() This is equivalent to Core::Socket::set_notifications_enabled(), and serves to disable the on_ready_to_read() notifications, as the sockets often implement these using the event loop, this method can help avoid waking the event loop and spamming useless calls to on_ready_to_read().
2022-02-01 03:15:44 +03:30
/// Disables any listening mechanisms that this socket uses.
/// Can be called with 'false' when `on_ready_to_read` notifications are no longer needed.
/// Conversely, set_notifications_enabled(true) will re-enable notifications.
virtual void set_notifications_enabled(bool) { }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
Function<void()> on_ready_to_read;
protected:
enum class SocketDomain {
Local,
Inet,
};
enum class SocketType {
Stream,
Datagram,
};
Socket()
{
}
static ErrorOr<int> create_fd(SocketDomain, SocketType);
// FIXME: This will need to be updated when IPv6 socket arrives. Perhaps a
// base class for all address types is appropriate.
LibCore: Remove the SocketError class SocketError is a relic from the KResult days when we couldn't have a string in the KResult type, only an errno. Now that we can use string literals with Error, it's no longer necessary. gai_strerror is thread safe, so we can use it here unlike strerror.
2021-12-18 11:37:22 +00:00
static ErrorOr<IPv4Address> resolve_host(String const&, SocketType);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
static ErrorOr<void> connect_local(int fd, String const& path);
static ErrorOr<void> connect_inet(int fd, SocketAddress const&);
};
/// A reusable socket maintains state about being connected in addition to
/// normal Socket capabilities, and can be reconnected once disconnected.
class ReusableSocket : public Socket {
public:
/// Returns whether the socket is currently connected.
virtual bool is_connected() = 0;
/// Reconnects the socket to the given host and port. Returns EALREADY if
/// is_connected() is true.
LibCore: Remove the SocketError class SocketError is a relic from the KResult days when we couldn't have a string in the KResult type, only an errno. Now that we can use string literals with Error, it's no longer necessary. gai_strerror is thread safe, so we can use it here unlike strerror.
2021-12-18 11:37:22 +00:00
virtual ErrorOr<void> reconnect(String const& host, u16 port) = 0;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
/// Connects the socket to the given socket address (IP address + port).
/// Returns EALREADY is_connected() is true.
virtual ErrorOr<void> reconnect(SocketAddress const&) = 0;
};
// Concrete classes.
enum class OpenMode : unsigned {
NotOpen = 0,
Read = 1,
Write = 2,
ReadWrite = 3,
Append = 4,
Truncate = 8,
MustBeNew = 16,
KeepOnExec = 32,
Nonblocking = 64,
};
AK_ENUM_BITWISE_OPERATORS(OpenMode)
class File final : public SeekableStream {
AK_MAKE_NONCOPYABLE(File);
public:
LibCore: Take StringViews by value in Stream::* function arguments
2022-02-05 20:18:07 +03:30
static ErrorOr<NonnullOwnPtr<File>> open(StringView filename, OpenMode, mode_t = 0644);
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<File>> adopt_fd(int fd, OpenMode);
LibCore: Add Core::Stream::File::exists()
2022-05-15 10:36:19 -05:00
static bool exists(StringView filename);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore: Add File::open_file_or_standard_stream()
2022-08-22 13:24:56 +02:00
static ErrorOr<NonnullOwnPtr<File>> open_file_or_standard_stream(StringView filename, OpenMode mode);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
File(File&& other) { operator=(move(other)); }
File& operator=(File&& other)
{
if (&other == this)
return *this;
m_mode = exchange(other.m_mode, OpenMode::NotOpen);
m_fd = exchange(other.m_fd, -1);
m_last_read_was_eof = exchange(other.m_last_read_was_eof, false);
return *this;
}
virtual bool is_readable() const override;
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes) override;
LibCore: Avoid some successive allocations in Stream::read_all() For the general case, allocations will always have the size of a block. In case of a smaller read a block will be filled entirely before another allocation appends. It also adds a specialization for Stream::File::read_all() that tries to detect the size of the file with fstat to perform a single allocation.
2022-02-27 12:57:31 +01:00
virtual ErrorOr<ByteBuffer> read_all(size_t block_size = 4096) override;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual bool is_writable() const override;
virtual ErrorOr<size_t> write(ReadonlyBytes) override;
virtual bool is_eof() const override;
virtual bool is_open() const override;
virtual void close() override;
virtual ErrorOr<off_t> seek(i64 offset, SeekMode) override;
LibCore+Tests: Add SeekableStream::truncate()
2022-02-03 19:21:51 +00:00
virtual ErrorOr<void> truncate(off_t length) override;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual ~File() override { close(); }
LibCore: Extract Stream::OpenMode conversion helper into static function
2022-04-10 18:17:31 +02:00
static int open_mode_to_options(OpenMode mode);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
private:
File(OpenMode mode)
: m_mode(mode)
{
}
LibCore: Take StringViews by value in Stream::* function arguments
2022-02-05 20:18:07 +03:30
ErrorOr<void> open_path(StringView filename, mode_t);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
OpenMode m_mode { OpenMode::NotOpen };
int m_fd { -1 };
bool m_last_read_was_eof { false };
};
class PosixSocketHelper {
AK_MAKE_NONCOPYABLE(PosixSocketHelper);
public:
template<typename T>
PosixSocketHelper(Badge<T>) requires(IsBaseOf<Socket, T>) { }
PosixSocketHelper(PosixSocketHelper&& other)
{
operator=(move(other));
}
PosixSocketHelper& operator=(PosixSocketHelper&& other)
{
m_fd = exchange(other.m_fd, -1);
m_last_read_was_eof = exchange(other.m_last_read_was_eof, false);
m_notifier = move(other.m_notifier);
return *this;
}
int fd() const { return m_fd; }
void set_fd(int fd) { m_fd = fd; }
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
ErrorOr<Bytes> read(Bytes, int flags = 0);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
ErrorOr<size_t> write(ReadonlyBytes);
bool is_eof() const { return !is_open() || m_last_read_was_eof; }
bool is_open() const { return m_fd != -1; }
void close();
ErrorOr<size_t> pending_bytes() const;
ErrorOr<bool> can_read_without_blocking(int timeout) const;
ErrorOr<void> set_blocking(bool enabled);
ErrorOr<void> set_close_on_exec(bool enabled);
LibCore: Add a timeout option to UDPSocket::connect This allows us to set a timeout during connection and during receive and send operations. I didn't add this to the other connect calls as it's not used anywhere else for the time being.
2022-02-06 16:40:12 +00:00
ErrorOr<void> set_receive_timeout(Time timeout);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
void setup_notifier();
RefPtr<Core::Notifier> notifier() { return m_notifier; }
private:
int m_fd { -1 };
bool m_last_read_was_eof { false };
RefPtr<Core::Notifier> m_notifier;
};
class TCPSocket final : public Socket {
public:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<TCPSocket>> connect(String const& host, u16 port);
static ErrorOr<NonnullOwnPtr<TCPSocket>> connect(SocketAddress const& address);
static ErrorOr<NonnullOwnPtr<TCPSocket>> adopt_fd(int fd);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
TCPSocket(TCPSocket&& other)
: Socket(static_cast<Socket&&>(other))
, m_helper(move(other.m_helper))
{
if (is_open())
setup_notifier();
}
TCPSocket& operator=(TCPSocket&& other)
{
Socket::operator=(static_cast<Socket&&>(other));
m_helper = move(other.m_helper);
if (is_open())
setup_notifier();
return *this;
}
virtual bool is_readable() const override { return is_open(); }
virtual bool is_writable() const override { return is_open(); }
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(buffer); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual ErrorOr<size_t> write(ReadonlyBytes buffer) override { return m_helper.write(buffer); }
virtual bool is_eof() const override { return m_helper.is_eof(); }
virtual bool is_open() const override { return m_helper.is_open(); };
virtual void close() override { m_helper.close(); };
virtual ErrorOr<size_t> pending_bytes() const override { return m_helper.pending_bytes(); }
virtual ErrorOr<bool> can_read_without_blocking(int timeout = 0) const override { return m_helper.can_read_without_blocking(timeout); }
LibCore: Add Core::Stream::Socket::set_notifications_enabled() This is equivalent to Core::Socket::set_notifications_enabled(), and serves to disable the on_ready_to_read() notifications, as the sockets often implement these using the event loop, this method can help avoid waking the event loop and spamming useless calls to on_ready_to_read().
2022-02-01 03:15:44 +03:30
virtual void set_notifications_enabled(bool enabled) override
{
if (auto notifier = m_helper.notifier())
notifier->set_enabled(enabled);
}
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
ErrorOr<void> set_blocking(bool enabled) override { return m_helper.set_blocking(enabled); }
ErrorOr<void> set_close_on_exec(bool enabled) override { return m_helper.set_close_on_exec(enabled); }
virtual ~TCPSocket() override { close(); }
private:
TCPSocket()
{
}
void setup_notifier()
{
VERIFY(is_open());
m_helper.setup_notifier();
m_helper.notifier()->on_ready_to_read = [this] {
if (on_ready_to_read)
on_ready_to_read();
};
}
PosixSocketHelper m_helper { Badge<TCPSocket> {} };
};
class UDPSocket final : public Socket {
public:
LibCore: Add a timeout option to UDPSocket::connect This allows us to set a timeout during connection and during receive and send operations. I didn't add this to the other connect calls as it's not used anywhere else for the time being.
2022-02-06 16:40:12 +00:00
static ErrorOr<NonnullOwnPtr<UDPSocket>> connect(String const& host, u16 port, Optional<Time> timeout = {});
static ErrorOr<NonnullOwnPtr<UDPSocket>> connect(SocketAddress const& address, Optional<Time> timeout = {});
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
UDPSocket(UDPSocket&& other)
: Socket(static_cast<Socket&&>(other))
, m_helper(move(other.m_helper))
{
if (is_open())
setup_notifier();
}
UDPSocket& operator=(UDPSocket&& other)
{
Socket::operator=(static_cast<Socket&&>(other));
m_helper = move(other.m_helper);
if (is_open())
setup_notifier();
return *this;
}
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes buffer) override
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
auto pending_bytes = TRY(this->pending_bytes());
if (pending_bytes > buffer.size()) {
// With UDP datagrams, reading a datagram into a buffer that's
// smaller than the datagram's size will cause the rest of the
// datagram to be discarded. That's not very nice, so let's bail
// early, telling the caller that he should allocate a bigger
// buffer.
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(EMSGSIZE);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
return m_helper.read(buffer);
}
virtual bool is_readable() const override { return is_open(); }
virtual bool is_writable() const override { return is_open(); }
virtual ErrorOr<size_t> write(ReadonlyBytes buffer) override { return m_helper.write(buffer); }
virtual bool is_eof() const override { return m_helper.is_eof(); }
virtual bool is_open() const override { return m_helper.is_open(); }
virtual void close() override { m_helper.close(); }
virtual ErrorOr<size_t> pending_bytes() const override { return m_helper.pending_bytes(); }
virtual ErrorOr<bool> can_read_without_blocking(int timeout = 0) const override { return m_helper.can_read_without_blocking(timeout); }
LibCore: Add Core::Stream::Socket::set_notifications_enabled() This is equivalent to Core::Socket::set_notifications_enabled(), and serves to disable the on_ready_to_read() notifications, as the sockets often implement these using the event loop, this method can help avoid waking the event loop and spamming useless calls to on_ready_to_read().
2022-02-01 03:15:44 +03:30
virtual void set_notifications_enabled(bool enabled) override
{
if (auto notifier = m_helper.notifier())
notifier->set_enabled(enabled);
}
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
ErrorOr<void> set_blocking(bool enabled) override { return m_helper.set_blocking(enabled); }
ErrorOr<void> set_close_on_exec(bool enabled) override { return m_helper.set_close_on_exec(enabled); }
virtual ~UDPSocket() override { close(); }
private:
Libraries: Use default constructors/destructors in LibCore https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-02-26 09:09:45 -07:00
UDPSocket() = default;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
void setup_notifier()
{
VERIFY(is_open());
m_helper.setup_notifier();
m_helper.notifier()->on_ready_to_read = [this] {
if (on_ready_to_read)
on_ready_to_read();
};
}
PosixSocketHelper m_helper { Badge<UDPSocket> {} };
};
class LocalSocket final : public Socket {
public:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<LocalSocket>> connect(String const& path);
LibCore: Implement LocalSocket::adopt_fd Similar to File::adopt_fd, this function creates a new LocalSocket with an existing fd. The main use of this function is to create LocalSocket objects from fds that have been passed to us by SystemServer to take over.
2022-01-14 13:24:01 +00:00
static ErrorOr<NonnullOwnPtr<LocalSocket>> adopt_fd(int fd);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LocalSocket(LocalSocket&& other)
: Socket(static_cast<Socket&&>(other))
, m_helper(move(other.m_helper))
{
if (is_open())
setup_notifier();
}
LocalSocket& operator=(LocalSocket&& other)
{
Socket::operator=(static_cast<Socket&&>(other));
m_helper = move(other.m_helper);
if (is_open())
setup_notifier();
return *this;
}
virtual bool is_readable() const override { return is_open(); }
virtual bool is_writable() const override { return is_open(); }
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(buffer); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual ErrorOr<size_t> write(ReadonlyBytes buffer) override { return m_helper.write(buffer); }
virtual bool is_eof() const override { return m_helper.is_eof(); }
virtual bool is_open() const override { return m_helper.is_open(); }
virtual void close() override { m_helper.close(); }
virtual ErrorOr<size_t> pending_bytes() const override { return m_helper.pending_bytes(); }
virtual ErrorOr<bool> can_read_without_blocking(int timeout = 0) const override { return m_helper.can_read_without_blocking(timeout); }
virtual ErrorOr<void> set_blocking(bool enabled) override { return m_helper.set_blocking(enabled); }
virtual ErrorOr<void> set_close_on_exec(bool enabled) override { return m_helper.set_close_on_exec(enabled); }
LibCore: Add Core::Stream::Socket::set_notifications_enabled() This is equivalent to Core::Socket::set_notifications_enabled(), and serves to disable the on_ready_to_read() notifications, as the sockets often implement these using the event loop, this method can help avoid waking the event loop and spamming useless calls to on_ready_to_read().
2022-02-01 03:15:44 +03:30
virtual void set_notifications_enabled(bool enabled) override
{
if (auto notifier = m_helper.notifier())
notifier->set_enabled(enabled);
}
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore: Implement LocalSocket::receive_fd and send_fd These are just wrappers over the sendfd and recvfd syscalls.
2022-01-13 21:21:16 +00:00
ErrorOr<int> receive_fd(int flags);
ErrorOr<void> send_fd(int fd);
LibCore: Implement LocalSocket::peer_pid Mostly a copy of Core::LocalSocket::peer_pid.
2022-01-14 13:25:37 +00:00
ErrorOr<pid_t> peer_pid() const;
LibCore+LibIPC: Make Core::Stream read_without_waiting() return Bytes For the reasoning, see the earlier commit about Core::Stream::read().
2022-04-15 15:11:11 +01:00
ErrorOr<Bytes> read_without_waiting(Bytes buffer);
LibCore: Implement LocalSocket::receive_fd and send_fd These are just wrappers over the sendfd and recvfd syscalls.
2022-01-13 21:21:16 +00:00
LibCore: Implement LocalSocket::release_fd release_fd() releases the fd associated with the LocalSocket it is called on. This is analogous to release_value() on container objects in AK, after which the object does not contain the value.
2022-01-15 12:10:04 +00:00
/// Release the fd associated with this LocalSocket. After the fd is
/// released, the socket will be considered "closed" and all operations done
/// on it will fail with ENOTCONN. Fails with ENOTCONN if the socket is
/// already closed.
ErrorOr<int> release_fd();
LibCore: Add fd() and notifier() accessors to Core::Stream::LocalSocket
2022-10-05 15:28:05 +02:00
Optional<int> fd() const;
RefPtr<Core::Notifier> notifier() { return m_helper.notifier(); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual ~LocalSocket() { close(); }
private:
Libraries: Use default constructors/destructors in LibCore https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-02-26 09:09:45 -07:00
LocalSocket() = default;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
void setup_notifier()
{
VERIFY(is_open());
m_helper.setup_notifier();
m_helper.notifier()->on_ready_to_read = [this] {
if (on_ready_to_read)
on_ready_to_read();
};
}
PosixSocketHelper m_helper { Badge<LocalSocket> {} };
};
// Buffered stream wrappers
template<typename T>
concept StreamLike = IsBaseOf<Stream, T>;
template<typename T>
concept SeekableStreamLike = IsBaseOf<SeekableStream, T>;
template<typename T>
concept SocketLike = IsBaseOf<Socket, T>;
template<typename T>
class BufferedHelper {
AK_MAKE_NONCOPYABLE(BufferedHelper);
public:
template<StreamLike U>
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
BufferedHelper(Badge<U>, NonnullOwnPtr<T> stream, ByteBuffer buffer)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
: m_stream(move(stream))
, m_buffer(move(buffer))
{
}
BufferedHelper(BufferedHelper&& other)
: m_stream(move(other.m_stream))
, m_buffer(move(other.m_buffer))
, m_buffered_size(exchange(other.m_buffered_size, 0))
{
}
BufferedHelper& operator=(BufferedHelper&& other)
{
m_stream = move(other.m_stream);
m_buffer = move(other.m_buffer);
m_buffered_size = exchange(other.m_buffered_size, 0);
return *this;
}
template<template<typename> typename BufferedType>
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<BufferedType<T>>> create_buffered(NonnullOwnPtr<T> stream, size_t buffer_size)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
if (!buffer_size)
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(EINVAL);
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
if (!stream->is_open())
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(ENOTCONN);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
Everywhere: Convert ByteBuffer factory methods from Optional -> ErrorOr Apologies for the enormous commit, but I don't see a way to split this up nicely. In the vast majority of cases it's a simple change. A few extra places can use TRY instead of manual error checking though. :^)
2022-01-20 17:47:39 +00:00
auto buffer = TRY(ByteBuffer::create_uninitialized(buffer_size));
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
Everywhere: Convert ByteBuffer factory methods from Optional -> ErrorOr Apologies for the enormous commit, but I don't see a way to split this up nicely. In the vast majority of cases it's a simple change. A few extra places can use TRY instead of manual error checking though. :^)
2022-01-20 17:47:39 +00:00
return adopt_nonnull_own_or_enomem(new BufferedType<T>(move(stream), move(buffer)));
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
T& stream() { return *m_stream; }
T const& stream() const { return *m_stream; }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
ErrorOr<Bytes> read(Bytes buffer)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
if (!stream().is_open())
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(ENOTCONN);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
if (!buffer.size())
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(ENOBUFS);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore: Make BufferedHelper::read() block at most once per read The previous method could block multiple times, leading to a completely stuck/deadlocked read() call, and it could also consume data without telling the user about it, which is Not A Good Thing :tm:. This patch makes it block at most once, and fixes loading HTTP pages with LibHTTP :^)
2022-02-08 15:01:09 +03:30
// Fill the internal buffer if it has run dry.
if (m_buffered_size == 0)
TRY(populate_read_buffer());
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
// Let's try to take all we can from the buffer first.
size_t buffer_nread = 0;
if (m_buffered_size > 0) {
// FIXME: Use a circular buffer to avoid shifting the buffer
// contents.
size_t amount_to_take = min(buffer.size(), m_buffered_size);
auto slice_to_take = m_buffer.span().slice(0, amount_to_take);
auto slice_to_shift = m_buffer.span().slice(amount_to_take);
slice_to_take.copy_to(buffer);
buffer_nread += amount_to_take;
if (amount_to_take < m_buffered_size) {
m_buffer.overwrite(0, slice_to_shift.data(), m_buffered_size - amount_to_take);
}
m_buffered_size -= amount_to_take;
}
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
return Bytes { buffer.data(), buffer_nread };
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
// Reads into the buffer until \n is encountered.
// The size of the Bytes object is the maximum amount of bytes that will be
LibCore+Everywhere: Make Core::Stream read_line() return StringView Similar reasoning to making Core::Stream::read() return Bytes, except that every user of read_line() creates a StringView from the result, so let's just return one right away.
2022-04-15 14:52:33 +01:00
// read. Returns the bytes read as a StringView.
ErrorOr<StringView> read_line(Bytes buffer)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
LibCore+Everywhere: Make Core::Stream read_line() return StringView Similar reasoning to making Core::Stream::read() return Bytes, except that every user of read_line() creates a StringView from the result, so let's just return one right away.
2022-04-15 14:52:33 +01:00
return StringView { TRY(read_until(buffer, "\n"sv)) };
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
ErrorOr<Bytes> read_until(Bytes buffer, StringView candidate)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
return read_until_any_of(buffer, Array { candidate });
}
template<size_t N>
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
ErrorOr<Bytes> read_until_any_of(Bytes buffer, Array<StringView, N> candidates)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
if (!stream().is_open())
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(ENOTCONN);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
if (buffer.is_empty())
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(ENOBUFS);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
// We fill the buffer through can_read_line.
if (!TRY(can_read_line()))
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
return Bytes {};
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
if (stream().is_eof()) {
if (buffer.size() < m_buffered_size) {
// Normally, reading from an EOFed stream and receiving bytes
// would mean that the stream is no longer EOF. However, it's
// possible with a buffered stream that the user is able to read
// the buffer contents even when the underlying stream is EOF.
// We already violate this invariant once by giving the user the
// chance to read the remaining buffer contents, but if the user
// doesn't give us a big enough buffer, then we would be
// violating the invariant twice the next time the user attempts
// to read, which is No Good. So let's give a descriptive error
// to the caller about why it can't read.
LibCore: Use Error::from_errno in Stream APIs This makes Stream APIs work with Lagom and is overall cleaner.
2021-12-29 23:13:11 +00:00
return Error::from_errno(EMSGSIZE);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
}
LibCore: Rewrite BufferedStream::read_until_any_of() with memmem This function used to sometimes return the entire input instead of the value up to the delimiter, fix that and rewrite it to be a bit more readable.
2022-02-02 19:06:51 +03:30
// The intention here is to try to match all of the possible
// delimiter candidates and try to find the longest one we can
// remove from the buffer after copying up to the delimiter to the
// user buffer.
Optional<size_t> longest_match;
size_t match_size = 0;
for (auto& candidate : candidates) {
auto result = AK::memmem_optional(m_buffer.data(), m_buffered_size, candidate.bytes().data(), candidate.bytes().size());
if (result.has_value()) {
auto previous_match = longest_match.value_or(*result);
if ((previous_match < *result) || (previous_match == *result && match_size < candidate.length())) {
longest_match = result;
match_size = candidate.length();
}
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
LibCore: Rewrite BufferedStream::read_until_any_of() with memmem This function used to sometimes return the entire input instead of the value up to the delimiter, fix that and rewrite it to be a bit more readable.
2022-02-02 19:06:51 +03:30
}
if (longest_match.has_value()) {
auto size_written_to_user_buffer = *longest_match;
auto buffer_to_take = m_buffer.span().slice(0, size_written_to_user_buffer);
auto buffer_to_shift = m_buffer.span().slice(size_written_to_user_buffer + match_size);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore: Rewrite BufferedStream::read_until_any_of() with memmem This function used to sometimes return the entire input instead of the value up to the delimiter, fix that and rewrite it to be a bit more readable.
2022-02-02 19:06:51 +03:30
buffer_to_take.copy_to(buffer);
m_buffer.overwrite(0, buffer_to_shift.data(), buffer_to_shift.size());
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore: Rewrite BufferedStream::read_until_any_of() with memmem This function used to sometimes return the entire input instead of the value up to the delimiter, fix that and rewrite it to be a bit more readable.
2022-02-02 19:06:51 +03:30
m_buffered_size -= size_written_to_user_buffer + match_size;
LibCore: Fix OOB read in Stream::BufferedSeekable::read_until_any_of If we do not decrement `m_buffered_size` whenever we read data from the buffer, we end up saying that there are more lines available when we reach the end of file. This bug caused callers to read garbage data. This also fixes an incorrect condition in an if statement. The separator candidate is searched for in `remaining_buffer`, so the separator's length should be compared against that.
2021-12-31 21:04:56 +01:00
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
return buffer.slice(0, size_written_to_user_buffer);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
// If we still haven't found anything, then it's most likely the case
// that the delimiter ends beyond the length of the caller-passed
// buffer. Let's just fill the caller's buffer up.
auto readable_size = min(m_buffered_size, buffer.size());
auto buffer_to_take = m_buffer.span().slice(0, readable_size);
auto buffer_to_shift = m_buffer.span().slice(readable_size);
buffer_to_take.copy_to(buffer);
m_buffer.overwrite(0, buffer_to_shift.data(), buffer_to_shift.size());
LibCore: Fix OOB read in Stream::BufferedSeekable::read_until_any_of If we do not decrement `m_buffered_size` whenever we read data from the buffer, we end up saying that there are more lines available when we reach the end of file. This bug caused callers to read garbage data. This also fixes an incorrect condition in an if statement. The separator candidate is searched for in `remaining_buffer`, so the separator's length should be compared against that.
2021-12-31 21:04:56 +01:00
m_buffered_size -= readable_size;
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
return buffer.slice(0, readable_size);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
// Returns whether a line can be read, populating the buffer in the process.
ErrorOr<bool> can_read_line()
{
if (stream().is_eof() && m_buffered_size > 0)
return true;
if (m_buffer.span().slice(0, m_buffered_size).contains_slow('\n'))
return true;
if (!stream().is_readable())
return false;
while (m_buffered_size < m_buffer.size()) {
auto populated_slice = TRY(populate_read_buffer());
if (stream().is_eof()) {
// We give the user one last hurrah to read the remaining
// contents as a "line".
return m_buffered_size > 0;
}
if (populated_slice.contains_slow('\n'))
return true;
LibCore: Stop buffering when a zero-size slice is read regardless of EOF The meaning of EOF depends on the underlying socket, but an empty slice should terminate the buffering (otherwise we'd just spin forever).
2022-02-02 19:09:05 +03:30
if (populated_slice.is_empty())
break;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
return false;
}
bool is_eof() const
{
if (m_buffered_size > 0) {
return false;
}
return stream().is_eof();
}
size_t buffer_size() const
{
return m_buffer.size();
}
LibCore: Make sure BufferedSocket takes the buffer into account pending_bytes() and can_read_without_blocking() should also take the buffered data into account, otherwise we'll end up pretending that the socket cannot be read from while it has buffered data.
2022-02-02 19:21:37 +03:30
size_t buffered_data_size() const
{
return m_buffered_size;
}
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
void clear_buffer()
{
m_buffered_size = 0;
}
private:
ErrorOr<ReadonlyBytes> populate_read_buffer()
{
if (m_buffered_size == m_buffer.size())
return ReadonlyBytes {};
auto fillable_slice = m_buffer.span().slice(m_buffered_size);
LibCore: Make BufferedHelper::read() block at most once per read The previous method could block multiple times, leading to a completely stuck/deadlocked read() call, and it could also consume data without telling the user about it, which is Not A Good Thing :tm:. This patch makes it block at most once, and fixes loading HTTP pages with LibHTTP :^)
2022-02-08 15:01:09 +03:30
size_t nread = 0;
do {
auto result = stream().read(fillable_slice);
if (result.is_error()) {
if (!result.error().is_errno())
return result.error();
if (result.error().code() == EINTR)
continue;
if (result.error().code() == EAGAIN)
break;
return result.error();
}
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
auto read_size = result.value().size();
LibCore: Make BufferedHelper::read() block at most once per read The previous method could block multiple times, leading to a completely stuck/deadlocked read() call, and it could also consume data without telling the user about it, which is Not A Good Thing :tm:. This patch makes it block at most once, and fixes loading HTTP pages with LibHTTP :^)
2022-02-08 15:01:09 +03:30
m_buffered_size += read_size;
nread += read_size;
break;
} while (true);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
return fillable_slice.slice(0, nread);
}
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
NonnullOwnPtr<T> m_stream;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
// FIXME: Replacing this with a circular buffer would be really nice and
// would avoid excessive copies; however, right now
// AK::CircularDuplexBuffer inlines its entire contents, and that
// would make for a very large object on the stack.
//
// The proper fix is to make a CircularQueue which uses a buffer on
// the heap.
ByteBuffer m_buffer;
size_t m_buffered_size { 0 };
};
// NOTE: A Buffered which accepts any Stream could be added here, but it is not
// needed at the moment.
template<SeekableStreamLike T>
class BufferedSeekable final : public SeekableStream {
friend BufferedHelper<T>;
public:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<BufferedSeekable<T>>> create(NonnullOwnPtr<T> stream, size_t buffer_size = 16384)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
return BufferedHelper<T>::template create_buffered<BufferedSeekable>(move(stream), buffer_size);
}
BufferedSeekable(BufferedSeekable&& other) = default;
BufferedSeekable& operator=(BufferedSeekable&& other) = default;
virtual bool is_readable() const override { return m_helper.stream().is_readable(); }
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(move(buffer)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual bool is_writable() const override { return m_helper.stream().is_writable(); }
virtual ErrorOr<size_t> write(ReadonlyBytes buffer) override { return m_helper.stream().write(buffer); }
virtual bool is_eof() const override { return m_helper.is_eof(); }
virtual bool is_open() const override { return m_helper.stream().is_open(); }
virtual void close() override { m_helper.stream().close(); }
virtual ErrorOr<off_t> seek(i64 offset, SeekMode mode) override
{
auto result = TRY(m_helper.stream().seek(offset, mode));
m_helper.clear_buffer();
return result;
}
LibCore+Tests: Add SeekableStream::truncate()
2022-02-03 19:21:51 +00:00
virtual ErrorOr<void> truncate(off_t length) override
{
return m_helper.stream().truncate(length);
}
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore+Everywhere: Make Core::Stream read_line() return StringView Similar reasoning to making Core::Stream::read() return Bytes, except that every user of read_line() creates a StringView from the result, so let's just return one right away.
2022-04-15 14:52:33 +01:00
ErrorOr<StringView> read_line(Bytes buffer) { return m_helper.read_line(move(buffer)); }
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
ErrorOr<Bytes> read_until(Bytes buffer, StringView candidate) { return m_helper.read_until(move(buffer), move(candidate)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
template<size_t N>
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
ErrorOr<Bytes> read_until_any_of(Bytes buffer, Array<StringView, N> candidates) { return m_helper.read_until_any_of(move(buffer), move(candidates)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
ErrorOr<bool> can_read_line() { return m_helper.can_read_line(); }
size_t buffer_size() const { return m_helper.buffer_size(); }
Libraries: Use default constructors/destructors in LibCore https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-02-26 09:09:45 -07:00
virtual ~BufferedSeekable() override = default;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
private:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
BufferedSeekable(NonnullOwnPtr<T> stream, ByteBuffer buffer)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
: m_helper(Badge<BufferedSeekable<T>> {}, move(stream), buffer)
{
}
BufferedHelper<T> m_helper;
};
LibCore: Add a pure virtual parent to Core::Stream::BufferedSocket<T> And declare a few of the stream classes in the forwarding header.
2022-02-01 03:14:23 +03:30
class BufferedSocketBase : public Socket {
public:
LibCore+Everywhere: Make Core::Stream read_line() return StringView Similar reasoning to making Core::Stream::read() return Bytes, except that every user of read_line() creates a StringView from the result, so let's just return one right away.
2022-04-15 14:52:33 +01:00
virtual ErrorOr<StringView> read_line(Bytes buffer) = 0;
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
virtual ErrorOr<Bytes> read_until(Bytes buffer, StringView candidate) = 0;
LibCore: Add a pure virtual parent to Core::Stream::BufferedSocket<T> And declare a few of the stream classes in the forwarding header.
2022-02-01 03:14:23 +03:30
virtual ErrorOr<bool> can_read_line() = 0;
virtual size_t buffer_size() const = 0;
};
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
template<SocketLike T>
LibCore: Add a pure virtual parent to Core::Stream::BufferedSocket<T> And declare a few of the stream classes in the forwarding header.
2022-02-01 03:14:23 +03:30
class BufferedSocket final : public BufferedSocketBase {
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
friend BufferedHelper<T>;
public:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<BufferedSocket<T>>> create(NonnullOwnPtr<T> stream, size_t buffer_size = 16384)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
return BufferedHelper<T>::template create_buffered<BufferedSocket>(move(stream), buffer_size);
}
BufferedSocket(BufferedSocket&& other)
LibCore: Add a pure virtual parent to Core::Stream::BufferedSocket<T> And declare a few of the stream classes in the forwarding header.
2022-02-01 03:14:23 +03:30
: BufferedSocketBase(static_cast<BufferedSocketBase&&>(other))
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
, m_helper(move(other.m_helper))
{
setup_notifier();
}
BufferedSocket& operator=(BufferedSocket&& other)
{
Socket::operator=(static_cast<Socket&&>(other));
m_helper = move(other.m_helper);
setup_notifier();
return *this;
}
virtual bool is_readable() const override { return m_helper.stream().is_readable(); }
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(move(buffer)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual bool is_writable() const override { return m_helper.stream().is_writable(); }
virtual ErrorOr<size_t> write(ReadonlyBytes buffer) override { return m_helper.stream().write(buffer); }
virtual bool is_eof() const override { return m_helper.is_eof(); }
virtual bool is_open() const override { return m_helper.stream().is_open(); }
virtual void close() override { m_helper.stream().close(); }
LibCore: Make sure BufferedSocket takes the buffer into account pending_bytes() and can_read_without_blocking() should also take the buffered data into account, otherwise we'll end up pretending that the socket cannot be read from while it has buffered data.
2022-02-02 19:21:37 +03:30
virtual ErrorOr<size_t> pending_bytes() const override
{
return TRY(m_helper.stream().pending_bytes()) + m_helper.buffered_data_size();
}
virtual ErrorOr<bool> can_read_without_blocking(int timeout = 0) const override { return m_helper.buffered_data_size() > 0 || TRY(m_helper.stream().can_read_without_blocking(timeout)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual ErrorOr<void> set_blocking(bool enabled) override { return m_helper.stream().set_blocking(enabled); }
virtual ErrorOr<void> set_close_on_exec(bool enabled) override { return m_helper.stream().set_close_on_exec(enabled); }
LibCore: Add Core::Stream::Socket::set_notifications_enabled() This is equivalent to Core::Socket::set_notifications_enabled(), and serves to disable the on_ready_to_read() notifications, as the sockets often implement these using the event loop, this method can help avoid waking the event loop and spamming useless calls to on_ready_to_read().
2022-02-01 03:15:44 +03:30
virtual void set_notifications_enabled(bool enabled) override { m_helper.stream().set_notifications_enabled(enabled); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore+Everywhere: Make Core::Stream read_line() return StringView Similar reasoning to making Core::Stream::read() return Bytes, except that every user of read_line() creates a StringView from the result, so let's just return one right away.
2022-04-15 14:52:33 +01:00
virtual ErrorOr<StringView> read_line(Bytes buffer) override { return m_helper.read_line(move(buffer)); }
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
virtual ErrorOr<Bytes> read_until(Bytes buffer, StringView candidate) override { return m_helper.read_until(move(buffer), move(candidate)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
template<size_t N>
LibCore+Everywhere: Make Core::Stream read_until() return Bytes This affects BufferedSeekable::read_until() and ::read_until_any_of(). For the reasoning, see the previous commit about Core::Stream::read().
2022-04-15 13:44:23 +01:00
ErrorOr<Bytes> read_until_any_of(Bytes buffer, Array<StringView, N> candidates) { return m_helper.read_until_any_of(move(buffer), move(candidates)); }
LibCore: Add a pure virtual parent to Core::Stream::BufferedSocket<T> And declare a few of the stream classes in the forwarding header.
2022-02-01 03:14:23 +03:30
virtual ErrorOr<bool> can_read_line() override { return m_helper.can_read_line(); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
LibCore: Add a pure virtual parent to Core::Stream::BufferedSocket<T> And declare a few of the stream classes in the forwarding header.
2022-02-01 03:14:23 +03:30
virtual size_t buffer_size() const override { return m_helper.buffer_size(); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
Libraries: Use default constructors/destructors in LibCore https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-02-26 09:09:45 -07:00
virtual ~BufferedSocket() override = default;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
private:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
BufferedSocket(NonnullOwnPtr<T> stream, ByteBuffer buffer)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
: m_helper(Badge<BufferedSocket<T>> {}, move(stream), buffer)
{
setup_notifier();
}
void setup_notifier()
{
m_helper.stream().on_ready_to_read = [this] {
if (on_ready_to_read)
on_ready_to_read();
};
}
BufferedHelper<T> m_helper;
};
using BufferedFile = BufferedSeekable<File>;
using BufferedTCPSocket = BufferedSocket<TCPSocket>;
using BufferedUDPSocket = BufferedSocket<UDPSocket>;
using BufferedLocalSocket = BufferedSocket<LocalSocket>;
/// A BasicReusableSocket allows one to use one of the base Core::Stream classes
/// as a ReusableSocket. It does not preserve any connection state or options,
/// and instead just recreates the stream when reconnecting.
template<SocketLike T>
class BasicReusableSocket final : public ReusableSocket {
public:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<BasicReusableSocket<T>>> connect(String const& host, u16 port)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
return make<BasicReusableSocket<T>>(TRY(T::connect(host, port)));
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
static ErrorOr<NonnullOwnPtr<BasicReusableSocket<T>>> connect(SocketAddress const& address)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
return make<BasicReusableSocket<T>>(TRY(T::connect(address)));
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
virtual bool is_connected() override
{
return m_socket.is_open();
}
LibCore: Remove the SocketError class SocketError is a relic from the KResult days when we couldn't have a string in the KResult type, only an errno. Now that we can use string literals with Error, it's no longer necessary. gai_strerror is thread safe, so we can use it here unlike strerror.
2021-12-18 11:37:22 +00:00
virtual ErrorOr<void> reconnect(String const& host, u16 port) override
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
{
if (is_connected())
LibCore: Remove the SocketError class SocketError is a relic from the KResult days when we couldn't have a string in the KResult type, only an errno. Now that we can use string literals with Error, it's no longer necessary. gai_strerror is thread safe, so we can use it here unlike strerror.
2021-12-18 11:37:22 +00:00
return Error::from_errno(EALREADY);
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
m_socket = TRY(T::connect(host, port));
LibCore: Remove the SocketError class SocketError is a relic from the KResult days when we couldn't have a string in the KResult type, only an errno. Now that we can use string literals with Error, it's no longer necessary. gai_strerror is thread safe, so we can use it here unlike strerror.
2021-12-18 11:37:22 +00:00
return {};
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
}
virtual ErrorOr<void> reconnect(SocketAddress const& address) override
{
if (is_connected())
return Error::from_errno(EALREADY);
m_socket = TRY(T::connect(address));
return {};
}
virtual bool is_readable() const override { return m_socket.is_readable(); }
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_socket.read(move(buffer)); }
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
virtual bool is_writable() const override { return m_socket.is_writable(); }
virtual ErrorOr<size_t> write(ReadonlyBytes buffer) override { return m_socket.write(buffer); }
virtual bool is_eof() const override { return m_socket.is_eof(); }
virtual bool is_open() const override { return m_socket.is_open(); }
virtual void close() override { m_socket.close(); }
virtual ErrorOr<size_t> pending_bytes() const override { return m_socket.pending_bytes(); }
virtual ErrorOr<bool> can_read_without_blocking(int timeout = 0) const override { return m_socket.can_read_without_blocking(timeout); }
virtual ErrorOr<void> set_blocking(bool enabled) override { return m_socket.set_blocking(enabled); }
virtual ErrorOr<void> set_close_on_exec(bool enabled) override { return m_socket.set_close_on_exec(enabled); }
private:
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
BasicReusableSocket(NonnullOwnPtr<T> socket)
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
: m_socket(move(socket))
{
}
LibCore+Userland+Tests: Convert Stream APIs to construct on heap As per previous discussion, it was decided that the Stream classes should be constructed on the heap. While I don't personally agree with this change, it does have the benefit of avoiding Function object reconstructions due to the lambda passed to Notifier pointing to a stale object reference. This also has the benefit of not having to "box" objects for virtual usage, as the objects come pre-boxed. However, it means that we now hit the heap everytime we construct a TCPSocket for instance, which might not be desirable.
2021-12-29 22:31:45 +00:00
NonnullOwnPtr<T> m_socket;
LibCore: Implement the Serenity Stream API classes The Serenity Stream API is the name for the new set of classes intended to replace IODevice and its descendants. It provides more flexibility for subclasses by allowing each subclass to override all the possible functionalities according to their wishes. Stream is the base class which implements majority of the functionality expected from a readable and writable stream. SeekableStream adds seeking on top, and provides a couple utility methods which derive from seek. Socket adds a couple of BSD socket utility functions such as checking whether there is data available to read and checking the pending bytes on the socket. As for the concrete classes, there is File which is a SeekableStream and is intended to operate on file-like objects; and TCPSocket, UDPSocket and LocalSocket, which handle TCP, UDP and UNIX sockets respectively. The concrete classes do not do buffering by default. For buffering functionality, a set of augmentative classes named BufferedSeekable and BufferedSocket have been implemented, intended to wrap a SeekableStream and a Socket, respectively.
2021-09-01 21:30:13 +00:00
};
using ReusableTCPSocket = BasicReusableSocket<TCPSocket>;
using ReusableUDPSocket = BasicReusableSocket<UDPSocket>;
}
Reference in a new issue Copy permalink