read.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 <stdlib.h>
#include <string.h>
 
#include <aaruformat.h>
 
#include "internal.h"
#include "log.h"

AARU_EXPORT int32_t AARU_CALL aaruf_read_media_tag(void *context, uint8_t *data, const int32_t tag, uint32_t *length)
{
    const uint32_t initial_length = length == NULL ? 0U : *length;
 
    TRACE("Entering aaruf_read_media_tag(%p, %p, %d, %u)", context, data, tag, initial_length);
 
    mediaTagEntry *item;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
        TRACE("Exiting aaruf_read_media_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(length == NULL)
    {
        FATAL("Invalid length pointer");
        TRACE("Exiting aaruf_read_media_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    const aaruformat_context *ctx = context;
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
        TRACE("Exiting aaruf_read_media_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    TRACE("Finding media tag %d", tag);
    HASH_FIND_INT(ctx->mediaTags, &tag, item);
 
    if(item == NULL)
    {
        TRACE("Media tag not found");
        *length = 0;
 
        TRACE("Exiting aaruf_read_media_tag() = AARUF_ERROR_MEDIA_TAG_NOT_PRESENT");
        return AARUF_ERROR_MEDIA_TAG_NOT_PRESENT;
    }
 
    if(data == NULL || *length < item->length)
    {
        TRACE("Buffer too small for media tag %d, required %u bytes", tag, item->length);
        *length = item->length;
 
        TRACE("Exiting aaruf_read_media_tag() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    *length = item->length;
    memcpy(data, item->data, item->length);
 
    TRACE("Media tag %d read successfully, length %u", tag, *length);
    TRACE("Exiting aaruf_read_media_tag() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_read_sector(void *context, const uint64_t sector_address, bool negative,
                                                uint8_t *data, uint32_t *length, uint8_t *sector_status)
{
    const uint32_t initial_length = length == NULL ? 0U : *length;
 
    TRACE("Entering aaruf_read_sector(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, negative, data,
          initial_length);
 
    aaruformat_context *ctx          = NULL;
    uint64_t            offset       = 0;
    uint64_t            block_offset = 0;
    BlockHeader        *block_header = NULL;
    uint8_t            *block        = NULL;
    size_t              read_bytes   = 0;
    uint8_t             lzma_properties[LZMA_PROPERTIES_LENGTH];
    size_t              lzma_size = 0;
    uint8_t            *cmp_data  = NULL;
    int                 error_no  = 0;
    *sector_status                = SectorStatusNotDumped;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    ctx = context;
 
    if(length == NULL)
    {
        FATAL("Invalid length pointer");
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_INCORRECT_DATA_SIZE");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(negative && sector_address > ctx->user_data_ddt_header.negative)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(ctx->ddt_version == 1)
    {
        if(negative)
        {
            FATAL("Negative sector addresses not supported in this image");
            return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
        }
 
        error_no = decode_ddt_entry_v1(ctx, sector_address, &offset, &block_offset, sector_status);
    }
    else if(ctx->ddt_version == 2)
        error_no = decode_ddt_entry_v2(ctx, sector_address, negative, &offset, &block_offset, sector_status);
 
    if(error_no != AARUF_STATUS_OK)
    {
        FATAL("Error %d decoding DDT entry", error_no);
 
        TRACE("Exiting aaruf_read_sector() = %d", error_no);
        return error_no;
    }
 
    // Partially written image... as we can't know the real sector size just assume it's common :/
    if(*sector_status == SectorStatusNotDumped)
    {
        *length = ctx->image_info.SectorSize;
 
        TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_SECTOR_NOT_DUMPED");
        return AARUF_STATUS_SECTOR_NOT_DUMPED;
    }
 
    // Check if block header is cached
    TRACE("Checking if block header is cached");
    block_header = find_in_cache_uint64(&ctx->block_header_cache, block_offset);
 
    // Read block header
    if(block_header == NULL)
    {
        TRACE("Allocating memory for block header");
        block_header = malloc(sizeof(BlockHeader));
        if(block_header == NULL)
        {
            FATAL("Not enough memory for block header");
 
            TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
            return AARUF_ERROR_NOT_ENOUGH_MEMORY;
        }
 
        TRACE("Reading block header");
        if(fseek(ctx->imageStream, block_offset, SEEK_SET) != 0)
        {
            FATAL("Could not seek to block header");
            free(block_header);
 
            TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_READ_HEADER");
            return AARUF_ERROR_CANNOT_READ_HEADER;
        }
 
        read_bytes = fread(block_header, 1, sizeof(BlockHeader), ctx->imageStream);
 
        if(read_bytes != sizeof(BlockHeader))
        {
            FATAL("Error reading block header");
            free(block_header);
 
            TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_READ_HEADER");
            return AARUF_ERROR_CANNOT_READ_HEADER;
        }
 
        TRACE("Adding block header to cache");
        add_to_cache_uint64(&ctx->block_header_cache, block_offset, block_header);
    }
    else if(fseek(ctx->imageStream, block_offset + sizeof(BlockHeader), SEEK_SET) != 0)
    {
        FATAL("Could not seek past cached block header");
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_READ_HEADER");
        return AARUF_ERROR_CANNOT_READ_HEADER;
    }
 
    if(data == NULL || *length < block_header->sectorSize)
    {
        TRACE("Buffer too small for sector, required %u bytes", block_header->sectorSize);
        *length = block_header->sectorSize;
 
        TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_BUFFER_TOO_SMALL");
        return AARUF_ERROR_BUFFER_TOO_SMALL;
    }
 
    // Check if block is cached
    TRACE("Checking if block is cached");
    block = find_in_cache_uint64(&ctx->block_cache, block_offset);
 
    if(block != NULL)
    {
        TRACE("Getting data from cache");
        memcpy(data, block + offset * block_header->sectorSize, block_header->sectorSize);
        *length = block_header->sectorSize;
 
        TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_OK");
        return AARUF_STATUS_OK;
    }
 
    // Decompress block
    switch(block_header->compression)
    {
        case None:
            TRACE("Allocating memory for block");
            block = (uint8_t *)malloc(block_header->length);
            if(block == NULL)
            {
                FATAL("Not enough memory for block");
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            TRACE("Reading block into memory");
            read_bytes = fread(block, 1, block_header->length, ctx->imageStream);
 
            if(read_bytes != block_header->length)
            {
                FATAL("Could not read block");
                free(block);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_READ_BLOCK");
                return AARUF_ERROR_CANNOT_READ_BLOCK;
            }
 
            break;
        case Lzma:
            if(block_header->cmpLength <= LZMA_PROPERTIES_LENGTH || block_header->length == 0)
            {
                FATAL("Invalid LZMA block lengths (cmpLength=%u, length=%u)", block_header->cmpLength,
                      block_header->length);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            lzma_size = block_header->cmpLength - LZMA_PROPERTIES_LENGTH;
            TRACE("Allocating memory for compressed data of size %zu bytes", lzma_size);
            cmp_data = malloc(lzma_size);
 
            if(cmp_data == NULL)
            {
                FATAL("Cannot allocate memory for block...");
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            TRACE("Allocating memory for block of size %zu bytes", block_header->length);
            block = malloc(block_header->length);
            if(block == NULL)
            {
                FATAL("Cannot allocate memory for block...");
                free(cmp_data);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            read_bytes = fread(lzma_properties, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
 
            if(read_bytes != LZMA_PROPERTIES_LENGTH)
            {
                FATAL("Could not read LZMA properties...");
                free(block);
                free(cmp_data);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            read_bytes = fread(cmp_data, 1, lzma_size, ctx->imageStream);
            if(read_bytes != lzma_size)
            {
                FATAL("Could not read compressed block...");
                free(cmp_data);
                free(block);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            TRACE("Decompressing block of size %zu bytes", block_header->length);
            read_bytes = block_header->length;
            error_no   = aaruf_lzma_decode_buffer(block, &read_bytes, cmp_data, &lzma_size, lzma_properties,
                                                  LZMA_PROPERTIES_LENGTH);
 
            if(error_no != 0)
            {
                FATAL("Got error %d from LZMA...", error_no);
                free(cmp_data);
                free(block);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            if(read_bytes != block_header->length)
            {
                FATAL("Error decompressing block, should be {0} bytes but got {1} bytes...");
                free(cmp_data);
                free(block);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            free(cmp_data);
 
            break;
        case Flac:
            TRACE("Allocating memory for compressed data of size %zu bytes", block_header->cmpLength);
            cmp_data = malloc(block_header->cmpLength);
 
            if(cmp_data == NULL)
            {
                FATAL("Cannot allocate memory for block...");
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            TRACE("Allocating memory for block of size %zu bytes", block_header->length);
            block = malloc(block_header->length);
            if(block == NULL)
            {
                FATAL("Cannot allocate memory for block...");
                free(cmp_data);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            TRACE("Reading compressed data into memory");
            read_bytes = fread(cmp_data, 1, block_header->cmpLength, ctx->imageStream);
            if(read_bytes != block_header->cmpLength)
            {
                FATAL("Could not read compressed block...");
                free(cmp_data);
                free(block);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            TRACE("Decompressing block of size %zu bytes", block_header->length);
            read_bytes =
                aaruf_flac_decode_redbook_buffer(block, block_header->length, cmp_data, block_header->cmpLength);
 
            if(read_bytes != block_header->length)
            {
                FATAL("Error decompressing block, should be {0} bytes but got {1} bytes...");
                free(cmp_data);
                free(block);
 
                TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK");
                return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
            }
 
            free(cmp_data);
 
            break;
        default:
            FATAL("Unsupported compression %d", block_header->compression);
            TRACE("Exiting aaruf_read_sector() = AARUF_ERROR_UNSUPPORTED_COMPRESSION");
            return AARUF_ERROR_UNSUPPORTED_COMPRESSION;
    }
 
    // Add block to cache
    TRACE("Adding block to cache");
    add_to_cache_uint64(&ctx->block_cache, block_offset, block);
 
    memcpy(data, block + offset * block_header->sectorSize, block_header->sectorSize);
    *length = block_header->sectorSize;
 
    TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_OK");
    return AARUF_STATUS_OK;
}

AARU_EXPORT int32_t AARU_CALL aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sector_address,
                                                      uint32_t *length, const uint8_t track, uint8_t *sector_status)
{
    const uint32_t initial_length = length == NULL ? 0U : *length;
 
    TRACE("Entering aaruf_read_track_sector(%p, %p, %" PRIu64 ", %u, %d)", context, data, sector_address,
          initial_length, track);
 
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    aaruformat_context *ctx = context;
 
    if(length == NULL)
    {
        FATAL("Invalid length pointer");
 
        TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_INCORRECT_DATA_SIZE");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(ctx->image_info.MetadataMediaType != OpticalDisc)
    {
        FATAL("Incorrect media type %d, expected OpticalDisc", ctx->image_info.MetadataMediaType);
 
        TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
        return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
    }
 
    for(int i = 0; i < ctx->number_of_data_tracks; i++)
        if(ctx->data_tracks[i].sequence == track)
            return aaruf_read_sector(context, ctx->data_tracks[i].start + sector_address, false, data, length,
                                     sector_status);
 
    TRACE("Track %d not found", track);
    TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_TRACK_NOT_FOUND");
    return AARUF_ERROR_TRACK_NOT_FOUND;
}

AARU_EXPORT int32_t AARU_CALL aaruf_read_sector_long(void *context, const uint64_t sector_address, bool negative,
                                                     uint8_t *data, uint32_t *length, uint8_t *sector_status)
{
    const uint32_t initial_length = length == NULL ? 0U : *length;
 
    TRACE("Entering aaruf_read_sector_long(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, data,
          initial_length);
 
    const aaruformat_context *ctx         = NULL;
    uint32_t                  bare_length = 0;
    uint32_t                  tag_length  = 0;
    uint8_t                  *bare_data   = NULL;
    int32_t                   res         = 0;
    int32_t                   query_status;
    TrackEntry                trk;
    int                       i         = 0;
    bool                      trk_found = false;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    ctx = context;
 
    if(length == NULL)
    {
        FATAL("Invalid length pointer");
 
        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_DATA_SIZE");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(negative && sector_address > ctx->user_data_ddt_header.negative)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    uint64_t corrected_sector_address = sector_address;
 
    // Calculate positive or negative sector
    if(negative)
        corrected_sector_address = ctx->user_data_ddt_header.negative - sector_address;
    else
        corrected_sector_address += ctx->user_data_ddt_header.negative;
 
    switch(ctx->image_info.MetadataMediaType)
    {
        case OpticalDisc:
            if(ctx->image_info.MediaType == DVDROM || ctx->image_info.MediaType == PS2DVD ||
               ctx->image_info.MediaType == SACD || ctx->image_info.MediaType == PS3DVD ||
               ctx->image_info.MediaType == DVDR || ctx->image_info.MediaType == DVDRW ||
               ctx->image_info.MediaType == DVDPR || ctx->image_info.MediaType == DVDPRW ||
               ctx->image_info.MediaType == DVDPRWDL || ctx->image_info.MediaType == DVDRDL ||
               ctx->image_info.MediaType == DVDPRDL || ctx->image_info.MediaType == DVDRAM ||
               ctx->image_info.MediaType == DVDRWDL || ctx->image_info.MediaType == DVDDownload ||
               ctx->image_info.MediaType == Nuon)
            {
                if(ctx->sector_id == NULL || ctx->sector_ied == NULL || ctx->sector_cpr_mai == NULL ||
                   ctx->sector_edc == NULL)
                    return aaruf_read_sector(context, sector_address, negative, data, length, sector_status);
 
                if(*length < 2064 || data == NULL)
                {
                    *length = 2064;
                    FATAL("Buffer too small for sector, required %u bytes", *length);
 
                    TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_BUFFER_TOO_SMALL");
                    return AARUF_ERROR_BUFFER_TOO_SMALL;
                }
 
                bare_length  = 0;
                query_status = aaruf_read_sector(context, sector_address, negative, NULL, &bare_length, sector_status);
 
                if(query_status != AARUF_ERROR_BUFFER_TOO_SMALL && query_status != AARUF_STATUS_OK)
                {
                    TRACE("Exiting aaruf_read_sector_long() = %d", query_status);
                    return query_status;
                }
 
                if(bare_length == 0)
                {
                    FATAL("Invalid bare sector length (0)");
 
                    TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                    return AARUF_ERROR_INCORRECT_DATA_SIZE;
                }
 
                TRACE("Allocating memory for bare data");
                bare_data = (uint8_t *)malloc(bare_length);
 
                if(bare_data == NULL)
                {
                    FATAL("Could not allocate memory for bare data");
 
                    TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                    return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                }
 
                res = aaruf_read_sector(context, sector_address, negative, bare_data, &bare_length, sector_status);
 
                if(res != AARUF_STATUS_OK)
                {
                    *length = 2064;
                    free(bare_data);
 
                    TRACE("Exiting aaruf_read_sector_long() = %d", res);
                    return res;
                }
 
                memcpy(data, ctx->sector_id + corrected_sector_address * 4, 4);
                memcpy(data + 4, ctx->sector_ied + corrected_sector_address * 2, 2);
                memcpy(data + 6, ctx->sector_cpr_mai + corrected_sector_address * 6, 6);
                memcpy(data + 12, bare_data, 2048);
                memcpy(data + 2060, ctx->sector_edc + corrected_sector_address * 4, 4);
 
                *length = 2064;
 
                free(bare_data);
                return AARUF_STATUS_OK;
            }
 
            if(*length < 2352 || data == NULL)
            {
                *length = 2352;
                FATAL("Buffer too small for sector, required %u bytes", *length);
 
                TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_BUFFER_TOO_SMALL");
                return AARUF_ERROR_BUFFER_TOO_SMALL;
            }
 
            if((ctx->sector_suffix == NULL || ctx->sector_prefix == NULL) &&
               (ctx->sector_suffix_ddt == NULL || ctx->sector_prefix_ddt == NULL) &&
               (ctx->sector_suffix_ddt2 == NULL || ctx->sector_prefix_ddt2 == NULL))
                return aaruf_read_sector(context, sector_address, negative, data, length, sector_status);
 
            bare_length  = 0;
            query_status = aaruf_read_sector(context, sector_address, negative, NULL, &bare_length, sector_status);
 
            if(query_status != AARUF_ERROR_BUFFER_TOO_SMALL && query_status != AARUF_STATUS_OK)
            {
                TRACE("Exiting aaruf_read_sector_long() = %d", query_status);
                return query_status;
            }
 
            if(bare_length == 0)
            {
                FATAL("Invalid bare sector length (0)");
 
                TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            TRACE("Allocating memory for bare data");
            bare_data = (uint8_t *)malloc(bare_length);
 
            if(bare_data == NULL)
            {
                FATAL("Could not allocate memory for bare data");
 
                TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                return AARUF_ERROR_NOT_ENOUGH_MEMORY;
            }
 
            res = aaruf_read_sector(context, sector_address, negative, bare_data, &bare_length, sector_status);
 
            if(res != AARUF_STATUS_OK)
            {
                free(bare_data);
 
                TRACE("Exiting aaruf_read_sector_long() = %d", res);
                return res;
            }
 
            trk_found = false;
 
            for(i = 0; i < ctx->number_of_data_tracks; i++)
                if(sector_address >= ctx->data_tracks[i].start && sector_address <= ctx->data_tracks[i].end)
                {
                    trk_found = true;
                    trk       = ctx->data_tracks[i];
                    break;
                }
 
            if(!trk_found)
            {
                FATAL("Track not found");
                free(bare_data);
 
                TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_TRACK_NOT_FOUND");
                return AARUF_ERROR_TRACK_NOT_FOUND;
            }
 
            switch(trk.type)
            {
                case Audio:
                case Data:
                    memcpy(data, bare_data, bare_length);
                    *length = bare_length;
                    free(bare_data);
                    return res;
                case CdMode1:
                    memcpy(data + 16, bare_data, 2048);
 
                    if(ctx->sector_prefix_ddt2 != NULL)
                    {
                        const uint64_t prefix_ddt_entry = ctx->sector_prefix_ddt2[corrected_sector_address];
                        const uint32_t prefix_status    = prefix_ddt_entry >> 60;
                        const uint64_t prefix_index     = prefix_ddt_entry & 0x0FFFFFFFFFFFFFFF;
 
                        if(prefix_status == SectorStatusMode1Correct)
                        {
                            aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address);
                            res = AARUF_STATUS_OK;
                        }
                        else if(prefix_status == SectorStatusNotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            memcpy(data, ctx->sector_prefix + prefix_index * 16, 16);
                    }
                    else if(ctx->sector_prefix != NULL)
                        memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16);
                    else if(ctx->sector_prefix_ddt != NULL)
                    {
                        if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
                        {
                            aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address);
                            res = AARUF_STATUS_OK;
                        }
                        else if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            memcpy(data,
                                   ctx->sector_prefix_corrected +
                                       ((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
                                   16);
                    }
                    else
                    {
                        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_REACHED_UNREACHABLE_CODE");
                        free(bare_data);
                        return AARUF_ERROR_REACHED_UNREACHABLE_CODE;
                    }
 
                    if(res != AARUF_STATUS_OK)
                    {
                        *length = 2352;
                        free(bare_data);
                        return res;
                    }
 
                    if(ctx->sector_suffix_ddt2 != NULL)
                    {
                        const uint64_t suffix_ddt_entry = ctx->sector_suffix_ddt2[corrected_sector_address];
                        const uint64_t suffix_status    = suffix_ddt_entry >> 60;
                        const uint64_t suffix_index     = suffix_ddt_entry & 0x0FFFFFFFFFFFFFFF;
 
                        if(suffix_status == SectorStatusMode1Correct)
                        {
                            aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, trk.type);
                            res = AARUF_STATUS_OK;
                        }
                        else if(suffix_status == SectorStatusNotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            memcpy(data + 2064, ctx->sector_suffix + suffix_index * 288, 288);
                    }
                    else if(ctx->sector_suffix != NULL)
                        memcpy(data + 2064, ctx->sector_suffix + corrected_sector_address * 288, 288);
                    else if(ctx->sector_suffix_ddt != NULL)
                    {
                        if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
                        {
                            aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, trk.type);
                            res = AARUF_STATUS_OK;
                        }
                        else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            memcpy(data + 2064,
                                   ctx->sector_suffix_corrected +
                                       ((ctx->sector_suffix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288,
                                   288);
                    }
                    else
                    {
                        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_REACHED_UNREACHABLE_CODE");
                        free(bare_data);
                        return AARUF_ERROR_REACHED_UNREACHABLE_CODE;
                    }
 
                    *length = 2352;
                    free(bare_data);
                    return res;
                case CdMode2Formless:
                case CdMode2Form1:
                case CdMode2Form2:
                    if(ctx->sector_prefix_ddt2 != NULL)
                    {
                        const uint64_t prefix_ddt_entry = ctx->sector_prefix_ddt2[corrected_sector_address];
                        const uint64_t prefix_status    = prefix_ddt_entry >> 60;
                        const uint64_t prefix_index     = prefix_ddt_entry & 0x0FFFFFFFFFFFFFFF;
 
                        if(prefix_status == SectorStatusMode2Form1Ok || prefix_status == SectorStatusMode2Form2Ok)
                        {
                            aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address);
                            res = AARUF_STATUS_OK;
                        }
                        else if(prefix_status == SectorStatusNotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            memcpy(data, ctx->sector_prefix + prefix_index * 16, 16);
                    }
                    else if(ctx->sector_prefix != NULL)
                        memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16);
                    else if(ctx->sector_prefix_ddt != NULL)
                    {
                        if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
                        {
                            aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address);
                            res = AARUF_STATUS_OK;
                        }
                        else if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            memcpy(data,
                                   ctx->sector_prefix_corrected +
                                       ((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
                                   16);
                    }
                    else
                    {
                        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_REACHED_UNREACHABLE_CODE");
                        free(bare_data);
                        return AARUF_ERROR_REACHED_UNREACHABLE_CODE;
                    }
 
                    if(res != AARUF_STATUS_OK)
                    {
                        *length = 2352;
                        free(bare_data);
                        return res;
                    }
 
                    if(ctx->mode2_subheaders != NULL && ctx->sector_suffix_ddt2 != NULL)
                    {
                        memcpy(data + 16, ctx->mode2_subheaders + corrected_sector_address * 8, 8);
                        const uint64_t suffix_ddt_entry = ctx->sector_suffix_ddt2[corrected_sector_address];
                        const uint64_t suffix_status    = suffix_ddt_entry >> 60;
                        const uint64_t suffix_index     = suffix_ddt_entry & 0x0FFFFFFFFFFFFFFF;
 
                        if(suffix_status == SectorStatusMode2Form1Ok)
                        {
                            memcpy(data + 24, bare_data, 2048);
                            aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form1);
                        }
                        else if(suffix_status == SectorStatusMode2Form2Ok ||
                                suffix_status == SectorStatusMode2Form2NoCrc)
                        {
                            memcpy(data + 24, bare_data, 2324);
                            if(suffix_status == SectorStatusMode2Form2Ok)
                                aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form2);
                        }
                        else if(suffix_status == SectorStatusNotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            // Mode 2 where ECC failed
                            memcpy(data + 24, bare_data, 2328);
                    }
                    else if(ctx->mode2_subheaders != NULL && ctx->sector_suffix_ddt != NULL)
                    {
                        memcpy(data + 16, ctx->mode2_subheaders + corrected_sector_address * 8, 8);
 
                        if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form1Ok)
                        {
                            memcpy(data + 24, bare_data, 2048);
                            aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form1);
                        }
                        else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok ||
                                (ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2NoCrc)
                        {
                            memcpy(data + 24, bare_data, 2324);
                            if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok)
                                aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form2);
                        }
                        else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
                            res = AARUF_STATUS_SECTOR_NOT_DUMPED;
                        else
                            // Mode 2 where ECC failed
                            memcpy(data + 24, bare_data, 2328);
                    }
                    else if(ctx->mode2_subheaders != NULL)
                    {
                        memcpy(data + 16, ctx->mode2_subheaders + corrected_sector_address * 8, 8);
                        memcpy(data + 24, bare_data, 2328);
                    }
                    else
                        memcpy(data + 16, bare_data, 2336);
 
                    *length = 2352;
                    free(bare_data);
                    return res;
                default:
                    FATAL("Invalid track type %d", trk.type);
                    free(bare_data);
 
                    TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INVALID_TRACK_FORMAT");
                    return AARUF_ERROR_INVALID_TRACK_FORMAT;
            }
        case BlockMedia:
            switch(ctx->image_info.MediaType)
            {
                case AppleFileWare:
                case AppleProfile:
                case AppleSonySS:
                case AppleSonyDS:
                case AppleWidget:
                case PriamDataTower:
                    if(ctx->sector_subchannel == NULL)
                        return aaruf_read_sector(context, sector_address, negative, data, length, sector_status);
 
                    switch(ctx->image_info.MediaType)
                    {
                        case AppleFileWare:
                        case AppleProfile:
                        case AppleWidget:
                            tag_length = 20;
                            break;
                        case AppleSonySS:
                        case AppleSonyDS:
                            tag_length = 12;
                            break;
                        case PriamDataTower:
                            tag_length = 24;
                            break;
                        default:
                            FATAL("Unsupported media type %d", ctx->image_info.MediaType);
 
                            TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                            return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
                    }
 
                    bare_length = 512;
 
                    if(*length < tag_length + bare_length || data == NULL)
                    {
                        *length = tag_length + bare_length;
                        FATAL("Buffer too small for sector, required %u bytes", *length);
 
                        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_BUFFER_TOO_SMALL");
                        return AARUF_ERROR_BUFFER_TOO_SMALL;
                    }
 
                    TRACE("Allocating memory for bare data of size %u bytes", bare_length);
                    bare_data = malloc(bare_length);
 
                    if(bare_data == NULL)
                    {
                        FATAL("Could not allocate memory for bare data");
 
                        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
                        return AARUF_ERROR_NOT_ENOUGH_MEMORY;
                    }
 
                    res = aaruf_read_sector(context, sector_address, negative, bare_data, &bare_length, sector_status);
 
                    if(res != AARUF_STATUS_OK)
                    {
                        free(bare_data);
 
                        TRACE("Exiting aaruf_read_sector_long() = %d", res);
                        return res;
                    }
 
                    if(bare_length != 512)
                    {
                        FATAL("Bare data length is %u, expected 512", bare_length);
                        free(bare_data);
 
                        TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                        return AARUF_ERROR_INCORRECT_DATA_SIZE;
                    }
 
                    memcpy(data + bare_length, ctx->sector_subchannel + corrected_sector_address * tag_length,
                           tag_length);
                    memcpy(data, bare_data, bare_length);
                    *length = tag_length + bare_length;
 
                    free(bare_data);
 
                    TRACE("Exiting aaruf_read_sector_long() = AARUF_STATUS_OK");
                    return AARUF_STATUS_OK;
                default:
                    FATAL("Incorrect media type %d for long sector reading", ctx->image_info.MediaType);
 
                    TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                    return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
        default:
            FATAL("Incorrect media type %d for long sector reading", ctx->image_info.MediaType);
 
            TRACE("Exiting aaruf_read_sector_long() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
            return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
    }
}

AARU_EXPORT int32_t AARU_CALL aaruf_read_sector_tag(const void *context, const uint64_t sector_address,
                                                    const bool negative, uint8_t *buffer, uint32_t *length,
                                                    const int32_t tag)
{
    const uint32_t initial_length = length == NULL ? 0U : *length;
 
    TRACE("Entering aaruf_read_sector_tag(%p, %" PRIu64 ", %d, %p, %u, %d)", context, sector_address, negative, buffer,
          initial_length, tag);
 
    const aaruformat_context *ctx = NULL;
 
    if(context == NULL)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    ctx = context;
 
    if(length == NULL)
    {
        FATAL("Invalid length pointer");
 
        TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
        return AARUF_ERROR_INCORRECT_DATA_SIZE;
    }
 
    // Not a libaaruformat context
    if(ctx->magic != AARU_MAGIC)
    {
        FATAL("Invalid context");
 
        TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_NOT_AARUFORMAT");
        return AARUF_ERROR_NOT_AARUFORMAT;
    }
 
    if(negative && sector_address > ctx->user_data_ddt_header.negative)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
    {
        FATAL("Sector address out of bounds");
 
        TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_OUT_OF_BOUNDS");
        return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
    }
 
    uint64_t corrected_sector_address = sector_address;
 
    // Calculate positive or negative sector
    if(negative)
        corrected_sector_address = ctx->user_data_ddt_header.negative - sector_address;
    else
        corrected_sector_address += ctx->user_data_ddt_header.negative;
 
    switch(tag)
    {
        case CdTrackFlags:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 1 || buffer == NULL)
            {
                *length = 1;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            for(int i = 0; i < ctx->tracks_header.entries; i++)
                if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end)
                {
                    buffer[0] = ctx->track_entries[i].flags;
                    TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
                    return AARUF_STATUS_OK;
                }
 
            FATAL("Track not found");
            return AARUF_ERROR_TRACK_NOT_FOUND;
        case CdTrackIsrc:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 12 || buffer == NULL)
            {
                *length = 12;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            for(int i = 0; i < ctx->tracks_header.entries; i++)
                if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end)
                {
                    memcpy(buffer, ctx->track_entries[i].isrc, 12);
                    TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
                    return AARUF_STATUS_OK;
                }
 
            FATAL("Track not found");
            return AARUF_ERROR_TRACK_NOT_FOUND;
        case CdSectorSubchannelAaru:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 96 || buffer == NULL)
            {
                *length = 96;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_subchannel + corrected_sector_address * 96, 96);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case DvdCmi:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 1 || buffer == NULL)
            {
                *length = 1;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_cpr_mai == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_cpr_mai + corrected_sector_address * 6, 1);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case DvdSectorInformation:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 1 || buffer == NULL)
            {
                *length = 1;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_id == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_id + corrected_sector_address * 4, 1);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case DvdSectorNumber:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 3 || buffer == NULL)
            {
                *length = 3;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_id == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_id + corrected_sector_address * 4 + 1, 3);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case DvdSectorIedAaru:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 2 || buffer == NULL)
            {
                *length = 2;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_ied == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_ied + corrected_sector_address * 2, 2);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case DvdSectorEdcAaru:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 4 || buffer == NULL)
            {
                *length = 4;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_edc == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_edc + corrected_sector_address * 4, 4);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case DvdTitleKeyDecrypted:
            if(ctx->image_info.MetadataMediaType != OpticalDisc)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 5 || buffer == NULL)
            {
                *length = 5;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_decrypted_title_key == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_decrypted_title_key + corrected_sector_address * 5, 5);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case AppleSonyTagAaru:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 12 || buffer == NULL)
            {
                *length = 12;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_subchannel + corrected_sector_address * 12, 12);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case AppleProfileTagAaru:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 20 || buffer == NULL)
            {
                *length = 20;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_subchannel + corrected_sector_address * 20, 20);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        case PriamDataTowerTagAaru:
            if(ctx->image_info.MetadataMediaType != BlockMedia)
            {
                FATAL("Invalid media type for tag");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
                return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
            }
 
            if(*length != 24 || buffer == NULL)
            {
                *length = 24;
                FATAL("Incorrect tag size");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_DATA_SIZE");
                return AARUF_ERROR_INCORRECT_DATA_SIZE;
            }
 
            if(ctx->sector_subchannel == NULL)
            {
                FATAL("Sector tag not found");
                TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_SECTOR_TAG_NOT_PRESENT");
                return AARUF_ERROR_SECTOR_TAG_NOT_PRESENT;
            }
 
            memcpy(buffer, ctx->sector_subchannel + corrected_sector_address * 24, 24);
            TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
            return AARUF_STATUS_OK;
        default:
            TRACE("Do not know how to read sector tag %d", tag);
            return AARUF_ERROR_INVALID_TAG;
    }
}