system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-10-04 15:09:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

LibCore+Everywhere: Make Core::Stream::read() return Bytes

Browse source 
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
This commit is contained in:
Sam Atkins 2022-04-15 13:33:02 +01:00 committed by Tim Flynn
parent 6654efcd82
commit 3b1e063d30
22 changed files with 103 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Meta/Lagom/Tools/CodeGenerators/LibUnicode/GeneratorUtil.h
View file

@ -259,8 +259,8 @@ inline ErrorOr<JsonValue> read_json_file(StringView path)
// FIXME: When Core::Stream supports reading an entire file, use that.
while (TRY(file->can_read_line())) {
auto nread = TRY(file->read(buffer));
TRY(builder.try_append(reinterpret_cast<char const*>(buffer.data()), nread));
auto bytes_read = TRY(file->read(buffer));
TRY(builder.try_append(StringView { bytes_read }));
}
return JsonValue::from_string(builder.build());

44
Tests/LibCore/TestLibCoreStream.cpp
View file

@ -63,7 +63,7 @@ TEST_CASE(file_read_bytes)
auto result = file->read(buffer);
EXPECT(!result.is_error());
EXPECT_EQ(result.value(), 131ul);
EXPECT_EQ(result.value().size(), 131ul);
StringView buffer_contents { buffer.bytes() };
EXPECT_EQ(buffer_contents, expected_buffer_contents);
@ -193,11 +193,11 @@ TEST_CASE(tcp_socket_read)
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_nread = client_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
auto maybe_read_bytes = client_socket->read(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
StringView received_data { receive_buffer.data(), nread };
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
}
@ -226,11 +226,11 @@ TEST_CASE(tcp_socket_write)
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_nread = server_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
auto maybe_read_bytes = server_socket->read(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
StringView received_data { receive_buffer.data(), nread };
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
}
@ -262,7 +262,7 @@ TEST_CASE(tcp_socket_eof)
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(1);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
EXPECT_EQ(client_socket->read(receive_buffer).release_value(), 0ul);
EXPECT(client_socket->read(receive_buffer).release_value().is_empty());
EXPECT(client_socket->is_eof());
}
@ -309,11 +309,11 @@ TEST_CASE(udp_socket_read_write)
auto maybe_client_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_client_receive_buffer.is_error());
auto client_receive_buffer = maybe_client_receive_buffer.release_value();
auto maybe_nread = client_socket->read(client_receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
auto maybe_read_bytes = client_socket->read(client_receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
StringView client_received_data { client_receive_buffer.data(), nread };
StringView client_received_data { read_bytes };
EXPECT_EQ(udp_reply_data, client_received_data);
}
@ -353,11 +353,11 @@ TEST_CASE(local_socket_read)
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_nread = client_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
auto maybe_read_bytes = client_socket->read(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
StringView received_data { receive_buffer.data(), nread };
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
return 0;
@ -384,11 +384,11 @@ TEST_CASE(local_socket_write)
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(pending_bytes);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_nread = server_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
EXPECT_EQ(maybe_nread.value(), sent_data.length());
auto maybe_read_bytes = server_socket->read(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
EXPECT_EQ(maybe_read_bytes.value().size(), sent_data.length());
StringView received_data { receive_buffer.data(), maybe_nread.value() };
StringView received_data { maybe_read_bytes.value() };
EXPECT_EQ(sent_data, received_data);
event_loop.quit(0);

4
Tests/LibTLS/TestTLSHandshake.cpp
View file

@ -79,8 +79,8 @@ TEST_CASE(test_TLS_hello_handshake)
auto tls = MUST(TLS::TLSv12::connect(DEFAULT_SERVER, port, move(options)));
ByteBuffer contents;
tls->on_ready_to_read = [&] {
auto nread = MUST(tls->read(contents.must_get_bytes_for_writing(4 * KiB)));
if (nread == 0) {
auto read_bytes = MUST(tls->read(contents.must_get_bytes_for_writing(4 * KiB)));
if (read_bytes.is_empty()) {
FAIL("No data received");
loop.quit(1);
}

2
Userland/Libraries/LibAudio/FlacLoader.cpp
View file

@ -114,7 +114,7 @@ MaybeLoaderError FlacLoaderPlugin::parse_header()
[[maybe_unused]] u128 md5_checksum;
VERIFY(streaminfo_data->is_aligned_to_byte_boundary());
auto md5_bytes_read = LOADER_TRY(streaminfo_data->read(md5_checksum.bytes()));
FLAC_VERIFY(md5_bytes_read == md5_checksum.my_size(), LoaderError::Category::IO, "MD5 Checksum size");
FLAC_VERIFY(md5_bytes_read.size() == md5_checksum.my_size(), LoaderError::Category::IO, "MD5 Checksum size");
md5_checksum.bytes().copy_to({ m_md5_checksum, sizeof(m_md5_checksum) });
// Parse other blocks

20
Userland/Libraries/LibCore/EventLoop.cpp
View file

@ -162,31 +162,31 @@ private:
#ifdef __serenity__
m_socket->on_ready_to_read = [this] {
u32 length;
auto maybe_nread = m_socket->read({ (u8*)&length, sizeof(length) });
if (maybe_nread.is_error()) {
dbgln("InspectorServerConnection: Failed to read message length from inspector server connection: {}", maybe_nread.error());
auto maybe_bytes_read = m_socket->read({ (u8*)&length, sizeof(length) });
if (maybe_bytes_read.is_error()) {
dbgln("InspectorServerConnection: Failed to read message length from inspector server connection: {}", maybe_bytes_read.error());
shutdown();
return;
}
auto nread = maybe_nread.release_value();
if (nread == 0) {
auto bytes_read = maybe_bytes_read.release_value();
if (bytes_read.is_empty()) {
dbgln_if(EVENTLOOP_DEBUG, "RPC client disconnected");
shutdown();
return;
}
VERIFY(nread == sizeof(length));
VERIFY(bytes_read.size() == sizeof(length));
auto request_buffer = ByteBuffer::create_uninitialized(length).release_value();
maybe_nread = m_socket->read(request_buffer.bytes());
if (maybe_nread.is_error()) {
dbgln("InspectorServerConnection: Failed to read message content from inspector server connection: {}", maybe_nread.error());
maybe_bytes_read = m_socket->read(request_buffer.bytes());
if (maybe_bytes_read.is_error()) {
dbgln("InspectorServerConnection: Failed to read message content from inspector server connection: {}", maybe_bytes_read.error());
shutdown();
return;
}
nread = maybe_nread.release_value();
bytes_read = maybe_bytes_read.release_value();
auto request_json = JsonValue::from_string(request_buffer);
if (request_json.is_error() || !request_json.value().is_object()) {

2
Userland/Libraries/LibCore/InputBitStream.h
View file

@ -31,7 +31,7 @@ public:
// ^Stream
virtual bool is_readable() const override { return m_stream.is_readable(); }
virtual ErrorOr<size_t> read(Bytes bytes) override
virtual ErrorOr<Bytes> read(Bytes bytes) override
{
if (m_current_byte.has_value() && is_aligned_to_byte_boundary()) {
bytes[0] = m_current_byte.release_value();

6
Userland/Libraries/LibCore/MemoryStream.h
View file

@ -29,15 +29,15 @@ public:
// FIXME: It doesn't make sense to truncate a memory stream. Therefore, we don't do anything here. Is that fine?
virtual ErrorOr<void> truncate(off_t) override { return Error::from_errno(ENOTSUP); }
virtual ErrorOr<size_t> read(Bytes bytes) override
virtual ErrorOr<Bytes> read(Bytes bytes) override
{
auto to_read = min(remaining(), bytes.size());
if (to_read == 0)
return 0;
return Bytes {};
m_bytes.slice(m_offset, to_read).copy_to(bytes);
m_offset += to_read;
return bytes.size();
return bytes.trim(to_read);
}
virtual ErrorOr<off_t> seek(i64 offset, SeekMode seek_mode = SeekMode::SetPosition) override

16
Userland/Libraries/LibCore/SOCKSProxyClient.cpp
View file

@ -107,7 +107,7 @@ ErrorOr<void> send_version_identifier_and_method_selection_message(Core::Stream:
return Error::from_string_literal("SOCKS negotiation failed: Failed to send version identifier and method selection message");
Socks5InitialResponse response;
size = TRY(socket.read({ &response, sizeof(response) }));
size = TRY(socket.read({ &response, sizeof(response) })).size();
if (size != sizeof(response))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive initial response");
@ -169,7 +169,7 @@ ErrorOr<Reply> send_connect_request_message(Core::Stream::Socket& socket, Core::
return Error::from_string_literal("SOCKS negotiation failed: Failed to send connect request");
Socks5ConnectResponseHeader response_header;
size = TRY(socket.read({ &response_header, sizeof(response_header) }));
size = TRY(socket.read({ &response_header, sizeof(response_header) })).size();
if (size != sizeof(response_header))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive connect response header");
@ -177,26 +177,26 @@ ErrorOr<Reply> send_connect_request_message(Core::Stream::Socket& socket, Core::
return Error::from_string_literal("SOCKS negotiation failed: Invalid version identifier");
u8 response_address_type;
size = TRY(socket.read({ &response_address_type, sizeof(response_address_type) }));
size = TRY(socket.read({ &response_address_type, sizeof(response_address_type) })).size();
if (size != sizeof(response_address_type))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive connect response address type");
switch (AddressType(response_address_type)) {
case AddressType::IPV4: {
u8 response_address_data[4];
size = TRY(socket.read({ response_address_data, sizeof(response_address_data) }));
size = TRY(socket.read({ response_address_data, sizeof(response_address_data) })).size();
if (size != sizeof(response_address_data))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive connect response address data");
break;
}
case AddressType::DomainName: {
u8 response_address_length;
size = TRY(socket.read({ &response_address_length, sizeof(response_address_length) }));
size = TRY(socket.read({ &response_address_length, sizeof(response_address_length) })).size();
if (size != sizeof(response_address_length))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive connect response address length");
ByteBuffer buffer;
buffer.resize(response_address_length);
size = TRY(socket.read(buffer));
size = TRY(socket.read(buffer)).size();
if (size != response_address_length)
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive connect response address data");
break;
@ -207,7 +207,7 @@ ErrorOr<Reply> send_connect_request_message(Core::Stream::Socket& socket, Core::
}
u16 bound_port;
size = TRY(socket.read({ &bound_port, sizeof(bound_port) }));
size = TRY(socket.read({ &bound_port, sizeof(bound_port) })).size();
if (size != sizeof(bound_port))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive connect response bound port");
@ -247,7 +247,7 @@ ErrorOr<u8> send_username_password_authentication_message(Core::Stream::Socket&
return Error::from_string_literal("SOCKS negotiation failed: Failed to send username/password authentication message");
Socks5UsernamePasswordResponse response;
size = TRY(socket.read({ &response, sizeof(response) }));
size = TRY(socket.read({ &response, sizeof(response) })).size();
if (size != sizeof(response))
return Error::from_string_literal("SOCKS negotiation failed: Failed to receive username/password authentication response");

2
Userland/Libraries/LibCore/SOCKSProxyClient.h
View file

@ -37,7 +37,7 @@ public:
virtual ~SOCKSProxyClient() override;
// ^Stream::Stream
virtual ErrorOr<size_t> read(Bytes bytes) override { return m_socket.read(bytes); }
virtual ErrorOr<Bytes> read(Bytes bytes) override { return m_socket.read(bytes); }
virtual ErrorOr<size_t> write(ReadonlyBytes bytes) override { return m_socket.write(bytes); }
virtual bool is_eof() const override { return m_socket.is_eof(); }
virtual bool is_open() const override { return m_socket.is_open(); }

12
Userland/Libraries/LibCore/Stream.cpp
View file

@ -41,7 +41,7 @@ bool Stream::read_or_error(Bytes buffer)
return false;
}
nread += result.value();
nread += result.value().size();
} while (nread < buffer.size());
return true;
@ -156,7 +156,7 @@ ErrorOr<void> File::open_path(StringView filename, mode_t permissions)
bool File::is_readable() const { return has_flag(m_mode, OpenMode::Read); }
bool File::is_writable() const { return has_flag(m_mode, OpenMode::Write); }
ErrorOr<size_t> File::read(Bytes buffer)
ErrorOr<Bytes> File::read(Bytes buffer)
{
if (!has_flag(m_mode, OpenMode::Read)) {
// NOTE: POSIX says that if the fd is not open for reading, the call
@ -167,7 +167,7 @@ ErrorOr<size_t> File::read(Bytes buffer)
ssize_t nread = TRY(System::read(m_fd, buffer));
m_last_read_was_eof = nread == 0;
return nread;
return buffer.trim(nread);
}
ErrorOr<size_t> File::write(ReadonlyBytes buffer)
@ -322,7 +322,7 @@ ErrorOr<void> Socket::connect_inet(int fd, SocketAddress const& address)
return System::connect(fd, bit_cast<struct sockaddr*>(&addr), sizeof(addr));
}
ErrorOr<size_t> PosixSocketHelper::read(Bytes buffer, int flags)
ErrorOr<Bytes> PosixSocketHelper::read(Bytes buffer, int flags)
{
if (!is_open()) {
return Error::from_errno(ENOTCONN);
@ -337,7 +337,7 @@ ErrorOr<size_t> PosixSocketHelper::read(Bytes buffer, int flags)
if (m_last_read_was_eof && m_notifier)
m_notifier->set_enabled(false);
return nread;
return buffer.trim(nread);
}
ErrorOr<size_t> PosixSocketHelper::write(ReadonlyBytes buffer)
@ -554,7 +554,7 @@ ErrorOr<pid_t> LocalSocket::peer_pid() const
ErrorOr<size_t> LocalSocket::read_without_waiting(Bytes buffer)
{
return m_helper.read(buffer, MSG_DONTWAIT);
return TRY(m_helper.read(buffer, MSG_DONTWAIT)).size();
}
ErrorOr<int> LocalSocket::release_fd()

26
Userland/Libraries/LibCore/Stream.h
View file

@ -31,9 +31,9 @@ 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.
/// Returns either the amount of bytes read, or an errno in the case of
/// Returns either the bytes that were read, or an errno in the case of
/// failure.
virtual ErrorOr<size_t> read(Bytes) = 0;
virtual ErrorOr<Bytes> read(Bytes) = 0;
/// Tries to fill the entire buffer through reading. Returns whether the
/// buffer was filled without an error.
virtual bool read_or_error(Bytes);
@ -194,7 +194,7 @@ public:
}
virtual bool is_readable() const override;
virtual ErrorOr<size_t> read(Bytes) override;
virtual ErrorOr<Bytes> read(Bytes) override;
virtual bool is_writable() const override;
virtual ErrorOr<size_t> write(ReadonlyBytes) override;
virtual bool is_eof() const override;
@ -243,7 +243,7 @@ public:
int fd() const { return m_fd; }
void set_fd(int fd) { m_fd = fd; }
ErrorOr<size_t> read(Bytes, int flags = 0);
ErrorOr<Bytes> read(Bytes, int flags = 0);
ErrorOr<size_t> write(ReadonlyBytes);
bool is_eof() const { return !is_open() || m_last_read_was_eof; }
@ -292,7 +292,7 @@ public:
virtual bool is_readable() const override { return is_open(); }
virtual bool is_writable() const override { return is_open(); }
virtual ErrorOr<size_t> read(Bytes buffer) override { return m_helper.read(buffer); }
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(buffer); }
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(); };
@ -351,7 +351,7 @@ public:
return *this;
}
virtual ErrorOr<size_t> read(Bytes buffer) override
virtual ErrorOr<Bytes> read(Bytes buffer) override
{
auto pending_bytes = TRY(this->pending_bytes());
if (pending_bytes > buffer.size()) {
@ -426,7 +426,7 @@ public:
virtual bool is_readable() const override { return is_open(); }
virtual bool is_writable() const override { return is_open(); }
virtual ErrorOr<size_t> read(Bytes buffer) override { return m_helper.read(buffer); }
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(buffer); }
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(); }
@ -523,7 +523,7 @@ public:
T& stream() { return *m_stream; }
T const& stream() const { return *m_stream; }
ErrorOr<size_t> read(Bytes buffer)
ErrorOr<Bytes> read(Bytes buffer)
{
if (!stream().is_open())
return Error::from_errno(ENOTCONN);
@ -552,7 +552,7 @@ public:
m_buffered_size -= amount_to_take;
}
return buffer_nread;
return Bytes { buffer.data(), buffer_nread };
}
// Reads into the buffer until \n is encountered.
@ -715,7 +715,7 @@ private:
break;
return result.error();
}
auto read_size = result.value();
auto read_size = result.value().size();
m_buffered_size += read_size;
nread += read_size;
break;
@ -752,7 +752,7 @@ public:
BufferedSeekable& operator=(BufferedSeekable&& other) = default;
virtual bool is_readable() const override { return m_helper.stream().is_readable(); }
virtual ErrorOr<size_t> read(Bytes buffer) override { return m_helper.read(move(buffer)); }
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(move(buffer)); }
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(); }
@ -823,7 +823,7 @@ public:
}
virtual bool is_readable() const override { return m_helper.stream().is_readable(); }
virtual ErrorOr<size_t> read(Bytes buffer) override { return m_helper.read(move(buffer)); }
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_helper.read(move(buffer)); }
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(); }
@ -911,7 +911,7 @@ public:
}
virtual bool is_readable() const override { return m_socket.is_readable(); }
virtual ErrorOr<size_t> read(Bytes buffer) override { return m_socket.read(move(buffer)); }
virtual ErrorOr<Bytes> read(Bytes buffer) override { return m_socket.read(move(buffer)); }
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(); }

2
Userland/Libraries/LibGemini/Job.cpp
View file

@ -63,7 +63,7 @@ String Job::read_line(size_t size)
ByteBuffer Job::receive(size_t size)
{
ByteBuffer buffer = ByteBuffer::create_uninitialized(size).release_value_but_fixme_should_propagate_errors();
auto nread = MUST(m_socket->read(buffer));
auto nread = MUST(m_socket->read(buffer)).size();
return buffer.slice(0, nread);
}

2
Userland/Libraries/LibHTTP/Job.cpp
View file

@ -172,7 +172,7 @@ ErrorOr<ByteBuffer> Job::receive(size_t size)
auto result = m_socket->read(buffer);
if (result.is_error() && result.error().is_errno() && result.error().code() == EINTR)
continue;
nread = TRY(result);
nread = TRY(result).size();
break;
} while (true);
return buffer.slice(0, nread);

6
Userland/Libraries/LibProtocol/Request.cpp
View file

@ -51,10 +51,10 @@ void Request::stream_into_impl(T& stream)
break;
if (result.is_error())
continue;
auto nread = result.value();
if (nread == 0)
auto read_bytes = result.release_value();
if (read_bytes.is_empty())
break;
if (!stream.write_or_error({ buf, nread })) {
if (!stream.write_or_error(read_bytes)) {
// FIXME: What do we do here?
TODO();
}

14
Userland/Libraries/LibTLS/Socket.cpp
View file

@ -18,18 +18,18 @@ constexpr static size_t MaximumApplicationDataChunkSize = 16 * KiB;
namespace TLS {
ErrorOr<size_t> TLSv12::read(Bytes bytes)
ErrorOr<Bytes> TLSv12::read(Bytes bytes)
{
m_eof = false;
auto size_to_read = min(bytes.size(), m_context.application_buffer.size());
if (size_to_read == 0) {
m_eof = true;
return 0;
return Bytes {};
}
m_context.application_buffer.span().slice(0, size_to_read).copy_to(bytes);
m_context.application_buffer = m_context.application_buffer.slice(size_to_read, m_context.application_buffer.size() - size_to_read);
return size_to_read;
return Bytes { bytes.data(), size_to_read };
}
String TLSv12::read_line(size_t max_size)
@ -186,7 +186,7 @@ ErrorOr<void> TLSv12::read_from_socket()
u8 buffer[16 * KiB];
Bytes bytes { buffer, array_size(buffer) };
size_t nread = 0;
Bytes read_bytes {};
auto& stream = underlying_stream();
do {
auto result = stream.read(bytes);
@ -198,9 +198,9 @@ ErrorOr<void> TLSv12::read_from_socket()
}
continue;
}
nread = result.release_value();
consume(bytes.slice(0, nread));
} while (nread > 0 && !m_context.critical_error);
read_bytes = result.release_value();
consume(read_bytes);
} while (!read_bytes.is_empty() && !m_context.critical_error);
return {};
}

4
Userland/Libraries/LibTLS/TLSv12.h
View file

@ -356,9 +356,9 @@ public:
/// 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.
/// Returns either the amount of bytes read, or an errno in the case of
/// Returns either the bytes that were read, or an errno in the case of
/// failure.
virtual ErrorOr<size_t> read(Bytes) override;
virtual ErrorOr<Bytes> read(Bytes) override;
/// 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

4
Userland/Libraries/LibWebSocket/Impl/WebSocketImpl.cpp
View file

@ -56,8 +56,8 @@ void WebSocketImpl::connect(ConnectionInfo const& connection_info)
ErrorOr<ByteBuffer> WebSocketImpl::read(int max_size)
{
auto buffer = TRY(ByteBuffer::create_uninitialized(max_size));
auto nread = TRY(m_socket->read(buffer));
return buffer.slice(0, nread);
auto read_bytes = TRY(m_socket->read(buffer));
return buffer.slice(0, read_bytes.size());
}
ErrorOr<String> WebSocketImpl::read_line(size_t size)

6
Userland/Services/EchoServer/Client.cpp
View file

@ -30,16 +30,16 @@ ErrorOr<void> Client::drain_socket()
auto buffer = TRY(ByteBuffer::create_uninitialized(1024));
while (TRY(m_socket->can_read_without_blocking())) {
auto nread = TRY(m_socket->read(buffer));
auto bytes_read = TRY(m_socket->read(buffer));
dbgln("Read {} bytes.", nread);
dbgln("Read {} bytes.", bytes_read.size());
if (m_socket->is_eof()) {
Core::deferred_invoke([this, strong_this = NonnullRefPtr(*this)] { quit(); });
break;
}
TRY(m_socket->write({ buffer.data(), nread }));
TRY(m_socket->write(bytes_read));
}
return {};

8
Userland/Services/FileOperation/main.cpp
View file

@ -238,15 +238,15 @@ ErrorOr<int> execute_work_items(Vector<WorkItem> const& items)
while (true) {
print_progress();
auto bytes_read = TRY(source_file->read(buffer.bytes()));
if (bytes_read == 0)
if (bytes_read.is_empty())
break;
if (auto result = destination_file->write(buffer); result.is_error()) {
if (auto result = destination_file->write(bytes_read); result.is_error()) {
// FIXME: Return the formatted string directly. There is no way to do this right now without the temporary going out of scope and being destroyed.
report_warning(String::formatted("Failed to write to destination file: {}", result.error()));
return result.error();
}
item_done += bytes_read;
executed_work_bytes += bytes_read;
item_done += bytes_read.size();
executed_work_bytes += bytes_read.size();
print_progress();
// FIXME: Remove this once the kernel is smart enough to schedule other threads
// while we're doing heavy I/O. Right now, copying a large file will totally

16
Userland/Services/InspectorServer/InspectableProcess.cpp
View file

@ -43,8 +43,8 @@ String InspectableProcess::wait_for_response()
}
u32 length {};
auto nread = m_socket->read({ (u8*)&length, sizeof(length) }).release_value_but_fixme_should_propagate_errors();
if (nread != sizeof(length)) {
auto length_bytes_read = m_socket->read({ (u8*)&length, sizeof(length) }).release_value_but_fixme_should_propagate_errors();
if (length_bytes_read.size() != sizeof(length)) {
dbgln("InspectableProcess got malformed data: PID {}", m_pid);
m_socket->close();
return {};
@ -54,17 +54,17 @@ String InspectableProcess::wait_for_response()
auto remaining_data_buffer = data_buffer.bytes();
while (!remaining_data_buffer.is_empty()) {
auto maybe_nread = m_socket->read(remaining_data_buffer);
if (maybe_nread.is_error()) {
dbgln("InspectableProcess::wait_for_response: Failed to read data: {}", maybe_nread.error());
auto maybe_bytes_read = m_socket->read(remaining_data_buffer);
if (maybe_bytes_read.is_error()) {
dbgln("InspectableProcess::wait_for_response: Failed to read data: {}", maybe_bytes_read.error());
break;
}
auto nread = maybe_nread.release_value();
if (nread == 0)
auto bytes_read = maybe_bytes_read.release_value();
if (bytes_read.is_empty())
break;
remaining_data_buffer = remaining_data_buffer.slice(nread);
remaining_data_buffer = remaining_data_buffer.slice(bytes_read.size());
}
VERIFY(data_buffer.size() == length);

2
Userland/Services/LookupServer/LookupServer.cpp
View file

@ -239,7 +239,7 @@ ErrorOr<Vector<Answer>> LookupServer::lookup(Name const& name, String const& nam
TRY(udp_socket->write(buffer));
u8 response_buffer[4096];
int nrecv = TRY(udp_socket->read({ response_buffer, sizeof(response_buffer) }));
int nrecv = TRY(udp_socket->read({ response_buffer, sizeof(response_buffer) })).size();
if (udp_socket->is_eof())
return Vector<Answer> {};

4
Userland/Services/TelnetServer/Client.cpp
View file

@ -76,9 +76,9 @@ ErrorOr<void> Client::drain_socket()
auto buffer = TRY(ByteBuffer::create_uninitialized(1024));
while (TRY(m_socket->can_read_without_blocking())) {
auto nread = TRY(m_socket->read(buffer));
auto read_bytes = TRY(m_socket->read(buffer));
m_parser.write({ buffer.data(), nread });
m_parser.write(StringView { read_bytes });
if (m_socket->is_eof()) {
Core::deferred_invoke([this, strong_this = NonnullRefPtr(*this)] { quit(); });