index_v3.c

Go to the documentation of this file.

/*
 * This file is part of the Aaru Data Preservation Suite.
 * Copyright (c) 2019-2025 Natalia Portillo.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the
 * License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "aaruformat.h"
#include "internal.h"
#include "log.h"
#include "utarray.h"
 
static bool add_subindex_entries(aaruformat_context *ctx, UT_array *index_entries, const IndexEntry *subindex_entry);

UT_array *process_index_v3(aaruformat_context *ctx)
{
    TRACE("Entering process_index_v3(%p)", ctx);
 
    UT_array  *index_entries = NULL;
    IndexEntry entry;
 
    if(ctx == NULL || ctx->imageStream == NULL) return NULL;
 
    // Initialize the index entries array
    const UT_icd index_entry_icd = {sizeof(IndexEntry), NULL, NULL, NULL};
 
    utarray_new(index_entries, &index_entry_icd);
 
    if(index_entries == NULL)
    {
        FATAL("Could not allocate memory for index entries array.");
        TRACE("Exiting process_index_v3() = NULL");
        return NULL;
    }
 
    // Read the index header
    TRACE("Reading index header at position %llu", ctx->header.indexOffset);
    if(fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_SET) != 0)
    {
        FATAL("Could not seek to index header at %llu.", ctx->header.indexOffset);
        utarray_free(index_entries);
 
        TRACE("Exiting process_index_v3() = NULL");
        return NULL;
    }
    IndexHeader3 idx_header;
    if(fread(&idx_header, sizeof(IndexHeader3), 1, ctx->imageStream) != 1)
    {
        FATAL("Could not read index header at %llu.", ctx->header.indexOffset);
        utarray_free(index_entries);
 
        TRACE("Exiting process_index_v3() = NULL");
        return NULL;
    }
 
    // Check if the index header is valid
    if(idx_header.identifier != IndexBlock3)
    {
        FATAL("Incorrect index identifier.");
        utarray_free(index_entries);
 
        TRACE("Exiting process_index_v3() = NULL");
        return NULL;
    }
 
    for(uint64_t i = 0; i < idx_header.entries; i++)
    {
        if(fread(&entry, sizeof(IndexEntry), 1, ctx->imageStream) != 1)
        {
            FATAL("Could not read index entry %llu at %llu.", (unsigned long long)i, ctx->header.indexOffset);
            utarray_free(index_entries);
 
            TRACE("Exiting process_index_v3() = NULL");
            return NULL;
        }
 
        if(entry.blockType == IndexBlock3)
        {
            // If the entry is a subindex, we need to read its entries
            if(!add_subindex_entries(ctx, index_entries, &entry))
            {
                utarray_free(index_entries);
 
                TRACE("Exiting process_index_v3() = NULL");
                return NULL;
            }
            continue;
        }
        utarray_push_back(index_entries, &entry);
    }
 
    TRACE("Read %llu index entries from index block at position %llu", (unsigned long long)idx_header.entries,
          ctx->header.indexOffset);
    return index_entries;
}

static bool add_subindex_entries(aaruformat_context *ctx, UT_array *index_entries, const IndexEntry *subindex_entry)
{
    TRACE("Entering add_subindex_entries(%p, %p, %p)", ctx, index_entries, subindex_entry);
 
    IndexHeader3 subindex_header;
    IndexEntry   entry;
 
    if(ctx == NULL || ctx->imageStream == NULL || index_entries == NULL || subindex_entry == NULL)
    {
        TRACE("Exiting add_subindex_entries() = false (invalid parameters)");
        return false;
    }
 
    // Seek to the subindex
    if(fseek(ctx->imageStream, subindex_entry->offset, SEEK_SET) != 0)
    {
        FATAL("Could not seek to subindex header at %llu.", (unsigned long long)subindex_entry->offset);
        TRACE("Exiting add_subindex_entries() = false (seek failed)");
        return false;
    }
 
    // Read the subindex header
    if(fread(&subindex_header, sizeof(IndexHeader3), 1, ctx->imageStream) != 1)
    {
        FATAL("Could not read subindex header at %llu.", (unsigned long long)subindex_entry->offset);
        TRACE("Exiting add_subindex_entries() = false (header read failed)");
        return false;
    }
 
    // Check if the subindex header is valid
    if(subindex_header.identifier != IndexBlock3)
    {
        FATAL("Incorrect subindex identifier.");
 
        TRACE("Exiting add_subindex_entries() = false (invalid identifier)");
        return false;
    }
 
    if(subindex_header.entries != 0 && subindex_header.entries > SIZE_MAX / sizeof(IndexEntry))
    {
        FATAL("Subindex entry count %llu is too large to process.", (unsigned long long)subindex_header.entries);
        TRACE("Exiting add_subindex_entries() = false (entry count overflow)");
        return false;
    }
 
    // Read each entry in the subindex and add it to the main index entries array
    for(uint64_t i = 0; i < subindex_header.entries; i++)
    {
        if(fread(&entry, sizeof(IndexEntry), 1, ctx->imageStream) != 1)
        {
            FATAL("Could not read subindex entry %llu at %llu.", (unsigned long long)i,
                  (unsigned long long)subindex_entry->offset);
            TRACE("Exiting add_subindex_entries() = false (entry read failed)");
            return false;
        }
        if(entry.blockType == IndexBlock3)
        {
            // If the entry is a subindex, we need to read its entries
            if(!add_subindex_entries(ctx, index_entries, &entry))
            {
                TRACE("Exiting add_subindex_entries() = false (nested subindex failed)");
                return false;
            }
            continue;
        }
        utarray_push_back(index_entries, &entry);
    }
 
    TRACE("Exiting add_subindex_entries() = true after appending %llu entries",
          (unsigned long long)subindex_header.entries);
    return true;
}

int32_t verify_index_v3(aaruformat_context *ctx)
{
    TRACE("Entering verify_index_v3(%p)", ctx);
 
    size_t       read_bytes = 0;
    IndexHeader3 index_header;
    uint64_t     crc64         = 0;
    IndexEntry  *index_entries = NULL;
 
    if(ctx == NULL || ctx->imageStream == NULL)
    {
        FATAL("Invalid context or image stream.");
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // This will traverse all blocks and check their CRC64 without uncompressing them
    TRACE("Checking index integrity at %llu.", ctx->header.indexOffset);
    if(fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_SET) != 0)
    {
        FATAL("Could not seek to index header at %llu.", ctx->header.indexOffset);
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_CANNOT_READ_HEADER");
        return AARUF_ERROR_CANNOT_READ_HEADER;
    }
 
    // Read the index header
    TRACE("Reading index header at position %llu", ctx->header.indexOffset);
    read_bytes = fread(&index_header, 1, sizeof(IndexHeader3), ctx->imageStream);
 
    if(read_bytes != sizeof(IndexHeader3))
    {
        FATAL("Could not read index header.");
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_CANNOT_READ_HEADER");
        return AARUF_ERROR_CANNOT_READ_HEADER;
    }
 
    if(index_header.identifier != IndexBlock3)
    {
        FATAL("Incorrect index identifier.");
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_CANNOT_READ_INDEX");
        return AARUF_ERROR_CANNOT_READ_INDEX;
    }
 
    TRACE("Index at %llu contains %llu entries.", ctx->header.indexOffset, (unsigned long long)index_header.entries);
 
    if(index_header.entries != 0 && index_header.entries > SIZE_MAX / sizeof(IndexEntry))
    {
        FATAL("Index entry count %llu is too large to process.", (unsigned long long)index_header.entries);
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    const size_t entries_size = (size_t)index_header.entries * sizeof(IndexEntry);
 
    if(entries_size > 0)
    {
        index_entries = malloc(entries_size);
 
        if(index_entries == NULL)
        {
            FATAL("Cannot allocate memory for index entries.");
 
            TRACE("Exiting verify_index_v3() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
        }
 
        read_bytes = fread(index_entries, 1, entries_size, ctx->imageStream);
 
        if(read_bytes != entries_size)
        {
            FATAL("Could not read index entries.");
            free(index_entries);
 
            TRACE("Exiting verify_index_v3() = AARUF_ERROR_CANNOT_READ_INDEX");
            return AARUF_ERROR_CANNOT_READ_INDEX;
        }
    }
 
    crc64_ctx *crc_ctx = aaruf_crc64_init();
 
    if(crc_ctx == NULL)
    {
        FATAL("Cannot initialize CRC64 context.");
        free(index_entries);
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    if(entries_size > 0)
    {
        const uint8_t *cursor    = (const uint8_t *)index_entries;
        size_t         remaining = entries_size;
 
        while(remaining > 0)
        {
            const uint32_t chunk = remaining > UINT32_MAX ? UINT32_MAX : (uint32_t)remaining;
 
            if(aaruf_crc64_update(crc_ctx, cursor, chunk) != 0)
            {
                FATAL("Failed to update index CRC.");
                aaruf_crc64_free(crc_ctx);
                free(index_entries);
 
                TRACE("Exiting verify_index_v3() = AARUF_ERROR_CANNOT_READ_INDEX");
                return AARUF_ERROR_CANNOT_READ_INDEX;
            }
 
            cursor += chunk;
            remaining -= chunk;
        }
    }
 
    if(aaruf_crc64_final(crc_ctx, &crc64) != 0)
    {
        FATAL("Failed to finalize index CRC.");
        aaruf_crc64_free(crc_ctx);
        free(index_entries);
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_CANNOT_READ_INDEX");
        return AARUF_ERROR_CANNOT_READ_INDEX;
    }
 
    aaruf_crc64_free(crc_ctx);
 
    // Due to how C# wrote it, it is effectively reversed
    if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
 
    if(crc64 != index_header.crc64)
    {
        FATAL("Expected index CRC 0x%16llX but got 0x%16llX.", index_header.crc64, crc64);
        free(index_entries);
 
        TRACE("Exiting verify_index_v3() = AARUF_ERROR_INVALID_BLOCK_CRC");
        return AARUF_ERROR_INVALID_BLOCK_CRC;
    }
 
    free(index_entries);
 
    TRACE("Exiting verify_index_v3() = AARUF_OK");
    return AARUF_STATUS_OK;
}