optical.c

Go to the documentation of this file.

/*
 * This file is part of the Aaru Data Preservation Suite.
 * Copyright (c) 2019-2026 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 <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "aaruformat.h"
#include "erasure_internal.h"
#include "internal.h"
#include "log.h"

void process_tracks_block(aaruformat_context *ctx, const IndexEntry *entry)
{
    int      pos        = 0;
    size_t   read_bytes = 0;
    uint64_t crc64      = 0;
    int      j = 0, k = 0;
 
    // Check if the context and image stream are valid
    if(ctx == NULL || ctx->imageStream == NULL)
    {
        FATAL("Invalid context or image stream.");
        return;
    }
 
    // Seek to block
    pos = aaruf_fseek(ctx->imageStream, (aaru_off_t)entry->offset, SEEK_SET);
    if(pos < 0 || aaruf_ftell(ctx->imageStream) != (aaru_off_t)entry->offset)
    {
        FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
 
        return;
    }
 
    // Even if those two checks shall have been done before
    read_bytes = fread(&ctx->tracks_header, 1, sizeof(TracksHeader), ctx->imageStream);
 
    if(read_bytes != sizeof(TracksHeader))
    {
        memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
        TRACE("Could not read tracks header, continuing...\n");
        return;
    }
 
    if(ctx->tracks_header.identifier != TracksBlock)
    {
        memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
        TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
    }
 
    ctx->image_info.ImageSize += sizeof(TrackEntry) * ctx->tracks_header.entries;
 
    ctx->track_entries = (TrackEntry *)malloc(sizeof(TrackEntry) * ctx->tracks_header.entries);
 
    if(ctx->track_entries == NULL)
    {
        memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
        FATAL("Could not allocate memory for metadata block, continuing...\n");
        return;
    }
 
    read_bytes = fread(ctx->track_entries, sizeof(TrackEntry), ctx->tracks_header.entries, ctx->imageStream);
 
    if(read_bytes != ctx->tracks_header.entries)
    {
        memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
        free(ctx->track_entries);
        ctx->track_entries = NULL;
        FATAL("Could not read metadata block, continuing...\n");
 
        return;
    }
 
    crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, ctx->tracks_header.entries * sizeof(TrackEntry));
 
    // Due to how C# wrote it, it is effectively reversed
    if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
 
    if(crc64 != ctx->tracks_header.crc64)
    {
        TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64, crc64,
              ctx->tracks_header.crc64);
 
        /* Attempt erasure coding recovery */
        uint8_t *recovered = NULL;
        uint32_t rec_size  = 0;
        if(ec_recover_meta_block(ctx, entry->offset, &recovered, &rec_size) == AARUF_STATUS_OK && recovered)
        {
            TRACE("EC recovery succeeded for tracks block at offset %" PRIu64, entry->offset);
            /* Re-parse TracksHeader + TrackEntry array from recovered bytes */
            if(rec_size >= sizeof(TracksHeader))
            {
                TracksHeader rec_hdr;
                memcpy(&rec_hdr, recovered, sizeof(TracksHeader));
                size_t entries_size = rec_hdr.entries * sizeof(TrackEntry);
                if(rec_size >= sizeof(TracksHeader) + entries_size && rec_hdr.entries > 0)
                {
                    free(ctx->track_entries);
                    ctx->track_entries = (TrackEntry *)malloc(entries_size);
                    if(ctx->track_entries)
                    {
                        memcpy(&ctx->tracks_header, &rec_hdr, sizeof(TracksHeader));
                        memcpy(ctx->track_entries, recovered + sizeof(TracksHeader), entries_size);
                        free(recovered);
                        goto tracks_parsed;
                    }
                }
            }
            free(recovered);
        }
 
        return;
    }
 
    tracks_parsed:
 
    TRACE("Found %d tracks at position %" PRIu64 ".\n", ctx->tracks_header.entries, entry->offset);
 
    ctx->image_info.HasPartitions = true;
    ctx->image_info.HasSessions   = true;
 
    ctx->number_of_data_tracks = 0;
 
    for(j = 0; j < ctx->tracks_header.entries; j++)
    {
        if(ctx->track_entries[j].sequence <= 99) ctx->number_of_data_tracks++;
    }
 
    if(ctx->number_of_data_tracks > 0)
    {
        ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks);
        if(ctx->data_tracks == NULL)
        {
            FATAL("Could not allocate memory for data tracks, continuing without filtered list.\n");
            ctx->number_of_data_tracks = 0;
        }
    }
    else
        ctx->data_tracks = NULL;
 
    if(ctx->data_tracks != NULL)
    {
        k = 0;
        for(j = 0; j < ctx->tracks_header.entries; j++)
        {
            if(ctx->track_entries[j].sequence <= 99)
                memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry));
        }
    }
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length)
{
    TRACE("Entering aaruf_get_tracks(%p, %p, %zu)", context, buffer, (length ? *length : 0));
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_tracks() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    const aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_tracks() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->tracks_header.entries == 0 || ctx->track_entries == NULL)
    {
        FATAL("Image contains no tracks");
 
        TRACE("Exiting aaruf_get_tracks() = AARUF_ERROR_TRACK_NOT_FOUND");
        return AARUF_ERROR_TRACK_NOT_FOUND;
    }
 
    size_t required_length = ctx->tracks_header.entries * sizeof(TrackEntry);
 
    if(buffer == NULL || length == NULL || *length < required_length)
    {
        if(length) *length = required_length;
        TRACE("Buffer too small for tracks, required %zu bytes", required_length);
 
        TRACE("Exiting aaruf_get_tracks() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    memcpy(buffer, ctx->track_entries, required_length);
    *length = required_length;
 
    TRACE("Exiting aaruf_get_tracks(%p, %p, %zu) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_tracks(void *context, TrackEntry *tracks, const int count)
{
    TRACE("Entering aaruf_set_tracks(%p, %p, %d)", context, tracks, count);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_tracks() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_tracks() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Clearing existing tracks
    if(count == 0)
    {
        memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
        free(ctx->track_entries);
        ctx->track_entries = NULL;
        free(ctx->data_tracks);
        ctx->data_tracks           = NULL;
        ctx->number_of_data_tracks = 0;
 
        TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(tracks == NULL || count < 0)
    {
        FATAL("Invalid tracks data");
 
        TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_INVALID_TRACK_FORMAT");
        return AARUF_ERROR_INVALID_TRACK_FORMAT;
    }
 
    ctx->tracks_header.identifier = TracksBlock;
    ctx->tracks_header.entries    = (uint16_t)count;
    free(ctx->track_entries);
    ctx->track_entries = malloc(sizeof(TrackEntry) * count);
    if(ctx->track_entries == NULL)
    {
        memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
        FATAL("Could not allocate memory for tracks");
 
        TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
    memcpy(ctx->track_entries, tracks, sizeof(TrackEntry) * count);
    ctx->tracks_header.crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, sizeof(TrackEntry) * count);
 
    ctx->image_info.HasPartitions = true;
    ctx->image_info.HasSessions   = true;
    ctx->dirty_tracks_block       = true;  // Mark tracks block as dirty
 
    free(ctx->data_tracks);
    ctx->data_tracks = NULL;
 
    ctx->number_of_data_tracks = 0;
 
    for(int j = 0; j < ctx->tracks_header.entries; j++)
        if(ctx->track_entries[j].sequence <= 99) ctx->number_of_data_tracks++;
 
    if(ctx->number_of_data_tracks > 0)
    {
        ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks);
        if(ctx->data_tracks == NULL)
        {
            free(ctx->track_entries);
            ctx->track_entries = NULL;
            memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
            ctx->number_of_data_tracks = 0;
            FATAL("Could not allocate memory for data tracks");
 
            TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
        }
    }
 
    if(ctx->data_tracks != NULL)
    {
        int k = 0;
        for(int j = 0; j < ctx->tracks_header.entries; j++)
            if(ctx->track_entries[j].sequence <= 99)
                memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry));
    }
 
    TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}