warnln("File does not exist");
            return 1;
        }
        auto file = Core::File::open(filename, Core::OpenMode::ReadOnly);
        if (file.is_error()) {
            warnln("Failed to open {}: {}", filename, file.error());
            return 1;
        }
        auto buffer = file.value()->read_all();

            

Reported by FlawFinder.

                          warnln("Nonexistent CA certs file '{}'", ca_certs_file);
            return 1;
        }
        auto config = Core::ConfigFile::open(ca_certs_file);
        auto now = Core::DateTime::now();
        auto last_year = Core::DateTime::create(now.year() - 1);
        auto next_year = Core::DateTime::create(now.year() + 1);
        for (auto& entity : config->groups()) {
            Certificate cert;

            

Reported by FlawFinder.

                              warnln("Nonexistent CA certs file '{}'", ca_certs_file);
                return 1;
            }
            auto config = Core::ConfigFile::open(ca_certs_file);
            auto now = Core::DateTime::now();
            auto last_year = Core::DateTime::create(now.year() - 1);
            auto next_year = Core::DateTime::create(now.year() + 1);
            for (auto& entity : config->groups()) {
                Certificate cert;

            

Reported by FlawFinder.

                  {
        I_TEST((BigInteger | BigEndian Export));
        auto number = "448378203247"_bigint;
        char exported[8] { 0 };
        auto exported_length = number.export_data({ exported, 8 }, true);
        if (exported_length == 5 && memcmp(exported + 3, "hello", 5) == 0) {
            PASS;
        } else {
            FAIL(Invalid value);

            

Reported by FlawFinder.

                      tls->set_root_certificates(s_root_ca_certificates);
        tls->connect(server ?: DEFAULT_SERVER, port);
        tls->on_tls_ready_to_read = [](auto& tls) {
            auto buffer = tls.read();
            if (buffer.has_value())
                out("{}", StringView { buffer->data(), buffer->size() });
        };
        tls->on_tls_ready_to_write = [&](auto&) {
            if (write.size()) {

            

Reported by FlawFinder.

                              warnln("Invalid key size for AES: {}", key_bits);
                return 1;
            }
            if (strlen(secret_key) != (size_t)key_bits / 8) {
                warnln("Key must be exactly {} bytes long", key_bits / 8);
                return 1;
            }
            return run(aes_cbc);
        }

            

Reported by FlawFinder.

                      auto out_span = out.bytes();
        cipher.encrypt(in, out_span, iv);
        if (out.size() != sizeof(result))
            FAIL(size mismatch);
        else if (memcmp(out_span.data(), result, out_span.size()) != 0) {
            FAIL(invalid data);
            print_buffer(out_span, Crypto::Cipher::AESCipher::block_size());
        } else
            PASS;

            

Reported by FlawFinder.

                      auto iv = ByteBuffer::create_zeroed(Crypto::Cipher::AESCipher::block_size());
        auto out_span = out.bytes();
        cipher.decrypt(in, out_span, iv);
        if (out_span.size() != strlen(true_value)) {
            FAIL(size mismatch);
            outln("Expected {} bytes but got {}", strlen(true_value), out_span.size());
        } else if (memcmp(out_span.data(), true_value, strlen(true_value)) != 0) {
            FAIL(invalid data);
            print_buffer(out_span, Crypto::Cipher::AESCipher::block_size());

            

Reported by FlawFinder.

                      auto out_span = out.bytes();
        cipher.decrypt(in, out_span, iv);
        if (out_span.size() != strlen(true_value)) {
            FAIL(size mismatch);
            outln("Expected {} bytes but got {}", strlen(true_value), out_span.size());
        } else if (memcmp(out_span.data(), true_value, strlen(true_value)) != 0) {
            FAIL(invalid data);
            print_buffer(out_span, Crypto::Cipher::AESCipher::block_size());
        } else

            

Reported by FlawFinder.

                      cipher.decrypt(in, out_span, iv);
        if (out_span.size() != strlen(true_value)) {
            FAIL(size mismatch);
            outln("Expected {} bytes but got {}", strlen(true_value), out_span.size());
        } else if (memcmp(out_span.data(), true_value, strlen(true_value)) != 0) {
            FAIL(invalid data);
            print_buffer(out_span, Crypto::Cipher::AESCipher::block_size());
        } else
            PASS;

            

Reported by FlawFinder.

                  if (file_size > 0)
        m_next_block = m_end_of_file = file_size / BLOCKSIZE;

    auto file_or_error = Core::File::open(name(), Core::OpenMode::ReadWrite);
    if (file_or_error.is_error()) {
        warnln("Couldn't open '{}': {}", name(), file_or_error.error());
        VERIFY_NOT_REACHED();
    }
    m_file = file_or_error.value();

            

Reported by FlawFinder.

              
void Heap::read_zero_block()
{
    char file_id[256];
    auto bytes_or_error = read_block(0);
    if (bytes_or_error.is_error())
        VERIFY_NOT_REACHED();
    auto buffer = bytes_or_error.value();
    memcpy(file_id, buffer.offset_pointer(0), strlen(FILE_ID));

            

Reported by FlawFinder.

                  if (bytes_or_error.is_error())
        VERIFY_NOT_REACHED();
    auto buffer = bytes_or_error.value();
    memcpy(file_id, buffer.offset_pointer(0), strlen(FILE_ID));
    file_id[strlen(FILE_ID)] = 0;
    if (strncmp(file_id, FILE_ID, strlen(FILE_ID)) != 0) {
        warnln("Corrupt zero page in {}", name());
        VERIFY_NOT_REACHED();
    }

            

Reported by FlawFinder.

                      VERIFY_NOT_REACHED();
    }
    dbgln_if(SQL_DEBUG, "Read zero block from {}", name());
    memcpy(&m_version, buffer.offset_pointer(VERSION_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Version: {}.{}", (m_version & 0xFFFF0000) >> 16, (m_version & 0x0000FFFF));
    memcpy(&m_schemas_root, buffer.offset_pointer(SCHEMAS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Schemas root node: {}", m_tables_root);
    memcpy(&m_tables_root, buffer.offset_pointer(TABLES_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Tables root node: {}", m_tables_root);

            

Reported by FlawFinder.

                  dbgln_if(SQL_DEBUG, "Read zero block from {}", name());
    memcpy(&m_version, buffer.offset_pointer(VERSION_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Version: {}.{}", (m_version & 0xFFFF0000) >> 16, (m_version & 0x0000FFFF));
    memcpy(&m_schemas_root, buffer.offset_pointer(SCHEMAS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Schemas root node: {}", m_tables_root);
    memcpy(&m_tables_root, buffer.offset_pointer(TABLES_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Tables root node: {}", m_tables_root);
    memcpy(&m_table_columns_root, buffer.offset_pointer(TABLE_COLUMNS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Table columns root node: {}", m_table_columns_root);

            

Reported by FlawFinder.

                  dbgln_if(SQL_DEBUG, "Version: {}.{}", (m_version & 0xFFFF0000) >> 16, (m_version & 0x0000FFFF));
    memcpy(&m_schemas_root, buffer.offset_pointer(SCHEMAS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Schemas root node: {}", m_tables_root);
    memcpy(&m_tables_root, buffer.offset_pointer(TABLES_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Tables root node: {}", m_tables_root);
    memcpy(&m_table_columns_root, buffer.offset_pointer(TABLE_COLUMNS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Table columns root node: {}", m_table_columns_root);
    memcpy(&m_free_list, buffer.offset_pointer(FREE_LIST_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Free list: {}", m_free_list);

            

Reported by FlawFinder.

                  dbgln_if(SQL_DEBUG, "Schemas root node: {}", m_tables_root);
    memcpy(&m_tables_root, buffer.offset_pointer(TABLES_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Tables root node: {}", m_tables_root);
    memcpy(&m_table_columns_root, buffer.offset_pointer(TABLE_COLUMNS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Table columns root node: {}", m_table_columns_root);
    memcpy(&m_free_list, buffer.offset_pointer(FREE_LIST_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Free list: {}", m_free_list);
    memcpy(m_user_values.data(), buffer.offset_pointer(USER_VALUES_OFFSET), m_user_values.size() * sizeof(u32));
    for (auto ix = 0u; ix < m_user_values.size(); ix++) {

            

Reported by FlawFinder.

                  dbgln_if(SQL_DEBUG, "Tables root node: {}", m_tables_root);
    memcpy(&m_table_columns_root, buffer.offset_pointer(TABLE_COLUMNS_ROOT_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Table columns root node: {}", m_table_columns_root);
    memcpy(&m_free_list, buffer.offset_pointer(FREE_LIST_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Free list: {}", m_free_list);
    memcpy(m_user_values.data(), buffer.offset_pointer(USER_VALUES_OFFSET), m_user_values.size() * sizeof(u32));
    for (auto ix = 0u; ix < m_user_values.size(); ix++) {
        if (m_user_values[ix]) {
            dbgln_if(SQL_DEBUG, "User value {}: {}", ix, m_user_values[ix]);

            

Reported by FlawFinder.

                  dbgln_if(SQL_DEBUG, "Table columns root node: {}", m_table_columns_root);
    memcpy(&m_free_list, buffer.offset_pointer(FREE_LIST_OFFSET), sizeof(u32));
    dbgln_if(SQL_DEBUG, "Free list: {}", m_free_list);
    memcpy(m_user_values.data(), buffer.offset_pointer(USER_VALUES_OFFSET), m_user_values.size() * sizeof(u32));
    for (auto ix = 0u; ix < m_user_values.size(); ix++) {
        if (m_user_values[ix]) {
            dbgln_if(SQL_DEBUG, "User value {}: {}", ix, m_user_values[ix]);
        }
    }

            

Reported by FlawFinder.

                  dbgln_if(SQL_DEBUG, "Read heap block {}", block);
    if (!seek_block(block))
        VERIFY_NOT_REACHED();
    auto ret = m_file->read(BLOCKSIZE);
    if (ret.is_empty())
        return String("Could not read block");
    return ret;
}


            

Reported by FlawFinder.

              #define __ENUMERATE_IMAGE_FORMAT(Name, Ext)                    \
    if (path.ends_with(Ext, CaseSensitivity::CaseInsensitive)) \
        return load_##Name(path);
    ENUMERATE_IMAGE_FORMATS
#undef __ENUMERATE_IMAGE_FORMAT

    return nullptr;
}


            

Reported by Cppcheck.

                      return {};

    bitmap->m_palette = new RGBA32[palette_size];
    memcpy(bitmap->m_palette, palette.data(), palette_size * sizeof(RGBA32));

    data.copy_to({ bitmap->scanline(0), bitmap->size_in_bytes() });

    return bitmap;
}

            

Reported by FlawFinder.

                      return nullptr;

    VERIFY(size_in_bytes() == new_bitmap->size_in_bytes());
    memcpy(new_bitmap->scanline(0), scanline(0), size_in_bytes());

    return new_bitmap;
}

RefPtr<Gfx::Bitmap> Bitmap::rotated(Gfx::RotationDirection rotation_direction) const

            

Reported by FlawFinder.

                  auto bitmap = Bitmap::try_create_with_anonymous_buffer(m_format, move(buffer), size(), scale(), palette_to_vector());
    if (!bitmap)
        return nullptr;
    memcpy(bitmap->scanline(0), scanline(0), size_in_bytes());
    return bitmap;
}

Bitmap::~Bitmap()
{

            

Reported by FlawFinder.

                  m_palette = new RGBA32[size];
    if (!source_palette.is_empty()) {
        VERIFY(source_palette.size() == size);
        memcpy(m_palette, source_palette.data(), size * sizeof(RGBA32));
    }
}

Vector<RGBA32> Bitmap::palette_to_vector() const
{

            

Reported by FlawFinder.

                  Vector<RGBA32> palette;

    auto read = [&]<typename T>(T& value) {
        if (stream.read({ &value, sizeof(T) }) != sizeof(T))
            return false;
        return true;
    };

    if (!read(actual_size) || !read(width) || !read(height) || !read(scale_factor) || !read(format) || !read(palette_size))

            

Reported by FlawFinder.

                      return true;
    };

    if (!read(actual_size) || !read(width) || !read(height) || !read(scale_factor) || !read(format) || !read(palette_size))
        return nullptr;

    if (format > BitmapFormat::BGRA8888 || format < BitmapFormat::Indexed1)
        return nullptr;


            

Reported by FlawFinder.

                      return true;
    };

    if (!read(actual_size) || !read(width) || !read(height) || !read(scale_factor) || !read(format) || !read(palette_size))
        return nullptr;

    if (format > BitmapFormat::BGRA8888 || format < BitmapFormat::Indexed1)
        return nullptr;


            

Reported by FlawFinder.

                      return true;
    };

    if (!read(actual_size) || !read(width) || !read(height) || !read(scale_factor) || !read(format) || !read(palette_size))
        return nullptr;

    if (format > BitmapFormat::BGRA8888 || format < BitmapFormat::Indexed1)
        return nullptr;


            

Reported by FlawFinder.

                      return true;
    };

    if (!read(actual_size) || !read(width) || !read(height) || !read(scale_factor) || !read(format) || !read(palette_size))
        return nullptr;

    if (format > BitmapFormat::BGRA8888 || format < BitmapFormat::Indexed1)
        return nullptr;


            

Reported by FlawFinder.

                  return custody;
}

KResult VirtualFileSystem::chmod(Custody& custody, mode_t mode)
{
    auto& inode = custody.inode();

    auto& current_process = Process::current();
    if (current_process.euid() != inode.metadata().uid && !current_process.is_superuser())

            

Reported by FlawFinder.

              
    // Only change the permission bits.
    mode = (inode.mode() & ~07777u) | (mode & 07777u);
    return inode.chmod(mode);
}

KResult VirtualFileSystem::chmod(StringView path, mode_t mode, Custody& base)
{
    auto custody_or_error = resolve_path(path, base);

            

Reported by FlawFinder.

                  return inode.chmod(mode);
}

KResult VirtualFileSystem::chmod(StringView path, mode_t mode, Custody& base)
{
    auto custody_or_error = resolve_path(path, base);
    if (custody_or_error.is_error())
        return custody_or_error.error();
    auto& custody = *custody_or_error.value();

            

Reported by FlawFinder.

                  if (custody_or_error.is_error())
        return custody_or_error.error();
    auto& custody = *custody_or_error.value();
    return chmod(custody, mode);
}

KResult VirtualFileSystem::rename(StringView old_path, StringView new_path, Custody& base)
{
    RefPtr<Custody> old_parent_custody;

            

Reported by FlawFinder.

                  return KSuccess;
}

KResult VirtualFileSystem::chown(Custody& custody, uid_t a_uid, gid_t a_gid)
{
    auto& inode = custody.inode();
    auto metadata = inode.metadata();

    auto& current_process = Process::current();

            

Reported by FlawFinder.

              
    if (metadata.is_setuid() || metadata.is_setgid()) {
        dbgln_if(VFS_DEBUG, "VirtualFileSystem::chown(): Stripping SUID/SGID bits from {}", inode.identifier());
        if (auto result = inode.chmod(metadata.mode & ~(04000 | 02000)); result.is_error())
            return result;
    }

    return inode.chown(new_uid, new_gid);
}

            

Reported by FlawFinder.

                          return result;
    }

    return inode.chown(new_uid, new_gid);
}

KResult VirtualFileSystem::chown(StringView path, uid_t a_uid, gid_t a_gid, Custody& base)
{
    auto custody_or_error = resolve_path(path, base);

            

Reported by FlawFinder.

                  return inode.chown(new_uid, new_gid);
}

KResult VirtualFileSystem::chown(StringView path, uid_t a_uid, gid_t a_gid, Custody& base)
{
    auto custody_or_error = resolve_path(path, base);
    if (custody_or_error.is_error())
        return custody_or_error.error();
    auto& custody = *custody_or_error.value();

            

Reported by FlawFinder.

                  if (custody_or_error.is_error())
        return custody_or_error.error();
    auto& custody = *custody_or_error.value();
    return chown(custody, a_uid, a_gid);
}

static bool hard_link_allowed(const Inode& inode)
{
    auto metadata = inode.metadata();

            

Reported by FlawFinder.

                  return parent_inode.create_child(basename, S_IFDIR | mode, 0, current_process.euid(), current_process.egid()).result();
}

KResult VirtualFileSystem::access(StringView path, int mode, Custody& base)
{
    auto custody_or_error = resolve_path(path, base);
    if (custody_or_error.is_error())
        return custody_or_error.error();
    auto& custody = *custody_or_error.value();

            

Reported by FlawFinder.

              {
    ScopedSpinLock page_lock(kernel_page_directory().get_lock());
    // Disable writing to the kernel text and rodata segments.
    for (auto i = start_of_kernel_text; i < start_of_kernel_data; i += PAGE_SIZE) {
        auto& pte = *ensure_pte(kernel_page_directory(), VirtualAddress(i));
        pte.set_writable(false);
    }
    if (Processor::current().has_feature(CPUFeature::NX)) {
        // Disable execution of the kernel data, bss and heap segments.

            

Reported by Cppcheck.

                  }
    if (Processor::current().has_feature(CPUFeature::NX)) {
        // Disable execution of the kernel data, bss and heap segments.
        for (auto i = start_of_kernel_data; i < end_of_kernel_image; i += PAGE_SIZE) {
            auto& pte = *ensure_pte(kernel_page_directory(), VirtualAddress(i));
            pte.set_execute_disabled(true);
        }
    }
}

            

Reported by Cppcheck.

                  return region->handle_fault(fault);
}

OwnPtr<Region> MemoryManager::allocate_contiguous_kernel_region(size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
{
    VERIFY(!(size % PAGE_SIZE));
    ScopedSpinLock lock(kernel_page_directory().get_lock());
    auto range = kernel_page_directory().range_allocator().allocate_anywhere(size);
    if (!range.has_value())

            

Reported by FlawFinder.

                      // FIXME: Would be nice to be able to return a KResultOr from here.
        return {};
    }
    return allocate_kernel_region_with_vmobject(range.value(), maybe_vmobject.release_value(), name, access, cacheable);
}

OwnPtr<Region> MemoryManager::allocate_kernel_region(size_t size, StringView name, Region::Access access, AllocationStrategy strategy, Region::Cacheable cacheable)
{
    VERIFY(!(size % PAGE_SIZE));

            

Reported by FlawFinder.

                  return allocate_kernel_region_with_vmobject(range.value(), maybe_vmobject.release_value(), name, access, cacheable);
}

OwnPtr<Region> MemoryManager::allocate_kernel_region(size_t size, StringView name, Region::Access access, AllocationStrategy strategy, Region::Cacheable cacheable)
{
    VERIFY(!(size % PAGE_SIZE));
    auto maybe_vm_object = AnonymousVMObject::try_create_with_size(size, strategy);
    if (maybe_vm_object.is_error())
        return {};

            

Reported by FlawFinder.

                  auto range = kernel_page_directory().range_allocator().allocate_anywhere(size);
    if (!range.has_value())
        return {};
    return allocate_kernel_region_with_vmobject(range.value(), maybe_vm_object.release_value(), name, access, cacheable);
}

OwnPtr<Region> MemoryManager::allocate_kernel_region(PhysicalAddress paddr, size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
{
    auto maybe_vm_object = AnonymousVMObject::try_create_for_physical_range(paddr, size);

            

Reported by FlawFinder.

                  return allocate_kernel_region_with_vmobject(range.value(), maybe_vm_object.release_value(), name, access, cacheable);
}

OwnPtr<Region> MemoryManager::allocate_kernel_region(PhysicalAddress paddr, size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
{
    auto maybe_vm_object = AnonymousVMObject::try_create_for_physical_range(paddr, size);
    if (maybe_vm_object.is_error())
        return {};
    VERIFY(!(size % PAGE_SIZE));

            

Reported by FlawFinder.

                  auto range = kernel_page_directory().range_allocator().allocate_anywhere(size);
    if (!range.has_value())
        return {};
    return allocate_kernel_region_with_vmobject(range.value(), maybe_vm_object.release_value(), name, access, cacheable);
}

OwnPtr<Region> MemoryManager::allocate_kernel_region_with_vmobject(VirtualRange const& range, VMObject& vmobject, StringView name, Region::Access access, Region::Cacheable cacheable)
{
    auto maybe_region = Region::try_create_kernel_only(range, vmobject, 0, KString::try_create(name), access, cacheable);

            

Reported by FlawFinder.

                  return allocate_kernel_region_with_vmobject(range.value(), maybe_vm_object.release_value(), name, access, cacheable);
}

OwnPtr<Region> MemoryManager::allocate_kernel_region_with_vmobject(VirtualRange const& range, VMObject& vmobject, StringView name, Region::Access access, Region::Cacheable cacheable)
{
    auto maybe_region = Region::try_create_kernel_only(range, vmobject, 0, KString::try_create(name), access, cacheable);
    if (maybe_region.is_error())
        return {};


            

Reported by FlawFinder.

              
OwnPtr<Region> MemoryManager::allocate_kernel_region_with_vmobject(VirtualRange const& range, VMObject& vmobject, StringView name, Region::Access access, Region::Cacheable cacheable)
{
    auto maybe_region = Region::try_create_kernel_only(range, vmobject, 0, KString::try_create(name), access, cacheable);
    if (maybe_region.is_error())
        return {};

    auto region = maybe_region.release_value();
    region->map(kernel_page_directory());

            

Reported by FlawFinder.

              
namespace Kernel::Memory {

Region::Region(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable, bool shared)
    : m_range(range)
    , m_offset_in_vmobject(offset_in_vmobject)
    , m_vmobject(move(vmobject))
    , m_name(move(name))
    , m_access(access | ((access & 0x7) << 4))

            

Reported by FlawFinder.

                  , m_offset_in_vmobject(offset_in_vmobject)
    , m_vmobject(move(vmobject))
    , m_name(move(name))
    , m_access(access | ((access & 0x7) << 4))
    , m_shared(shared)
    , m_cacheable(cacheable == Cacheable::Yes)
{
    VERIFY(m_range.base().is_page_aligned());
    VERIFY(m_range.size());

            

Reported by FlawFinder.

                  , m_offset_in_vmobject(offset_in_vmobject)
    , m_vmobject(move(vmobject))
    , m_name(move(name))
    , m_access(access | ((access & 0x7) << 4))
    , m_shared(shared)
    , m_cacheable(cacheable == Cacheable::Yes)
{
    VERIFY(m_range.base().is_page_aligned());
    VERIFY(m_range.size());

            

Reported by FlawFinder.

              
        // Create a new region backed by the same VMObject.
        auto maybe_region = Region::try_create_user_accessible(
            m_range, m_vmobject, m_offset_in_vmobject, m_name ? m_name->try_clone() : OwnPtr<KString> {}, access(), m_cacheable ? Cacheable::Yes : Cacheable::No, m_shared);
        if (maybe_region.is_error()) {
            dbgln("Region::clone: Unable to allocate new Region");
            return maybe_region.error();
        }


            

Reported by FlawFinder.

                  // Set up a COW region. The parent (this) region becomes COW as well!
    remap();
    auto maybe_clone_region = Region::try_create_user_accessible(
        m_range, vmobject_clone, m_offset_in_vmobject, m_name ? m_name->try_clone() : OwnPtr<KString> {}, access(), m_cacheable ? Cacheable::Yes : Cacheable::No, m_shared);
    if (maybe_clone_region.is_error()) {
        dbgln("Region::clone: Unable to allocate new Region for COW");
        return maybe_clone_region.error();
    }
    auto clone_region = maybe_clone_region.release_value();

            

Reported by FlawFinder.

                  return bytes;
}

KResultOr<NonnullOwnPtr<Region>> Region::try_create_user_accessible(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable, bool shared)
{
    return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, shared));
}

KResultOr<NonnullOwnPtr<Region>> Region::try_create_kernel_only(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable)

            

Reported by FlawFinder.

              
KResultOr<NonnullOwnPtr<Region>> Region::try_create_user_accessible(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable, bool shared)
{
    return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, shared));
}

KResultOr<NonnullOwnPtr<Region>> Region::try_create_kernel_only(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable)
{
    return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, false));

            

Reported by FlawFinder.

                  return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, shared));
}

KResultOr<NonnullOwnPtr<Region>> Region::try_create_kernel_only(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable)
{
    return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, false));
}

bool Region::should_cow(size_t page_index) const

            

Reported by FlawFinder.

              
KResultOr<NonnullOwnPtr<Region>> Region::try_create_kernel_only(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable)
{
    return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, false));
}

bool Region::should_cow(size_t page_index) const
{
    if (!vmobject().is_anonymous())

            

Reported by FlawFinder.

                      return PageFaultResponse::ShouldCrash;
    }
    VERIFY(fault.type() == PageFault::Type::ProtectionViolation);
    if (fault.access() == PageFault::Access::Write && is_writable() && should_cow(page_index_in_region)) {
        dbgln_if(PAGE_FAULT_DEBUG, "PV(cow) fault in Region({})[{}] at {}", this, page_index_in_region, fault.vaddr());
        auto* phys_page = physical_page(page_index_in_region);
        if (phys_page->is_shared_zero_page() || phys_page->is_lazy_committed_page()) {
            dbgln_if(PAGE_FAULT_DEBUG, "NP(zero) fault in Region({})[{}] at {}", this, page_index_in_region, fault.vaddr());
            return handle_zero_fault(page_index_in_region);

            

Reported by FlawFinder.

                  else
        VERIFY_NOT_REACHED();

    size_t count = glyph_count_by_type(type);
    size_t bytes_per_glyph = sizeof(unsigned) * header.glyph_height;

    auto* rows = const_cast<unsigned*>((const unsigned*)(data + sizeof(FontFileHeader)));
    u8* widths = (u8*)(rows) + count * bytes_per_glyph;
    return adopt_ref(*new BitmapFont(String(header.name), String(header.family), rows, widths, !header.is_variable_width, header.glyph_width, header.glyph_height, header.glyph_spacing, type, header.baseline, header.mean_line, header.presentation_size, header.weight));

            

Reported by Cppcheck.

              
    auto* rows = const_cast<unsigned*>((const unsigned*)(data + sizeof(FontFileHeader)));
    u8* widths = (u8*)(rows) + count * bytes_per_glyph;
    return adopt_ref(*new BitmapFont(String(header.name), String(header.family), rows, widths, !header.is_variable_width, header.glyph_width, header.glyph_height, header.glyph_spacing, type, header.baseline, header.mean_line, header.presentation_size, header.weight));
}

size_t BitmapFont::glyph_count_by_type(FontTypes type)
{
    if (type == FontTypes::Default)

            

Reported by Cppcheck.

              
size_t BitmapFont::glyph_count_by_type(FontTypes type)
{
    if (type == FontTypes::Default)
        return 256;

    if (type == FontTypes::LatinExtendedA)
        return 384;


            

Reported by Cppcheck.

              namespace Gfx {

struct [[gnu::packed]] FontFileHeader {
    char magic[4];
    u8 glyph_width;
    u8 glyph_height;
    u8 type;
    u8 is_variable_width;
    u8 glyph_spacing;

            

Reported by FlawFinder.

                  u8 mean_line;
    u8 presentation_size;
    u16 weight;
    char name[32];
    char family[32];
    u16 unused;
};

static_assert(sizeof(FontFileHeader) == 80);

            

Reported by FlawFinder.

                  u8 presentation_size;
    u16 weight;
    char name[32];
    char family[32];
    u16 unused;
};

static_assert(sizeof(FontFileHeader) == 80);


            

Reported by FlawFinder.

              {
    size_t bytes_per_glyph = sizeof(u32) * glyph_height();
    auto* new_rows = static_cast<unsigned*>(kmalloc_array(m_glyph_count, bytes_per_glyph));
    memcpy(new_rows, m_rows, bytes_per_glyph * m_glyph_count);
    auto* new_widths = static_cast<u8*>(malloc(m_glyph_count));
    memcpy(new_widths, m_glyph_widths, m_glyph_count);
    return adopt_ref(*new BitmapFont(m_name, m_family, new_rows, new_widths, m_fixed_width, m_glyph_width, m_glyph_height, m_glyph_spacing, m_type, m_baseline, m_mean_line, m_presentation_size, m_weight, true));
}


            

Reported by FlawFinder.

                  auto* new_rows = static_cast<unsigned*>(kmalloc_array(m_glyph_count, bytes_per_glyph));
    memcpy(new_rows, m_rows, bytes_per_glyph * m_glyph_count);
    auto* new_widths = static_cast<u8*>(malloc(m_glyph_count));
    memcpy(new_widths, m_glyph_widths, m_glyph_count);
    return adopt_ref(*new BitmapFont(m_name, m_family, new_rows, new_widths, m_fixed_width, m_glyph_width, m_glyph_height, m_glyph_spacing, m_type, m_baseline, m_mean_line, m_presentation_size, m_weight, true));
}

NonnullRefPtr<BitmapFont> BitmapFont::create(u8 glyph_height, u8 glyph_width, bool fixed, FontTypes type)
{

            

Reported by FlawFinder.

              {
    FontFileHeader header;
    memset(&header, 0, sizeof(FontFileHeader));
    memcpy(header.magic, "!Fnt", 4);
    header.glyph_width = m_glyph_width;
    header.glyph_height = m_glyph_height;
    header.type = m_type;
    header.baseline = m_baseline;
    header.mean_line = m_mean_line;

            

Reported by FlawFinder.

                  size_t bytes_per_glyph = sizeof(u32) * glyph_height();

    auto* new_rows = static_cast<unsigned*>(calloc(new_glyph_count, bytes_per_glyph));
    memcpy(new_rows, m_rows, bytes_per_glyph * item_count_to_copy);

    auto* new_widths = static_cast<u8*>(calloc(new_glyph_count, 1));
    memcpy(new_widths, m_glyph_widths, item_count_to_copy);

    kfree(m_rows);

            

Reported by FlawFinder.

                  ScopeGuard flush_stream {
        [&] {
            auto buffer = output_stream.copy_into_contiguous_buffer();
            if (buffer.is_empty())
                return;
            fwrite(buffer.data(), sizeof(char), buffer.size(), stderr);
        }
    };


            

Reported by Cppcheck.

              {
    if (line.is_empty())
        return;
    String histcontrol = getenv("HISTCONTROL");
    auto ignoredups = histcontrol == "ignoredups" || histcontrol == "ignoreboth";
    auto ignorespace = histcontrol == "ignorespace" || histcontrol == "ignoreboth";
    if (ignoredups && !m_history.is_empty() && line == m_history.last().entry)
        return;
    if (ignorespace && line.starts_with(' '))

            

Reported by FlawFinder.

                      if (!istty) {
            m_configuration.set(Configuration::NonInteractive);
        } else {
            auto* term = getenv("TERM");
            if (StringView { term }.starts_with("xterm"))
                m_configuration.set(Configuration::Full);
            else
                m_configuration.set(Configuration::NoEscapeSequences);
        }

            

Reported by FlawFinder.

              bool Editor::load_history(const String& path)
{
    auto history_file = Core::File::construct(path);
    if (!history_file->open(Core::OpenMode::ReadOnly))
        return false;
    auto data = history_file->read_all();
    auto hist = StringView { data.data(), data.size() };
    for (auto& str : hist.split_view("\n\n")) {
        auto it = str.find("::").value_or(0);

            

Reported by FlawFinder.

              {
    Vector<HistoryEntry> final_history { { "", 0 } };
    {
        auto file_or_error = Core::File::open(path, Core::OpenMode::ReadWrite, 0600);
        if (file_or_error.is_error())
            return false;
        auto file = file_or_error.release_value();
        merge(
            file->line_begin(), file->line_end(), m_history.begin(), m_history.end(), final_history,

            

Reported by FlawFinder.

                          [](const HistoryEntry& left, const HistoryEntry& right) { return left.timestamp < right.timestamp; });
    }

    auto file_or_error = Core::File::open(path, Core::OpenMode::WriteOnly, 0600);
    if (file_or_error.is_error())
        return false;
    auto file = file_or_error.release_value();
    final_history.take_first();
    for (const auto& entry : final_history)

            

Reported by FlawFinder.

              
void Editor::handle_read_event()
{
    char keybuf[16];
    ssize_t nread = 0;

    if (!m_incomplete_data.size())
        nread = read(0, keybuf, sizeof(keybuf));


            

Reported by FlawFinder.

              
Result<Vector<size_t, 2>, Editor::Error> Editor::vt_dsr()
{
    char buf[16];

    // Read whatever junk there is before talking to the terminal
    // and insert them later when we're reading user input.
    bool more_junk_to_read { false };
    timeval timeout { 0, 0 };

            

Reported by FlawFinder.

                  ssize_t nread = 0;

    if (!m_incomplete_data.size())
        nread = read(0, keybuf, sizeof(keybuf));

    if (nread < 0) {
        if (errno == EINTR) {
            if (!m_was_interrupted) {
                if (m_was_resized)

            

Reported by FlawFinder.

                      more_junk_to_read = false;
        [[maybe_unused]] auto rc = select(1, &readfds, nullptr, nullptr, &timeout);
        if (FD_ISSET(0, &readfds)) {
            auto nread = read(0, buf, 16);
            if (nread < 0) {
                m_input_error = Error::ReadFailure;
                finish();
                break;
            }

            

Reported by FlawFinder.