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 <stddef.h>
#include <stdint.h>
 
#include "aaruformat.h"
#include "log.h"

AARU_EXPORT int32_t AARU_CALL aaruf_get_geometry(const void *context, uint32_t *cylinders, uint32_t *heads,
                                                 uint32_t *sectors_per_track)
{
    TRACE("Entering aaruf_get_geometry(%p, %p, %p, %p)", context, cylinders, heads, sectors_per_track);
 
    const aaruformat_context *ctx = NULL;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_geometry() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_geometry() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->geometry_block.identifier != GeometryBlock)
    {
        FATAL("No geometry block present");
 
        TRACE("Exiting aaruf_get_geometry() = AARUF_ERROR_CANNOT_READ_BLOCK");
        return AARUF_ERROR_CANNOT_READ_BLOCK;
    }
 
    *cylinders         = ctx->geometry_block.cylinders;
    *heads             = ctx->geometry_block.heads;
    *sectors_per_track = ctx->geometry_block.sectorsPerTrack;
 
    TRACE("Exiting aaruf_get_geometry(%p, %u, %u, %u) = AARUF_STATUS_OK", context, *cylinders, *heads,
          *sectors_per_track);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_geometry(void *context, const uint32_t cylinders, const uint32_t heads,
                                                 const uint32_t sectors_per_track)
{
    TRACE("Entering aaruf_set_geometry(%p, %u, %u, %u)", context, cylinders, heads, sectors_per_track);
 
    aaruformat_context *ctx = NULL;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_geometry() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_geometry() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_write_sector() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    ctx->geometry_block.identifier      = GeometryBlock;
    ctx->geometry_block.cylinders       = cylinders;
    ctx->geometry_block.heads           = heads;
    ctx->geometry_block.sectorsPerTrack = sectors_per_track;
    ctx->cylinders                      = cylinders;
    ctx->heads                          = heads;
    ctx->sectors_per_track              = sectors_per_track;
    ctx->dirty_geometry_block           = true;  // Mark geometry block as dirty
 
    TRACE("Exiting aaruf_set_geometry(%p, %u, %u, %u) = AARUF_STATUS_OK", context, cylinders, heads, sectors_per_track);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_sequence(void *context, const int32_t sequence,
                                                       const int32_t last_sequence)
{
    TRACE("Entering aaruf_set_media_sequence(%p, %d, %d)", context, sequence, last_sequence);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_sequence() = 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_set_media_sequence() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_sequence() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    ctx->metadata_block_header.mediaSequence     = sequence;
    ctx->metadata_block_header.lastMediaSequence = last_sequence;
 
    TRACE("Exiting aaruf_set_media_sequence(%p, %d, %d) = AARUF_STATUS_OK", context, sequence, last_sequence);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_creator(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_creator(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_creator() = 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_set_creator() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_creator() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for creator");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->creator != NULL) free(ctx->creator);
    ctx->creator                             = copy;
    ctx->metadata_block_header.creatorLength = length;
 
    TRACE("Exiting aaruf_set_creator(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_comments(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_comments(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_comments() = 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_set_comments() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_comments() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for comments");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->comments != NULL) free(ctx->comments);
    ctx->comments                             = copy;
    ctx->metadata_block_header.commentsLength = length;
 
    TRACE("Exiting aaruf_set_comments(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_title(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_media_title(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_title() = 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_set_media_title() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_title() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for media title");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->media_title != NULL) free(ctx->media_title);
    ctx->media_title                            = copy;
    ctx->metadata_block_header.mediaTitleLength = length;
    ctx->dirty_metadata_block                   = true;  // Mark metadata block as dirty
 
    TRACE("Exiting aaruf_set_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_manufacturer(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_media_manufacturer(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_manufacturer() = 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_set_media_manufacturer() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_manufacturer() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for media manufacturer");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->media_manufacturer != NULL) free(ctx->media_manufacturer);
    ctx->media_manufacturer                            = copy;
    ctx->metadata_block_header.mediaManufacturerLength = length;
 
    TRACE("Exiting aaruf_set_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_model(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_media_model(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_model() = 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_set_media_model() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_model() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for media model");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->media_model != NULL) free(ctx->media_model);
    ctx->media_model                            = copy;
    ctx->metadata_block_header.mediaModelLength = length;
 
    TRACE("Exiting aaruf_set_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_serial_number(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_media_serial_number(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_serial_number() = 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_set_media_serial_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_serial_number() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for media serial number");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->media_serial_number != NULL) free(ctx->media_serial_number);
    ctx->media_serial_number                           = copy;
    ctx->metadata_block_header.mediaSerialNumberLength = length;
 
    TRACE("Exiting aaruf_set_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_barcode(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_media_barcode(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_barcode() = 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_set_media_barcode() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_barcode() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for media barcode");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->media_barcode != NULL) free(ctx->media_barcode);
    ctx->media_barcode                            = copy;
    ctx->metadata_block_header.mediaBarcodeLength = length;
 
    TRACE("Exiting aaruf_set_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_media_part_number(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_media_part_number(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_part_number() = 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_set_media_part_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_media_part_number() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for creator");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->media_part_number != NULL) free(ctx->media_part_number);
    ctx->media_part_number                           = copy;
    ctx->metadata_block_header.mediaPartNumberLength = length;
 
    TRACE("Exiting aaruf_set_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_drive_manufacturer(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_drive_manufacturer(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_drive_manufacturer() = 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_set_drive_manufacturer() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_drive_manufacturer() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for drive manufacturer");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->drive_manufacturer != NULL) free(ctx->drive_manufacturer);
    ctx->drive_manufacturer                            = copy;
    ctx->metadata_block_header.driveManufacturerLength = length;
 
    TRACE("Exiting aaruf_set_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_drive_model(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_drive_model(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_drive_model() = 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_set_drive_model() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_drive_model() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for media model");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->drive_model != NULL) free(ctx->drive_model);
    ctx->drive_model                            = copy;
    ctx->metadata_block_header.driveModelLength = length;
 
    TRACE("Exiting aaruf_set_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_drive_serial_number(void *context, const uint8_t *data, const int32_t length)
{
    TRACE("Entering aaruf_set_drive_serial_number(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_drive_serial_number() = 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_set_drive_serial_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_drive_serial_number() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for drive serial number");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->drive_serial_number != NULL) free(ctx->drive_serial_number);
    ctx->drive_serial_number                           = copy;
    ctx->metadata_block_header.driveSerialNumberLength = length;
 
    TRACE("Exiting aaruf_set_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_drive_firmware_revision(void *context, const uint8_t *data,
                                                                const int32_t length)
{
    TRACE("Entering aaruf_set_drive_firmware_revision(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_drive_firmware_revision() = 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_set_drive_firmware_revision() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_drive_firmware_revision() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Initialize
    if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock;
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for creator");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(copy, data, length);
    if(ctx->drive_firmware_revision != NULL) free(ctx->drive_firmware_revision);
    ctx->drive_firmware_revision                           = copy;
    ctx->metadata_block_header.driveFirmwareRevisionLength = length;
 
    TRACE("Exiting aaruf_set_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_cicm_metadata(const void *context, uint8_t *buffer, size_t *length)
{
    TRACE("Entering aaruf_get_cicm_metadata(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_cicm_metadata() = 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_cicm_metadata() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->cicm_block == NULL || ctx->cicm_block_header.length == 0 || ctx->cicm_block_header.identifier != CicmBlock)
    {
        TRACE("No CICM XML metadata present");
        *length = 0;
 
        TRACE("Exiting aaruf_get_cicm_metadata() = AARUF_ERROR_CANNOT_READ_BLOCK");
        return AARUF_ERROR_CANNOT_READ_BLOCK;
    }
 
    if(*length < ctx->cicm_block_header.length)
    {
        TRACE("Buffer too small for CICM XML metadata, required %u bytes", ctx->cicm_block_header.length);
        *length = ctx->cicm_block_header.length;
 
        TRACE("Exiting aaruf_get_cicm_metadata() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    *length = ctx->cicm_block_header.length;
    memcpy(buffer, ctx->cicm_block, ctx->cicm_block_header.length);
 
    TRACE("CICM XML metadata read successfully, length %u", *length);
    TRACE("Exiting aaruf_get_cicm_metadata(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_aaru_json_metadata(const void *context, uint8_t *buffer, size_t *length)
{
    TRACE("Entering aaruf_get_aaru_json_metadata(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_aaru_json_metadata() = 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_aaru_json_metadata() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->json_block == NULL || ctx->json_block_header.length == 0 ||
       ctx->json_block_header.identifier != AaruMetadataJsonBlock)
    {
        TRACE("No Aaru metadata JSON present");
        *length = 0;
 
        TRACE("Exiting aaruf_get_aaru_json_metadata() = AARUF_ERROR_CANNOT_READ_BLOCK");
        return AARUF_ERROR_CANNOT_READ_BLOCK;
    }
 
    if(*length < ctx->json_block_header.length)
    {
        TRACE("Buffer too small for Aaru metadata JSON, required %u bytes", ctx->json_block_header.length);
        *length = ctx->json_block_header.length;
 
        TRACE("Exiting aaruf_get_aaru_json_metadata() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    *length = ctx->json_block_header.length;
    memcpy(buffer, ctx->json_block, ctx->json_block_header.length);
 
    TRACE("Aaru metadata JSON read successfully, length %u", *length);
    TRACE("Exiting aaruf_get_aaru_json_metadata(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_set_aaru_json_metadata(void *context, uint8_t *data, size_t length)
{
    TRACE("Entering aaruf_set_aaru_json_metadata(%p, %p, %d)", context, data, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_aaru_json_metadata() = 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_set_aaru_json_metadata() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_set_aaru_json_metadata() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    // Reserve memory
    uint8_t *copy = malloc(length);
    if(copy == NULL)
    {
        FATAL("Could not allocate memory for Aaru metadata JSON");
        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
    }
 
    // Copy opaque UTF-8 string
    memcpy(copy, data, length);
    if(ctx->json_block != NULL) free(ctx->json_block);
    ctx->json_block                   = copy;
    ctx->json_block_header.identifier = AaruMetadataJsonBlock;
    ctx->json_block_header.length     = (uint32_t)length;
    ctx->dirty_json_block             = true;  // Mark JSON block as dirty
 
    TRACE("Exiting aaruf_set_aaru_json_metadata(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_sequence(const void *context, int32_t *sequence, int32_t *last_sequence)
{
    TRACE("Entering aaruf_get_media_sequence(%p, %p, %p)", context, sequence, last_sequence);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_set_media_sequence() = 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_set_media_sequence() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_set_media_sequence() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    *sequence      = ctx->metadata_block_header.mediaSequence;
    *last_sequence = ctx->metadata_block_header.lastMediaSequence;
 
    TRACE("Exiting aaruf_set_media_sequence(%p, %d, %d) = AARUF_STATUS_OK", context, *sequence, *last_sequence);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_creator(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_creator(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_creator() = 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_creator() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->creator == NULL ||
       ctx->metadata_block_header.creatorLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_creator() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.creatorLength)
    {
        *length = ctx->metadata_block_header.creatorLength;
 
        TRACE("Exiting aaruf_get_creator() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->creator, ctx->metadata_block_header.creatorLength);
    *length = ctx->metadata_block_header.creatorLength;
 
    TRACE("Exiting aaruf_get_creator(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_comments(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_comments(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_comments() = 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_comments() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->comments == NULL ||
       ctx->metadata_block_header.commentsLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_comments() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.commentsLength)
    {
        *length = ctx->metadata_block_header.commentsLength;
 
        TRACE("Exiting aaruf_get_comments() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->comments, ctx->metadata_block_header.commentsLength);
    *length = ctx->metadata_block_header.commentsLength;
 
    TRACE("Exiting aaruf_get_comments(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_title(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_media_title(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_media_title() = 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_media_title() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_title == NULL ||
       ctx->metadata_block_header.mediaTitleLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_media_title() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.mediaTitleLength)
    {
        *length = ctx->metadata_block_header.mediaTitleLength;
 
        TRACE("Exiting aaruf_get_media_title() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->media_title, ctx->metadata_block_header.mediaTitleLength);
    *length = ctx->metadata_block_header.mediaTitleLength;
 
    TRACE("Exiting aaruf_get_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_manufacturer(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_media_manufacturer(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_media_manufacturer() = 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_media_manufacturer() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_manufacturer == NULL ||
       ctx->metadata_block_header.mediaManufacturerLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_media_manufacturer() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.mediaManufacturerLength)
    {
        *length = ctx->metadata_block_header.mediaManufacturerLength;
 
        TRACE("Exiting aaruf_get_media_manufacturer() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->media_manufacturer, ctx->metadata_block_header.mediaManufacturerLength);
    *length = ctx->metadata_block_header.mediaManufacturerLength;
 
    TRACE("Exiting aaruf_get_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_model(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_media_model(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_media_model() = 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_media_model() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_model == NULL ||
       ctx->metadata_block_header.mediaModelLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_media_model() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.mediaModelLength)
    {
        *length = ctx->metadata_block_header.mediaModelLength;
 
        TRACE("Exiting aaruf_get_media_model() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->media_model, ctx->metadata_block_header.mediaModelLength);
    *length = ctx->metadata_block_header.mediaModelLength;
 
    TRACE("Exiting aaruf_get_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_serial_number(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_media_serial_number(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_media_serial_number() = 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_media_serial_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_serial_number == NULL ||
       ctx->metadata_block_header.mediaSerialNumberLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_media_serial_number() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.mediaSerialNumberLength)
    {
        *length = ctx->metadata_block_header.mediaSerialNumberLength;
 
        TRACE("Exiting aaruf_get_media_serial_number() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->media_serial_number, ctx->metadata_block_header.mediaSerialNumberLength);
    *length = ctx->metadata_block_header.mediaSerialNumberLength;
 
    TRACE("Exiting aaruf_get_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_barcode(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_media_barcode(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_media_barcode() = 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_media_barcode() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_barcode == NULL ||
       ctx->metadata_block_header.mediaBarcodeLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_media_barcode() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.mediaBarcodeLength)
    {
        *length = ctx->metadata_block_header.mediaBarcodeLength;
 
        TRACE("Exiting aaruf_get_media_barcode() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->media_barcode, ctx->metadata_block_header.mediaBarcodeLength);
    *length = ctx->metadata_block_header.mediaBarcodeLength;
 
    TRACE("Exiting aaruf_get_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_media_part_number(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_media_part_number(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_media_part_number() = 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_media_part_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_part_number == NULL ||
       ctx->metadata_block_header.mediaPartNumberLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_media_part_number() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.mediaPartNumberLength)
    {
        *length = ctx->metadata_block_header.mediaPartNumberLength;
 
        TRACE("Exiting aaruf_get_media_part_number() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->media_part_number, ctx->metadata_block_header.mediaPartNumberLength);
    *length = ctx->metadata_block_header.mediaPartNumberLength;
 
    TRACE("Exiting aaruf_get_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_drive_manufacturer(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_drive_manufacturer(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_drive_manufacturer() = 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_drive_manufacturer() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_manufacturer == NULL ||
       ctx->metadata_block_header.driveManufacturerLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_drive_manufacturer() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.driveManufacturerLength)
    {
        *length = ctx->metadata_block_header.driveManufacturerLength;
 
        TRACE("Exiting aaruf_get_drive_manufacturer() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->drive_manufacturer, ctx->metadata_block_header.driveManufacturerLength);
    *length = ctx->metadata_block_header.driveManufacturerLength;
 
    TRACE("Exiting aaruf_get_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_drive_model(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_drive_model(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_drive_model() = 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_drive_model() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_model == NULL ||
       ctx->metadata_block_header.driveModelLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_drive_model() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.driveModelLength)
    {
        *length = ctx->metadata_block_header.driveModelLength;
 
        TRACE("Exiting aaruf_get_drive_model() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->drive_model, ctx->metadata_block_header.driveModelLength);
    *length = ctx->metadata_block_header.driveModelLength;
 
    TRACE("Exiting aaruf_get_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_drive_serial_number(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_drive_serial_number(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_drive_serial_number() = 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_drive_serial_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_serial_number == NULL ||
       ctx->metadata_block_header.driveSerialNumberLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_drive_serial_number() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.driveSerialNumberLength)
    {
        *length = ctx->metadata_block_header.driveSerialNumberLength;
 
        TRACE("Exiting aaruf_get_drive_serial_number() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->drive_serial_number, ctx->metadata_block_header.driveSerialNumberLength);
    *length = ctx->metadata_block_header.driveSerialNumberLength;
 
    TRACE("Exiting aaruf_get_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_drive_firmware_revision(const void *context, uint8_t *buffer, int32_t *length)
{
    TRACE("Entering aaruf_get_drive_firmware_revision(%p, %p, %p)", context, buffer, length);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_drive_firmware_revision() = 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_drive_firmware_revision() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_firmware_revision == NULL ||
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
    {
        FATAL("No metadata block present");
 
        TRACE("Exiting aaruf_get_drive_firmware_revision() = AARUF_ERROR_METADATA_NOT_PRESENT");
        return AARUF_ERROR_METADATA_NOT_PRESENT;
    }
 
    if(buffer == NULL || *length < ctx->metadata_block_header.driveFirmwareRevisionLength)
    {
        *length = ctx->metadata_block_header.driveFirmwareRevisionLength;
 
        TRACE("Exiting aaruf_get_drive_firmware_revision() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Copy opaque UTF-16LE string
    memcpy(buffer, ctx->drive_firmware_revision, ctx->metadata_block_header.driveFirmwareRevisionLength);
    *length = ctx->metadata_block_header.driveFirmwareRevisionLength;
 
    TRACE("Exiting aaruf_get_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_user_sectors(const void *context, uint64_t *sectors)
{
    TRACE("Entering aaruf_get_user_sectors(%p, %p)", context, sectors);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_user_sectors() = 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_user_sectors() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    *sectors = ctx->user_data_ddt_header.blocks;
 
    TRACE("Exiting aaruf_get_user_sectors(%p, %llu) = AARUF_STATUS_OK", context, *sectors);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_negative_sectors(const void *context, uint16_t *sectors)
{
    TRACE("Entering aaruf_get_negative_sectors(%p, %p)", context, sectors);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_negative_sectors() = 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_negative_sectors() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    *sectors = ctx->user_data_ddt_header.negative;
 
    TRACE("Exiting aaruf_get_negative_sectors(%p, %u) = AARUF_STATUS_OK", context, *sectors);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_overflow_sectors(const void *context, uint16_t *sectors)
{
    TRACE("Entering aaruf_get_overflow_sectors(%p, %p)", context, sectors);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_overflow_sectors() = 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_overflow_sectors() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    *sectors = ctx->user_data_ddt_header.overflow;
 
    TRACE("Exiting aaruf_get_overflow_sectors(%p, %u) = AARUF_STATUS_OK", context, *sectors);
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_get_image_info(const void *context, ImageInfo *image_info)
{
    TRACE("Entering aaruf_get_image_info(%p, %p)", context, image_info);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_get_image_info() = 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_image_info() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(image_info == NULL)
    {
        FATAL("image_info parameter is NULL");
 
        TRACE("Exiting aaruf_get_image_info() = AARUF_ERROR_INCORRECT_DATA_SIZE");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    // Perform deep copy of the image_info structure
    memcpy(image_info, &ctx->image_info, sizeof(ImageInfo));
 
    TRACE("Exiting aaruf_get_image_info() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_sequence(void *context)
{
    TRACE("Entering aaruf_clear_media_sequence(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_sequence() = 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_clear_media_sequence() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_sequence() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_sequence() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    ctx->metadata_block_header.mediaSequence     = 0;
    ctx->metadata_block_header.lastMediaSequence = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaBarcodeLength == 0 && ctx->metadata_block_header.mediaPartNumberLength == 0 &&
       ctx->metadata_block_header.driveModelLength == 0 && ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_sequence() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_creator(void *context)
{
    TRACE("Entering aaruf_clear_creator(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_creator() = 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_clear_creator() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_creator() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_creator() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->creator != NULL) free(ctx->creator);
 
    ctx->creator                             = NULL;
    ctx->metadata_block_header.creatorLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.commentsLength == 0 && ctx->metadata_block_header.mediaTitleLength == 0 &&
       ctx->metadata_block_header.mediaManufacturerLength == 0 && ctx->metadata_block_header.mediaModelLength == 0 &&
       ctx->metadata_block_header.mediaSerialNumberLength == 0 && ctx->metadata_block_header.mediaBarcodeLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_creator() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_comments(void *context)
{
    TRACE("Entering aaruf_clear_comments(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_comments() = 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_clear_comments() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_comments() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_comments() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->comments != NULL) free(ctx->comments);
 
    ctx->comments                             = NULL;
    ctx->metadata_block_header.commentsLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.mediaTitleLength == 0 &&
       ctx->metadata_block_header.mediaManufacturerLength == 0 && ctx->metadata_block_header.mediaModelLength == 0 &&
       ctx->metadata_block_header.mediaSerialNumberLength == 0 && ctx->metadata_block_header.mediaBarcodeLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_comments() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_title(void *context)
{
    TRACE("Entering aaruf_clear_media_title(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_title() = 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_clear_media_title() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_title() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_title() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->media_title != NULL) free(ctx->media_title);
 
    ctx->media_title                            = NULL;
    ctx->metadata_block_header.mediaTitleLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaManufacturerLength == 0 && ctx->metadata_block_header.mediaModelLength == 0 &&
       ctx->metadata_block_header.mediaSerialNumberLength == 0 && ctx->metadata_block_header.mediaBarcodeLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_title() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_manufacturer(void *context)
{
    TRACE("Entering aaruf_clear_media_manufacturer(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_manufacturer() = 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_clear_media_manufacturer() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_manufacturer() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_manufacturer() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->media_manufacturer != NULL) free(ctx->media_manufacturer);
 
    ctx->media_manufacturer                            = NULL;
    ctx->metadata_block_header.mediaManufacturerLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaModelLength == 0 &&
       ctx->metadata_block_header.mediaSerialNumberLength == 0 && ctx->metadata_block_header.mediaBarcodeLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_manufacturer() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_model(void *context)
{
    TRACE("Entering aaruf_clear_media_model(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_model() = 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_clear_media_model() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_model() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_model() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->media_model != NULL) free(ctx->media_model);
 
    ctx->media_model                            = NULL;
    ctx->metadata_block_header.mediaModelLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaSerialNumberLength == 0 && ctx->metadata_block_header.mediaBarcodeLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_model() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_serial_number(void *context)
{
    TRACE("Entering aaruf_clear_media_serial_number(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_serial_number() = 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_clear_media_serial_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_serial_number() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_serial_number() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->media_serial_number != NULL) free(ctx->media_serial_number);
 
    ctx->media_serial_number                           = NULL;
    ctx->metadata_block_header.mediaSerialNumberLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaBarcodeLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_serial_number() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_barcode(void *context)
{
    TRACE("Entering aaruf_clear_media_barcode(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_barcode() = 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_clear_media_barcode() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_barcode() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_barcode() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->media_barcode != NULL) free(ctx->media_barcode);
 
    ctx->media_barcode                            = NULL;
    ctx->metadata_block_header.mediaBarcodeLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaPartNumberLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_barcode() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_media_part_number(void *context)
{
    TRACE("Entering aaruf_clear_media_part_number(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_media_part_number() = 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_clear_media_part_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_media_part_number() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_media_part_number() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->media_part_number != NULL) free(ctx->media_part_number);
 
    ctx->media_part_number                           = NULL;
    ctx->metadata_block_header.mediaPartNumberLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaBarcodeLength == 0 && ctx->metadata_block_header.driveModelLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_media_part_number() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_drive_manufacturer(void *context)
{
    TRACE("Entering aaruf_clear_drive_manufacturer(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_drive_manufacturer() = 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_clear_drive_manufacturer() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_drive_manufacturer() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_drive_manufacturer() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->drive_manufacturer != NULL) free(ctx->drive_manufacturer);
 
    ctx->drive_manufacturer                            = NULL;
    ctx->metadata_block_header.driveManufacturerLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaBarcodeLength == 0 && ctx->metadata_block_header.mediaPartNumberLength == 0 &&
       ctx->metadata_block_header.driveModelLength == 0 && ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_drive_manufacturer() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_drive_model(void *context)
{
    TRACE("Entering aaruf_clear_drive_model(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_drive_model() = 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_clear_drive_model() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_drive_model() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_drive_model() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->drive_model != NULL) free(ctx->drive_model);
 
    ctx->drive_model                            = NULL;
    ctx->metadata_block_header.driveModelLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaBarcodeLength == 0 && ctx->metadata_block_header.mediaPartNumberLength == 0 &&
       ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_drive_model() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_drive_serial_number(void *context)
{
    TRACE("Entering aaruf_clear_drive_serial_number(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_drive_serial_number() = 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_clear_drive_serial_number() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_drive_serial_number() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_drive_serial_number() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->drive_serial_number != NULL) free(ctx->drive_serial_number);
 
    ctx->drive_serial_number                           = NULL;
    ctx->metadata_block_header.driveSerialNumberLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaBarcodeLength == 0 && ctx->metadata_block_header.mediaPartNumberLength == 0 &&
       ctx->metadata_block_header.driveModelLength == 0 && ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveFirmwareRevisionLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_drive_serial_number() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_clear_drive_firmware_revision(void *context)
{
    TRACE("Entering aaruf_clear_drive_firmware_revision(%p)", context);
 
    // Check context is correct AaruFormat context
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_clear_drive_firmware_revision() = 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_clear_drive_firmware_revision() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    // Check we are writing
    if(!ctx->is_writing)
    {
        FATAL("Trying to write a read-only image");
 
        TRACE("Exiting aaruf_clear_drive_firmware_revision() = AARUF_READ_ONLY");
        return AARUF_READ_ONLY;
    }
 
    if(ctx->metadata_block_header.identifier != MetadataBlock)
    {
        TRACE("Exiting aaruf_clear_drive_firmware_revision() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    if(ctx->drive_firmware_revision != NULL) free(ctx->drive_firmware_revision);
 
    ctx->drive_firmware_revision                           = NULL;
    ctx->metadata_block_header.driveFirmwareRevisionLength = 0;
 
    // Check if all metadata is clear
    if(ctx->metadata_block_header.mediaSequence == 0 && ctx->metadata_block_header.lastMediaSequence == 0 &&
       ctx->metadata_block_header.creatorLength == 0 && ctx->metadata_block_header.commentsLength == 0 &&
       ctx->metadata_block_header.mediaTitleLength == 0 && ctx->metadata_block_header.mediaManufacturerLength == 0 &&
       ctx->metadata_block_header.mediaModelLength == 0 && ctx->metadata_block_header.mediaSerialNumberLength == 0 &&
       ctx->metadata_block_header.mediaBarcodeLength == 0 && ctx->metadata_block_header.mediaPartNumberLength == 0 &&
       ctx->metadata_block_header.driveModelLength == 0 && ctx->metadata_block_header.driveManufacturerLength == 0 &&
       ctx->metadata_block_header.driveSerialNumberLength == 0)
        ctx->metadata_block_header.identifier = 0;
 
    TRACE("Exiting aaruf_clear_drive_firmware_revision() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}