system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-21 10:05:32 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe

Browse source
This commit is contained in:
Ali Mohammad Pur 2021-09-06 03:29:52 +04:30 committed by Andreas Kling
parent 3a9f00c59b
commit 97e97bccab
105 changed files with 629 additions and 290 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
AK/Base64.cpp
View file

@ -87,7 +87,8 @@ ByteBuffer decode_base64(const StringView& input)
output.append(out2);
}
return ByteBuffer::copy(output.data(), output.size());
// FIXME: Handle OOM failure.
return ByteBuffer::copy(output).release_value();
}
String encode_base64(ReadonlyBytes input)

33
AK/ByteBuffer.h
View file

@ -62,31 +62,35 @@ public:
return *this;
}
[[nodiscard]] static ByteBuffer create_uninitialized(size_t size)
[[nodiscard]] static Optional<ByteBuffer> create_uninitialized(size_t size)
{
auto buffer = ByteBuffer();
auto ok = buffer.try_resize(size);
VERIFY(ok);
return buffer;
if (!buffer.try_resize(size))
return {};
return { move(buffer) };
}
[[nodiscard]] static ByteBuffer create_zeroed(size_t size)
[[nodiscard]] static Optional<ByteBuffer> create_zeroed(size_t size)
{
auto buffer = create_uninitialized(size);
auto buffer_result = create_uninitialized(size);
if (!buffer_result.has_value())
return {};
auto& buffer = buffer_result.value();
buffer.zero_fill();
VERIFY(size == 0 || (buffer[0] == 0 && buffer[size - 1] == 0));
return buffer;
return buffer_result;
}
[[nodiscard]] static ByteBuffer copy(void const* data, size_t size)
[[nodiscard]] static Optional<ByteBuffer> copy(void const* data, size_t size)
{
auto buffer = create_uninitialized(size);
if (size != 0)
__builtin_memcpy(buffer.data(), data, size);
if (buffer.has_value() && size != 0)
__builtin_memcpy(buffer->data(), data, size);
return buffer;
}
[[nodiscard]] static ByteBuffer copy(ReadonlyBytes bytes)
[[nodiscard]] static Optional<ByteBuffer> copy(ReadonlyBytes bytes)
{
return copy(bytes.data(), bytes.size());
}
@ -133,12 +137,13 @@ public:
[[nodiscard]] void* end_pointer() { return data() + m_size; }
[[nodiscard]] void const* end_pointer() const { return data() + m_size; }
// FIXME: Make this function handle failures too.
[[nodiscard]] ByteBuffer slice(size_t offset, size_t size) const
{
// I cannot hand you a slice I don't have
VERIFY(offset + size <= this->size());
return copy(offset_pointer(offset), size);
return copy(offset_pointer(offset), size).release_value();
}
void clear()
@ -237,8 +242,10 @@ private:
if (!other.m_inline) {
m_outline_buffer = other.m_outline_buffer;
m_outline_capacity = other.m_outline_capacity;
} else
} else {
VERIFY(other.m_size <= inline_capacity);
__builtin_memcpy(m_inline_buffer, other.m_inline_buffer, other.m_size);
}
other.m_size = 0;
other.m_inline = true;
}

8
AK/Hex.cpp
View file

@ -20,7 +20,11 @@ Optional<ByteBuffer> decode_hex(const StringView& input)
if ((input.length() % 2) != 0)
return {};
auto output = ByteBuffer::create_zeroed(input.length() / 2);
auto output_result = ByteBuffer::create_zeroed(input.length() / 2);
if (!output_result.has_value())
return {};
auto& output = output_result.value();
for (size_t i = 0; i < input.length() / 2; ++i) {
const auto c1 = decode_hex_digit(input[i * 2]);
@ -34,7 +38,7 @@ Optional<ByteBuffer> decode_hex(const StringView& input)
output[i] = (c1 << 4) + c2;
}
return output;
return output_result;
}
String encode_hex(const ReadonlyBytes input)

5
AK/MemoryStream.h
View file

@ -224,7 +224,7 @@ public:
size_t nwritten = 0;
while (bytes.size() - nwritten > 0) {
if ((m_write_offset + nwritten) % chunk_size == 0)
m_chunks.append(ByteBuffer::create_uninitialized(chunk_size));
m_chunks.append(ByteBuffer::create_uninitialized(chunk_size).release_value()); // FIXME: Handle possible OOM situation.
nwritten += bytes.slice(nwritten).copy_trimmed_to(m_chunks.last().bytes().slice((m_write_offset + nwritten) % chunk_size));
}
@ -241,7 +241,8 @@ public:
ByteBuffer copy_into_contiguous_buffer() const
{
auto buffer = ByteBuffer::create_uninitialized(size());
// FIXME: Handle possible OOM situation.
auto buffer = ByteBuffer::create_uninitialized(size()).release_value();
const auto nread = read_without_consuming(buffer);
VERIFY(nread == buffer.size());

3
AK/String.cpp
View file

@ -176,7 +176,8 @@ ByteBuffer String::to_byte_buffer() const
{
if (!m_impl)
return {};
return ByteBuffer::copy(reinterpret_cast<const u8*>(characters()), length());
// FIXME: Handle OOM failure.
return ByteBuffer::copy(bytes()).release_value();
}
template<typename T>

3
AK/StringBuilder.cpp
View file

@ -69,7 +69,8 @@ void StringBuilder::appendvf(char const* fmt, va_list ap)
ByteBuffer StringBuilder::to_byte_buffer() const
{
return ByteBuffer::copy(data(), length());
// FIXME: Handle OOM failure.
return ByteBuffer::copy(data(), length()).release_value();
}
String StringBuilder::to_string() const

33
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -213,7 +213,10 @@ KResult Ext2FSInode::write_indirect_block(BlockBasedFileSystem::BlockIndex block
const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
VERIFY(blocks_indices.size() <= entries_per_block);
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto block_contents_result = ByteBuffer::create_uninitialized(fs().block_size());
if (!block_contents_result.has_value())
return ENOMEM;
auto block_contents = block_contents_result.release_value();
OutputMemoryStream stream { block_contents };
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
@ -235,7 +238,10 @@ KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex
VERIFY(blocks_indices.size() > old_blocks_length);
VERIFY(blocks_indices.size() <= entries_per_doubly_indirect_block);
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto block_contents_result = ByteBuffer::create_uninitialized(fs().block_size());
if (!block_contents_result.has_value())
return ENOMEM;
auto block_contents = block_contents_result.release_value();
auto* block_as_pointers = (unsigned*)block_contents.data();
OutputMemoryStream stream { block_contents };
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
@ -275,7 +281,10 @@ KResult Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::BlockInd
VERIFY(old_blocks_length >= new_blocks_length);
VERIFY(new_blocks_length <= entries_per_doubly_indirect_block);
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto block_contents_result = ByteBuffer::create_uninitialized(fs().block_size());
if (!block_contents_result.has_value())
return ENOMEM;
auto block_contents = block_contents_result.release_value();
auto* block_as_pointers = (unsigned*)block_contents.data();
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers));
TRY(fs().read_block(block, &buffer, fs().block_size()));
@ -308,7 +317,10 @@ KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex
VERIFY(blocks_indices.size() > old_blocks_length);
VERIFY(blocks_indices.size() <= entries_per_triply_indirect_block);
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto block_contents_result = ByteBuffer::create_uninitialized(fs().block_size());
if (!block_contents_result.has_value())
return ENOMEM;
auto block_contents = block_contents_result.release_value();
auto* block_as_pointers = (unsigned*)block_contents.data();
OutputMemoryStream stream { block_contents };
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
@ -351,7 +363,10 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockInd
VERIFY(old_blocks_length >= new_blocks_length);
VERIFY(new_blocks_length <= entries_per_triply_indirect_block);
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto block_contents_result = ByteBuffer::create_uninitialized(fs().block_size());
if (!block_contents_result.has_value())
return ENOMEM;
auto block_contents = block_contents_result.release_value();
auto* block_as_pointers = (unsigned*)block_contents.data();
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers));
TRY(fs().read_block(block, &buffer, fs().block_size()));
@ -583,7 +598,8 @@ Vector<Ext2FS::BlockIndex> Ext2FSInode::compute_block_list_impl_internal(const e
if (!count)
return;
size_t read_size = count * sizeof(u32);
auto array_storage = ByteBuffer::create_uninitialized(read_size);
// FIXME: Handle possible OOM situation.
auto array_storage = ByteBuffer::create_uninitialized(read_size).release_value();
auto* array = (u32*)array_storage.data();
auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)array);
if (auto result = fs().read_block(array_block_index, &buffer, read_size, 0); result.is_error()) {
@ -1109,7 +1125,10 @@ KResult Ext2FSInode::write_directory(Vector<Ext2FSDirectoryEntry>& entries)
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::write_directory(): New directory contents to write (size {}):", identifier(), directory_size);
auto directory_data = ByteBuffer::create_uninitialized(directory_size);
auto directory_data_result = ByteBuffer::create_uninitialized(directory_size);
if (!directory_data_result.has_value())
return ENOMEM;
auto directory_data = directory_data_result.release_value();
OutputMemoryStream stream { directory_data };
for (auto& entry : entries) {

31
Kernel/Net/NE2000NetworkAdapter.cpp
View file

@ -251,7 +251,7 @@ UNMAP_AFTER_INIT int NE2000NetworkAdapter::ram_test()
out8(REG_WR_REMOTEBYTECOUNT1, 0x00);
out8(REG_WR_RECEIVECONFIGURATION, BIT_RECEIVECONFIGURATION_MON);
out8(REG_RW_COMMAND, BIT_COMMAND_DMA_ABORT | BIT_COMMAND_START);
auto buffer = ByteBuffer::create_uninitialized(NE2K_RAM_SIZE);
Array<u8, NE2K_RAM_SIZE> buffer;
const u8 patterns[3] = { 0x5a, 0xff, 0x00 };
for (int i = 0; i < 3; ++i) {
@ -412,22 +412,35 @@ void NE2000NetworkAdapter::receive()
dbgln_if(NE2000_DEBUG, "NE2000NetworkAdapter: Packet received {} length={}", (packet_ok ? "intact" : "damaged"), header.length);
if (packet_ok) {
auto packet = NetworkByteBuffer::create_uninitialized(sizeof(received_packet_header) + header.length);
int bytes_left = packet.size();
size_t bytes_in_packet = sizeof(received_packet_header) + header.length;
auto packet_result = NetworkByteBuffer::create_uninitialized(bytes_in_packet);
u8 drop_buffer[NE2K_PAGE_SIZE];
Bytes buffer { drop_buffer, array_size(drop_buffer) };
bool will_drop { false };
if (!packet_result.has_value()) {
dbgln("NE2000NetworkAdapter: Not enough memory for packet with length = {}, dropping.", header.length);
will_drop = true;
} else {
buffer = packet_result->bytes();
}
int current_offset = 0;
int ring_offset = header_address;
while (bytes_left > 0) {
int copy_size = min(bytes_left, NE2K_PAGE_SIZE);
rdma_read(ring_offset, packet.span().slice(current_offset, copy_size));
current_offset += copy_size;
while (bytes_in_packet > 0) {
int copy_size = min(bytes_in_packet, NE2K_PAGE_SIZE);
rdma_read(ring_offset, buffer.slice(current_offset, copy_size));
if (!will_drop)
current_offset += copy_size;
ring_offset += copy_size;
bytes_left -= copy_size;
bytes_in_packet -= copy_size;
if (ring_offset == NE2K_RAM_RECV_END)
ring_offset = NE2K_RAM_RECV_BEGIN;
}
did_receive(packet.span().slice(sizeof(received_packet_header)));
if (!will_drop)
did_receive(buffer.slice(sizeof(received_packet_header)));
}
if (header.next_packet_page == (NE2K_RAM_RECV_BEGIN >> 8))

8
Kernel/Net/NetworkAdapter.cpp
View file

@ -33,8 +33,12 @@ void NetworkAdapter::send_packet(ReadonlyBytes packet)
void NetworkAdapter::send(const MACAddress& destination, const ARPPacket& packet)
{
size_t size_in_bytes = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
auto buffer = NetworkByteBuffer::create_zeroed(size_in_bytes);
auto* eth = (EthernetFrameHeader*)buffer.data();
auto buffer_result = NetworkByteBuffer::create_zeroed(size_in_bytes);
if (!buffer_result.has_value()) {
dbgln("Dropping ARP packet targeted at {} as there is not enough memory to buffer it", packet.target_hardware_address().to_string());
return;
}
auto* eth = (EthernetFrameHeader*)buffer_result->data();
eth->set_source(mac_address());
eth->set_destination(destination);
eth->set_ether_type(EtherType::ARP);

16
Kernel/Random.h
View file

@ -30,8 +30,9 @@ public:
using HashType = HashT;
using DigestType = typename HashT::DigestType;
// FIXME: Do something other than VERIFY()'ing inside Optional in case of OOM.
FortunaPRNG()
: m_counter(ByteBuffer::create_zeroed(BlockType::block_size()))
: m_counter(ByteBuffer::create_zeroed(BlockType::block_size()).release_value())
{
}
@ -95,8 +96,17 @@ private:
}
}
DigestType digest = new_key.digest();
m_key = ByteBuffer::copy(digest.immutable_data(),
digest.data_length());
if (m_key.size() == digest.data_length()) {
// Avoid reallocating, just overwrite the key.
m_key.overwrite(0, digest.immutable_data(), digest.data_length());
} else {
auto buffer_result = ByteBuffer::copy(digest.immutable_data(), digest.data_length());
// If there's no memory left to copy this into, bail out.
if (!buffer_result.has_value())
return;
m_key = buffer_result.release_value();
}
m_reseed_number++;
m_p0_len = 0;

5
Kernel/Storage/IDEChannel.cpp
View file

@ -379,8 +379,9 @@ UNMAP_AFTER_INIT void IDEChannel::detect_disks()
}
}
ByteBuffer wbuf = ByteBuffer::create_uninitialized(512);
ByteBuffer bbuf = ByteBuffer::create_uninitialized(512);
// FIXME: Handle possible OOM situation here.
ByteBuffer wbuf = ByteBuffer::create_uninitialized(512).release_value();
ByteBuffer bbuf = ByteBuffer::create_uninitialized(512).release_value();
u8* b = bbuf.data();
u16* w = (u16*)wbuf.data();

10
Kernel/Storage/Partition/GUIDPartitionTable.cpp
View file

@ -58,7 +58,8 @@ Result<NonnullOwnPtr<GUIDPartitionTable>, PartitionTable::Error> GUIDPartitionTa
GUIDPartitionTable::GUIDPartitionTable(const StorageDevice& device)
: MBRPartitionTable(device)
{
m_cached_header = ByteBuffer::create_zeroed(m_device->block_size());
// FIXME: Handle OOM failure here.
m_cached_header = ByteBuffer::create_zeroed(m_device->block_size()).release_value();
VERIFY(partitions_count() == 0);
if (!initialize())
m_valid = false;
@ -87,7 +88,12 @@ bool GUIDPartitionTable::initialize()
return false;
}
auto entries_buffer = ByteBuffer::create_zeroed(m_device->block_size());
auto entries_buffer_result = ByteBuffer::create_zeroed(m_device->block_size());
if (!entries_buffer_result.has_value()) {
dbgln("GUIPartitionTable: not enough memory for entries buffer");
return false;
}
auto entries_buffer = entries_buffer_result.release_value();
auto raw_entries_buffer = UserOrKernelBuffer::for_kernel_buffer(entries_buffer.data());
size_t raw_byte_index = header().partition_array_start_lba * m_device->block_size();
for (size_t entry_index = 0; entry_index < header().entries_count; entry_index++) {

4
Kernel/Storage/Partition/MBRPartitionTable.cpp
View file

@ -47,7 +47,7 @@ bool MBRPartitionTable::read_boot_record()
MBRPartitionTable::MBRPartitionTable(const StorageDevice& device, u32 start_lba)
: PartitionTable(device)
, m_start_lba(start_lba)
, m_cached_header(ByteBuffer::create_zeroed(m_device->block_size()))
, m_cached_header(ByteBuffer::create_zeroed(m_device->block_size()).release_value()) // FIXME: Do something sensible if this fails because of OOM.
{
if (!read_boot_record() || !initialize())
return;
@ -68,7 +68,7 @@ MBRPartitionTable::MBRPartitionTable(const StorageDevice& device, u32 start_lba)
MBRPartitionTable::MBRPartitionTable(const StorageDevice& device)
: PartitionTable(device)
, m_start_lba(0)
, m_cached_header(ByteBuffer::create_zeroed(m_device->block_size()))
, m_cached_header(ByteBuffer::create_zeroed(m_device->block_size()).release_value()) // FIXME: Do something sensible if this fails because of OOM.
{
if (!read_boot_record() || contains_ebr() || is_protective_mbr() || !initialize())
return;

8
Kernel/Storage/StorageDevice.cpp
View file

@ -73,7 +73,10 @@ KResultOr<size_t> StorageDevice::read(FileDescription&, u64 offset, UserOrKernel
off_t pos = whole_blocks * block_size();
if (remaining > 0) {
auto data = ByteBuffer::create_uninitialized(block_size());
auto data_result = ByteBuffer::create_uninitialized(block_size());
if (!data_result.has_value())
return ENOMEM;
auto data = data_result.release_value();
auto data_buffer = UserOrKernelBuffer::for_kernel_buffer(data.data());
auto read_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Read, index + whole_blocks, 1, data_buffer, block_size());
auto result = read_request->wait();
@ -141,7 +144,8 @@ KResultOr<size_t> StorageDevice::write(FileDescription&, u64 offset, const UserO
// partial write, we have to read the block's content first, modify it,
// then write the whole block back to the disk.
if (remaining > 0) {
auto data = ByteBuffer::create_zeroed(block_size());
// FIXME: Do something sensible with this OOM scenario.
auto data = ByteBuffer::create_zeroed(block_size()).release_value();
auto data_buffer = UserOrKernelBuffer::for_kernel_buffer(data.data());
{

2
Meta/Lagom/Fuzzers/FuzzFlacLoader.cpp
View file

@ -10,7 +10,7 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto flac_data = ByteBuffer::copy(data, size);
auto flac_data = ByteBuffer::copy(data, size).release_value();
auto flac = make<Audio::FlacLoaderPlugin>(flac_data);
if (!flac->sniff())

4
Meta/Lagom/Fuzzers/FuzzIMAPParser.cpp
View file

@ -11,7 +11,7 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto parser = IMAP::Parser();
parser.parse(ByteBuffer::copy(data, size), true);
parser.parse(ByteBuffer::copy(data, size), false);
parser.parse(ByteBuffer::copy(data, size).release_value(), true);
parser.parse(ByteBuffer::copy(data, size).release_value(), false);
return 0;
}

3
Meta/Lagom/Fuzzers/FuzzMD5.cpp
View file

@ -10,7 +10,6 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto buffer = ByteBuffer::copy(data, size);
Crypto::Hash::MD5::hash(buffer);
Crypto::Hash::MD5::hash(data, size);
return 0;
}

3
Meta/Lagom/Fuzzers/FuzzRSAKeyParsing.cpp
View file

@ -10,7 +10,6 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
ByteBuffer rsa_data = ByteBuffer::copy(data, size);
Crypto::PK::RSA::parse_rsa_key(rsa_data);
Crypto::PK::RSA::parse_rsa_key({ data, size });
return 0;
}

3
Meta/Lagom/Fuzzers/FuzzSHA1.cpp
View file

@ -10,7 +10,6 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto buffer = ByteBuffer::copy(data, size);
Crypto::Hash::SHA1::hash(buffer);
Crypto::Hash::SHA1::hash(data, size);
return 0;
}

3
Meta/Lagom/Fuzzers/FuzzSHA256.cpp
View file

@ -10,7 +10,6 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto buffer = ByteBuffer::copy(data, size);
Crypto::Hash::SHA256::hash(buffer);
Crypto::Hash::SHA256::hash(data, size);
return 0;
}

3
Meta/Lagom/Fuzzers/FuzzSHA384.cpp
View file

@ -10,7 +10,6 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto buffer = ByteBuffer::copy(data, size);
Crypto::Hash::SHA384::hash(buffer);
Crypto::Hash::SHA384::hash(data, size);
return 0;
}

3
Meta/Lagom/Fuzzers/FuzzSHA512.cpp
View file

@ -10,7 +10,6 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto buffer = ByteBuffer::copy(data, size);
Crypto::Hash::SHA512::hash(buffer);
Crypto::Hash::SHA512::hash(data, size);
return 0;
}

2
Meta/Lagom/Fuzzers/FuzzWAVLoader.cpp
View file

@ -10,7 +10,7 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
auto wav_data = ByteBuffer::copy(data, size);
auto wav_data = ByteBuffer::copy(data, size).release_value();
auto wav = make<Audio::WavLoaderPlugin>(wav_data);
if (!wav->sniff())

3
Meta/Lagom/Fuzzers/FuzzZip.cpp
View file

@ -10,8 +10,7 @@
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
ByteBuffer zip_data = ByteBuffer::copy(data, size);
auto zip_file = Archive::Zip::try_create(zip_data);
auto zip_file = Archive::Zip::try_create({ data, size });
if (!zip_file.has_value())
return 0;

6
Tests/AK/TestByteBuffer.cpp
View file

@ -10,10 +10,10 @@
TEST_CASE(equality_operator)
{
ByteBuffer a = ByteBuffer::copy("Hello, world", 7);
ByteBuffer b = ByteBuffer::copy("Hello, friend", 7);
ByteBuffer a = ByteBuffer::copy("Hello, world", 7).release_value();
ByteBuffer b = ByteBuffer::copy("Hello, friend", 7).release_value();
// `a` and `b` are both "Hello, ".
ByteBuffer c = ByteBuffer::copy("asdf", 4);
ByteBuffer c = ByteBuffer::copy("asdf", 4).release_value();
ByteBuffer d;
EXPECT_EQ(a == a, true);
EXPECT_EQ(a == b, true);

7
Tests/Kernel/stress-writeread.cpp
View file

@ -84,7 +84,12 @@ int main(int argc, char** argv)
args_parser.add_positional_argument(target, "Target device/file path", "target");
args_parser.parse(argc, argv);
auto buffer = AK::ByteBuffer::create_zeroed(block_size);
auto buffer_result = AK::ByteBuffer::create_zeroed(block_size);
if (!buffer_result.has_value()) {
warnln("Failed to allocate a buffer of {} bytes", block_size);
return EXIT_FAILURE;
}
auto buffer = buffer_result.release_value();
int fd = open(target, O_CREAT | O_RDWR, 0666);
if (fd < 0) {

2
Tests/LibC/TestSnprintf.cpp
View file

@ -53,7 +53,7 @@ static bool test_single(const Testcase& testcase)
}
// Setup
ByteBuffer actual = ByteBuffer::create_uninitialized(SANDBOX_CANARY_SIZE + testcase.dest_n + SANDBOX_CANARY_SIZE);
ByteBuffer actual = ByteBuffer::create_uninitialized(SANDBOX_CANARY_SIZE + testcase.dest_n + SANDBOX_CANARY_SIZE).release_value();
fill_with_random(actual.data(), actual.size());
ByteBuffer expected = actual;
VERIFY(actual.offset_pointer(0) != expected.offset_pointer(0));

2
Tests/LibC/TestStrlcpy.cpp
View file

@ -55,7 +55,7 @@ static bool test_single(const Testcase& testcase)
}
// Setup
ByteBuffer actual = ByteBuffer::create_uninitialized(SANDBOX_CANARY_SIZE + testcase.dest_n + SANDBOX_CANARY_SIZE);
ByteBuffer actual = ByteBuffer::create_uninitialized(SANDBOX_CANARY_SIZE + testcase.dest_n + SANDBOX_CANARY_SIZE).release_value();
fill_with_random(actual.data(), actual.size());
ByteBuffer expected = actual;
VERIFY(actual.offset_pointer(0) != expected.offset_pointer(0));

6
Tests/LibCompress/TestDeflate.cpp
View file

@ -113,7 +113,7 @@ TEST_CASE(deflate_decompress_zeroes)
TEST_CASE(deflate_round_trip_store)
{
auto original = ByteBuffer::create_uninitialized(1024);
auto original = ByteBuffer::create_uninitialized(1024).release_value();
fill_with_random(original.data(), 1024);
auto compressed = Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::STORE);
EXPECT(compressed.has_value());
@ -124,7 +124,7 @@ TEST_CASE(deflate_round_trip_store)
TEST_CASE(deflate_round_trip_compress)
{
auto original = ByteBuffer::create_zeroed(2048);
auto original = ByteBuffer::create_zeroed(2048).release_value();
fill_with_random(original.data(), 1024); // we pre-filled the second half with 0s to make sure we test back references as well
// Since the different levels just change how much time is spent looking for better matches, just use fast here to reduce test time
auto compressed = Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::FAST);
@ -137,7 +137,7 @@ TEST_CASE(deflate_round_trip_compress)
TEST_CASE(deflate_round_trip_compress_large)
{
auto size = Compress::DeflateCompressor::block_size * 2;
auto original = ByteBuffer::create_uninitialized(size); // Compress a buffer larger than the maximum block size to test the sliding window mechanism
auto original = ByteBuffer::create_uninitialized(size).release_value(); // Compress a buffer larger than the maximum block size to test the sliding window mechanism
fill_with_random(original.data(), size);
// Since the different levels just change how much time is spent looking for better matches, just use fast here to reduce test time
auto compressed = Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::FAST);

2
Tests/LibCompress/TestGzip.cpp
View file

@ -87,7 +87,7 @@ TEST_CASE(gzip_decompress_repeat_around_buffer)
TEST_CASE(gzip_round_trip)
{
auto original = ByteBuffer::create_uninitialized(1024);
auto original = ByteBuffer::create_uninitialized(1024).release_value();
fill_with_random(original.data(), 1024);
auto compressed = Compress::GzipCompressor::compress_all(original);
EXPECT(compressed.has_value());

36
Tests/LibCrypto/TestAES.cpp
View file

@ -12,7 +12,7 @@
static ByteBuffer operator""_b(const char* string, size_t length)
{
return ByteBuffer::copy(string, length);
return ByteBuffer::copy(string, length).release_value();
}
TEST_CASE(test_AES_CBC_name)
@ -23,8 +23,8 @@ TEST_CASE(test_AES_CBC_name)
static auto test_aes_cbc_encrypt = [](auto& cipher, auto& result) {
auto in = "This is a test! This is another test!"_b;
auto out = cipher.create_aligned_buffer(in.size());
auto iv = ByteBuffer::create_zeroed(Crypto::Cipher::AESCipher::block_size());
auto out = cipher.create_aligned_buffer(in.size()).release_value();
auto iv = ByteBuffer::create_zeroed(Crypto::Cipher::AESCipher::block_size()).release_value();
auto out_span = out.bytes();
cipher.encrypt(in, out_span, iv);
EXPECT_EQ(out.size(), sizeof(result));
@ -84,9 +84,9 @@ TEST_CASE(test_AES_CBC_encrypt_with_unsigned_256bit_key)
static auto test_aes_cbc_decrypt = [](auto& cipher, auto& result, auto result_len) {
auto true_value = "This is a test! This is another test!";
auto in = ByteBuffer::copy(result, result_len);
auto out = cipher.create_aligned_buffer(in.size());
auto iv = ByteBuffer::create_zeroed(Crypto::Cipher::AESCipher::block_size());
auto in = ByteBuffer::copy(result, result_len).release_value();
auto out = cipher.create_aligned_buffer(in.size()).release_value();
auto iv = ByteBuffer::create_zeroed(Crypto::Cipher::AESCipher::block_size()).release_value();
auto out_span = out.bytes();
cipher.decrypt(in, out_span, iv);
EXPECT_EQ(out_span.size(), strlen(true_value));
@ -142,7 +142,7 @@ TEST_CASE(test_AES_CTR_name)
static auto test_aes_ctr_encrypt = [](auto key, auto ivec, auto in, auto out_expected) {
// nonce is already included in ivec.
Crypto::Cipher::AESCipher::CTRMode cipher(key, 8 * key.size(), Crypto::Cipher::Intent::Encryption);
ByteBuffer out_actual = ByteBuffer::create_zeroed(in.size());
ByteBuffer out_actual = ByteBuffer::create_zeroed(in.size()).release_value();
Bytes out_span = out_actual.bytes();
cipher.encrypt(in, out_span, ivec);
EXPECT_EQ(out_expected.size(), out_actual.size());
@ -309,7 +309,7 @@ TEST_CASE(test_AES_CTR_256bit_encrypt_36bytes_with_high_counter)
static auto test_aes_ctr_decrypt = [](auto key, auto ivec, auto in, auto out_expected) {
// nonce is already included in ivec.
Crypto::Cipher::AESCipher::CTRMode cipher(key, 8 * key.size(), Crypto::Cipher::Intent::Decryption);
ByteBuffer out_actual = ByteBuffer::create_zeroed(in.size());
ByteBuffer out_actual = ByteBuffer::create_zeroed(in.size()).release_value();
auto out_span = out_actual.bytes();
cipher.decrypt(in, out_span, ivec);
EXPECT_EQ(out_expected.size(), out_span.size());
@ -347,7 +347,7 @@ TEST_CASE(test_AES_GCM_128bit_encrypt_empty)
Crypto::Cipher::AESCipher::GCMMode cipher("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b, 128, Crypto::Cipher::Intent::Encryption);
u8 result_tag[] { 0x58, 0xe2, 0xfc, 0xce, 0xfa, 0x7e, 0x30, 0x61, 0x36, 0x7f, 0x1d, 0x57, 0xa4, 0xe7, 0x45, 0x5a };
Bytes out;
auto tag = ByteBuffer::create_uninitialized(16);
auto tag = ByteBuffer::create_uninitialized(16).release_value();
cipher.encrypt({}, out, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b.bytes(), {}, tag);
EXPECT(memcmp(result_tag, tag.data(), tag.size()) == 0);
}
@ -357,8 +357,8 @@ TEST_CASE(test_AES_GCM_128bit_encrypt_zeros)
Crypto::Cipher::AESCipher::GCMMode cipher("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b, 128, Crypto::Cipher::Intent::Encryption);
u8 result_tag[] { 0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd, 0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf };
u8 result_ct[] { 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92, 0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78 };
auto tag = ByteBuffer::create_uninitialized(16);
auto out = ByteBuffer::create_uninitialized(16);
auto tag = ByteBuffer::create_uninitialized(16).release_value();
auto out = ByteBuffer::create_uninitialized(16).release_value();
auto out_bytes = out.bytes();
cipher.encrypt("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b.bytes(), out_bytes, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b.bytes(), {}, tag);
EXPECT(memcmp(result_ct, out.data(), out.size()) == 0);
@ -370,8 +370,8 @@ TEST_CASE(test_AES_GCM_128bit_encrypt_multiple_blocks_with_iv)
Crypto::Cipher::AESCipher::GCMMode cipher("\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08"_b, 128, Crypto::Cipher::Intent::Encryption);
u8 result_tag[] { 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6, 0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4 };
u8 result_ct[] { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c, 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85 };
auto tag = ByteBuffer::create_uninitialized(16);
auto out = ByteBuffer::create_uninitialized(64);
auto tag = ByteBuffer::create_uninitialized(16).release_value();
auto out = ByteBuffer::create_uninitialized(64).release_value();
auto out_bytes = out.bytes();
cipher.encrypt(
"\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39\x1a\xaf\xd2\x55"_b.bytes(),
@ -388,8 +388,8 @@ TEST_CASE(test_AES_GCM_128bit_encrypt_with_aad)
Crypto::Cipher::AESCipher::GCMMode cipher("\xfe\xff\xe9\x92\x86\x65\x73\x1c\x6d\x6a\x8f\x94\x67\x30\x83\x08"_b, 128, Crypto::Cipher::Intent::Encryption);
u8 result_tag[] { 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6, 0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4 };
u8 result_ct[] { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c, 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85 };
auto tag = ByteBuffer::create_uninitialized(16);
auto out = ByteBuffer::create_uninitialized(64);
auto tag = ByteBuffer::create_uninitialized(16).release_value();
auto out = ByteBuffer::create_uninitialized(64).release_value();
auto out_bytes = out.bytes();
cipher.encrypt(
"\xd9\x31\x32\x25\xf8\x84\x06\xe5\xa5\x59\x09\xc5\xaf\xf5\x26\x9a\x86\xa7\xa9\x53\x15\x34\xf7\xda\x2e\x4c\x30\x3d\x8a\x31\x8a\x72\x1c\x3c\x0c\x95\x95\x68\x09\x53\x2f\xcf\x0e\x24\x49\xa6\xb5\x25\xb1\x6a\xed\xf5\xaa\x0d\xe6\x57\xba\x63\x7b\x39\x1a\xaf\xd2\x55"_b.bytes(),
@ -417,7 +417,7 @@ TEST_CASE(test_AES_GCM_128bit_decrypt_zeros)
u8 input_tag[] { 0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd, 0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf };
u8 input_ct[] { 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92, 0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78 };
u8 result_pt[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
auto out = ByteBuffer::create_uninitialized(16);
auto out = ByteBuffer::create_uninitialized(16).release_value();
auto out_bytes = out.bytes();
auto consistency = cipher.decrypt({ input_ct, 16 }, out_bytes, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b.bytes(), {}, { input_tag, 16 });
EXPECT_EQ(consistency, Crypto::VerificationConsistency::Consistent);
@ -430,7 +430,7 @@ TEST_CASE(test_AES_GCM_128bit_decrypt_multiple_blocks_with_iv)
u8 input_tag[] { 0xab, 0x6e, 0x47, 0xd4, 0x2c, 0xec, 0x13, 0xbd, 0xf5, 0x3a, 0x67, 0xb2, 0x12, 0x57, 0xbd, 0xdf };
u8 input_ct[] { 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92, 0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78 };
u8 result_pt[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
auto out = ByteBuffer::create_uninitialized(16);
auto out = ByteBuffer::create_uninitialized(16).release_value();
auto out_bytes = out.bytes();
auto consistency = cipher.decrypt({ input_ct, 16 }, out_bytes, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"_b.bytes(), {}, { input_tag, 16 });
EXPECT_EQ(consistency, Crypto::VerificationConsistency::Consistent);
@ -443,7 +443,7 @@ TEST_CASE(test_AES_GCM_128bit_decrypt_multiple_blocks_with_aad)
u8 input_tag[] { 0x93, 0xae, 0x16, 0x97, 0x49, 0xa3, 0xbf, 0x39, 0x4f, 0x61, 0xb7, 0xc1, 0xb1, 0x2, 0x4f, 0x60 };
u8 input_ct[] { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c, 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85 };
u8 result_pt[] { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a, 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, 0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53, 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, 0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55 };
auto out = ByteBuffer::create_uninitialized(64);
auto out = ByteBuffer::create_uninitialized(64).release_value();
auto out_bytes = out.bytes();
auto consistency = cipher.decrypt(
{ input_ct, 64 },

2
Tests/LibCrypto/TestRSA.cpp
View file

@ -12,7 +12,7 @@
static ByteBuffer operator""_b(const char* string, size_t length)
{
return ByteBuffer::copy(string, length);
return ByteBuffer::copy(string, length).release_value();
}
TEST_CASE(test_RSA_raw_encrypt)

2
Tests/LibIMAP/TestQuotedPrintable.cpp
View file

@ -17,7 +17,7 @@ TEST_CASE(test_decode)
auto decode_equal_byte_buffer = [](const char* input, const char* expected, size_t expected_length) {
auto decoded = IMAP::decode_quoted_printable(StringView(input));
EXPECT(decoded == ByteBuffer::copy(expected, expected_length));
EXPECT(decoded == *ByteBuffer::copy(expected, expected_length));
};
decode_equal("hello world", "hello world");

4
Tests/LibTLS/TestTLSHandshake.cpp
View file

@ -18,7 +18,7 @@ constexpr const char* DEFAULT_SERVER { "www.google.com" };
static ByteBuffer operator""_b(const char* string, size_t length)
{
return ByteBuffer::copy(string, length);
return ByteBuffer::copy(string, length).release_value();
}
Vector<Certificate> load_certificates();
@ -69,7 +69,7 @@ TEST_CASE(test_TLS_hello_handshake)
RefPtr<TLS::TLSv12> tls = TLS::TLSv12::construct(nullptr);
tls->set_root_certificates(s_root_ca_certificates);
bool sent_request = false;
ByteBuffer contents = ByteBuffer::create_uninitialized(0);
ByteBuffer contents;
tls->on_tls_ready_to_write = [&](TLS::TLSv12& tls) {
if (sent_request)
return;

3
Userland/Applications/FontEditor/GlyphEditorWidget.cpp
View file

@ -80,8 +80,7 @@ void GlyphEditorWidget::copy_glyph()
metadata.set("width", String::number(bitmap.width()));
metadata.set("height", String::number(bitmap.height()));
auto data = ByteBuffer::copy(&bits[0], bitmap.width() * bitmap.height());
GUI::Clipboard::the().set_data(data, "glyph/x-fonteditor", metadata);
GUI::Clipboard::the().set_data(ReadonlyBytes(&bits[0], bitmap.width() * bitmap.height()), "glyph/x-fonteditor", metadata);
}
void GlyphEditorWidget::paste_glyph()

7
Userland/Applications/HexEditor/HexEditorWidget.cpp
View file

@ -75,7 +75,12 @@ HexEditorWidget::HexEditorWidget()
auto file_size = value.to_int();
if (file_size.has_value() && file_size.value() > 0) {
m_document_dirty = false;
m_editor->set_buffer(ByteBuffer::create_zeroed(file_size.value()));
auto buffer_result = ByteBuffer::create_zeroed(file_size.value());
if (!buffer_result.has_value()) {
GUI::MessageBox::show(window(), "Entered file size is too large.", "Error", GUI::MessageBox::Type::Error);
return;
}
m_editor->set_buffer(buffer_result.release_value());
set_path({});
update_title();
} else {

3
Userland/Applications/ImageViewer/ViewWidget.cpp
View file

@ -242,8 +242,7 @@ void ViewWidget::load_from_file(const String& path)
// Spawn a new ImageDecoder service process and connect to it.
auto client = ImageDecoderClient::Client::construct();
// FIXME: Find a way to avoid the memory copying here.
auto decoded_image_or_error = client->decode_image(ByteBuffer::copy(mapped_file.bytes()));
auto decoded_image_or_error = client->decode_image(mapped_file.bytes());
if (!decoded_image_or_error.has_value()) {
show_error();
return;

2
Userland/Applications/PixelPaint/Image.cpp
View file

@ -56,7 +56,7 @@ void Image::paint_into(GUI::Painter& painter, Gfx::IntRect const& dest_rect) con
}
}
RefPtr<Gfx::Bitmap> Image::try_decode_bitmap(ByteBuffer const& bitmap_data)
RefPtr<Gfx::Bitmap> Image::try_decode_bitmap(ReadonlyBytes const& bitmap_data)
{
// Spawn a new ImageDecoder service process and connect to it.
auto client = ImageDecoderClient::Client::construct();

2
Userland/Applications/PixelPaint/Image.h
View file

@ -50,7 +50,7 @@ public:
static Result<NonnullRefPtr<Image>, String> try_create_from_pixel_paint_json(JsonObject const&);
static RefPtr<Image> try_create_from_bitmap(NonnullRefPtr<Gfx::Bitmap>);
static RefPtr<Gfx::Bitmap> try_decode_bitmap(const ByteBuffer& bitmap_data);
static RefPtr<Gfx::Bitmap> try_decode_bitmap(const ReadonlyBytes& bitmap_data);
// This generates a new Bitmap with the final image (all layers composed according to their attributes.)
RefPtr<Gfx::Bitmap> try_compose_bitmap(Gfx::BitmapFormat format) const;

2
Userland/Applications/PixelPaint/ProjectLoader.cpp
View file

@ -35,7 +35,7 @@ Result<void, String> ProjectLoader::try_load_from_fd_and_close(int fd, StringVie
auto& mapped_file = *file_or_error.value();
// FIXME: Find a way to avoid the memory copy here.
auto bitmap = Image::try_decode_bitmap(ByteBuffer::copy(mapped_file.bytes()));
auto bitmap = Image::try_decode_bitmap(mapped_file.bytes());
if (!bitmap)
return String { "Unable to decode image"sv };
auto image = Image::try_create_from_bitmap(bitmap.release_nonnull());

2
Userland/Applications/Spreadsheet/ExportDialog.cpp
View file

@ -35,7 +35,7 @@ CSVExportDialogPage::CSVExportDialogPage(const Sheet& sheet)
m_headers.extend(m_data.take_first());
auto temp_template = String::formatted("{}/spreadsheet-csv-export.{}.XXXXXX", Core::StandardPaths::tempfile_directory(), getpid());
auto temp_path = ByteBuffer::create_uninitialized(temp_template.length() + 1);
auto temp_path = ByteBuffer::create_uninitialized(temp_template.length() + 1).release_value();
auto buf = reinterpret_cast<char*>(temp_path.data());
auto copy_ok = temp_template.copy_characters_to_buffer(buf, temp_path.size());
VERIFY(copy_ok);

2
Userland/Applications/Spreadsheet/Readers/Test/TestXSV.cpp
View file

@ -85,7 +85,7 @@ BENCHMARK_CASE(fairly_big_data)
{
constexpr auto num_rows = 100000u;
constexpr auto line = "well,hello,friends,1,2,3,4,5,6,7,8,pizza,guacamole\n"sv;
auto buf = ByteBuffer::create_uninitialized((line.length() * num_rows) + 1);
auto buf = ByteBuffer::create_uninitialized((line.length() * num_rows) + 1).release_value();
buf[buf.size() - 1] = '\0';
for (size_t row = 0; row <= num_rows; ++row) {

6
Userland/Applications/Spreadsheet/Writers/Test/TestXSVWriter.cpp
View file

@ -18,7 +18,7 @@ TEST_CASE(can_write)
{ 7, 8, 9 },
};
auto buffer = ByteBuffer::create_uninitialized(1024);
auto buffer = ByteBuffer::create_uninitialized(1024).release_value();
OutputMemoryStream stream { buffer };
Writer::CSV csv(stream, data);
@ -39,7 +39,7 @@ TEST_CASE(can_write_with_header)
{ 7, 8, 9 },
};
auto buffer = ByteBuffer::create_uninitialized(1024);
auto buffer = ByteBuffer::create_uninitialized(1024).release_value();
OutputMemoryStream stream { buffer };
Writer::CSV csv(stream, data, { "A", "B\"", "C" });
@ -60,7 +60,7 @@ TEST_CASE(can_write_with_different_behaviours)
{ "We\"ll", "Hello,", " Friends" },
};
auto buffer = ByteBuffer::create_uninitialized(1024);
auto buffer = ByteBuffer::create_uninitialized(1024).release_value();
OutputMemoryStream stream { buffer };
Writer::CSV csv(stream, data, { "A", "B\"", "C" }, Writer::WriterBehaviour::QuoteOnlyInFieldStart | Writer::WriterBehaviour::WriteHeaders);

87
Userland/DevTools/UserspaceEmulator/Emulator_syscalls.cpp
View file

@ -413,7 +413,10 @@ int Emulator::virt$setsockopt(FlatPtr params_addr)
mmu().copy_from_vm(&params, params_addr, sizeof(params));
if (params.option == SO_RCVTIMEO || params.option == SO_TIMESTAMP) {
auto host_value_buffer = ByteBuffer::create_zeroed(params.value_size);
auto host_value_buffer_result = ByteBuffer::create_zeroed(params.value_size);
if (!host_value_buffer_result.has_value())
return -ENOMEM;
auto& host_value_buffer = host_value_buffer_result.value();
mmu().copy_from_vm(host_value_buffer.data(), (FlatPtr)params.value, params.value_size);
int rc = setsockopt(params.sockfd, params.level, params.option, host_value_buffer.data(), host_value_buffer.size());
if (rc < 0)
@ -542,7 +545,10 @@ int Emulator::virt$get_process_name(FlatPtr buffer, int size)
{
if (size < 0)
return -EINVAL;
auto host_buffer = ByteBuffer::create_zeroed((size_t)size);
auto host_buffer_result = ByteBuffer::create_zeroed((size_t)size);
if (!host_buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = host_buffer_result.value();
int rc = syscall(SC_get_process_name, host_buffer.data(), host_buffer.size());
mmu().copy_to_vm(buffer, host_buffer.data(), host_buffer.size());
return rc;
@ -582,13 +588,20 @@ int Emulator::virt$recvmsg(int sockfd, FlatPtr msg_addr, int flags)
Vector<ByteBuffer, 1> buffers;
Vector<iovec, 1> iovs;
for (const auto& iov : mmu_iovs) {
buffers.append(ByteBuffer::create_uninitialized(iov.iov_len));
auto buffer_result = ByteBuffer::create_uninitialized(iov.iov_len);
if (!buffer_result.has_value())
return -ENOMEM;
buffers.append(buffer_result.release_value());
iovs.append({ buffers.last().data(), buffers.last().size() });
}
ByteBuffer control_buffer;
if (mmu_msg.msg_control)
control_buffer = ByteBuffer::create_uninitialized(mmu_msg.msg_controllen);
if (mmu_msg.msg_control) {
auto buffer_result = ByteBuffer::create_uninitialized(mmu_msg.msg_controllen);
if (!buffer_result.has_value())
return -ENOMEM;
control_buffer = buffer_result.release_value();
}
sockaddr_storage addr;
msghdr msg = { &addr, sizeof(addr), iovs.data(), (int)iovs.size(), mmu_msg.msg_control ? control_buffer.data() : nullptr, mmu_msg.msg_controllen, mmu_msg.msg_flags };
@ -625,8 +638,12 @@ int Emulator::virt$sendmsg(int sockfd, FlatPtr msg_addr, int flags)
}
ByteBuffer control_buffer;
if (mmu_msg.msg_control)
control_buffer = ByteBuffer::create_uninitialized(mmu_msg.msg_controllen);
if (mmu_msg.msg_control) {
auto buffer_result = ByteBuffer::create_uninitialized(mmu_msg.msg_controllen);
if (!buffer_result.has_value())
return -ENOMEM;
control_buffer = buffer_result.release_value();
}
sockaddr_storage address;
socklen_t address_length = 0;
@ -733,7 +750,10 @@ int Emulator::virt$getgroups(ssize_t count, FlatPtr groups)
if (!count)
return syscall(SC_getgroups, 0, nullptr);
auto buffer = ByteBuffer::create_uninitialized(count * sizeof(gid_t));
auto buffer_result = ByteBuffer::create_uninitialized(count * sizeof(gid_t));
if (!buffer_result.has_value())
return -ENOMEM;
auto& buffer = buffer_result.value();
int rc = syscall(SC_getgroups, count, buffer.data());
if (rc < 0)
return rc;
@ -858,7 +878,10 @@ u32 Emulator::virt$mmap(u32 params_addr)
String name_str;
if (params.name.characters) {
auto name = ByteBuffer::create_uninitialized(params.name.length);
auto buffer_result = ByteBuffer::create_uninitialized(params.name.length);
if (!buffer_result.has_value())
return -ENOMEM;
auto& name = buffer_result.value();
mmu().copy_from_vm(name.data(), (FlatPtr)params.name.characters, params.name.length);
name_str = { name.data(), name.size() };
}
@ -1002,7 +1025,10 @@ u32 Emulator::virt$read(int fd, FlatPtr buffer, ssize_t size)
{
if (size < 0)
return -EINVAL;
auto local_buffer = ByteBuffer::create_uninitialized(size);
auto buffer_result = ByteBuffer::create_uninitialized(size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& local_buffer = buffer_result.value();
int nread = syscall(SC_read, fd, local_buffer.data(), local_buffer.size());
if (nread < 0) {
if (nread == -EPERM) {
@ -1029,7 +1055,10 @@ void Emulator::virt$exit(int status)
ssize_t Emulator::virt$getrandom(FlatPtr buffer, size_t buffer_size, unsigned int flags)
{
auto host_buffer = ByteBuffer::create_uninitialized(buffer_size);
auto buffer_result = ByteBuffer::create_uninitialized(buffer_size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
int rc = syscall(SC_getrandom, host_buffer.data(), host_buffer.size(), flags);
if (rc < 0)
return rc;
@ -1039,7 +1068,10 @@ ssize_t Emulator::virt$getrandom(FlatPtr buffer, size_t buffer_size, unsigned in
int Emulator::virt$get_dir_entries(int fd, FlatPtr buffer, ssize_t size)
{
auto host_buffer = ByteBuffer::create_uninitialized(size);
auto buffer_result = ByteBuffer::create_uninitialized(size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
int rc = syscall(SC_get_dir_entries, fd, host_buffer.data(), host_buffer.size());
if (rc < 0)
return rc;
@ -1215,7 +1247,10 @@ int Emulator::virt$realpath(FlatPtr params_addr)
mmu().copy_from_vm(&params, params_addr, sizeof(params));
auto path = mmu().copy_buffer_from_vm((FlatPtr)params.path.characters, params.path.length);
auto host_buffer = ByteBuffer::create_zeroed(params.buffer.size);
auto buffer_result = ByteBuffer::create_zeroed(params.buffer.size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
Syscall::SC_realpath_params host_params;
host_params.path = { (const char*)path.data(), path.size() };
@ -1231,7 +1266,10 @@ int Emulator::virt$gethostname(FlatPtr buffer, ssize_t buffer_size)
{
if (buffer_size < 0)
return -EINVAL;
auto host_buffer = ByteBuffer::create_zeroed(buffer_size);
auto buffer_result = ByteBuffer::create_zeroed(buffer_size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
int rc = syscall(SC_gethostname, host_buffer.data(), host_buffer.size());
if (rc < 0)
return rc;
@ -1316,7 +1354,10 @@ int Emulator::virt$setpgid(pid_t pid, pid_t pgid)
int Emulator::virt$ttyname(int fd, FlatPtr buffer, size_t buffer_size)
{
auto host_buffer = ByteBuffer::create_zeroed(buffer_size);
auto buffer_result = ByteBuffer::create_zeroed(buffer_size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
int rc = syscall(SC_ttyname, fd, host_buffer.data(), host_buffer.size());
if (rc < 0)
return rc;
@ -1326,7 +1367,10 @@ int Emulator::virt$ttyname(int fd, FlatPtr buffer, size_t buffer_size)
int Emulator::virt$getcwd(FlatPtr buffer, size_t buffer_size)
{
auto host_buffer = ByteBuffer::create_zeroed(buffer_size);
auto buffer_result = ByteBuffer::create_zeroed(buffer_size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
int rc = syscall(SC_getcwd, host_buffer.data(), host_buffer.size());
if (rc < 0)
return rc;
@ -1436,12 +1480,12 @@ int Emulator::virt$clock_nanosleep(FlatPtr params_addr)
params.requested_sleep = &requested_sleep;
auto remaining_vm_addr = params.remaining_sleep;
auto remaining = ByteBuffer::create_zeroed(sizeof(timespec));
params.remaining_sleep = (timespec*)remaining.data();
timespec remaining { 0, 0 };
params.remaining_sleep = &remaining;
int rc = syscall(SC_clock_nanosleep, &params);
if (remaining_vm_addr)
mmu().copy_to_vm((FlatPtr)remaining_vm_addr, remaining.data(), sizeof(timespec));
mmu().copy_to_vm((FlatPtr)remaining_vm_addr, &remaining, sizeof(timespec));
return rc;
}
@ -1452,7 +1496,10 @@ int Emulator::virt$readlink(FlatPtr params_addr)
mmu().copy_from_vm(&params, params_addr, sizeof(params));
auto path = mmu().copy_buffer_from_vm((FlatPtr)params.path.characters, params.path.length);
auto host_buffer = ByteBuffer::create_zeroed(params.buffer.size);
auto buffer_result = ByteBuffer::create_zeroed(params.buffer.size);
if (!buffer_result.has_value())
return -ENOMEM;
auto& host_buffer = buffer_result.value();
Syscall::SC_readlink_params host_params;
host_params.path = { (const char*)path.data(), path.size() };

12
Userland/DevTools/UserspaceEmulator/SoftMMU.cpp
View file

@ -63,17 +63,17 @@ void SoftMMU::ensure_split_at(X86::LogicalAddress address)
// a previous page, and that it belongs to the same region.
auto* old_region = verify_cast<MmapRegion>(m_page_to_region_map[page_index]);
//dbgln("splitting at {:p}", address.offset());
//dbgln(" old region: {:p}-{:p}", old_region->base(), old_region->end() - 1);
// dbgln("splitting at {:p}", address.offset());
// dbgln(" old region: {:p}-{:p}", old_region->base(), old_region->end() - 1);
NonnullOwnPtr<MmapRegion> new_region = old_region->split_at(VirtualAddress(offset));
//dbgln(" new region: {:p}-{:p}", new_region->base(), new_region->end() - 1);
//dbgln(" up old region: {:p}-{:p}", old_region->base(), old_region->end() - 1);
// dbgln(" new region: {:p}-{:p}", new_region->base(), new_region->end() - 1);
// dbgln(" up old region: {:p}-{:p}", old_region->base(), old_region->end() - 1);
size_t first_page_in_region = new_region->base() / PAGE_SIZE;
size_t last_page_in_region = (new_region->base() + new_region->size() - 1) / PAGE_SIZE;
//dbgln(" @ remapping pages {} thru {}", first_page_in_region, last_page_in_region);
// dbgln(" @ remapping pages {} thru {}", first_page_in_region, last_page_in_region);
for (size_t page = first_page_in_region; page <= last_page_in_region; ++page) {
VERIFY(m_page_to_region_map[page] == old_region);
@ -321,7 +321,7 @@ void SoftMMU::copy_from_vm(void* destination, const FlatPtr source, size_t size)
ByteBuffer SoftMMU::copy_buffer_from_vm(const FlatPtr source, size_t size)
{
auto buffer = ByteBuffer::create_uninitialized(size);
auto buffer = ByteBuffer::create_uninitialized(size).release_value(); // FIXME: Handle possible OOM situation.
copy_from_vm(buffer.data(), source, size);
return buffer;
}

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

@ -134,11 +134,11 @@ bool FlacLoaderPlugin::parse_header()
ok = ok && (m_total_samples > 0);
CHECK_OK("Number of samples");
// Parse checksum into a buffer first
ByteBuffer md5_checksum = ByteBuffer::create_uninitialized(128 / 8);
Array<u8, 128 / 8> md5_checksum;
auto md5_bytes_read = streaminfo_data.read(md5_checksum);
ok = ok && (md5_bytes_read == md5_checksum.size());
CHECK_OK("MD5 Checksum");
md5_checksum.bytes().copy_to({ m_md5_checksum, sizeof(m_md5_checksum) });
md5_checksum.span().copy_to({ m_md5_checksum, sizeof(m_md5_checksum) });
// Parse other blocks
// TODO: For a simple first implementation, all other blocks are skipped as allowed by the FLAC specification.
@ -195,7 +195,12 @@ FlacRawMetadataBlock FlacLoaderPlugin::next_meta_block(InputBitStream& bit_input
u32 block_length = bit_input.read_bits_big_endian(24);
m_data_start_location += 3;
CHECK_IO_ERROR();
ByteBuffer block_data = ByteBuffer::create_uninitialized(block_length);
auto block_data_result = ByteBuffer::create_uninitialized(block_length);
if (!block_data_result.has_value()) {
m_error_string = "Out of memory";
return FlacRawMetadataBlock {};
}
auto block_data = block_data_result.release_value();
// Reads exactly the bytes necessary into the Bytes container
bit_input.read(block_data);
m_data_start_location += block_length;
@ -544,7 +549,7 @@ FlacSubframeHeader FlacLoaderPlugin::next_subframe_header(InputBitStream& bit_st
FlacSubframeType subframe_type;
u8 order = 0;
//LPC has the highest bit set
// LPC has the highest bit set
if ((subframe_code & 0b100000) > 0) {
subframe_type = FlacSubframeType::LPC;
order = (subframe_code & 0b011111) + 1;
@ -808,9 +813,10 @@ ALWAYS_INLINE i32 decode_unsigned_exp_golomb(u8 k, InputBitStream& bit_input)
u64 read_utf8_char(InputStream& input)
{
u64 character;
ByteBuffer single_byte_buffer = ByteBuffer::create_uninitialized(1);
input.read(single_byte_buffer);
u8 start_byte = single_byte_buffer[0];
u8 buffer = 0;
Bytes buffer_bytes { &buffer, 1 };
input.read(buffer_bytes);
u8 start_byte = buffer_bytes[0];
// Signal byte is zero: ASCII character
if ((start_byte & 0b10000000) == 0) {
return start_byte;
@ -826,8 +832,8 @@ u64 read_utf8_char(InputStream& input)
u8 start_byte_bitmask = AK::exp2(bits_from_start_byte) - 1;
character = start_byte_bitmask & start_byte;
for (u8 i = length - 1; i > 0; --i) {
input.read(single_byte_buffer);
u8 current_byte = single_byte_buffer[0];
input.read(buffer_bytes);
u8 current_byte = buffer_bytes[0];
character = (character << 6) | (current_byte & 0b00111111);
}
return character;

11
Userland/Libraries/LibAudio/WavLoader.cpp
View file

@ -69,7 +69,10 @@ RefPtr<Buffer> WavLoaderPlugin::get_more_samples(size_t max_bytes_to_read_from_i
bytes_to_read, m_num_channels, m_sample_rate,
pcm_bits_per_sample(m_sample_format), sample_format_name(m_sample_format));
ByteBuffer sample_data = ByteBuffer::create_zeroed(bytes_to_read);
auto sample_data_result = ByteBuffer::create_zeroed(bytes_to_read);
if (!sample_data_result.has_value())
return nullptr;
auto sample_data = sample_data_result.release_value();
m_stream->read_or_error(sample_data.bytes());
if (m_stream->handle_any_error()) {
return nullptr;
@ -244,17 +247,17 @@ bool WavLoaderPlugin::parse_header()
while (true) {
search_byte = read_u8();
CHECK_OK("Reading byte searching for data");
if (search_byte != 0x64) //D
if (search_byte != 0x64) // D
continue;
search_byte = read_u8();
CHECK_OK("Reading next byte searching for data");
if (search_byte != 0x61) //A
if (search_byte != 0x61) // A
continue;
u16 search_remaining = read_u16();
CHECK_OK("Reading remaining bytes searching for data");
if (search_remaining != 0x6174) //TA
if (search_remaining != 0x6174) // TA
continue;
data_sz = read_u32();

22
Userland/Libraries/LibCore/IODevice.cpp
View file

@ -43,7 +43,12 @@ ByteBuffer IODevice::read(size_t max_size)
return {};
if (!max_size)
return {};
auto buffer = ByteBuffer::create_uninitialized(max_size);
auto buffer_result = ByteBuffer::create_uninitialized(max_size);
if (!buffer_result.has_value()) {
dbgln("IODevice::read: Not enough memory to allocate a buffer of {} bytes", max_size);
return {};
}
auto buffer = buffer_result.release_value();
auto* buffer_ptr = (char*)buffer.data();
size_t remaining_buffer_space = buffer.size();
size_t taken_from_buffered = 0;
@ -166,7 +171,13 @@ ByteBuffer IODevice::read_all()
}
data.append((const u8*)read_buffer, nread);
}
return ByteBuffer::copy(data.data(), data.size());
auto result = ByteBuffer::copy(data);
if (result.has_value())
return result.release_value();
set_error(ENOMEM);
return {};
}
String IODevice::read_line(size_t max_size)
@ -186,7 +197,12 @@ String IODevice::read_line(size_t max_size)
m_buffered_data.clear();
return line;
}
auto line = ByteBuffer::create_uninitialized(max_size + 1);
auto line_result = ByteBuffer::create_uninitialized(max_size + 1);
if (!line_result.has_value()) {
dbgln("IODevice::read_line: Not enough memory to allocate a buffer of {} bytes", max_size + 1);
return {};
}
auto line = line_result.release_value();
size_t line_index = 0;
while (line_index < max_size) {
u8 ch = m_buffered_data[line_index];

3
Userland/Libraries/LibCore/UDPServer.cpp
View file

@ -63,7 +63,8 @@ bool UDPServer::bind(const IPv4Address& address, u16 port)
ByteBuffer UDPServer::receive(size_t size, sockaddr_in& in)
{
auto buf = ByteBuffer::create_uninitialized(size);
// FIXME: Handle possible OOM situation.
auto buf = ByteBuffer::create_uninitialized(size).release_value();
socklen_t in_len = sizeof(in);
ssize_t rlen = ::recvfrom(m_fd, buf.data(), size, 0, (sockaddr*)&in, &in_len);
if (rlen < 0) {

13
Userland/Libraries/LibCoredump/Reader.cpp
View file

@ -18,11 +18,14 @@ OwnPtr<Reader> Reader::create(const String& path)
auto file_or_error = MappedFile::map(path);
if (file_or_error.is_error())
return {};
return adopt_own(*new Reader(file_or_error.value()->bytes()));
auto decompressed_data = decompress_coredump(file_or_error.value()->bytes());
if (!decompressed_data.has_value())
return {};
return adopt_own_if_nonnull(new (nothrow) Reader(decompressed_data.release_value()));
}
Reader::Reader(ReadonlyBytes coredump_bytes)
: m_coredump_buffer(decompress_coredump(coredump_bytes))
Reader::Reader(ByteBuffer coredump_data)
: m_coredump_buffer(move(coredump_data))
, m_coredump_image(m_coredump_buffer.bytes())
{
size_t index = 0;
@ -37,14 +40,14 @@ Reader::Reader(ReadonlyBytes coredump_bytes)
VERIFY(m_notes_segment_index != -1);
}
ByteBuffer Reader::decompress_coredump(const ReadonlyBytes& raw_coredump)
Optional<ByteBuffer> Reader::decompress_coredump(const ReadonlyBytes& raw_coredump)
{
if (!Compress::GzipDecompressor::is_likely_compressed(raw_coredump))
return ByteBuffer::copy(raw_coredump); // handle old format coredumps (uncompressed)
auto decompressed_coredump = Compress::GzipDecompressor::decompress_all(raw_coredump);
if (!decompressed_coredump.has_value())
return ByteBuffer::copy(raw_coredump); // if we didn't manage to decompress it, try and parse it as decompressed coredump
return decompressed_coredump.value();
return decompressed_coredump;
}
Reader::~Reader()

4
Userland/Libraries/LibCoredump/Reader.h
View file

@ -51,9 +51,9 @@ public:
HashMap<String, String> metadata() const;
private:
Reader(ReadonlyBytes);
Reader(ByteBuffer);
static ByteBuffer decompress_coredump(const ReadonlyBytes&);
static Optional<ByteBuffer> decompress_coredump(const ReadonlyBytes&);
class NotesEntryIterator {
public:

18
Userland/Libraries/LibCrypto/Cipher/Mode/GCM.h
View file

@ -66,8 +66,14 @@ public:
void encrypt(const ReadonlyBytes& in, Bytes out, const ReadonlyBytes& iv_in, const ReadonlyBytes& aad, Bytes tag)
{
auto iv_buf = ByteBuffer::copy(iv_in.data(), iv_in.size());
auto iv = iv_buf.bytes();
auto iv_buf_result = ByteBuffer::copy(iv_in);
// Not enough memory to figure out :shrug:
if (!iv_buf_result.has_value()) {
dbgln("GCM::encrypt: Not enough memory to allocate {} bytes for IV", iv_in.size());
return;
}
auto iv = iv_buf_result->bytes();
// Increment the IV for block 0
CTR<T>::increment(iv);
@ -90,8 +96,12 @@ public:
VerificationConsistency decrypt(ReadonlyBytes in, Bytes out, ReadonlyBytes iv_in, ReadonlyBytes aad, ReadonlyBytes tag)
{
auto iv_buf = ByteBuffer::copy(iv_in.data(), iv_in.size());
auto iv = iv_buf.bytes();
auto iv_buf_result = ByteBuffer::copy(iv_in);
// Not enough memory to figure out :shrug:
if (!iv_buf_result.has_value())
return VerificationConsistency::Inconsistent;
auto iv = iv_buf_result->bytes();
// Increment the IV for block 0
CTR<T>::increment(iv);

2
Userland/Libraries/LibCrypto/Cipher/Mode/Mode.h
View file

@ -26,7 +26,7 @@ public:
const T& cipher() const { return m_cipher; }
ByteBuffer create_aligned_buffer(size_t input_size) const
Optional<ByteBuffer> create_aligned_buffer(size_t input_size) const
{
size_t remainder = (input_size + T::block_size()) % T::block_size();
if (remainder == 0)

6
Userland/Libraries/LibCrypto/Hash/HashManager.h
View file

@ -83,18 +83,18 @@ public:
Manager()
{
m_pre_init_buffer = ByteBuffer::create_zeroed(0);
m_pre_init_buffer = ByteBuffer();
}
Manager(const Manager& other) // NOT a copy constructor!
{
m_pre_init_buffer = ByteBuffer::create_zeroed(0); // will not be used
m_pre_init_buffer = ByteBuffer(); // will not be used
initialize(other.m_kind);
}
Manager(HashKind kind)
{
m_pre_init_buffer = ByteBuffer::create_zeroed(0);
m_pre_init_buffer = ByteBuffer();
initialize(kind);
}

2
Userland/Libraries/LibCrypto/NumberTheory/ModularFunctions.cpp
View file

@ -165,7 +165,7 @@ UnsignedBigInteger random_number(const UnsignedBigInteger& min, const UnsignedBi
UnsignedBigInteger base;
auto size = range.trimmed_length() * sizeof(u32) + 2;
// "+2" is intentional (see below).
auto buffer = ByteBuffer::create_uninitialized(size);
auto buffer = ByteBuffer::create_uninitialized(size).release_value(); // FIXME: Handle possible OOM situation.
auto* buf = buffer.data();
fill_with_random(buf, size);

2
Userland/Libraries/LibCrypto/PK/Code/EMSA_PSS.h
View file

@ -147,7 +147,7 @@ public:
void MGF1(ReadonlyBytes seed, size_t length, Bytes out)
{
auto& hash_fn = this->hasher();
ByteBuffer T = ByteBuffer::create_zeroed(0);
ByteBuffer T;
for (size_t counter = 0; counter < length / HashFunction::DigestSize - 1; ++counter) {
hash_fn.update(seed);
hash_fn.update((u8*)&counter, 4);

7
Userland/Libraries/LibCrypto/PK/RSA.cpp
View file

@ -198,7 +198,12 @@ RSA::KeyPairType RSA::parse_rsa_key(ReadonlyBytes der)
// Now just read it as a PKCS#1 DER.
auto data = data_result.release_value();
// FIXME: This is pretty awkward, maybe just generate a zero'd out ByteBuffer from the parser instead?
auto padded_data = ByteBuffer::create_zeroed(data.size_in_bytes());
auto padded_data_result = ByteBuffer::create_zeroed(data.size_in_bytes());
if (!padded_data_result.has_value()) {
dbgln_if(RSA_PARSE_DEBUG, "RSA PKCS#1 key parse failed: Not enough memory");
return keypair;
}
auto padded_data = padded_data_result.release_value();
padded_data.overwrite(0, data.data(), data.size_in_bytes());
return parse_rsa_key(padded_data.bytes());

8
Userland/Libraries/LibELF/DynamicLinker.cpp
View file

@ -169,7 +169,13 @@ static void allocate_tls()
return;
auto page_aligned_size = align_up_to(s_total_tls_size, PAGE_SIZE);
ByteBuffer initial_tls_data = ByteBuffer::create_zeroed(page_aligned_size);
auto initial_tls_data_result = ByteBuffer::create_zeroed(page_aligned_size);
if (!initial_tls_data_result.has_value()) {
dbgln("Failed to allocate initial TLS data");
VERIFY_NOT_REACHED();
}
auto& initial_tls_data = initial_tls_data_result.value();
// Initialize TLS data
for (const auto& entry : s_loaders) {

5
Userland/Libraries/LibGUI/Clipboard.cpp
View file

@ -56,9 +56,12 @@ Clipboard::DataAndType Clipboard::data_and_type() const
if (!response.data().is_valid())
return {};
auto data = ByteBuffer::copy(response.data().data<void>(), response.data().size());
if (!data.has_value())
return {};
auto type = response.mime_type();
auto metadata = response.metadata().entries();
return { data, type, metadata };
return { data.release_value(), type, metadata };
}
RefPtr<Gfx::Bitmap> Clipboard::bitmap() const

7
Userland/Libraries/LibGfx/BMPLoader.cpp
View file

@ -946,7 +946,12 @@ static bool uncompress_bmp_rle_data(BMPLoadingContext& context, ByteBuffer& buff
dbgln("Suspiciously large amount of RLE data");
return false;
}
buffer = ByteBuffer::create_zeroed(buffer_size);
auto buffer_result = ByteBuffer::create_zeroed(buffer_size);
if (!buffer_result.has_value()) {
dbgln("Not enough memory for buffer allocation");
return false;
}
buffer = buffer_result.release_value();
// Avoid as many if statements as possible by pulling out
// compression-dependent actions into separate lambdas

12
Userland/Libraries/LibGfx/BMPWriter.cpp
View file

@ -45,7 +45,11 @@ private:
static ByteBuffer write_pixel_data(const RefPtr<Bitmap> bitmap, int pixel_row_data_size, int bytes_per_pixel, bool include_alpha_channel)
{
int image_size = pixel_row_data_size * bitmap->height();
auto buffer = ByteBuffer::create_uninitialized(image_size);
auto buffer_result = ByteBuffer::create_uninitialized(image_size);
if (!buffer_result.has_value())
return {};
auto buffer = buffer_result.release_value();
int current_row = 0;
for (int y = bitmap->physical_height() - 1; y >= 0; --y) {
@ -95,7 +99,11 @@ ByteBuffer BMPWriter::dump(const RefPtr<Bitmap> bitmap, DibHeader dib_header)
int pixel_row_data_size = (m_bytes_per_pixel * 8 * bitmap->width() + 31) / 32 * 4;
int image_size = pixel_row_data_size * bitmap->height();
auto buffer = ByteBuffer::create_uninitialized(pixel_data_offset);
auto buffer_result = ByteBuffer::create_uninitialized(pixel_data_offset);
if (!buffer_result.has_value())
return {};
auto buffer = buffer_result.release_value();
auto pixel_data = write_pixel_data(bitmap, pixel_row_data_size, m_bytes_per_pixel, m_include_alpha_channel);
pixel_data = compress_pixel_data(pixel_data, m_compression);

3
Userland/Libraries/LibGfx/Bitmap.cpp
View file

@ -247,7 +247,8 @@ RefPtr<Bitmap> Bitmap::try_create_from_serialized_byte_buffer(ByteBuffer&& buffe
ByteBuffer Bitmap::serialize_to_byte_buffer() const
{
auto buffer = ByteBuffer::create_uninitialized(sizeof(size_t) + 4 * sizeof(unsigned) + sizeof(BitmapFormat) + sizeof(RGBA32) * palette_size(m_format) + size_in_bytes());
// FIXME: Somehow handle possible OOM situation here.
auto buffer = ByteBuffer::create_uninitialized(sizeof(size_t) + 4 * sizeof(unsigned) + sizeof(BitmapFormat) + sizeof(RGBA32) * palette_size(m_format) + size_in_bytes()).release_value();
OutputMemoryStream stream { buffer };
auto write = [&]<typename T>(T value) {

3
Userland/Libraries/LibGfx/PNGWriter.cpp
View file

@ -221,7 +221,8 @@ ByteBuffer PNGWriter::encode(Gfx::Bitmap const& bitmap)
writer.add_IHDR_chunk(bitmap.width(), bitmap.height(), 8, 6, 0, 0, 0);
writer.add_IDAT_chunk(bitmap);
writer.add_IEND_chunk();
return ByteBuffer::copy(writer.m_data);
// FIXME: Handle OOM failure.
return ByteBuffer::copy(writer.m_data).release_value();
}
}

1
Userland/Libraries/LibHTTP/HttpRequest.h
View file

@ -47,7 +47,6 @@ public:
void set_method(Method method) { m_method = method; }
ByteBuffer const& body() const { return m_body; }
void set_body(ReadonlyBytes body) { m_body = ByteBuffer::copy(body); }
void set_body(ByteBuffer&& body) { m_body = move(body); }
String method_name() const;

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

@ -136,17 +136,17 @@ void Job::on_socket_connected()
return;
auto line = read_line(PAGE_SIZE);
if (line.is_null()) {
warnln("Job: Expected HTTP status");
dbgln("Job: Expected HTTP status");
return deferred_invoke([this] { did_fail(Core::NetworkJob::Error::TransmissionFailed); });
}
auto parts = line.split_view(' ');
if (parts.size() < 3) {
warnln("Job: Expected 3-part HTTP status, got '{}'", line);
dbgln("Job: Expected 3-part HTTP status, got '{}'", line);
return deferred_invoke([this] { did_fail(Core::NetworkJob::Error::ProtocolFailed); });
}
auto code = parts[1].to_uint();
if (!code.has_value()) {
warnln("Job: Expected numeric HTTP status");
dbgln("Job: Expected numeric HTTP status");
return deferred_invoke([this] { did_fail(Core::NetworkJob::Error::ProtocolFailed); });
}
m_code = code.value();
@ -164,7 +164,7 @@ void Job::on_socket_connected()
// that is not a valid trailing header.
return finish_up();
}
warnln("Job: Expected HTTP header");
dbgln("Job: Expected HTTP header");
return did_fail(Core::NetworkJob::Error::ProtocolFailed);
}
if (line.is_empty()) {
@ -185,7 +185,7 @@ void Job::on_socket_connected()
// that is not a valid trailing header.
return finish_up();
}
warnln("Job: Expected HTTP header with key/value");
dbgln("Job: Expected HTTP header with key/value");
return deferred_invoke([this] { did_fail(Core::NetworkJob::Error::ProtocolFailed); });
}
auto name = parts[0];
@ -196,7 +196,7 @@ void Job::on_socket_connected()
// that is not a valid trailing header.
return finish_up();
}
warnln("Job: Malformed HTTP header: '{}' ({})", line, line.length());
dbgln("Job: Malformed HTTP header: '{}' ({})", line, line.length());
return deferred_invoke([this] { did_fail(Core::NetworkJob::Error::ProtocolFailed); });
}
auto value = line.substring(name.length() + 2, line.length() - name.length() - 2);
@ -363,7 +363,7 @@ void Job::finish_up()
VERIFY(!m_has_scheduled_finish);
m_state = State::Finished;
if (!m_can_stream_response) {
auto flattened_buffer = ByteBuffer::create_uninitialized(m_received_size);
auto flattened_buffer = ByteBuffer::create_uninitialized(m_received_size).release_value(); // FIXME: Handle possible OOM situation.
u8* flat_ptr = flattened_buffer.data();
for (auto& received_buffer : m_received_buffers) {
memcpy(flat_ptr, received_buffer.data(), received_buffer.size());

8
Userland/Libraries/LibIPC/Connection.h
View file

@ -231,13 +231,17 @@ protected:
// Sometimes we might receive a partial message. That's okay, just stash away
// the unprocessed bytes and we'll prepend them to the next incoming message
// in the next run of this function.
auto remaining_bytes = ByteBuffer::copy(bytes.data() + index, bytes.size() - index);
auto remaining_bytes_result = ByteBuffer::copy(bytes.span().slice(index));
if (!remaining_bytes_result.has_value()) {
dbgln("{}::drain_messages_from_peer: Failed to allocate buffer", *this);
return false;
}
if (!m_unprocessed_bytes.is_empty()) {
dbgln("{}::drain_messages_from_peer: Already have unprocessed bytes", *this);
shutdown();
return false;
}
m_unprocessed_bytes = remaining_bytes;
m_unprocessed_bytes = remaining_bytes_result.release_value();
}
if (!m_unprocessed_messages.is_empty()) {

8
Userland/Libraries/LibIPC/Decoder.cpp
View file

@ -110,10 +110,14 @@ bool Decoder::decode(ByteBuffer& value)
return true;
}
if (length == 0) {
value = ByteBuffer::create_uninitialized(0);
value = {};
return true;
}
value = ByteBuffer::create_uninitialized(length);
if (auto buffer_result = ByteBuffer::create_uninitialized(length); buffer_result.has_value())
value = buffer_result.release_value();
else
return false;
m_stream >> value.bytes();
return !m_stream.handle_any_error();
}

2
Userland/Libraries/LibImageDecoderClient/Client.cpp
View file

@ -20,7 +20,7 @@ void Client::die()
on_death();
}
Optional<DecodedImage> Client::decode_image(const ByteBuffer& encoded_data)
Optional<DecodedImage> Client::decode_image(const ReadonlyBytes& encoded_data)
{
if (encoded_data.is_empty())
return {};

2
Userland/Libraries/LibImageDecoderClient/Client.h
View file

@ -30,7 +30,7 @@ class Client final
C_OBJECT(Client);
public:
Optional<DecodedImage> decode_image(const ByteBuffer&);
Optional<DecodedImage> decode_image(const ReadonlyBytes&);
Function<void()> on_death;

6
Userland/Libraries/LibJS/AST.cpp
View file

@ -2106,6 +2106,8 @@ Value ArrayExpression::execute(Interpreter& interpreter, GlobalObject& global_ob
InterpreterNodeScope node_scope { interpreter, *this };
auto* array = Array::create(global_object, 0);
array->indexed_properties();
size_t index = 0;
for (auto& element : m_elements) {
auto value = Value();
if (element) {
@ -2115,7 +2117,7 @@ Value ArrayExpression::execute(Interpreter& interpreter, GlobalObject& global_ob
if (is<SpreadExpression>(*element)) {
get_iterator_values(global_object, value, [&](Value iterator_value) {
array->indexed_properties().append(iterator_value);
array->indexed_properties().put(index++, iterator_value, default_attributes);
return IterationDecision::Continue;
});
if (interpreter.exception())
@ -2123,7 +2125,7 @@ Value ArrayExpression::execute(Interpreter& interpreter, GlobalObject& global_ob
continue;
}
}
array->indexed_properties().append(value);
array->indexed_properties().put(index++, value, default_attributes);
}
return array;
}

2
Userland/Libraries/LibJS/Runtime/ArrayBuffer.cpp
View file

@ -21,7 +21,7 @@ ArrayBuffer* ArrayBuffer::create(GlobalObject& global_object, ByteBuffer* buffer
ArrayBuffer::ArrayBuffer(size_t byte_size, Object& prototype)
: Object(prototype)
, m_buffer(ByteBuffer::create_zeroed(byte_size))
, m_buffer(ByteBuffer::create_zeroed(byte_size).release_value()) // FIXME: Handle this possible OOM failure.
, m_detach_key(js_undefined())
{
}

2
Userland/Libraries/LibJS/Runtime/ArrayBuffer.h
View file

@ -125,7 +125,7 @@ template<typename T>
static ByteBuffer numeric_to_raw_bytes(GlobalObject& global_object, Value value, bool is_little_endian)
{
using UnderlyingBufferDataType = Conditional<IsSame<ClampedU8, T>, u8, T>;
ByteBuffer raw_bytes = ByteBuffer::create_uninitialized(sizeof(UnderlyingBufferDataType));
ByteBuffer raw_bytes = ByteBuffer::create_uninitialized(sizeof(UnderlyingBufferDataType)).release_value(); // FIXME: Handle possible OOM situation.
auto flip_if_needed = [&]() {
if (is_little_endian)
return;

2
Userland/Libraries/LibLine/Editor.cpp
View file

@ -185,7 +185,7 @@ Editor::Editor(Configuration configuration)
: m_configuration(move(configuration))
{
m_always_refresh = m_configuration.refresh_behaviour == Configuration::RefreshBehaviour::Eager;
m_pending_chars = ByteBuffer::create_uninitialized(0);
m_pending_chars = {};
get_terminal_size();
m_suggestion_display = make<XtermSuggestionDisplay>(m_num_lines, m_num_columns);
}

8
Userland/Libraries/LibPDF/Filter.cpp
View file

@ -44,7 +44,11 @@ Optional<ByteBuffer> Filter::decode_ascii_hex(ReadonlyBytes const& bytes)
// FIXME: Integrate this padding into AK/Hex?
auto output = ByteBuffer::create_zeroed(bytes.size() / 2 + 1);
auto output_result = ByteBuffer::create_zeroed(bytes.size() / 2 + 1);
if (!output_result.has_value())
return output_result;
auto output = output_result.release_value();
for (size_t i = 0; i < bytes.size() / 2; ++i) {
const auto c1 = decode_hex_digit(static_cast<char>(bytes[i * 2]));
@ -61,7 +65,7 @@ Optional<ByteBuffer> Filter::decode_ascii_hex(ReadonlyBytes const& bytes)
// Process last byte with a padded zero
output[output.size() - 1] = decode_hex_digit(static_cast<char>(bytes[bytes.size() - 1])) * 16;
return output;
return { move(output) };
};
Optional<ByteBuffer> Filter::decode_ascii85(ReadonlyBytes const& bytes)

5
Userland/Libraries/LibPDF/Parser.cpp
View file

@ -262,7 +262,10 @@ bool Parser::initialize_hint_tables()
auto overflow_size = overflow_hint_stream->bytes().size();
auto total_size = primary_size + overflow_size;
possible_merged_stream_buffer = ByteBuffer::create_uninitialized(total_size);
auto buffer_result = ByteBuffer::create_uninitialized(total_size);
if (!buffer_result.has_value())
return false;
possible_merged_stream_buffer = buffer_result.release_value();
auto ok = possible_merged_stream_buffer.try_append(primary_hint_stream->bytes());
ok = ok && possible_merged_stream_buffer.try_append(overflow_hint_stream->bytes());
if (!ok)

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

@ -22,7 +22,11 @@ RefPtr<Request> RequestClient::start_request(String const& method, URL const& ur
for (auto& it : request_headers)
header_dictionary.add(it.key, it.value);
auto response = IPCProxy::start_request(method, url, header_dictionary, ByteBuffer::copy(request_body));
auto body_result = ByteBuffer::copy(request_body);
if (!body_result.has_value())
return nullptr;
auto response = IPCProxy::start_request(method, url, header_dictionary, body_result.release_value());
auto request_id = response.request_id();
if (request_id < 0 || !response.response_fd().has_value())
return nullptr;

4
Userland/Libraries/LibProtocol/WebSocket.cpp
View file

@ -27,7 +27,9 @@ void WebSocket::send(ByteBuffer binary_or_text_message, bool is_text)
void WebSocket::send(StringView text_message)
{
send(ByteBuffer::copy(text_message.bytes()), true);
auto data_result = ByteBuffer::copy(text_message.bytes());
VERIFY(data_result.has_value());
send(data_result.release_value(), true);
}
void WebSocket::close(u16 code, String reason)

3
Userland/Libraries/LibSQL/Heap.cpp
View file

@ -203,7 +203,8 @@ void Heap::update_zero_block()
}
}
auto buffer = ByteBuffer::create_zeroed(BLOCKSIZE);
// FIXME: Handle an OOM failure here.
auto buffer = ByteBuffer::create_zeroed(BLOCKSIZE).release_value();
buffer.overwrite(0, FILE_ID, strlen(FILE_ID));
buffer.overwrite(VERSION_OFFSET, &m_version, sizeof(u32));
buffer.overwrite(SCHEMAS_ROOT_OFFSET, &m_schemas_root, sizeof(u32));

2
Userland/Libraries/LibTLS/Handshake.cpp
View file

@ -151,7 +151,7 @@ ByteBuffer TLSv12::build_handshake_finished()
u8 out[verify_data_length];
auto outbuffer = Bytes { out, verify_data_length };
auto dummy = ByteBuffer::create_zeroed(0);
ByteBuffer dummy;
auto digest = m_context.handshake_hash.digest();
auto hashbuf = ReadonlyBytes { digest.immutable_data(), m_context.handshake_hash.digest_size() };

21
Userland/Libraries/LibTLS/HandshakeClient.cpp
View file

@ -192,7 +192,12 @@ void TLSv12::build_rsa_pre_master_secret(PacketBuilder& builder)
*(u16*)random_bytes = AK::convert_between_host_and_network_endian((u16)Version::V12);
}
m_context.premaster_key = ByteBuffer::copy(random_bytes, bytes);
auto premaster_key_result = ByteBuffer::copy(random_bytes, bytes);
if (!premaster_key_result.has_value()) {
dbgln("RSA premaster key generation failed, not enough memory");
return;
}
m_context.premaster_key = premaster_key_result.release_value();
const auto& certificate_option = verify_chain_and_get_matching_certificate(m_context.extensions.SNI); // if the SNI is empty, we'll make a special case and match *a* leaf certificate.
if (!certificate_option.has_value()) {
@ -239,11 +244,21 @@ void TLSv12::build_dhe_rsa_pre_master_secret(PacketBuilder& builder)
auto dh_random = Crypto::NumberTheory::random_number(0, dh_p);
auto dh_Yc = Crypto::NumberTheory::ModularPower(dh_g, dh_random, dh_p);
auto dh_Yc_bytes = ByteBuffer::create_uninitialized(dh_key_size);
auto dh_Yc_bytes_result = ByteBuffer::create_uninitialized(dh_key_size);
if (!dh_Yc_bytes_result.has_value()) {
dbgln("Failed to build DHE_RSA premaster secret: not enough memory");
return;
}
auto dh_Yc_bytes = dh_Yc_bytes_result.release_value();
dh_Yc.export_data(dh_Yc_bytes);
auto premaster_key = Crypto::NumberTheory::ModularPower(dh_Ys, dh_random, dh_p);
m_context.premaster_key = ByteBuffer::create_uninitialized(dh_key_size);
auto premaster_key_result = ByteBuffer::create_uninitialized(dh_key_size);
if (!premaster_key_result.has_value()) {
dbgln("Failed to build DHE_RSA premaster secret: not enough memory");
return;
}
m_context.premaster_key = premaster_key_result.release_value();
premaster_key.export_data(m_context.premaster_key, true);
dh.p.clear();

21
Userland/Libraries/LibTLS/HandshakeServer.cpp
View file

@ -240,15 +240,30 @@ ssize_t TLSv12::handle_dhe_rsa_server_key_exchange(ReadonlyBytes buffer)
{
auto dh_p_length = AK::convert_between_host_and_network_endian(ByteReader::load16(buffer.offset_pointer(3)));
auto dh_p = buffer.slice(5, dh_p_length);
m_context.server_diffie_hellman_params.p = ByteBuffer::copy(dh_p.data(), dh_p.size());
auto p_result = ByteBuffer::copy(dh_p);
if (!p_result.has_value()) {
dbgln("dhe_rsa_server_key_exchange failed: Not enough memory");
return 0;
}
m_context.server_diffie_hellman_params.p = p_result.release_value();
auto dh_g_length = AK::convert_between_host_and_network_endian(ByteReader::load16(buffer.offset_pointer(5 + dh_p_length)));
auto dh_g = buffer.slice(7 + dh_p_length, dh_g_length);
m_context.server_diffie_hellman_params.g = ByteBuffer::copy(dh_g.data(), dh_g.size());
auto g_result = ByteBuffer::copy(dh_g);
if (!g_result.has_value()) {
dbgln("dhe_rsa_server_key_exchange failed: Not enough memory");
return 0;
}
m_context.server_diffie_hellman_params.g = g_result.release_value();
auto dh_Ys_length = AK::convert_between_host_and_network_endian(ByteReader::load16(buffer.offset_pointer(7 + dh_p_length + dh_g_length)));
auto dh_Ys = buffer.slice(9 + dh_p_length + dh_g_length, dh_Ys_length);
m_context.server_diffie_hellman_params.Ys = ByteBuffer::copy(dh_Ys.data(), dh_Ys.size());
auto Ys_result = ByteBuffer::copy(dh_Ys);
if (!Ys_result.has_value()) {
dbgln("dhe_rsa_server_key_exchange failed: Not enough memory");
return 0;
}
m_context.server_diffie_hellman_params.Ys = Ys_result.release_value();
if constexpr (TLS_DEBUG) {
dbgln("dh_p: {:hex-dump}", dh_p);

54
Userland/Libraries/LibTLS/Record.cpp
View file

@ -97,7 +97,12 @@ void TLSv12::update_packet(ByteBuffer& packet)
if (m_context.crypto.created == 1) {
// `buffer' will continue to be encrypted
auto buffer = ByteBuffer::create_uninitialized(length);
auto buffer_result = ByteBuffer::create_uninitialized(length);
if (!buffer_result.has_value()) {
dbgln("LibTLS: Failed to allocate enough memory");
VERIFY_NOT_REACHED();
}
auto buffer = buffer_result.release_value();
size_t buffer_position = 0;
auto iv_size = iv_length();
@ -112,7 +117,12 @@ void TLSv12::update_packet(ByteBuffer& packet)
[&](Crypto::Cipher::AESCipher::GCMMode& gcm) {
VERIFY(is_aead());
// We need enough space for a header, the data, a tag, and the IV
ct = ByteBuffer::create_uninitialized(length + header_size + iv_size + 16);
auto ct_buffer_result = ByteBuffer::create_uninitialized(length + header_size + iv_size + 16);
if (!ct_buffer_result.has_value()) {
dbgln("LibTLS: Failed to allocate enough memory for the ciphertext");
VERIFY_NOT_REACHED();
}
ct = ct_buffer_result.release_value();
// copy the header over
ct.overwrite(0, packet.data(), header_size - 2);
@ -161,7 +171,12 @@ void TLSv12::update_packet(ByteBuffer& packet)
[&](Crypto::Cipher::AESCipher::CBCMode& cbc) {
VERIFY(!is_aead());
// We need enough space for a header, iv_length bytes of IV and whatever the packet contains
ct = ByteBuffer::create_uninitialized(length + header_size + iv_size);
auto ct_buffer_result = ByteBuffer::create_uninitialized(length + header_size + iv_size);
if (!ct_buffer_result.has_value()) {
dbgln("LibTLS: Failed to allocate enough memory for the ciphertext");
VERIFY_NOT_REACHED();
}
ct = ct_buffer_result.release_value();
// copy the header over
ct.overwrite(0, packet.data(), header_size - 2);
@ -179,7 +194,12 @@ void TLSv12::update_packet(ByteBuffer& packet)
VERIFY(buffer_position == buffer.size());
auto iv = ByteBuffer::create_uninitialized(iv_size);
auto iv_buffer_result = ByteBuffer::create_uninitialized(iv_size);
if (!iv_buffer_result.has_value()) {
dbgln("LibTLS: Failed to allocate memory for IV");
VERIFY_NOT_REACHED();
}
auto iv = iv_buffer_result.release_value();
fill_with_random(iv.data(), iv.size());
// write it into the ciphertext portion of the message
@ -266,14 +286,18 @@ ByteBuffer TLSv12::hmac_message(const ReadonlyBytes& buf, const Optional<Readonl
hmac.update(buf2.value());
}
auto digest = hmac.digest();
auto mac = ByteBuffer::copy(digest.immutable_data(), digest.data_length());
auto mac_result = ByteBuffer::copy(digest.immutable_data(), digest.data_length());
if (!mac_result.has_value()) {
dbgln("Failed to calculate message HMAC: Not enough memory");
return {};
}
if constexpr (TLS_DEBUG) {
dbgln("HMAC of the block for sequence number {}", sequence_number);
print_buffer(mac);
print_buffer(*mac_result);
}
return mac;
return mac_result.release_value();
}
ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
@ -336,7 +360,13 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
auto packet_length = length - iv_length() - 16;
auto payload = plain;
decrypted = ByteBuffer::create_uninitialized(packet_length);
auto decrypted_result = ByteBuffer::create_uninitialized(packet_length);
if (!decrypted_result.has_value()) {
dbgln("Failed to allocate memory for the packet");
return_value = Error::DecryptionFailed;
return;
}
decrypted = decrypted_result.release_value();
// AEAD AAD (13)
// Seq. no (8)
@ -394,7 +424,13 @@ ssize_t TLSv12::handle_message(ReadonlyBytes buffer)
VERIFY(!is_aead());
auto iv_size = iv_length();
decrypted = cbc.create_aligned_buffer(length - iv_size);
auto decrypted_result = cbc.create_aligned_buffer(length - iv_size);
if (!decrypted_result.has_value()) {
dbgln("Failed to allocate memory for the packet");
return_value = Error::DecryptionFailed;
return;
}
decrypted = decrypted_result.release_value();
auto iv = buffer.slice(header_size, iv_size);
Bytes decrypted_span = decrypted;

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

@ -15,9 +15,8 @@ namespace TLS {
Optional<ByteBuffer> TLSv12::read()
{
if (m_context.application_buffer.size()) {
auto buf = m_context.application_buffer.slice(0, m_context.application_buffer.size());
m_context.application_buffer.clear();
return buf;
auto buf = move(m_context.application_buffer);
return { move(buf) };
}
return {};
}
@ -47,10 +46,18 @@ String TLSv12::read_line(size_t max_size)
if (offset > max_size)
return {};
auto buffer = ByteBuffer::copy(start, offset);
auto buffer_result = ByteBuffer::copy(start, offset);
if (!buffer_result.has_value()) {
dbgln("TLS: Failed to read line, not enough memory");
dbgln("max_size < offset: {} < {} (size = {})", max_size, offset, m_context.application_buffer.size());
dbgln("-> {:32hex-dump}", ReadonlyBytes { start, offset });
return {};
}
String line { bit_cast<char const*>(start), offset, Chomp };
m_context.application_buffer = m_context.application_buffer.slice(offset + 1, m_context.application_buffer.size() - offset - 1);
return String::copy(buffer, Chomp);
return line;
}
bool TLSv12::write(ReadonlyBytes buffer)

3
Userland/Libraries/LibTLS/TLSPacketBuilder.h
View file

@ -36,7 +36,8 @@ public:
PacketBuilder(MessageType type, Version version, size_t size_hint = 0xfdf)
{
m_packet_data = ByteBuffer::create_uninitialized(size_hint + 16);
// FIXME: Handle possible OOM situation.
m_packet_data = ByteBuffer::create_uninitialized(size_hint + 16).release_value();
m_current_length = 5;
m_packet_data[0] = (u8)type;
ByteReader::store(m_packet_data.offset_pointer(1), AK::convert_between_host_and_network_endian((u16)version));

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

@ -35,7 +35,7 @@ void TLSv12::consume(ReadonlyBytes record)
dbgln_if(TLS_DEBUG, "Consuming {} bytes", record.size());
if (!m_context.message_buffer.try_append(record.data(), record.size())) {
if (!m_context.message_buffer.try_append(record)) {
dbgln("Not enough space in message buffer, dropping the record");
return;
}
@ -306,7 +306,7 @@ TLSv12::TLSv12(Core::Object* parent, Options options)
{
m_context.options = move(options);
m_context.is_server = false;
m_context.tls_buffer = ByteBuffer::create_uninitialized(0);
m_context.tls_buffer = {};
#ifdef SOCK_NONBLOCK
int fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
#else

15
Userland/Libraries/LibVideo/MatroskaReader.cpp
View file

@ -404,18 +404,27 @@ OwnPtr<Block> MatroskaReader::parse_simple_block()
for (int i = 0; i < frame_count; i++) {
auto current_frame_size = frame_sizes.at(i);
block->add_frame(ByteBuffer::copy(m_streamer.data(), current_frame_size));
auto frame_result = ByteBuffer::copy(m_streamer.data(), current_frame_size);
if (!frame_result.has_value())
return {};
block->add_frame(frame_result.release_value());
m_streamer.drop_octets(current_frame_size);
}
} else if (block->lacing() == Block::Lacing::FixedSize) {
auto frame_count = m_streamer.read_octet() + 1;
auto individual_frame_size = total_frame_content_size / frame_count;
for (int i = 0; i < frame_count; i++) {
block->add_frame(ByteBuffer::copy(m_streamer.data(), individual_frame_size));
auto frame_result = ByteBuffer::copy(m_streamer.data(), individual_frame_size);
if (!frame_result.has_value())
return {};
block->add_frame(frame_result.release_value());
m_streamer.drop_octets(individual_frame_size);
}
} else {
block->add_frame(ByteBuffer::copy(m_streamer.data(), total_frame_content_size));
auto frame_result = ByteBuffer::copy(m_streamer.data(), total_frame_content_size);
if (!frame_result.has_value())
return {};
block->add_frame(frame_result.release_value());
m_streamer.drop_octets(total_frame_content_size);
}
return block;

7
Userland/Libraries/LibWasm/Parser/Parser.cpp
View file

@ -738,7 +738,10 @@ ParseResult<CustomSection> CustomSection::parse(InputStream& stream)
if (name.is_error())
return name.error();
auto data_buffer = ByteBuffer::create_uninitialized(64);
ByteBuffer data_buffer;
if (!data_buffer.try_resize(64))
return ParseError::OutOfMemory;
while (!stream.has_any_error() && !stream.unreliable_eof()) {
char buf[16];
auto size = stream.read({ buf, 16 });
@ -1413,6 +1416,8 @@ String parse_error_to_string(ParseError error)
return "The parser encountered an unimplemented feature";
case ParseError::HugeAllocationRequested:
return "Parsing caused an attempt to allocate a very big chunk of memory, likely malformed data";
case ParseError::OutOfMemory:
return "The parser hit an OOM condition";
case ParseError::ExpectedFloatingImmediate:
return "Expected a floating point immediate";
case ParseError::ExpectedSignedImmediate:

1
Userland/Libraries/LibWasm/Types.h
View file

@ -36,6 +36,7 @@ enum class ParseError {
InvalidTag,
InvalidType,
HugeAllocationRequested,
OutOfMemory,
// FIXME: This should not exist!
NotImplemented,
};

3
Userland/Libraries/LibWeb/Loader/Resource.cpp
View file

@ -68,7 +68,8 @@ static String mime_type_from_content_type(const String& content_type)
void Resource::did_load(Badge<ResourceLoader>, ReadonlyBytes data, const HashMap<String, String, CaseInsensitiveStringTraits>& headers, Optional<u32> status_code)
{
VERIFY(!m_loaded);
m_encoded_data = ByteBuffer::copy(data);
// FIXME: Handle OOM failure.
m_encoded_data = ByteBuffer::copy(data).release_value();
m_response_headers = headers;
m_status_code = move(status_code);
m_loaded = true;

3
Userland/Libraries/LibWeb/XHR/XMLHttpRequest.cpp
View file

@ -212,7 +212,8 @@ DOM::ExceptionOr<void> XMLHttpRequest::send()
if (!weak_this)
return;
auto& xhr = const_cast<XMLHttpRequest&>(*weak_this);
auto response_data = ByteBuffer::copy(data);
// FIXME: Handle OOM failure.
auto response_data = ByteBuffer::copy(data).release_value();
// FIXME: There's currently no difference between transmitted and length.
u64 transmitted = response_data.size();
u64 length = response_data.size();

2
Userland/Libraries/LibWebSocket/Message.h
View file

@ -15,7 +15,7 @@ class Message {
public:
explicit Message(String const& data)
: m_is_text(true)
, m_data(ByteBuffer::copy(data.bytes()))
, m_data(ByteBuffer::copy(data.bytes()).release_value()) // FIXME: Handle possible OOM situation.
{
}

15
Userland/Libraries/LibWebSocket/WebSocket.cpp
View file

@ -98,7 +98,7 @@ void WebSocket::close(u16 code, String message)
VERIFY(m_state == WebSocket::InternalState::Open);
VERIFY(m_impl);
auto message_bytes = message.bytes();
auto close_payload = ByteBuffer::create_uninitialized(message_bytes.size() + 2);
auto close_payload = ByteBuffer::create_uninitialized(message_bytes.size() + 2).release_value(); // FIXME: Handle possible OOM situation.
close_payload.overwrite(0, (u8*)&code, 2);
close_payload.overwrite(2, message_bytes.data(), message_bytes.size());
send_frame(WebSocket::OpCode::ConnectionClose, close_payload, true);
@ -428,7 +428,7 @@ void WebSocket::read_frame()
masking_key[3] = masking_key_data[3];
}
auto payload = ByteBuffer::create_uninitialized(payload_length);
auto payload = ByteBuffer::create_uninitialized(payload_length).release_value(); // FIXME: Handle possible OOM situation.
u64 read_length = 0;
while (read_length < payload_length) {
auto payload_part = m_impl->read(payload_length - read_length);
@ -546,11 +546,14 @@ void WebSocket::send_frame(WebSocket::OpCode op_code, ReadonlyBytes payload, boo
fill_with_random(masking_key, 4);
m_impl->send(ReadonlyBytes(masking_key, 4));
// Mask the payload
auto masked_payload = ByteBuffer::create_uninitialized(payload.size());
for (size_t i = 0; i < payload.size(); ++i) {
masked_payload[i] = payload[i] ^ (masking_key[i % 4]);
auto buffer_result = ByteBuffer::create_uninitialized(payload.size());
if (buffer_result.has_value()) {
auto& masked_payload = buffer_result.value();
for (size_t i = 0; i < payload.size(); ++i) {
masked_payload[i] = payload[i] ^ (masking_key[i % 4]);
}
m_impl->send(masked_payload);
}
m_impl->send(masked_payload);
} else {
m_impl->send(payload);
}

2
Userland/Services/DHCPClient/DHCPv4.h
View file

@ -239,7 +239,7 @@ private:
class DHCPv4PacketBuilder {
public:
DHCPv4PacketBuilder()
: m_buffer(ByteBuffer::create_zeroed(sizeof(DHCPv4Packet)))
: m_buffer(ByteBuffer::create_zeroed(sizeof(DHCPv4Packet)).release_value()) // FIXME: Handle possible OOM failure.
{
auto* options = peek().options();
// set the magic DHCP cookie value

6
Userland/Services/RequestServer/HttpCommon.h
View file

@ -69,7 +69,11 @@ OwnPtr<Request> start_request(TBadgedProtocol&& protocol, ClientConnection& clie
request.set_method(HTTP::HttpRequest::Method::GET);
request.set_url(url);
request.set_headers(headers);
request.set_body(body);
auto allocated_body_result = ByteBuffer::copy(body);
if (!allocated_body_result.has_value())
return {};
request.set_body(allocated_body_result.release_value());
auto output_stream = make<OutputFileStream>(pipe_result.value().write_fd);
output_stream->make_unbuffered();

4
Userland/Services/SpiceAgent/ClipboardServerConnection.cpp
View file

@ -38,8 +38,8 @@ RefPtr<Gfx::Bitmap> ClipboardServerConnection::get_bitmap()
if (!format.has_value() || format.value() == 0)
return nullptr;
auto data = ByteBuffer::copy(clipping.data().data<void>(), clipping.data().size());
auto clipping_bitmap = Gfx::Bitmap::try_create_wrapper((Gfx::BitmapFormat)format.value(), { (int)width.value(), (int)height.value() }, scale.value(), pitch.value(), data.data());
auto data = clipping.data().data<void>();
auto clipping_bitmap = Gfx::Bitmap::try_create_wrapper((Gfx::BitmapFormat)format.value(), { (int)width.value(), (int)height.value() }, scale.value(), pitch.value(), const_cast<void*>(data));
auto bitmap = Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRA8888, { (int)width.value(), (int)height.value() }, scale.value());
for (int y = 0; y < clipping_bitmap->physical_height(); ++y) {

24
Userland/Services/SpiceAgent/SpiceAgent.cpp
View file

@ -59,7 +59,7 @@ void SpiceAgent::on_message_received()
{
ChunkHeader header {};
read_n(&header, sizeof(header));
auto buffer = ByteBuffer::create_uninitialized(header.size);
auto buffer = ByteBuffer::create_uninitialized(header.size).release_value(); // FIXME: Handle possible OOM situation.
read_n(buffer.data(), buffer.size());
auto* message = reinterpret_cast<Message*>(buffer.data());
switch (message->type) {
@ -75,15 +75,17 @@ void SpiceAgent::on_message_received()
auto* request_message = reinterpret_cast<ClipboardRequest*>(message->data);
auto clipboard = m_clipboard_connection.get_clipboard_data();
auto& mime = clipboard.mime_type();
ByteBuffer byte_buffer;
ByteBuffer backing_byte_buffer;
ReadonlyBytes bytes;
if (mime == "image/x-serenityos") {
auto bitmap = m_clipboard_connection.get_bitmap();
byte_buffer = Gfx::PNGWriter::encode(*bitmap);
backing_byte_buffer = Gfx::PNGWriter::encode(*bitmap);
bytes = backing_byte_buffer;
} else {
auto clip_data = clipboard.data();
byte_buffer = ByteBuffer::copy(clip_data.data<void>(), clip_data.size());
auto data = clipboard.data();
bytes = { data.data<void>(), data.size() };
}
auto clipboard_buffer = Clipboard::make_buffer((ClipboardType)request_message->type, byte_buffer);
auto clipboard_buffer = Clipboard::make_buffer((ClipboardType)request_message->type, bytes);
send_message(clipboard_buffer);
break;
}
@ -116,7 +118,7 @@ void SpiceAgent::on_message_received()
case (u32)MessageType::Clipboard: {
auto* clipboard_message = reinterpret_cast<Clipboard*>(message->data);
auto type = (ClipboardType)clipboard_message->type;
auto data_buffer = ByteBuffer::create_uninitialized(message->size - sizeof(u32));
auto data_buffer = ByteBuffer::create_uninitialized(message->size - sizeof(u32)).release_value(); // FIXME: Handle possible OOM situation.
const auto total_bytes = message->size - sizeof(Clipboard);
auto bytes_copied = header.size - sizeof(Message) - sizeof(Clipboard);
@ -204,7 +206,7 @@ SpiceAgent::Message* SpiceAgent::initialize_headers(u8* data, size_t additional_
ByteBuffer SpiceAgent::AnnounceCapabilities::make_buffer(bool request, const Vector<Capability>& capabilities)
{
size_t required_size = sizeof(ChunkHeader) + sizeof(Message) + sizeof(AnnounceCapabilities);
auto buffer = ByteBuffer::create_uninitialized(required_size);
auto buffer = ByteBuffer::create_uninitialized(required_size).release_value(); // FIXME: Handle possible OOM situation.
u8* data = buffer.data();
auto* message = initialize_headers(data, sizeof(AnnounceCapabilities), MessageType::AnnounceCapabilities);
@ -226,7 +228,7 @@ ByteBuffer SpiceAgent::ClipboardGrab::make_buffer(const Vector<ClipboardType>& t
VERIFY(types.size() > 0);
size_t variable_data_size = sizeof(u32) * types.size();
size_t required_size = sizeof(ChunkHeader) + sizeof(Message) + variable_data_size;
auto buffer = ByteBuffer::create_uninitialized(required_size);
auto buffer = ByteBuffer::create_uninitialized(required_size).release_value(); // FIXME: Handle possible OOM situation.
u8* data = buffer.data();
auto* message = initialize_headers(data, variable_data_size, MessageType::ClipboardGrab);
@ -244,7 +246,7 @@ ByteBuffer SpiceAgent::Clipboard::make_buffer(ClipboardType type, ReadonlyBytes
{
size_t data_size = sizeof(Clipboard) + contents.size();
size_t required_size = sizeof(ChunkHeader) + sizeof(Message) + data_size;
auto buffer = ByteBuffer::create_uninitialized(required_size);
auto buffer = ByteBuffer::create_uninitialized(required_size).release_value(); // FIXME: Handle possible OOM situation.
u8* data = buffer.data();
auto* message = initialize_headers(data, data_size, MessageType::Clipboard);
@ -262,7 +264,7 @@ ByteBuffer SpiceAgent::ClipboardRequest::make_buffer(ClipboardType type)
{
size_t data_size = sizeof(ClipboardRequest);
size_t required_size = sizeof(ChunkHeader) + sizeof(Message) + data_size;
auto buffer = ByteBuffer::create_uninitialized(required_size);
auto buffer = ByteBuffer::create_uninitialized(required_size).release_value(); // FIXME: Handle possible OOM situation.
u8* data = buffer.data();
auto* message = initialize_headers(data, data_size, MessageType::ClipboardRequest);

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

@ -150,7 +150,7 @@ void Client::send_command(Command command)
void Client::send_commands(Vector<Command> commands)
{
auto buffer = ByteBuffer::create_uninitialized(commands.size() * 3);
auto buffer = ByteBuffer::create_uninitialized(commands.size() * 3).release_value(); // FIXME: Handle possible OOM situation.
OutputMemoryStream stream { buffer };
for (auto& command : commands)

15
Userland/Shell/AST.cpp
View file

@ -1589,7 +1589,13 @@ void Execute::for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(Non
return Break;
}
} else {
auto entry = ByteBuffer::create_uninitialized(line_end + ifs.length());
auto entry_result = ByteBuffer::create_uninitialized(line_end + ifs.length());
if (!entry_result.has_value()) {
loop.quit(Break);
notifier->set_enabled(false);
return Break;
}
auto entry = entry_result.release_value();
auto rc = stream.read_or_error(entry);
VERIFY(rc);
@ -1675,7 +1681,12 @@ void Execute::for_each_entry(RefPtr<Shell> shell, Function<IterationDecision(Non
} while (action == Continue);
if (!stream.eof()) {
auto entry = ByteBuffer::create_uninitialized(stream.size());
auto entry_result = ByteBuffer::create_uninitialized(stream.size());
if (!entry_result.has_value()) {
shell->raise_error(Shell::ShellError::OutOfMemory, {}, position());
return;
}
auto entry = entry_result.release_value();
auto rc = stream.read_or_error(entry);
VERIFY(rc);
callback(make_ref_counted<StringValue>(String::copy(entry)));

3
Userland/Shell/Shell.cpp
View file

@ -1999,6 +1999,9 @@ void Shell::possibly_print_error() const
case ShellError::OpenFailure:
warnln("Shell: Open failed for {}", m_error_description);
break;
case ShellError::OutOfMemory:
warnln("Shell: Hit an OOM situation");
break;
case ShellError::InternalControlFlowBreak:
case ShellError::InternalControlFlowContinue:
return;

1
Userland/Shell/Shell.h
View file

@ -233,6 +233,7 @@ public:
InvalidGlobError,
InvalidSliceContentsError,
OpenFailure,
OutOfMemory,
};
void raise_error(ShellError kind, String description, Optional<AST::Position> position = {})

Some files were not shown because too many files have changed in this diff Show more