metadata_write.c

Go to the documentation of this file.

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

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_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_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;
}