metadata.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 <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "aaruformat.h"
#include "log.h"

void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry)
{
    TRACE("Entering process_metadata_block(%p, %p)", ctx, entry);
    int    pos        = 0;
    size_t read_bytes = 0;
 
    // Check if the context and image stream are valid
    if(ctx == NULL || ctx->imageStream == NULL)
    {
        FATAL("Invalid context or image stream.");
        TRACE("Exiting process_metadata_block()");
        return;
    }
 
    // Seek to block
    TRACE("Seeking to metadata block at position %" PRIu64, entry->offset);
    pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
    if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
    {
        FATAL("Could not seek to %" PRIu64 " as indicated by index entry...", entry->offset);
 
        TRACE("Exiting process_metadata_block()");
        return;
    }
 
    // Even if those two checks shall have been done before
    TRACE("Reading metadata block header at position %" PRIu64, entry->offset);
    read_bytes = fread(&ctx->metadata_block_header, 1, sizeof(MetadataBlockHeader), ctx->imageStream);
 
    if(read_bytes != sizeof(MetadataBlockHeader))
    {
        memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
        FATAL("Could not read metadata block header, continuing...");
 
        TRACE("Exiting process_metadata_block()");
        return;
    }
 
    if(ctx->metadata_block_header.identifier != entry->blockType)
    {
        memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
        TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
 
        TRACE("Exiting process_metadata_block()");
        return;
    }
 
    ctx->image_info.ImageSize += ctx->metadata_block_header.blockSize;
 
    ctx->metadata_block = (uint8_t *)malloc(ctx->metadata_block_header.blockSize + sizeof(MetadataBlockHeader));
 
    if(ctx->metadata_block == NULL)
    {
        memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
        FATAL("Could not allocate memory for metadata block, continuing...");
 
        TRACE("Exiting process_metadata_block()");
        return;
    }
 
    TRACE("Reading metadata block of size %u at position %" PRIu64,
          ctx->metadata_block_header.blockSize + sizeof(MetadataBlockHeader), entry->offset);
 
    fseek(ctx->imageStream, entry->offset, SEEK_SET);
    read_bytes = fread(ctx->metadata_block, 1, ctx->metadata_block_header.blockSize + sizeof(MetadataBlockHeader),
                       ctx->imageStream);
 
    if(read_bytes != ctx->metadata_block_header.blockSize + sizeof(MetadataBlockHeader))
    {
        memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
        free(ctx->metadata_block);
        FATAL("Could not read metadata block, continuing...");
 
        return;
    }
 
    if(ctx->metadata_block_header.mediaSequence > 0 && ctx->metadata_block_header.lastMediaSequence > 0)
    {
        ctx->media_sequence      = ctx->metadata_block_header.mediaSequence;
        ctx->last_media_sequence = ctx->metadata_block_header.lastMediaSequence;
        TRACE("Setting media sequence as %d of %d", ctx->media_sequence, ctx->last_media_sequence);
    }
 
    if(ctx->metadata_block_header.creatorLength > 0 &&
       ctx->metadata_block_header.creatorOffset + ctx->metadata_block_header.creatorLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->creator = (uint8_t *)malloc(ctx->metadata_block_header.creatorLength);
        if(ctx->creator != NULL)
            memcpy(ctx->creator, ctx->metadata_block + ctx->metadata_block_header.creatorOffset,
                   ctx->metadata_block_header.creatorLength);
    }
 
    if(ctx->metadata_block_header.commentsLength > 0 &&
       ctx->metadata_block_header.commentsOffset + ctx->metadata_block_header.commentsLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->comments = (uint8_t *)malloc(ctx->metadata_block_header.commentsLength);
        if(ctx->comments != NULL)
            memcpy(ctx->comments, ctx->metadata_block + ctx->metadata_block_header.commentsOffset,
                   ctx->metadata_block_header.commentsLength);
    }
 
    if(ctx->metadata_block_header.mediaTitleLength > 0 &&
       ctx->metadata_block_header.mediaTitleOffset + ctx->metadata_block_header.mediaTitleLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->media_title = (uint8_t *)malloc(ctx->metadata_block_header.mediaTitleLength);
        if(ctx->media_title != NULL)
            memcpy(ctx->media_title, ctx->metadata_block + ctx->metadata_block_header.mediaTitleOffset,
                   ctx->metadata_block_header.mediaTitleLength);
    }
 
    if(ctx->metadata_block_header.mediaManufacturerLength > 0 &&
       ctx->metadata_block_header.mediaManufacturerOffset + ctx->metadata_block_header.mediaManufacturerLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->media_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.mediaManufacturerLength);
        if(ctx->media_manufacturer != NULL)
            memcpy(ctx->media_manufacturer, ctx->metadata_block + ctx->metadata_block_header.mediaManufacturerOffset,
                   ctx->metadata_block_header.mediaManufacturerLength);
    }
 
    if(ctx->metadata_block_header.mediaModelLength > 0 &&
       ctx->metadata_block_header.mediaModelOffset + ctx->metadata_block_header.mediaModelLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->media_model = (uint8_t *)malloc(ctx->metadata_block_header.mediaModelLength);
        if(ctx->media_model != NULL)
            memcpy(ctx->media_model, ctx->metadata_block + ctx->metadata_block_header.mediaModelOffset,
                   ctx->metadata_block_header.mediaModelLength);
    }
 
    if(ctx->metadata_block_header.mediaSerialNumberLength > 0 &&
       ctx->metadata_block_header.mediaSerialNumberOffset + ctx->metadata_block_header.mediaSerialNumberLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->media_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaSerialNumberLength);
        if(ctx->media_serial_number != NULL)
            memcpy(ctx->media_serial_number, ctx->metadata_block + ctx->metadata_block_header.mediaSerialNumberOffset,
                   ctx->metadata_block_header.mediaSerialNumberLength);
    }
 
    if(ctx->metadata_block_header.mediaBarcodeLength > 0 &&
       ctx->metadata_block_header.mediaBarcodeOffset + ctx->metadata_block_header.mediaBarcodeLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->media_barcode = (uint8_t *)malloc(ctx->metadata_block_header.mediaBarcodeLength);
        if(ctx->media_barcode != NULL)
            memcpy(ctx->media_barcode, ctx->metadata_block + ctx->metadata_block_header.mediaBarcodeOffset,
                   ctx->metadata_block_header.mediaBarcodeLength);
    }
 
    if(ctx->metadata_block_header.mediaPartNumberLength > 0 &&
       ctx->metadata_block_header.mediaPartNumberOffset + ctx->metadata_block_header.mediaPartNumberLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->media_part_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaPartNumberLength);
        if(ctx->media_part_number != NULL)
            memcpy(ctx->media_part_number, ctx->metadata_block + ctx->metadata_block_header.mediaPartNumberOffset,
                   ctx->metadata_block_header.mediaPartNumberLength);
    }
 
    if(ctx->metadata_block_header.driveManufacturerLength > 0 &&
       ctx->metadata_block_header.driveManufacturerOffset + ctx->metadata_block_header.driveManufacturerLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->drive_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.driveManufacturerLength);
        if(ctx->drive_manufacturer != NULL)
            memcpy(ctx->drive_manufacturer, ctx->metadata_block + ctx->metadata_block_header.driveManufacturerOffset,
                   ctx->metadata_block_header.driveManufacturerLength);
    }
 
    if(ctx->metadata_block_header.driveModelLength > 0 &&
       ctx->metadata_block_header.driveModelOffset + ctx->metadata_block_header.driveModelLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->drive_model = (uint8_t *)malloc(ctx->metadata_block_header.driveModelLength);
        if(ctx->drive_model != NULL)
            memcpy(ctx->drive_model, ctx->metadata_block + ctx->metadata_block_header.driveModelOffset,
                   ctx->metadata_block_header.driveModelLength);
    }
 
    if(ctx->metadata_block_header.driveSerialNumberLength > 0 &&
       ctx->metadata_block_header.driveSerialNumberOffset + ctx->metadata_block_header.driveSerialNumberLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->drive_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.driveSerialNumberLength);
        if(ctx->drive_serial_number != NULL)
            memcpy(ctx->drive_serial_number, ctx->metadata_block + ctx->metadata_block_header.driveSerialNumberOffset,
                   ctx->metadata_block_header.driveSerialNumberLength);
    }
 
    if(ctx->metadata_block_header.driveFirmwareRevisionLength > 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionOffset +
               ctx->metadata_block_header.driveFirmwareRevisionLength <=
           ctx->metadata_block_header.blockSize)
    {
        ctx->drive_firmware_revision = (uint8_t *)malloc(ctx->metadata_block_header.driveFirmwareRevisionLength);
        if(ctx->drive_firmware_revision != NULL)
            memcpy(ctx->drive_firmware_revision,
                   ctx->metadata_block + ctx->metadata_block_header.driveFirmwareRevisionOffset,
                   ctx->metadata_block_header.driveFirmwareRevisionLength);
    }
 
    TRACE("Exiting process_metadata_block()");
}

void process_geometry_block(aaruformat_context *ctx, const IndexEntry *entry)
{
    TRACE("Entering process_geometry_block(%p, %p)", ctx, entry);
    size_t read_bytes = 0;
 
    // Check if the context and image stream are valid
    if(ctx == NULL || ctx->imageStream == NULL)
    {
        FATAL("Invalid context or image stream.");
 
        TRACE("Exiting process_geometry_block()");
        return;
    }
 
    // Seek to block
    if(fseek(ctx->imageStream, entry->offset, SEEK_SET) != 0)
    {
        FATAL("Could not seek to %" PRIu64 " as indicated by index entry...", entry->offset);
 
        TRACE("Exiting process_geometry_block()");
        return;
    }
 
    TRACE("Reading geometry block header at position %" PRIu64, entry->offset);
    read_bytes = fread(&ctx->geometry_block, 1, sizeof(GeometryBlockHeader), ctx->imageStream);
 
    if(read_bytes != sizeof(GeometryBlockHeader))
    {
        memset(&ctx->geometry_block, 0, sizeof(GeometryBlockHeader));
        TRACE("Could not read geometry block header, continuing...");
        return;
    }
 
    if(ctx->geometry_block.identifier != GeometryBlock)
    {
        memset(&ctx->geometry_block, 0, sizeof(GeometryBlockHeader));
        TRACE("Incorrect identifier for geometry block at position %" PRIu64 "", entry->offset);
        return;
    }
 
    ctx->image_info.ImageSize += sizeof(GeometryBlockHeader);
 
    TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometry_block.cylinders,
          ctx->geometry_block.heads, ctx->geometry_block.sectorsPerTrack);
 
    ctx->cylinders         = ctx->geometry_block.cylinders;
    ctx->heads             = ctx->geometry_block.heads;
    ctx->sectors_per_track = ctx->geometry_block.sectorsPerTrack;
 
    TRACE("Exiting process_geometry_block()");
}

void process_cicm_block(aaruformat_context *ctx, const IndexEntry *entry)
{
    TRACE("Entering process_cicm_block(%p, %p)", ctx, entry);
    int    pos        = 0;
    size_t read_bytes = 0;
 
    // Check if the context and image stream are valid
    if(ctx == NULL || ctx->imageStream == NULL)
    {
        FATAL("Invalid context or image stream.");
 
        TRACE("Exiting process_cicm_block()");
        return;
    }
 
    // Seek to block
    TRACE("Seeking to CICM XML metadata block at position %" PRIu64, entry->offset);
    pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
    if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
    {
        FATAL("Could not seek to %" PRIu64 " as indicated by index entry...", entry->offset);
 
        TRACE("Exiting process_cicm_block()");
        return;
    }
 
    // Even if those two checks shall have been done before
    TRACE("Reading CICM XML metadata block header at position %" PRIu64, entry->offset);
    read_bytes = fread(&ctx->cicm_block_header, 1, sizeof(CicmMetadataBlock), ctx->imageStream);
 
    if(read_bytes != sizeof(CicmMetadataBlock))
    {
        memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
        TRACE("Could not read CICM XML metadata header, continuing...");
        return;
    }
 
    if(ctx->cicm_block_header.identifier != CicmBlock)
    {
        memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
        TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
    }
 
    ctx->image_info.ImageSize += ctx->cicm_block_header.length;
 
    ctx->cicm_block = (uint8_t *)malloc(ctx->cicm_block_header.length);
 
    if(ctx->cicm_block == NULL)
    {
        memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
        TRACE("Could not allocate memory for CICM XML metadata block, continuing...");
 
        TRACE("Exiting process_cicm_block()");
        return;
    }
 
    TRACE("Reading CICM XML metadata block of size %u at position %" PRIu64, ctx->cicm_block_header.length,
          entry->offset + sizeof(CicmMetadataBlock));
    read_bytes = fread(ctx->cicm_block, 1, ctx->cicm_block_header.length, ctx->imageStream);
 
    if(read_bytes != ctx->cicm_block_header.length)
    {
        memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
        free(ctx->cicm_block);
        TRACE("Could not read CICM XML metadata block, continuing...");
    }
 
    TRACE("Found CICM XML metadata block %" PRIu64 ".", entry->offset);
 
    TRACE("Exiting process_cicm_block()");
}

void process_aaru_metadata_json_block(aaruformat_context *ctx, const IndexEntry *entry)
{
    TRACE("Entering process_aaru_metadata_json_block(%p, %p)", ctx, entry);
    int    pos        = 0;
    size_t read_bytes = 0;
 
    // Check if the context and image stream are valid
    if(ctx == NULL || ctx->imageStream == NULL)
    {
        FATAL("Invalid context or image stream.");
 
        TRACE("Exiting process_aaru_metadata_json_block()");
        return;
    }
 
    // Seek to block
    TRACE("Seeking to Aaru metadata JSON block at position %" PRIu64, entry->offset);
    pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
    if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
    {
        FATAL("Could not seek to %" PRIu64 " as indicated by index entry...", entry->offset);
 
        TRACE("Exiting process_aaru_metadata_json_block()");
        return;
    }
 
    // Even if those two checks shall have been done before
    TRACE("Reading Aaru metadata JSON block header at position %" PRIu64, entry->offset);
    read_bytes = fread(&ctx->json_block_header, 1, sizeof(AaruMetadataJsonBlockHeader), ctx->imageStream);
 
    if(read_bytes != sizeof(AaruMetadataJsonBlockHeader))
    {
        memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
        TRACE("Could not read Aaru metadata JSON header, continuing...");
        return;
    }
 
    if(ctx->json_block_header.identifier != AaruMetadataJsonBlock)
    {
        memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
        TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
    }
 
    ctx->image_info.ImageSize += ctx->json_block_header.length;
 
    ctx->json_block = (uint8_t *)malloc(ctx->json_block_header.length);
 
    if(ctx->json_block == NULL)
    {
        memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
        TRACE("Could not allocate memory for Aaru metadata JSON block, continuing...");
 
        TRACE("Exiting process_aaru_metadata_json_block()");
        return;
    }
 
    TRACE("Reading Aaru metadata JSON block of size %u at position %" PRIu64, ctx->json_block_header.length,
          entry->offset + sizeof(AaruMetadataJsonBlockHeader));
    read_bytes = fread(ctx->json_block, 1, ctx->json_block_header.length, ctx->imageStream);
 
    if(read_bytes != ctx->json_block_header.length)
    {
        memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
        free(ctx->json_block);
        TRACE("Could not read Aaru metadata JSON block, continuing...");
    }
 
    TRACE("Found Aaru metadata JSON block %" PRIu64 ".", entry->offset);
 
    TRACE("Exiting process_aaru_metadata_json_block()");
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_readable_sector_tags(const void *context, uint8_t *buffer, size_t *length)
{
    TRACE("Entering aaruf_get_readable_sector_tags(%p, %p, %zu)", context, buffer, (length ? *length : 0));
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_readable_sector_tags() = 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_readable_sector_tags() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->readableSectorTags == NULL)
    {
        FATAL("Image contains no readable sector tags");
 
        TRACE("Exiting aaruf_get_readable_sector_tags() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    size_t required_length = sizeof(bool) * (MaxSectorTag + 1);
 
    if(buffer == NULL || length == NULL || *length < required_length)
    {
        if(length) *length = required_length;
        TRACE("Buffer too small for readable sector tags, required %zu bytes", required_length);
 
        TRACE("Exiting aaruf_get_readable_sector_tags() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    memcpy(buffer, ctx->readableSectorTags, required_length);
    *length = required_length;
 
    TRACE("Exiting aaruf_get_readable_sector_tags(%p, %p, %zu) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_readable_media_tags(const void *context, uint8_t *buffer, size_t *length)
{
    TRACE("Entering aaruf_get_readable_media_tags(%p, %p, %zu)", context, buffer, (length ? *length : 0));
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_readable_media_tags() = 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_readable_media_tags() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Required size: one byte for each MediaTagType (0 to MaxMediaTag)
    size_t required_length = MaxMediaTag + 1;
 
    if(buffer == NULL || length == NULL || *length < required_length)
    {
        if(length) *length = required_length;
        TRACE("Buffer too small for readable media tags, required %zu bytes", required_length);
 
        TRACE("Exiting aaruf_get_readable_media_tags() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Initialize all bytes to false (0)
    memset(buffer, 0, required_length);
 
    // Iterate through all media tag types and mark present ones as true
    for(int32_t tag_type = 0; tag_type <= MaxMediaTag; tag_type++)
    {
        mediaTagEntry *item = NULL;
        HASH_FIND_INT(ctx->mediaTags, &tag_type, item);
 
        if(item != NULL)
        {
            buffer[tag_type] = 1;
            TRACE("Media tag type %d is present", tag_type);
        }
    }
 
    *length = required_length;
 
    TRACE("Exiting aaruf_get_readable_media_tags(%p, %p, %zu) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}