create.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 <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "aaruformat.h"
#include "enums.h"
#include "internal.h"
#include "log.h"
 
static void cleanup_failed_create(aaruformat_context *ctx)
{
    if(ctx == NULL) return;
 
    if(ctx->sector_hash_map != NULL)
    {
        free_map(ctx->sector_hash_map);
        ctx->sector_hash_map = NULL;
    }
 
    if(ctx->index_entries != NULL)
    {
        utarray_free(ctx->index_entries);
        ctx->index_entries = NULL;
    }
 
    if(ctx->user_data_ddt2 != NULL)
    {
        free(ctx->user_data_ddt2);
        ctx->user_data_ddt2 = NULL;
    }
 
    if(ctx->spamsum_context != NULL)
    {
        aaruf_spamsum_free(ctx->spamsum_context);
        ctx->spamsum_context = NULL;
    }
 
    if(ctx->blake3_context != NULL)
    {
        free(ctx->blake3_context);
        ctx->blake3_context = NULL;
    }
 
    if(ctx->ecc_cd_context != NULL)
    {
        free(ctx->ecc_cd_context);
        ctx->ecc_cd_context = NULL;
    }
 
    if(ctx->readableSectorTags != NULL)
    {
        free(ctx->readableSectorTags);
        ctx->readableSectorTags = NULL;
    }
 
    // ApplicationVersion and Version are fixed-size arrays, not pointers - no need to free
 
    if(ctx->imageStream != NULL)
    {
        fclose(ctx->imageStream);
        ctx->imageStream = NULL;
    }
 
    free(ctx);
}

AARU_EXPORT void AARU_CALL *aaruf_create(const char *filepath, const uint32_t media_type, const uint32_t sector_size,
                                         const uint64_t user_sectors, const uint64_t negative_sectors,
                                         const uint64_t overflow_sectors, const char *options,
                                         const uint8_t *application_name, const uint8_t application_name_length,
                                         const uint8_t application_major_version,
                                         const uint8_t application_minor_version, const bool is_tape)
{
    TRACE("Entering aaruf_create(%s, %u, %u, %llu, %llu, %llu, %s, %s, %u, %u, %u, %d)", filepath, media_type,
          sector_size, user_sectors, negative_sectors, overflow_sectors, options,
          application_name ? (const char *)application_name : "NULL", application_name_length,
          application_major_version, application_minor_version, is_tape);
 
    // Parse the options
    TRACE("Parsing options");
    bool               table_shift_found = false;
    const aaru_options parsed_options    = parse_options(options, &table_shift_found);
 
    // Allocate context
    TRACE("Allocating memory for context");
    aaruformat_context *ctx = malloc(sizeof(aaruformat_context));
    if(ctx == NULL)
    {
        FATAL("Not enough memory to create context");
        errno = AARUF_ERROR_NOT_ENOUGH_MEMORY;
 
        TRACE("Exiting aaruf_create() = NULL");
        return NULL;
    }
 
    memset(ctx, 0, sizeof(aaruformat_context));
 
    // Create the image file
    TRACE("Creating image file %s", filepath);
    ctx->imageStream = fopen(filepath, "wb+");
    if(ctx->imageStream == NULL)
    {
        FATAL("Error %d opening file %s for writing", errno, filepath);
        errno = AARUF_ERROR_CANNOT_CREATE_FILE;
 
        TRACE("Exiting aaruf_create() = NULL");
        cleanup_failed_create(ctx);
        return NULL;
    }
 
    if(application_name_length > AARU_HEADER_APP_NAME_LEN)
    {
        FATAL("Application name too long (%u bytes, maximum %u bytes)", application_name_length,
              AARU_HEADER_APP_NAME_LEN);
        errno = AARUF_ERROR_INVALID_APP_NAME_LENGTH;
 
        TRACE("Exiting aaruf_create() = NULL");
        cleanup_failed_create(ctx);
        return NULL;
    }
 
    // Initialize header
    TRACE("Initializing header");
    ctx->header.identifier = AARU_MAGIC;
    memcpy(ctx->header.application, application_name, application_name_length);
    ctx->header.imageMajorVersion       = AARUF_VERSION_V2;
    ctx->header.imageMinorVersion       = 0;
    ctx->header.applicationMajorVersion = application_major_version;
    ctx->header.applicationMinorVersion = application_minor_version;
    ctx->header.mediaType               = media_type;
    ctx->header.indexOffset             = 0;
    ctx->header.creationTime            = get_filetime_uint64();
    ctx->header.lastWrittenTime         = get_filetime_uint64();
 
    // Generate random GUID for the image
    TRACE("Generating random GUID");
    generate_random_bytes(ctx->header.guid, GUID_SIZE);
 
    ctx->readableSectorTags = (bool *)malloc(sizeof(bool) * MaxSectorTag);
 
    if(ctx->readableSectorTags == NULL)
    {
        errno = AARUF_ERROR_NOT_ENOUGH_MEMORY;
 
        TRACE("Exiting aaruf_create() = NULL");
        cleanup_failed_create(ctx);
        return NULL;
    }
 
    memset(ctx->readableSectorTags, 0, sizeof(bool) * MaxSectorTag);
 
    // Initialize image info
    TRACE("Initializing image info");
 
    // Copy application name (UTF-8) to image_info
    memset(ctx->image_info.Application, 0, 64);
    size_t copy_len = application_name_length < 63 ? application_name_length : 63;
    memcpy(ctx->image_info.Application, application_name, copy_len);
    ctx->image_info.Application[63] = '\0';
 
    // Set application version string directly in the fixed-size array
    memset(ctx->image_info.ApplicationVersion, 0, 32);
    sprintf(ctx->image_info.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion,
            ctx->header.applicationMinorVersion);
 
    // Set image version string directly in the fixed-size array
    memset(ctx->image_info.Version, 0, 32);
    sprintf(ctx->image_info.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
 
    ctx->image_info.MediaType            = ctx->header.mediaType;
    ctx->image_info.ImageSize            = 0;
    ctx->image_info.CreationTime         = ctx->header.creationTime;
    ctx->image_info.LastModificationTime = ctx->header.lastWrittenTime;
    ctx->image_info.MetadataMediaType    = aaruf_get_xml_mediatype(ctx->header.mediaType);
    ctx->image_info.SectorSize           = sector_size;
    ctx->image_info.Sectors              = user_sectors;
 
    // Initialize caches
    TRACE("Initializing caches");
    ctx->block_header_cache.cache     = NULL;
    const uint64_t cache_divisor      = (uint64_t)ctx->image_info.SectorSize * (1ULL << ctx->shift);
    ctx->block_header_cache.max_items = cache_divisor == 0 ? 0 : MAX_CACHE_SIZE / cache_divisor;
    ctx->block_cache.cache            = NULL;
    ctx->block_cache.max_items        = ctx->block_header_cache.max_items;
 
    // TODO: Cache tracks and sessions?
 
    // Initialize ECC for Compact Disc
    TRACE("Initializing Compact Disc ECC");
    ctx->ecc_cd_context = (CdEccContext *)aaruf_ecc_cd_init();
 
    ctx->magic                 = AARU_MAGIC;
    ctx->library_major_version = LIBAARUFORMAT_MAJOR_VERSION;
    ctx->library_minor_version = LIBAARUFORMAT_MINOR_VERSION;
 
    if(!is_tape)
    {  // Initialize DDT2
        TRACE("Initializing DDT2");
        ctx->in_memory_ddt                            = true;
        ctx->user_data_ddt_header.identifier          = DeDuplicationTable2;
        ctx->user_data_ddt_header.type                = UserData;
        ctx->user_data_ddt_header.compression         = None;
        ctx->user_data_ddt_header.tableLevel          = 0;
        ctx->user_data_ddt_header.previousLevelOffset = 0;
        ctx->user_data_ddt_header.negative            = negative_sectors;
        ctx->user_data_ddt_header.blocks              = user_sectors + overflow_sectors + negative_sectors;
        ctx->user_data_ddt_header.overflow            = overflow_sectors;
        ctx->user_data_ddt_header.start               = 0;
        ctx->user_data_ddt_header.blockAlignmentShift = parsed_options.block_alignment;
        ctx->user_data_ddt_header.dataShift           = parsed_options.data_shift;
 
        if(parsed_options.table_shift == -1 || !table_shift_found)
        {
            const uint64_t total_sectors = user_sectors + overflow_sectors + negative_sectors;
 
            if(total_sectors < 8388608ULL)
                ctx->user_data_ddt_header.tableShift = 0;
            else
                ctx->user_data_ddt_header.tableShift = 22;
        }
        else
            ctx->user_data_ddt_header.tableShift =
                parsed_options.table_shift > 0 ? (uint8_t)parsed_options.table_shift : 0;
 
        ctx->user_data_ddt_header.levels = ctx->user_data_ddt_header.tableShift > 0 ? 2 : 1;
 
        uint8_t effective_table_shift = ctx->user_data_ddt_header.tableShift;
        if(effective_table_shift >= 63)
        {
            TRACE("Clamping table shift from %u to 62 to avoid overflow", effective_table_shift);
            effective_table_shift                = 62;
            ctx->user_data_ddt_header.tableShift = effective_table_shift;
        }
 
        const uint64_t sectors_per_entry  = 1ULL << effective_table_shift;
        ctx->user_data_ddt_header.entries = ctx->user_data_ddt_header.blocks / sectors_per_entry;
        if(ctx->user_data_ddt_header.blocks % sectors_per_entry != 0 || ctx->user_data_ddt_header.entries == 0)
            ctx->user_data_ddt_header.entries++;
 
        TRACE("Initializing primary/single DDT");
        ctx->user_data_ddt2 =
            (uint64_t *)calloc(ctx->user_data_ddt_header.entries, sizeof(uint64_t));  // All entries to zero
        if(ctx->user_data_ddt2 == NULL)
        {
            FATAL("Not enough memory to allocate primary DDT (big)");
            errno = AARUF_ERROR_NOT_ENOUGH_MEMORY;
            TRACE("Exiting aaruf_create() = NULL");
            cleanup_failed_create(ctx);
            return NULL;
        }
 
        // Set the primary DDT offset (just after the header, block aligned)
        ctx->primary_ddt_offset       = sizeof(AaruHeaderV2);  // Start just after the header
        const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1;
        ctx->primary_ddt_offset       = ctx->primary_ddt_offset + alignment_mask & ~alignment_mask;
 
        TRACE("Primary DDT will be placed at offset %" PRIu64, ctx->primary_ddt_offset);
 
        // Calculate size of primary DDT table
        const uint64_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint64_t);
 
        // Calculate where data blocks can start (after primary DDT + header)
        if(ctx->user_data_ddt_header.tableShift > 0)
        {
            const uint64_t data_start_position = ctx->primary_ddt_offset + sizeof(DdtHeader2) + primary_table_size;
            ctx->next_block_position           = data_start_position + alignment_mask & ~alignment_mask;
        }
        else
            ctx->next_block_position = ctx->primary_ddt_offset;  // Single-level DDT can start anywhere
    }
    else
    {
        // Fill needed values
        ctx->user_data_ddt_header.blockAlignmentShift = parsed_options.block_alignment;
        ctx->header.blockAlignmentShift               = parsed_options.block_alignment;
        ctx->user_data_ddt_header.dataShift           = parsed_options.data_shift;
 
        // Calculate aligned next block position
        const uint64_t alignment_mask = (1ULL << parsed_options.block_alignment) - 1;
        ctx->next_block_position      = sizeof(AaruHeaderV2);  // Start just after the header
        ctx->next_block_position      = ctx->next_block_position + alignment_mask & ~alignment_mask;
        ctx->is_tape                  = 1;
        ctx->tape_ddt                 = NULL;
    }
 
    TRACE("Data blocks will start at position %" PRIu64, ctx->next_block_position);
 
    // Position file pointer at the data start position
    if(fseek(ctx->imageStream, ctx->next_block_position, SEEK_SET) != 0)
    {
        FATAL("Could not seek to data start position");
        errno = AARUF_ERROR_CANNOT_CREATE_FILE;
        TRACE("Exiting aaruf_create() = NULL");
        cleanup_failed_create(ctx);
        return NULL;
    }
 
    // Initialize index entries array
    TRACE("Initializing index entries array");
    const UT_icd index_entry_icd = {sizeof(IndexEntry), NULL, NULL, NULL};
    utarray_new(ctx->index_entries, &index_entry_icd);
 
    if(ctx->index_entries == NULL)
    {
        FATAL("Not enough memory to create index entries array");
        errno = AARUF_ERROR_NOT_ENOUGH_MEMORY;
 
        TRACE("Exiting aaruf_create() = NULL");
        cleanup_failed_create(ctx);
        return NULL;
    }
 
    ctx->compression_enabled = parsed_options.compress;
    ctx->lzma_dict_size      = parsed_options.dictionary;
    ctx->deduplicate         = parsed_options.deduplicate;
    if(ctx->deduplicate)
        ctx->sector_hash_map = create_map(ctx->user_data_ddt_header.blocks * 25 / 100);  // 25% of total sectors
 
    ctx->rewinded           = false;
    ctx->last_written_block = 0;
 
    if(parsed_options.md5)
    {
        ctx->calculating_md5 = true;
        aaruf_md5_init(&ctx->md5_context);
    }
    if(parsed_options.sha1)
    {
        ctx->calculating_sha1 = true;
        aaruf_sha1_init(&ctx->sha1_context);
    }
    if(parsed_options.sha256)
    {
        ctx->calculating_sha256 = true;
        aaruf_sha256_init(&ctx->sha256_context);
    }
    if(parsed_options.spamsum)
    {
        ctx->calculating_spamsum = true;
        ctx->spamsum_context     = aaruf_spamsum_init();
    }
    if(parsed_options.blake3)
    {
        ctx->blake3_context = calloc(1, sizeof(blake3_hasher));
        if(ctx->blake3_context != NULL)
        {
            ctx->calculating_blake3 = true;
            blake3_hasher_init(ctx->blake3_context);
        }
    }
 
    // Is writing
    ctx->is_writing = true;
 
    // Initialize dirty flags - all true by default for new images
    ctx->dirty_secondary_ddt                 = true;
    ctx->dirty_primary_ddt                   = true;
    ctx->dirty_single_level_ddt              = true;
    ctx->dirty_checksum_block                = true;
    ctx->dirty_tracks_block                  = true;
    ctx->dirty_mode2_subheaders_block        = true;
    ctx->dirty_sector_prefix_block           = true;
    ctx->dirty_sector_prefix_ddt             = true;
    ctx->dirty_sector_suffix_block           = true;
    ctx->dirty_sector_suffix_ddt             = true;
    ctx->dirty_sector_subchannel_block       = true;
    ctx->dirty_dvd_long_sector_blocks        = true;
    ctx->dirty_dvd_title_key_decrypted_block = true;
    ctx->dirty_media_tags                    = true;
    ctx->dirty_tape_ddt                      = true;
    ctx->dirty_tape_file_block               = true;
    ctx->dirty_tape_partition_block          = true;
    ctx->dirty_geometry_block                = true;
    ctx->dirty_metadata_block                = true;
    ctx->dirty_dumphw_block                  = true;
    ctx->dirty_cicm_block                    = true;
    ctx->dirty_json_block                    = true;
    ctx->dirty_flux_block                    = true;
    ctx->dirty_index_block                   = true;
 
    TRACE("Exiting aaruf_create() = %p", ctx);
    // Return context
    return ctx;
}