aaru-dps/libaaruformat
1
0
Fork 0
mirror of https://github.com/aaru-dps/libaaruformat.git synced 2025-12-16 11:14:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename field names for consistency across the codebase

Browse Source
This commit is contained in:
Natalia Portillo
2025-10-09 02:33:35 +01:00
parent 5e346e6fd5
commit b884cfe8ea
27 changed files with 1929 additions and 1904 deletions
Download Patch File Download Diff File Expand all files Collapse all files

157
include/aaruformat/context.h
View File

@@ -144,7 +144,7 @@ typedef struct TapeDdtHashEntry
UT_hash_handle hh; ///< UTHASH handle
} TapeDdtHashEntry;
/** \struct aaruformatContext
/** \struct aaruformat_context
* \brief Master context representing an open or in‑creation Aaru image.
*
* Contains stream handle, parsed headers, deduplication structures, optical extras, metadata blocks, checksum
@@ -168,38 +168,38 @@ typedef struct TapeDdtHashEntry
* - shift retained for backward compatibility with earlier single‑level address shift semantics.
* - mappedMemoryDdtSize is meaningful only if userDataDdt references an mmapped region.
*/
typedef struct aaruformatContext
typedef struct aaruformat_context
{
/* Core & header */
uint64_t magic; ///< File magic (AARU_MAGIC) post-open.
AaruHeaderV2 header; ///< Parsed container header (v2).
uint8_t libraryMajorVersion; ///< Linked library major version.
uint8_t libraryMinorVersion; ///< Linked library minor version.
FILE *imageStream; ///< Underlying FILE* stream (binary mode).
uint64_t magic; ///< File magic (AARU_MAGIC) post-open.
AaruHeaderV2 header; ///< Parsed container header (v2).
uint8_t library_major_version; ///< Linked library major version.
uint8_t library_minor_version; ///< Linked library minor version.
FILE *imageStream; ///< Underlying FILE* stream (binary mode).
/* Deduplication tables (DDT) */
uint8_t shift; ///< Legacy overall shift (deprecated by data_shift/table_shift).
bool inMemoryDdt; ///< True if primary (and possibly secondary) DDT loaded.
uint64_t *userDataDdt; ///< Legacy flat DDT pointer (NULL when using v2 mini/big arrays).
size_t mappedMemoryDdtSize; ///< Length of mmapped DDT if userDataDdt is mmapped.
uint32_t *sectorPrefixDdt; ///< Legacy CD sector prefix DDT (deprecated by *2).
uint32_t *sectorSuffixDdt; ///< Legacy CD sector suffix DDT.
uint32_t *sectorPrefixDdt2; ///< CD sector prefix DDT V2.
uint32_t *sectorSuffixDdt2; ///< CD sector suffix DDT V2.
TapeDdtHashEntry *tapeDdt; ///< Hash table root for tape DDT entries
DdtHeader2 userDataDdtHeader; ///< Active user data DDT v2 header (primary table meta).
int ddtVersion; ///< DDT version in use (1=legacy, 2=v2 hierarchical).
uint32_t *userDataDdtBig; ///< DDT entries (big variant) primary/secondary current.
uint64_t cachedDdtOffset; ///< File offset of currently cached secondary DDT (0=none).
uint64_t cachedDdtPosition; ///< Position index of cached secondary DDT.
uint64_t primaryDdtOffset; ///< File offset of the primary DDT v2 table.
uint32_t *cachedSecondaryDdtBig; ///< Cached secondary table (big entries) or NULL.
uint8_t shift; ///< Legacy overall shift (deprecated by data_shift/table_shift).
bool in_memory_ddt; ///< True if primary (and possibly secondary) DDT loaded.
uint64_t *user_data_ddt; ///< Legacy flat DDT pointer (NULL when using v2 mini/big arrays).
size_t mapped_memory_ddt_size; ///< Length of mmapped DDT if userDataDdt is mmapped.
uint32_t *sector_prefix_ddt; ///< Legacy CD sector prefix DDT (deprecated by *2).
uint32_t *sector_suffix_ddt; ///< Legacy CD sector suffix DDT.
uint32_t *sector_prefix_ddt2; ///< CD sector prefix DDT V2.
uint32_t *sector_suffix_ddt2; ///< CD sector suffix DDT V2.
TapeDdtHashEntry *tape_ddt; ///< Hash table root for tape DDT entries
DdtHeader2 user_data_ddt_header; ///< Active user data DDT v2 header (primary table meta).
int ddt_version; ///< DDT version in use (1=legacy, 2=v2 hierarchical).
uint32_t *user_data_ddt2; ///< DDT entries (big variant) primary/secondary current.
uint64_t cached_ddt_offset; ///< File offset of currently cached secondary DDT (0=none).
uint64_t cached_ddt_position; ///< Position index of cached secondary DDT.
uint64_t primary_ddt_offset; ///< File offset of the primary DDT v2 table.
uint32_t *cached_secondary_ddt2; ///< Cached secondary table (big entries) or NULL.
/* Optical auxiliary buffers (NULL if not present) */
uint8_t *sector_prefix; ///< Raw per-sector prefix (e.g., sync+header) uncorrected.
uint8_t *sectorPrefixCorrected; ///< Corrected variant (post error correction) if stored.
uint8_t *sector_prefix_corrected; ///< Corrected variant (post error correction) if stored.
uint8_t *sector_suffix; ///< Raw per-sector suffix (EDC/ECC) uncorrected.
uint8_t *sectorSuffixCorrected; ///< Corrected suffix if stored separately.
uint8_t *sector_suffix_corrected; ///< Corrected suffix if stored separately.
uint8_t *sector_subchannel; ///< Raw 96-byte subchannel (if captured).
uint8_t *mode2_subheaders; ///< MODE2 Form1/Form2 8-byte subheaders (concatenated).
uint8_t *sector_id; ///< DVD sector ID (4 bytes) if present.
@@ -209,54 +209,55 @@ typedef struct aaruformatContext
uint8_t *sector_decrypted_title_key; ///< DVD decrypted title key (5 bytes) if present.
/* Metadata & geometry */
GeometryBlockHeader geometryBlock; ///< Logical geometry block (if present).
MetadataBlockHeader metadataBlockHeader; ///< Metadata block header.
uint8_t *metadataBlock; ///< Raw metadata UTF-16LE concatenated strings.
CicmMetadataBlock cicmBlockHeader; ///< CICM metadata header (if present).
uint8_t *cicmBlock; ///< CICM XML payload.
DumpHardwareHeader dumpHardwareHeader; ///< Dump hardware header.
struct DumpHardwareEntriesWithData *dumpHardwareEntriesWithData; ///< Array of dump hardware entries + strings.
AaruMetadataJsonBlockHeader jsonBlockHeader; ///< JSON metadata block header (if present).
uint8_t *jsonBlock; ///< JSON metadata block payload (UTF-8).
uint8_t *Creator; ///< Who (person) created the image?
uint8_t *MediaTitle; ///< Title of the media represented by the image
uint8_t *Comments; ///< Image comments
uint8_t *MediaManufacturer; ///< Manufacturer of the media represented by the image
uint8_t *MediaModel; ///< Model of the media represented by the image
uint8_t *MediaSerialNumber; ///< Serial number of the media represented by the image
uint8_t *MediaBarcode; ///< Barcode of the media represented by the image
uint8_t *MediaPartNumber; ///< Part number of the media represented by the image
uint8_t *DriveManufacturer; ///< Manufacturer of the drive used to read the media represented by the image
uint8_t *DriveModel; ///< Model of the drive used to read the media represented by the image
uint8_t *DriveSerialNumber; ///< Serial number of the drive used to read the media represented by the image
uint8_t *DriveFirmwareRevision; ///< Firmware revision of the drive used to read the media represented by the image
int32_t MediaSequence; ///< Number in sequence for the media represented by the image
int32_t LastMediaSequence; ///< Last media of the sequence the media represented by the image corresponds to
uint32_t Cylinders; ///< Cylinders of the media represented by the image
uint32_t Heads; ///< Heads of the media represented by the image
uint32_t SectorsPerTrack; ///< Sectors per track of the media represented by the image (for variable image, the
///< smallest)
GeometryBlockHeader geometry_block; ///< Logical geometry block (if present).
MetadataBlockHeader metadata_block_header; ///< Metadata block header.
uint8_t *metadata_block; ///< Raw metadata UTF-16LE concatenated strings.
CicmMetadataBlock cicm_block_header; ///< CICM metadata header (if present).
uint8_t *cicm_block; ///< CICM XML payload.
DumpHardwareHeader dump_hardware_header; ///< Dump hardware header.
struct DumpHardwareEntriesWithData *dump_hardware_entries_with_data; ///< Array of dump hardware entries + strings.
AaruMetadataJsonBlockHeader json_block_header; ///< JSON metadata block header (if present).
uint8_t *json_block; ///< JSON metadata block payload (UTF-8).
uint8_t *creator; ///< Who (person) created the image?
uint8_t *media_title; ///< Title of the media represented by the image
uint8_t *comments; ///< Image comments
uint8_t *media_manufacturer; ///< Manufacturer of the media represented by the image
uint8_t *media_model; ///< Model of the media represented by the image
uint8_t *media_serial_number; ///< Serial number of the media represented by the image
uint8_t *media_barcode; ///< Barcode of the media represented by the image
uint8_t *media_part_number; ///< Part number of the media represented by the image
uint8_t *drive_manufacturer; ///< Manufacturer of the drive used to read the media represented by the image
uint8_t *drive_model; ///< Model of the drive used to read the media represented by the image
uint8_t *drive_serial_number; ///< Serial number of the drive used to read the media represented by the image
uint8_t
*drive_firmware_revision; ///< Firmware revision of the drive used to read the media represented by the image
int32_t media_sequence; ///< Number in sequence for the media represented by the image
int32_t last_media_sequence; ///< Last media of the sequence the media represented by the image corresponds to
uint32_t cylinders; ///< Cylinders of the media represented by the image
uint32_t heads; ///< Heads of the media represented by the image
uint32_t sectors_per_track; ///< Sectors per track of the media represented by the image (for variable image, the
///< smallest)
/* Optical information */
TracksHeader tracksHeader; ///< Tracks header (optical) if present.
TrackEntry *trackEntries; ///< Full track list (tracksHeader.entries elements).
uint8_t numberOfDataTracks; ///< Count of tracks considered "data" (sequence 1..99 heuristics).
TrackEntry *dataTracks; ///< Filtered list of data tracks (subset of trackEntries).
TracksHeader tracks_header; ///< Tracks header (optical) if present.
TrackEntry *track_entries; ///< Full track list (tracksHeader.entries elements).
uint8_t number_of_data_tracks; ///< Count of tracks considered "data" (sequence 1..99 heuristics).
TrackEntry *data_tracks; ///< Filtered list of data tracks (subset of trackEntries).
/* Integrity & ECC */
CdEccContext *eccCdContext; ///< CD ECC/EDC helper tables (allocated on demand).
crc64_ctx *crc64Context; ///< Opaque CRC64 context for streaming updates.
CdEccContext *ecc_cd_context; ///< CD ECC/EDC helper tables (allocated on demand).
crc64_ctx *crc64_context; ///< Opaque CRC64 context for streaming updates.
/* Index & deduplication lookup */
UT_array *indexEntries; ///< Flattened index entries (UT_array of IndexEntry).
hash_map_t *sectorHashMap; ///< Deduplication hash map (fingerprint->entry mapping).
UT_array *index_entries; ///< Flattened index entries (UT_array of IndexEntry).
hash_map_t *sector_hash_map; ///< Deduplication hash map (fingerprint->entry mapping).
/* Caches */
struct CacheHeader blockHeaderCache; ///< LRU/Cache header for block headers.
struct CacheHeader blockCache; ///< LRU/Cache header for block payloads.
struct CacheHeader block_header_cache; ///< LRU/Cache header for block headers.
struct CacheHeader block_cache; ///< LRU/Cache header for block payloads.
/* High-level summary */
ImageInfo imageInfo; ///< Exposed high-level image info summary.
ImageInfo image_info; ///< Exposed high-level image info summary.
/* Tags */
bool *readableSectorTags; ///< Per-sector boolean array (optical tags read successfully?).
@@ -276,17 +277,17 @@ typedef struct aaruformatContext
blake3_hasher *blake3_context; ///< Opaque BLAKE3 context for streaming updates
/* Write path */
bool isWriting; ///< True if context opened/created for writing.
BlockHeader currentBlockHeader; ///< Header for block currently being assembled (write path).
uint8_t *writingBuffer; ///< Accumulation buffer for current block data.
int currentBlockOffset; ///< Logical offset inside block (units: bytes or sectors depending on path).
int writingBufferPosition; ///< Current size / position within writingBuffer.
uint64_t nextBlockPosition; ///< Absolute file offset where next block will be written.
bool rewinded; ///< True if stream has been rewound after open (write path).
uint64_t last_written_block; ///< Last written block number (write path).
uint8_t currentTrackType; ///< Current track type (when writing optical images with tracks, needed for block
///< compression type).
bool writingLong; ///< True if writing long sectors
bool is_writing; ///< True if context opened/created for writing.
BlockHeader current_block_header; ///< Header for block currently being assembled (write path).
uint8_t *writing_buffer; ///< Accumulation buffer for current block data.
int current_block_offset; ///< Logical offset inside block (units: bytes or sectors depending on path).
int writing_buffer_position; ///< Current size / position within writingBuffer.
uint64_t next_block_position; ///< Absolute file offset where next block will be written.
bool rewinded; ///< True if stream has been rewound after open (write path).
uint64_t last_written_block; ///< Last written block number (write path).
uint8_t current_track_type; ///< Current track type (when writing optical images with tracks, needed for block
///< compression type).
bool writing_long; ///< True if writing long sectors
size_t sector_prefix_length; ///< Length of sector_prefix
size_t sector_suffix_length; ///< Length of sector_suffix
size_t sector_prefix_offset; ///< Current position in sector_prefix
@@ -298,10 +299,10 @@ typedef struct aaruformatContext
uint32_t lzma_dict_size; ///< LZMA dictionary size (writing path).
/* Tape-specific structures */
tapeFileHashEntry *tapeFiles; ///< Hash table root for tape files
TapePartitionHashEntry *tapePartitions; ///< Hash table root for tape partitions
bool is_tape; ///< True if the image is a tape image
} aaruformatContext;
tapeFileHashEntry *tape_files; ///< Hash table root for tape files
TapePartitionHashEntry *tape_partitions; ///< Hash table root for tape partitions
bool is_tape; ///< True if the image is a tape image
} aaruformat_context;
/** \struct DumpHardwareEntriesWithData
* \brief In-memory representation of a dump hardware entry plus decoded variable-length fields & extents.

70
include/internal.h
View File

@@ -21,43 +21,43 @@
#include "utarray.h"
UT_array *process_index_v1(aaruformatContext *ctx);
int32_t verify_index_v1(aaruformatContext *ctx);
UT_array *process_index_v2(aaruformatContext *ctx);
int32_t verify_index_v2(aaruformatContext *ctx);
UT_array *process_index_v3(aaruformatContext *ctx);
int32_t verify_index_v3(aaruformatContext *ctx);
int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry);
int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt);
int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt);
void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_aaru_metadata_json_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry);
void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *entry);
int32_t decode_ddt_entry_v1(aaruformatContext *ctx, uint64_t sector_address, uint64_t *offset, uint64_t *block_offset,
uint8_t *sector_status);
int32_t decode_ddt_entry_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status);
int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status);
int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status);
bool set_ddt_entry_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry);
bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry);
bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry);
bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, uint64_t offset, uint64_t block_offset,
uint8_t sector_status, uint64_t *ddt_entry);
UT_array *process_index_v1(aaruformat_context *ctx);
int32_t verify_index_v1(aaruformat_context *ctx);
UT_array *process_index_v2(aaruformat_context *ctx);
int32_t verify_index_v2(aaruformat_context *ctx);
UT_array *process_index_v3(aaruformat_context *ctx);
int32_t verify_index_v3(aaruformat_context *ctx);
int32_t process_data_block(aaruformat_context *ctx, IndexEntry *entry);
int32_t process_ddt_v1(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt);
int32_t process_ddt_v2(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt);
void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_geometry_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_tracks_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_cicm_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_aaru_metadata_json_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_dumphw_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_checksum_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_tape_files_block(aaruformat_context *ctx, const IndexEntry *entry);
void process_tape_partitions_block(aaruformat_context *ctx, const IndexEntry *entry);
int32_t decode_ddt_entry_v1(aaruformat_context *ctx, uint64_t sector_address, uint64_t *offset, uint64_t *block_offset,
uint8_t *sector_status);
int32_t decode_ddt_entry_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status);
int32_t decode_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status);
int32_t decode_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status);
bool set_ddt_entry_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry);
bool set_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry);
bool set_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry);
bool set_ddt_tape(aaruformat_context *ctx, uint64_t sector_address, uint64_t offset, uint64_t block_offset,
uint8_t sector_status, uint64_t *ddt_entry);
aaru_options parse_options(const char *options);
uint64_t get_filetime_uint64();
int32_t aaruf_close_current_block(aaruformatContext *ctx);
int32_t aaruf_close_current_block(aaruformat_context *ctx);
int compare_extents(const void *a, const void *b);
#endif // LIBAARUFORMAT_INTERNAL_H

2
src/blocks/checksum.c
View File

@@ -36,7 +36,7 @@
* @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the checksum block.
*/
void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_checksum_block(aaruformat_context *ctx, const IndexEntry *entry)
{
TRACE("Entering process_checksum_block(%p, %p)", ctx, entry);

12
src/blocks/data.c
View File

@@ -68,7 +68,7 @@
* the context is destroyed. The function may replace existing data in the context.
*/
int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
int32_t process_data_block(aaruformat_context *ctx, IndexEntry *entry)
{
TRACE("Entering process_data_block(%p, %p)", ctx, entry);
BlockHeader block_header;
@@ -119,15 +119,15 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
return AARUF_STATUS_OK;
}
ctx->imageInfo.ImageSize += block_header.cmpLength;
ctx->image_info.ImageSize += block_header.cmpLength;
// Unused, skip
if(entry->dataType == UserData)
{
if(block_header.sectorSize > ctx->imageInfo.SectorSize)
if(block_header.sectorSize > ctx->image_info.SectorSize)
{
TRACE("Setting sector size to %" PRIu64 " bytes", block_header.sectorSize);
ctx->imageInfo.SectorSize = block_header.sectorSize;
ctx->image_info.SectorSize = block_header.sectorSize;
}
TRACE("Exiting process_data_block() = AARUF_STATUS_OK");
@@ -339,7 +339,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
{
case CdSectorPrefix:
case CdSectorPrefixCorrected:
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixCorrected = data; }
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_corrected = data; }
else
ctx->sector_prefix = data;
@@ -350,7 +350,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
case CdSectorSuffix:
case CdSectorSuffixCorrected:
if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixCorrected = data;
ctx->sector_suffix_corrected = data;
else
ctx->sector_suffix = data;

18
src/blocks/dump.c
View File

@@ -51,14 +51,14 @@ static void free_dump_hardware_entries_array(DumpHardwareEntriesWithData *entrie
}
}
static void reset_dump_hardware_context(aaruformatContext *ctx)
static void reset_dump_hardware_context(aaruformat_context *ctx)
{
if(ctx == NULL) return;
free_dump_hardware_entries_array(ctx->dumpHardwareEntriesWithData, ctx->dumpHardwareHeader.entries);
free(ctx->dumpHardwareEntriesWithData);
ctx->dumpHardwareEntriesWithData = NULL;
memset(&ctx->dumpHardwareHeader, 0, sizeof(ctx->dumpHardwareHeader));
free_dump_hardware_entries_array(ctx->dump_hardware_entries_with_data, ctx->dump_hardware_header.entries);
free(ctx->dump_hardware_entries_with_data);
ctx->dump_hardware_entries_with_data = NULL;
memset(&ctx->dump_hardware_header, 0, sizeof(ctx->dump_hardware_header));
}
static bool read_dump_string(FILE *stream, const char *field_name, uint32_t length, uint32_t *remaining,
@@ -105,7 +105,7 @@ static bool read_dump_string(FILE *stream, const char *field_name, uint32_t leng
* @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the dump hardware block.
*/
void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_dumphw_block(aaruformat_context *ctx, const IndexEntry *entry)
{
TRACE("Entering process_dumphw_block(%p, %p)", ctx, entry);
size_t read_bytes = 0;
@@ -214,7 +214,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(header.entries == 0)
{
reset_dump_hardware_context(ctx);
ctx->dumpHardwareHeader = header;
ctx->dump_hardware_header = header;
TRACE("Dump hardware block contains no entries. Clearing existing metadata.");
TRACE("Exiting process_dumphw_block()");
return;
@@ -336,8 +336,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
}
reset_dump_hardware_context(ctx);
ctx->dumpHardwareEntriesWithData = entries;
ctx->dumpHardwareHeader = header;
ctx->dump_hardware_entries_with_data = entries;
ctx->dump_hardware_header = header;
if(remaining_payload != 0)
{

285
src/blocks/metadata.c
View File

@@ -32,7 +32,7 @@
* @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the metadata block.
*/
void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry)
{
TRACE("Entering process_metadata_block(%p, %p)", ctx, entry);
int pos = 0;
@@ -59,176 +59,177 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
// Even if those two checks shall have been done before
TRACE("Reading metadata block header at position %" PRIu64, entry->offset);
read_bytes = fread(&ctx->metadataBlockHeader, 1, sizeof(MetadataBlockHeader), ctx->imageStream);
read_bytes = fread(&ctx->metadata_block_header, 1, sizeof(MetadataBlockHeader), ctx->imageStream);
if(read_bytes != sizeof(MetadataBlockHeader))
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
FATAL("Could not read metadata block header, continuing...");
TRACE("Exiting process_metadata_block()");
return;
}
if(ctx->metadataBlockHeader.identifier != entry->blockType)
if(ctx->metadata_block_header.identifier != entry->blockType)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
TRACE("Exiting process_metadata_block()");
return;
}
ctx->imageInfo.ImageSize += ctx->metadataBlockHeader.blockSize;
ctx->image_info.ImageSize += ctx->metadata_block_header.blockSize;
ctx->metadataBlock = (uint8_t *)malloc(ctx->metadataBlockHeader.blockSize);
ctx->metadata_block = (uint8_t *)malloc(ctx->metadata_block_header.blockSize);
if(ctx->metadataBlock == NULL)
if(ctx->metadata_block == NULL)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
FATAL("Could not allocate memory for metadata block, continuing...");
TRACE("Exiting process_metadata_block()");
return;
}
TRACE("Reading metadata block of size %u at position %" PRIu64, ctx->metadataBlockHeader.blockSize,
TRACE("Reading metadata block of size %u at position %" PRIu64, ctx->metadata_block_header.blockSize,
entry->offset + sizeof(MetadataBlockHeader));
read_bytes = fread(ctx->metadataBlock, 1, ctx->metadataBlockHeader.blockSize, ctx->imageStream);
read_bytes = fread(ctx->metadata_block, 1, ctx->metadata_block_header.blockSize, ctx->imageStream);
if(read_bytes != ctx->metadataBlockHeader.blockSize)
if(read_bytes != ctx->metadata_block_header.blockSize)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
free(ctx->metadataBlock);
memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
free(ctx->metadata_block);
FATAL("Could not read metadata block, continuing...");
}
if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0)
if(ctx->metadata_block_header.mediaSequence > 0 && ctx->metadata_block_header.lastMediaSequence > 0)
{
ctx->MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
TRACE("Setting media sequence as %d of %d", ctx->MediaSequence, ctx->LastMediaSequence);
ctx->media_sequence = ctx->metadata_block_header.mediaSequence;
ctx->last_media_sequence = ctx->metadata_block_header.lastMediaSequence;
TRACE("Setting media sequence as %d of %d", ctx->media_sequence, ctx->last_media_sequence);
}
if(ctx->metadataBlockHeader.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.creatorLength > 0 &&
ctx->metadata_block_header.creatorOffset + ctx->metadata_block_header.creatorLength <=
ctx->metadata_block_header.blockSize)
{
ctx->Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength);
if(ctx->Creator != NULL)
memcpy(ctx->Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset,
ctx->metadataBlockHeader.creatorLength);
ctx->creator = (uint8_t *)malloc(ctx->metadata_block_header.creatorLength);
if(ctx->creator != NULL)
memcpy(ctx->creator, ctx->metadata_block + ctx->metadata_block_header.creatorOffset,
ctx->metadata_block_header.creatorLength);
}
if(ctx->metadataBlockHeader.commentsLength > 0 &&
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.commentsLength > 0 &&
ctx->metadata_block_header.commentsOffset + ctx->metadata_block_header.commentsLength <=
ctx->metadata_block_header.blockSize)
{
ctx->Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength);
if(ctx->Comments != NULL)
memcpy(ctx->Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset,
ctx->metadataBlockHeader.commentsLength);
ctx->comments = (uint8_t *)malloc(ctx->metadata_block_header.commentsLength);
if(ctx->comments != NULL)
memcpy(ctx->comments, ctx->metadata_block + ctx->metadata_block_header.commentsOffset,
ctx->metadata_block_header.commentsLength);
}
if(ctx->metadataBlockHeader.mediaTitleLength > 0 &&
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.mediaTitleLength > 0 &&
ctx->metadata_block_header.mediaTitleOffset + ctx->metadata_block_header.mediaTitleLength <=
ctx->metadata_block_header.blockSize)
{
ctx->MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength);
if(ctx->MediaTitle != NULL)
memcpy(ctx->MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset,
ctx->metadataBlockHeader.mediaTitleLength);
ctx->media_title = (uint8_t *)malloc(ctx->metadata_block_header.mediaTitleLength);
if(ctx->media_title != NULL)
memcpy(ctx->media_title, ctx->metadata_block + ctx->metadata_block_header.mediaTitleOffset,
ctx->metadata_block_header.mediaTitleLength);
}
if(ctx->metadataBlockHeader.mediaManufacturerLength > 0 &&
ctx->metadataBlockHeader.mediaManufacturerOffset + ctx->metadataBlockHeader.mediaManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.mediaManufacturerLength > 0 &&
ctx->metadata_block_header.mediaManufacturerOffset + ctx->metadata_block_header.mediaManufacturerLength <=
ctx->metadata_block_header.blockSize)
{
ctx->MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
if(ctx->MediaManufacturer != NULL)
memcpy(ctx->MediaManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->metadataBlockHeader.mediaManufacturerLength);
ctx->media_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.mediaManufacturerLength);
if(ctx->media_manufacturer != NULL)
memcpy(ctx->media_manufacturer, ctx->metadata_block + ctx->metadata_block_header.mediaManufacturerOffset,
ctx->metadata_block_header.mediaManufacturerLength);
}
if(ctx->metadataBlockHeader.mediaModelLength > 0 &&
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.mediaModelLength > 0 &&
ctx->metadata_block_header.mediaModelOffset + ctx->metadata_block_header.mediaModelLength <=
ctx->metadata_block_header.blockSize)
{
ctx->MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength);
if(ctx->MediaModel != NULL)
memcpy(ctx->MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset,
ctx->metadataBlockHeader.mediaModelLength);
ctx->media_model = (uint8_t *)malloc(ctx->metadata_block_header.mediaModelLength);
if(ctx->media_model != NULL)
memcpy(ctx->media_model, ctx->metadata_block + ctx->metadata_block_header.mediaModelOffset,
ctx->metadata_block_header.mediaModelLength);
}
if(ctx->metadataBlockHeader.mediaSerialNumberLength > 0 &&
ctx->metadataBlockHeader.mediaSerialNumberOffset + ctx->metadataBlockHeader.mediaSerialNumberLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.mediaSerialNumberLength > 0 &&
ctx->metadata_block_header.mediaSerialNumberOffset + ctx->metadata_block_header.mediaSerialNumberLength <=
ctx->metadata_block_header.blockSize)
{
ctx->MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
if(ctx->MediaSerialNumber != NULL)
memcpy(ctx->MediaSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->metadataBlockHeader.mediaSerialNumberLength);
ctx->media_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaSerialNumberLength);
if(ctx->media_serial_number != NULL)
memcpy(ctx->media_serial_number, ctx->metadata_block + ctx->metadata_block_header.mediaSerialNumberOffset,
ctx->metadata_block_header.mediaSerialNumberLength);
}
if(ctx->metadataBlockHeader.mediaBarcodeLength > 0 &&
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.mediaBarcodeLength > 0 &&
ctx->metadata_block_header.mediaBarcodeOffset + ctx->metadata_block_header.mediaBarcodeLength <=
ctx->metadata_block_header.blockSize)
{
ctx->MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
if(ctx->MediaBarcode != NULL)
memcpy(ctx->MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset,
ctx->metadataBlockHeader.mediaBarcodeLength);
ctx->media_barcode = (uint8_t *)malloc(ctx->metadata_block_header.mediaBarcodeLength);
if(ctx->media_barcode != NULL)
memcpy(ctx->media_barcode, ctx->metadata_block + ctx->metadata_block_header.mediaBarcodeOffset,
ctx->metadata_block_header.mediaBarcodeLength);
}
if(ctx->metadataBlockHeader.mediaPartNumberLength > 0 &&
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.mediaPartNumberLength > 0 &&
ctx->metadata_block_header.mediaPartNumberOffset + ctx->metadata_block_header.mediaPartNumberLength <=
ctx->metadata_block_header.blockSize)
{
ctx->MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
if(ctx->MediaPartNumber != NULL)
memcpy(ctx->MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset,
ctx->metadataBlockHeader.mediaPartNumberLength);
ctx->media_part_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaPartNumberLength);
if(ctx->media_part_number != NULL)
memcpy(ctx->media_part_number, ctx->metadata_block + ctx->metadata_block_header.mediaPartNumberOffset,
ctx->metadata_block_header.mediaPartNumberLength);
}
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveManufacturerOffset + ctx->metadataBlockHeader.driveManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.driveManufacturerLength > 0 &&
ctx->metadata_block_header.driveManufacturerOffset + ctx->metadata_block_header.driveManufacturerLength <=
ctx->metadata_block_header.blockSize)
{
ctx->DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
if(ctx->DriveManufacturer != NULL)
memcpy(ctx->DriveManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->metadataBlockHeader.driveManufacturerLength);
ctx->drive_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.driveManufacturerLength);
if(ctx->drive_manufacturer != NULL)
memcpy(ctx->drive_manufacturer, ctx->metadata_block + ctx->metadata_block_header.driveManufacturerOffset,
ctx->metadata_block_header.driveManufacturerLength);
}
if(ctx->metadataBlockHeader.driveModelLength > 0 &&
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.driveModelLength > 0 &&
ctx->metadata_block_header.driveModelOffset + ctx->metadata_block_header.driveModelLength <=
ctx->metadata_block_header.blockSize)
{
ctx->DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength);
if(ctx->DriveModel != NULL)
memcpy(ctx->DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset,
ctx->metadataBlockHeader.driveModelLength);
ctx->drive_model = (uint8_t *)malloc(ctx->metadata_block_header.driveModelLength);
if(ctx->drive_model != NULL)
memcpy(ctx->drive_model, ctx->metadata_block + ctx->metadata_block_header.driveModelOffset,
ctx->metadata_block_header.driveModelLength);
}
if(ctx->metadataBlockHeader.driveSerialNumberLength > 0 &&
ctx->metadataBlockHeader.driveSerialNumberOffset + ctx->metadataBlockHeader.driveSerialNumberLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.driveSerialNumberLength > 0 &&
ctx->metadata_block_header.driveSerialNumberOffset + ctx->metadata_block_header.driveSerialNumberLength <=
ctx->metadata_block_header.blockSize)
{
ctx->DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
if(ctx->DriveSerialNumber != NULL)
memcpy(ctx->DriveSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->metadataBlockHeader.driveSerialNumberLength);
ctx->drive_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.driveSerialNumberLength);
if(ctx->drive_serial_number != NULL)
memcpy(ctx->drive_serial_number, ctx->metadata_block + ctx->metadata_block_header.driveSerialNumberOffset,
ctx->metadata_block_header.driveSerialNumberLength);
}
if(ctx->metadataBlockHeader.driveFirmwareRevisionLength > 0 &&
ctx->metadataBlockHeader.driveFirmwareRevisionOffset + ctx->metadataBlockHeader.driveFirmwareRevisionLength <=
ctx->metadataBlockHeader.blockSize)
if(ctx->metadata_block_header.driveFirmwareRevisionLength > 0 &&
ctx->metadata_block_header.driveFirmwareRevisionOffset +
ctx->metadata_block_header.driveFirmwareRevisionLength <=
ctx->metadata_block_header.blockSize)
{
ctx->DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
if(ctx->DriveFirmwareRevision != NULL)
memcpy(ctx->DriveFirmwareRevision,
ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionOffset,
ctx->metadataBlockHeader.driveFirmwareRevisionLength);
ctx->drive_firmware_revision = (uint8_t *)malloc(ctx->metadata_block_header.driveFirmwareRevisionLength);
if(ctx->drive_firmware_revision != NULL)
memcpy(ctx->drive_firmware_revision,
ctx->metadata_block + ctx->metadata_block_header.driveFirmwareRevisionOffset,
ctx->metadata_block_header.driveFirmwareRevisionLength);
}
TRACE("Exiting process_metadata_block()");
@@ -242,7 +243,7 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
* @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the geometry block.
*/
void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_geometry_block(aaruformat_context *ctx, const IndexEntry *entry)
{
TRACE("Entering process_geometry_block(%p, %p)", ctx, entry);
size_t read_bytes = 0;
@@ -266,30 +267,30 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry)
}
TRACE("Reading geometry block header at position %" PRIu64, entry->offset);
read_bytes = fread(&ctx->geometryBlock, 1, sizeof(GeometryBlockHeader), ctx->imageStream);
read_bytes = fread(&ctx->geometry_block, 1, sizeof(GeometryBlockHeader), ctx->imageStream);
if(read_bytes != sizeof(GeometryBlockHeader))
{
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
memset(&ctx->geometry_block, 0, sizeof(GeometryBlockHeader));
TRACE("Could not read geometry block header, continuing...");
return;
}
if(ctx->geometryBlock.identifier != GeometryBlock)
if(ctx->geometry_block.identifier != GeometryBlock)
{
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
memset(&ctx->geometry_block, 0, sizeof(GeometryBlockHeader));
TRACE("Incorrect identifier for geometry block at position %" PRIu64 "", entry->offset);
return;
}
ctx->imageInfo.ImageSize += sizeof(GeometryBlockHeader);
ctx->image_info.ImageSize += sizeof(GeometryBlockHeader);
TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometryBlock.cylinders,
ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack);
TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometry_block.cylinders,
ctx->geometry_block.heads, ctx->geometry_block.sectorsPerTrack);
ctx->Cylinders = ctx->geometryBlock.cylinders;
ctx->Heads = ctx->geometryBlock.heads;
ctx->SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack;
ctx->cylinders = ctx->geometry_block.cylinders;
ctx->heads = ctx->geometry_block.heads;
ctx->sectors_per_track = ctx->geometry_block.sectorsPerTrack;
TRACE("Exiting process_geometry_block()");
}
@@ -302,7 +303,7 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry)
* @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the CICM block.
*/
void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_cicm_block(aaruformat_context *ctx, const IndexEntry *entry)
{
TRACE("Entering process_cicm_block(%p, %p)", ctx, entry);
int pos = 0;
@@ -330,42 +331,42 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
// Even if those two checks shall have been done before
TRACE("Reading CICM XML metadata block header at position %" PRIu64, entry->offset);
read_bytes = fread(&ctx->cicmBlockHeader, 1, sizeof(CicmMetadataBlock), ctx->imageStream);
read_bytes = fread(&ctx->cicm_block_header, 1, sizeof(CicmMetadataBlock), ctx->imageStream);
if(read_bytes != sizeof(CicmMetadataBlock))
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
TRACE("Could not read CICM XML metadata header, continuing...");
return;
}
if(ctx->cicmBlockHeader.identifier != CicmBlock)
if(ctx->cicm_block_header.identifier != CicmBlock)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
}
ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length;
ctx->image_info.ImageSize += ctx->cicm_block_header.length;
ctx->cicmBlock = (uint8_t *)malloc(ctx->cicmBlockHeader.length);
ctx->cicm_block = (uint8_t *)malloc(ctx->cicm_block_header.length);
if(ctx->cicmBlock == NULL)
if(ctx->cicm_block == NULL)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
TRACE("Could not allocate memory for CICM XML metadata block, continuing...");
TRACE("Exiting process_cicm_block()");
return;
}
TRACE("Reading CICM XML metadata block of size %u at position %" PRIu64, ctx->cicmBlockHeader.length,
TRACE("Reading CICM XML metadata block of size %u at position %" PRIu64, ctx->cicm_block_header.length,
entry->offset + sizeof(CicmMetadataBlock));
read_bytes = fread(ctx->cicmBlock, 1, ctx->cicmBlockHeader.length, ctx->imageStream);
read_bytes = fread(ctx->cicm_block, 1, ctx->cicm_block_header.length, ctx->imageStream);
if(read_bytes != ctx->cicmBlockHeader.length)
if(read_bytes != ctx->cicm_block_header.length)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
free(ctx->cicmBlock);
memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
free(ctx->cicm_block);
TRACE("Could not read CICM XML metadata block, continuing...");
}
@@ -466,7 +467,7 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
*
* @internal
*/
void process_aaru_metadata_json_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_aaru_metadata_json_block(aaruformat_context *ctx, const IndexEntry *entry)
{
TRACE("Entering process_aaru_metadata_json_block(%p, %p)", ctx, entry);
int pos = 0;
@@ -494,42 +495,42 @@ void process_aaru_metadata_json_block(aaruformatContext *ctx, const IndexEntry *
// Even if those two checks shall have been done before
TRACE("Reading Aaru metadata JSON block header at position %" PRIu64, entry->offset);
read_bytes = fread(&ctx->jsonBlockHeader, 1, sizeof(AaruMetadataJsonBlockHeader), ctx->imageStream);
read_bytes = fread(&ctx->json_block_header, 1, sizeof(AaruMetadataJsonBlockHeader), ctx->imageStream);
if(read_bytes != sizeof(AaruMetadataJsonBlockHeader))
{
memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader));
memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
TRACE("Could not read Aaru metadata JSON header, continuing...");
return;
}
if(ctx->jsonBlockHeader.identifier != AaruMetadataJsonBlock)
if(ctx->json_block_header.identifier != AaruMetadataJsonBlock)
{
memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader));
memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
}
ctx->imageInfo.ImageSize += ctx->jsonBlockHeader.length;
ctx->image_info.ImageSize += ctx->json_block_header.length;
ctx->jsonBlock = (uint8_t *)malloc(ctx->jsonBlockHeader.length);
ctx->json_block = (uint8_t *)malloc(ctx->json_block_header.length);
if(ctx->jsonBlock == NULL)
if(ctx->json_block == NULL)
{
memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader));
memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
TRACE("Could not allocate memory for Aaru metadata JSON block, continuing...");
TRACE("Exiting process_aaru_metadata_json_block()");
return;
}
TRACE("Reading Aaru metadata JSON block of size %u at position %" PRIu64, ctx->jsonBlockHeader.length,
TRACE("Reading Aaru metadata JSON block of size %u at position %" PRIu64, ctx->json_block_header.length,
entry->offset + sizeof(AaruMetadataJsonBlockHeader));
read_bytes = fread(ctx->jsonBlock, 1, ctx->jsonBlockHeader.length, ctx->imageStream);
read_bytes = fread(ctx->json_block, 1, ctx->json_block_header.length, ctx->imageStream);
if(read_bytes != ctx->jsonBlockHeader.length)
if(read_bytes != ctx->json_block_header.length)
{
memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader));
free(ctx->jsonBlock);
memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
free(ctx->json_block);
TRACE("Could not read Aaru metadata JSON block, continuing...");
}

138
src/blocks/optical.c
View File

@@ -108,7 +108,7 @@
* @see aaruf_get_tracks()
* @see aaruf_set_tracks()
*/
void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_tracks_block(aaruformat_context *ctx, const IndexEntry *entry)
{
int pos = 0;
size_t read_bytes = 0;
@@ -132,87 +132,87 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
}
// Even if those two checks shall have been done before
read_bytes = fread(&ctx->tracksHeader, 1, sizeof(TracksHeader), ctx->imageStream);
read_bytes = fread(&ctx->tracks_header, 1, sizeof(TracksHeader), ctx->imageStream);
if(read_bytes != sizeof(TracksHeader))
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
TRACE("Could not read tracks header, continuing...\n");
return;
}
if(ctx->tracksHeader.identifier != TracksBlock)
if(ctx->tracks_header.identifier != TracksBlock)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
}
ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries;
ctx->image_info.ImageSize += sizeof(TrackEntry) * ctx->tracks_header.entries;
ctx->trackEntries = (TrackEntry *)malloc(sizeof(TrackEntry) * ctx->tracksHeader.entries);
ctx->track_entries = (TrackEntry *)malloc(sizeof(TrackEntry) * ctx->tracks_header.entries);
if(ctx->trackEntries == NULL)
if(ctx->track_entries == NULL)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
FATAL("Could not allocate memory for metadata block, continuing...\n");
return;
}
read_bytes = fread(ctx->trackEntries, sizeof(TrackEntry), ctx->tracksHeader.entries, ctx->imageStream);
read_bytes = fread(ctx->track_entries, sizeof(TrackEntry), ctx->tracks_header.entries, ctx->imageStream);
if(read_bytes != ctx->tracksHeader.entries)
if(read_bytes != ctx->tracks_header.entries)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
free(ctx->trackEntries);
ctx->trackEntries = NULL;
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
free(ctx->track_entries);
ctx->track_entries = NULL;
FATAL("Could not read metadata block, continuing...\n");
return;
}
crc64 = aaruf_crc64_data((const uint8_t *)ctx->trackEntries, ctx->tracksHeader.entries * sizeof(TrackEntry));
crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, ctx->tracks_header.entries * sizeof(TrackEntry));
// Due to how C# wrote it, it is effectively reversed
if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
if(crc64 != ctx->tracksHeader.crc64)
if(crc64 != ctx->tracks_header.crc64)
{
TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", crc64,
ctx->tracksHeader.crc64);
ctx->tracks_header.crc64);
return;
}
TRACE("Found %d tracks at position %" PRIu64 ".\n", ctx->tracksHeader.entries, entry->offset);
TRACE("Found %d tracks at position %" PRIu64 ".\n", ctx->tracks_header.entries, entry->offset);
ctx->imageInfo.HasPartitions = true;
ctx->imageInfo.HasSessions = true;
ctx->image_info.HasPartitions = true;
ctx->image_info.HasSessions = true;
ctx->numberOfDataTracks = 0;
ctx->number_of_data_tracks = 0;
for(j = 0; j < ctx->tracksHeader.entries; j++)
for(j = 0; j < ctx->tracks_header.entries; j++)
{
if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) ctx->numberOfDataTracks++;
if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99) ctx->number_of_data_tracks++;
}
if(ctx->numberOfDataTracks > 0)
if(ctx->number_of_data_tracks > 0)
{
ctx->dataTracks = malloc(sizeof(TrackEntry) * ctx->numberOfDataTracks);
if(ctx->dataTracks == NULL)
ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks);
if(ctx->data_tracks == NULL)
{
FATAL("Could not allocate memory for data tracks, continuing without filtered list.\n");
ctx->numberOfDataTracks = 0;
ctx->number_of_data_tracks = 0;
}
}
else
ctx->dataTracks = NULL;
ctx->data_tracks = NULL;
if(ctx->dataTracks != NULL)
if(ctx->data_tracks != NULL)
{
k = 0;
for(j = 0; j < ctx->tracksHeader.entries; j++)
for(j = 0; j < ctx->tracks_header.entries; j++)
{
if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99)
memcpy(&ctx->dataTracks[k++], &ctx->trackEntries[j], sizeof(TrackEntry));
if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99)
memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry));
}
}
}
@@ -291,7 +291,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_NOT_AARUFORMAT;
}
const aaruformatContext *ctx = context;
const aaruformat_context *ctx = context;
// Not a libaaruformat context
if(ctx->magic != AARU_MAGIC)
@@ -302,7 +302,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->tracksHeader.entries == 0 || ctx->trackEntries == NULL)
if(ctx->tracks_header.entries == 0 || ctx->track_entries == NULL)
{
FATAL("Image contains no tracks");
@@ -310,7 +310,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_TRACK_NOT_FOUND;
}
size_t required_length = ctx->tracksHeader.entries * sizeof(TrackEntry);
size_t required_length = ctx->tracks_header.entries * sizeof(TrackEntry);
if(buffer == NULL || length == NULL || *length < required_length)
{
@@ -321,7 +321,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_BUFFER_TOO_SMALL;
}
memcpy(buffer, ctx->trackEntries, required_length);
memcpy(buffer, ctx->track_entries, required_length);
*length = required_length;
TRACE("Exiting aaruf_get_tracks(%p, %p, %zu) = AARUF_STATUS_OK", context, buffer, *length);
@@ -403,7 +403,7 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count)
return AARUF_ERROR_NOT_AARUFORMAT;
}
aaruformatContext *ctx = context;
aaruformat_context *ctx = context;
// Not a libaaruformat context
if(ctx->magic != AARU_MAGIC)
@@ -417,12 +417,12 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count)
// Clearing existing tracks
if(count == 0)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
free(ctx->trackEntries);
ctx->trackEntries = NULL;
free(ctx->dataTracks);
ctx->dataTracks = NULL;
ctx->numberOfDataTracks = 0;
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
free(ctx->track_entries);
ctx->track_entries = NULL;
free(ctx->data_tracks);
ctx->data_tracks = NULL;
ctx->number_of_data_tracks = 0;
TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
@@ -436,41 +436,41 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count)
return AARUF_ERROR_INVALID_TRACK_FORMAT;
}
ctx->tracksHeader.identifier = TracksBlock;
ctx->tracksHeader.entries = (uint16_t)count;
free(ctx->trackEntries);
ctx->trackEntries = malloc(sizeof(TrackEntry) * count);
if(ctx->trackEntries == NULL)
ctx->tracks_header.identifier = TracksBlock;
ctx->tracks_header.entries = (uint16_t)count;
free(ctx->track_entries);
ctx->track_entries = malloc(sizeof(TrackEntry) * count);
if(ctx->track_entries == NULL)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
FATAL("Could not allocate memory for tracks");
TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
return AARUF_ERROR_NOT_ENOUGH_MEMORY;
}
memcpy(ctx->trackEntries, tracks, sizeof(TrackEntry) * count);
ctx->tracksHeader.crc64 = aaruf_crc64_data((const uint8_t *)ctx->trackEntries, sizeof(TrackEntry) * count);
memcpy(ctx->track_entries, tracks, sizeof(TrackEntry) * count);
ctx->tracks_header.crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, sizeof(TrackEntry) * count);
ctx->imageInfo.HasPartitions = true;
ctx->imageInfo.HasSessions = true;
ctx->image_info.HasPartitions = true;
ctx->image_info.HasSessions = true;
free(ctx->dataTracks);
ctx->dataTracks = NULL;
free(ctx->data_tracks);
ctx->data_tracks = NULL;
ctx->numberOfDataTracks = 0;
ctx->number_of_data_tracks = 0;
for(int j = 0; j < ctx->tracksHeader.entries; j++)
if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) ctx->numberOfDataTracks++;
for(int j = 0; j < ctx->tracks_header.entries; j++)
if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99) ctx->number_of_data_tracks++;
if(ctx->numberOfDataTracks > 0)
if(ctx->number_of_data_tracks > 0)
{
ctx->dataTracks = malloc(sizeof(TrackEntry) * ctx->numberOfDataTracks);
if(ctx->dataTracks == NULL)
ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks);
if(ctx->data_tracks == NULL)
{
free(ctx->trackEntries);
ctx->trackEntries = NULL;
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
ctx->numberOfDataTracks = 0;
free(ctx->track_entries);
ctx->track_entries = NULL;
memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
ctx->number_of_data_tracks = 0;
FATAL("Could not allocate memory for data tracks");
TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
@@ -478,12 +478,12 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count)
}
}
if(ctx->dataTracks != NULL)
if(ctx->data_tracks != NULL)
{
int k = 0;
for(int j = 0; j < ctx->tracksHeader.entries; j++)
if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99)
memcpy(&ctx->dataTracks[k++], &ctx->trackEntries[j], sizeof(TrackEntry));
for(int j = 0; j < ctx->tracks_header.entries; j++)
if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99)
memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry));
}
TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK");

32
src/blocks/tape.c
View File

@@ -123,7 +123,7 @@
* @see tapeFileHashEntry for the hash table entry structure
* @see process_tape_partition_block() for partition metadata processing
*/
void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_tape_files_block(aaruformat_context *ctx, const IndexEntry *entry)
{
long pos = 0;
size_t read_bytes = 0;
@@ -160,7 +160,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry)
return;
}
ctx->imageInfo.ImageSize += sizeof(TapeFileEntry) * tape_file_header.entries;
ctx->image_info.ImageSize += sizeof(TapeFileEntry) * tape_file_header.entries;
uint8_t *buffer = malloc(sizeof(TapeFileEntry) * tape_file_header.entries);
if(buffer == NULL)
@@ -207,7 +207,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry)
// Replace if exists, add if new
tapeFileHashEntry *old_entry = NULL;
HASH_REPLACE(hh, ctx->tapeFiles, key, sizeof(uint64_t), hash_entry, old_entry);
HASH_REPLACE(hh, ctx->tape_files, key, sizeof(uint64_t), hash_entry, old_entry);
// Free old entry if it was replaced
if(old_entry != NULL)
@@ -343,7 +343,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry)
* @see TapePartitionHashEntry for the hash table entry structure
* @see process_tape_files_block() for tape file metadata processing
*/
void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *entry)
void process_tape_partitions_block(aaruformat_context *ctx, const IndexEntry *entry)
{
long pos = 0;
size_t read_bytes = 0;
@@ -380,7 +380,7 @@ void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *ent
return;
}
ctx->imageInfo.ImageSize += sizeof(TapePartitionEntry) * tape_partition_header.entries;
ctx->image_info.ImageSize += sizeof(TapePartitionEntry) * tape_partition_header.entries;
uint8_t *buffer = malloc(sizeof(TapePartitionEntry) * tape_partition_header.entries);
if(buffer == NULL)
@@ -427,7 +427,7 @@ void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *ent
// Replace if exists, add if new
TapePartitionHashEntry *old_entry = NULL;
HASH_REPLACE(hh, ctx->tapePartitions, key, sizeof(uint8_t), hash_entry, old_entry);
HASH_REPLACE(hh, ctx->tape_partitions, key, sizeof(uint8_t), hash_entry, old_entry);
// Free old entry if it was replaced
if(old_entry != NULL)
@@ -572,7 +572,7 @@ int32_t aaruf_get_tape_file(const void *context, const uint8_t partition, const
TRACE("Entering aaruf_get_tape_file(%p, %d, %d, %llu, %llu)", context, partition, file, *starting_block,
*ending_block);
const aaruformatContext *ctx = NULL;
const aaruformat_context *ctx = NULL;
if(context == NULL)
{
@@ -595,7 +595,7 @@ int32_t aaruf_get_tape_file(const void *context, const uint8_t partition, const
uint64_t key = (uint64_t)partition << 32 | file;
tapeFileHashEntry *entry = NULL;
HASH_FIND(hh, ctx->tapeFiles, &key, sizeof(uint64_t), entry);
HASH_FIND(hh, ctx->tape_files, &key, sizeof(uint64_t), entry);
if(entry == NULL)
{
@@ -773,7 +773,7 @@ int32_t aaruf_set_tape_file(void *context, const uint8_t partition, const uint32
TRACE("Entering aaruf_set_tape_file(%p, %d, %d, %llu, %llu)", context, partition, file, starting_block,
ending_block);
aaruformatContext *ctx = NULL;
aaruformat_context *ctx = NULL;
if(context == NULL)
{
@@ -795,7 +795,7 @@ int32_t aaruf_set_tape_file(void *context, const uint8_t partition, const uint32
}
// Check we are writing
if(!ctx->isWriting)
if(!ctx->is_writing)
{
FATAL("Trying to write a read-only image");
@@ -824,7 +824,7 @@ int32_t aaruf_set_tape_file(void *context, const uint8_t partition, const uint32
// Replace if exists, add if new
tapeFileHashEntry *old_entry = NULL;
HASH_REPLACE(hh, ctx->tapeFiles, key, sizeof(uint64_t), hash_entry, old_entry);
HASH_REPLACE(hh, ctx->tape_files, key, sizeof(uint64_t), hash_entry, old_entry);
// Free old entry if it was replaced
if(old_entry != NULL)
@@ -984,7 +984,7 @@ int32_t aaruf_get_tape_partition(const void *context, const uint8_t partition, u
{
TRACE("Entering aaruf_get_tape_partition(%p, %d, %llu, %llu)", context, partition, *starting_block, *ending_block);
const aaruformatContext *ctx = NULL;
const aaruformat_context *ctx = NULL;
if(context == NULL)
{
@@ -1007,7 +1007,7 @@ int32_t aaruf_get_tape_partition(const void *context, const uint8_t partition, u
uint8_t key = partition;
TapePartitionHashEntry *entry = NULL;
HASH_FIND(hh, ctx->tapePartitions, &key, sizeof(uint8_t), entry);
HASH_FIND(hh, ctx->tape_partitions, &key, sizeof(uint8_t), entry);
if(entry == NULL)
{
@@ -1198,7 +1198,7 @@ int32_t aaruf_set_tape_partition(void *context, const uint8_t partition, const u
{
TRACE("Entering aaruf_set_tape_partition(%p, %d, %llu, %llu)", context, partition, starting_block, ending_block);
aaruformatContext *ctx = NULL;
aaruformat_context *ctx = NULL;
if(context == NULL)
{
@@ -1220,7 +1220,7 @@ int32_t aaruf_set_tape_partition(void *context, const uint8_t partition, const u
}
// Check we are writing
if(!ctx->isWriting)
if(!ctx->is_writing)
{
FATAL("Trying to write a read-only image");
@@ -1248,7 +1248,7 @@ int32_t aaruf_set_tape_partition(void *context, const uint8_t partition, const u
// Replace if exists, add if new
TapePartitionHashEntry *old_entry = NULL;
HASH_REPLACE(hh, ctx->tapePartitions, key, sizeof(uint8_t), hash_entry, old_entry);
HASH_REPLACE(hh, ctx->tape_partitions, key, sizeof(uint8_t), hash_entry, old_entry);
// Free old entry if it was replaced
if(old_entry != NULL)

825
src/close.c
View File

File diff suppressed because it is too large Load Diff

182
src/create.c
View File

@@ -30,26 +30,26 @@
#include "internal.h"
#include "log.h"
static void cleanup_failed_create(aaruformatContext *ctx)
static void cleanup_failed_create(aaruformat_context *ctx)
{
if(ctx == NULL) return;
if(ctx->sectorHashMap != NULL)
if(ctx->sector_hash_map != NULL)
{
free_map(ctx->sectorHashMap);
ctx->sectorHashMap = NULL;
free_map(ctx->sector_hash_map);
ctx->sector_hash_map = NULL;
}
if(ctx->indexEntries != NULL)
if(ctx->index_entries != NULL)
{
utarray_free(ctx->indexEntries);
ctx->indexEntries = NULL;
utarray_free(ctx->index_entries);
ctx->index_entries = NULL;
}
if(ctx->userDataDdtBig != NULL)
if(ctx->user_data_ddt2 != NULL)
{
free(ctx->userDataDdtBig);
ctx->userDataDdtBig = NULL;
free(ctx->user_data_ddt2);
ctx->user_data_ddt2 = NULL;
}
if(ctx->spamsum_context != NULL)
@@ -64,10 +64,10 @@ static void cleanup_failed_create(aaruformatContext *ctx)
ctx->blake3_context = NULL;
}
if(ctx->eccCdContext != NULL)
if(ctx->ecc_cd_context != NULL)
{
free(ctx->eccCdContext);
ctx->eccCdContext = NULL;
free(ctx->ecc_cd_context);
ctx->ecc_cd_context = NULL;
}
if(ctx->readableSectorTags != NULL)
@@ -297,7 +297,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
// Allocate context
TRACE("Allocating memory for context");
aaruformatContext *ctx = malloc(sizeof(aaruformatContext));
aaruformat_context *ctx = malloc(sizeof(aaruformat_context));
if(ctx == NULL)
{
FATAL("Not enough memory to create context");
@@ -307,7 +307,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
return NULL;
}
memset(ctx, 0, sizeof(aaruformatContext));
memset(ctx, 0, sizeof(aaruformat_context));
// Create the image file
TRACE("Creating image file %s", filepath);
@@ -386,29 +386,29 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
// Ensure it fits in the Application buffer (64 bytes including null terminator)
if(app_name_utf8_len < 64)
{
u_strToUTF8(ctx->imageInfo.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status);
u_strToUTF8(ctx->image_info.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status);
if(U_FAILURE(status))
{
TRACE("Error converting application name to UTF-8: %d, using raw bytes", status);
// Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64);
memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
memset(ctx->image_info.Application, 0, 64);
memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
}
}
else
{
TRACE("Application name too long for buffer, truncating");
u_strToUTF8(ctx->imageInfo.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status);
ctx->imageInfo.Application[63] = '\0';
u_strToUTF8(ctx->image_info.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status);
ctx->image_info.Application[63] = '\0';
}
}
else
{
TRACE("Error getting UTF-8 length: %d, using raw bytes", status);
// Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64);
memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
memset(ctx->image_info.Application, 0, 64);
memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
}
free(app_name_utf16);
@@ -417,95 +417,95 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
{
TRACE("Could not allocate memory for UTF-16 conversion, using raw bytes");
// Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64);
memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
memset(ctx->image_info.Application, 0, 64);
memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
}
// Set application version string directly in the fixed-size array
memset(ctx->imageInfo.ApplicationVersion, 0, 32);
sprintf(ctx->imageInfo.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion,
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->imageInfo.Version, 0, 32);
sprintf(ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
memset(ctx->image_info.Version, 0, 32);
sprintf(ctx->image_info.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
ctx->imageInfo.MediaType = ctx->header.mediaType;
ctx->imageInfo.ImageSize = 0;
ctx->imageInfo.CreationTime = ctx->header.creationTime;
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime;
ctx->imageInfo.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType);
ctx->imageInfo.SectorSize = sector_size;
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;
// Initialize caches
TRACE("Initializing caches");
ctx->blockHeaderCache.cache = NULL;
const uint64_t cache_divisor = (uint64_t)ctx->imageInfo.SectorSize * (1ULL << ctx->shift);
ctx->blockHeaderCache.max_items = cache_divisor == 0 ? 0 : MAX_CACHE_SIZE / cache_divisor;
ctx->blockCache.cache = NULL;
ctx->blockCache.max_items = ctx->blockHeaderCache.max_items;
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->eccCdContext = (CdEccContext *)aaruf_ecc_cd_init();
ctx->ecc_cd_context = (CdEccContext *)aaruf_ecc_cd_init();
ctx->magic = AARU_MAGIC;
ctx->libraryMajorVersion = LIBAARUFORMAT_MAJOR_VERSION;
ctx->libraryMinorVersion = LIBAARUFORMAT_MINOR_VERSION;
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->inMemoryDdt = true;
ctx->userDataDdtHeader.identifier = DeDuplicationTable2;
ctx->userDataDdtHeader.type = UserData;
ctx->userDataDdtHeader.compression = None;
ctx->userDataDdtHeader.tableLevel = 0;
ctx->userDataDdtHeader.previousLevelOffset = 0;
ctx->userDataDdtHeader.negative = negative_sectors;
ctx->userDataDdtHeader.blocks = user_sectors + overflow_sectors + negative_sectors;
ctx->userDataDdtHeader.overflow = overflow_sectors;
ctx->userDataDdtHeader.start = 0;
ctx->userDataDdtHeader.blockAlignmentShift = parsed_options.block_alignment;
ctx->userDataDdtHeader.dataShift = parsed_options.data_shift;
ctx->userDataDdtHeader.sizeType = BigDdtSizeType;
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;
ctx->user_data_ddt_header.sizeType = BigDdtSizeType;
if(parsed_options.table_shift == -1)
{
const uint64_t total_sectors = user_sectors + overflow_sectors + negative_sectors;
if(total_sectors < 0x8388608ULL)
ctx->userDataDdtHeader.tableShift = 0;
ctx->user_data_ddt_header.tableShift = 0;
else
ctx->userDataDdtHeader.tableShift = 22;
ctx->user_data_ddt_header.tableShift = 22;
}
else
ctx->userDataDdtHeader.tableShift =
ctx->user_data_ddt_header.tableShift =
parsed_options.table_shift > 0 ? (uint8_t)parsed_options.table_shift : 0;
ctx->userDataDdtHeader.levels = ctx->userDataDdtHeader.tableShift > 0 ? 2 : 1;
ctx->user_data_ddt_header.levels = ctx->user_data_ddt_header.tableShift > 0 ? 2 : 1;
uint8_t effective_table_shift = ctx->userDataDdtHeader.tableShift;
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->userDataDdtHeader.tableShift = 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->userDataDdtHeader.entries = ctx->userDataDdtHeader.blocks / sectors_per_entry;
if(ctx->userDataDdtHeader.blocks % sectors_per_entry != 0 || ctx->userDataDdtHeader.entries == 0)
ctx->userDataDdtHeader.entries++;
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");
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType)
if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
{
ctx->userDataDdtBig =
(uint32_t *)calloc(ctx->userDataDdtHeader.entries, sizeof(uint32_t)); // All entries to zero
if(ctx->userDataDdtBig == NULL)
ctx->user_data_ddt2 =
(uint32_t *)calloc(ctx->user_data_ddt_header.entries, sizeof(uint32_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;
@@ -516,42 +516,42 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
}
// Set the primary DDT offset (just after the header, block aligned)
ctx->primaryDdtOffset = sizeof(AaruHeaderV2); // Start just after the header
const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1;
ctx->primaryDdtOffset = ctx->primaryDdtOffset + alignment_mask & ~alignment_mask;
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->primaryDdtOffset);
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->userDataDdtHeader.entries * sizeof(uint32_t);
const uint64_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t);
// Calculate where data blocks can start (after primary DDT + header)
if(ctx->userDataDdtHeader.tableShift > 0)
if(ctx->user_data_ddt_header.tableShift > 0)
{
const uint64_t data_start_position = ctx->primaryDdtOffset + sizeof(DdtHeader2) + primary_table_size;
ctx->nextBlockPosition = data_start_position + alignment_mask & ~alignment_mask;
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->nextBlockPosition = ctx->primaryDdtOffset; // Single-level DDT can start anywhere
ctx->next_block_position = ctx->primary_ddt_offset; // Single-level DDT can start anywhere
}
else
{
// Fill needed values
ctx->userDataDdtHeader.blockAlignmentShift = parsed_options.block_alignment;
ctx->userDataDdtHeader.dataShift = parsed_options.data_shift;
ctx->user_data_ddt_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->nextBlockPosition = sizeof(AaruHeaderV2); // Start just after the header
ctx->nextBlockPosition = ctx->nextBlockPosition + alignment_mask & ~alignment_mask;
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->tapeDdt = NULL;
ctx->tape_ddt = NULL;
}
TRACE("Data blocks will start at position %" PRIu64, ctx->nextBlockPosition);
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->nextBlockPosition, SEEK_SET) != 0)
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;
@@ -563,9 +563,9 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
// Initialize index entries array
TRACE("Initializing index entries array");
const UT_icd index_entry_icd = {sizeof(IndexEntry), NULL, NULL, NULL};
utarray_new(ctx->indexEntries, &index_entry_icd);
utarray_new(ctx->index_entries, &index_entry_icd);
if(ctx->indexEntries == NULL)
if(ctx->index_entries == NULL)
{
FATAL("Not enough memory to create index entries array");
errno = AARUF_ERROR_NOT_ENOUGH_MEMORY;
@@ -579,7 +579,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
ctx->lzma_dict_size = parsed_options.dictionary;
ctx->deduplicate = parsed_options.deduplicate;
if(ctx->deduplicate)
ctx->sectorHashMap = create_map(ctx->userDataDdtHeader.blocks * 25 / 100); // 25% of total sectors
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;
@@ -615,7 +615,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
}
// Is writing
ctx->isWriting = true;
ctx->is_writing = true;
TRACE("Exiting aaruf_create() = %p", ctx);
// Return context

58
src/ddt/ddt_v1.c
View File

@@ -82,7 +82,7 @@
* @warning The function modifies context state including sector count, shift value, and DDT version.
* Ensure proper context cleanup when the function completes.
*/
int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt)
int32_t process_ddt_v1(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt)
{
TRACE("Entering process_ddt_v1(%p, %p, %d)", ctx, entry, *found_user_data_ddt);
@@ -129,13 +129,13 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
*found_user_data_ddt = true;
ctx->imageInfo.ImageSize += ddt_header.cmpLength;
ctx->image_info.ImageSize += ddt_header.cmpLength;
if(entry->dataType == UserData)
{
ctx->imageInfo.Sectors = ddt_header.entries;
ctx->shift = ddt_header.shift;
ctx->ddtVersion = 1;
ctx->image_info.Sectors = ddt_header.entries;
ctx->shift = ddt_header.shift;
ctx->ddt_version = 1;
// Check for DDT compression
switch(ddt_header.compression)
@@ -157,8 +157,8 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
break;
}
ctx->userDataDdt = (uint64_t *)malloc(ddt_header.length);
if(ctx->userDataDdt == NULL)
ctx->user_data_ddt = (uint64_t *)malloc(ddt_header.length);
if(ctx->user_data_ddt == NULL)
{
TRACE("Cannot allocate memory for DDT, continuing...");
free(cmp_data);
@@ -170,8 +170,8 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
{
TRACE("Could not read LZMA properties, continuing...");
free(cmp_data);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(ctx->user_data_ddt);
ctx->user_data_ddt = NULL;
break;
}
@@ -180,22 +180,22 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
{
TRACE("Could not read compressed block, continuing...");
free(cmp_data);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(ctx->user_data_ddt);
ctx->user_data_ddt = NULL;
break;
}
read_bytes = ddt_header.length;
TRACE("Decompressing block of size %zu bytes", ddt_header.length);
error_no = aaruf_lzma_decode_buffer((uint8_t *)ctx->userDataDdt, &read_bytes, cmp_data, &lzma_size,
error_no = aaruf_lzma_decode_buffer((uint8_t *)ctx->user_data_ddt, &read_bytes, cmp_data, &lzma_size,
lzma_properties, LZMA_PROPERTIES_LENGTH);
if(error_no != 0)
{
FATAL("Got error %d from LZMA, stopping...", error_no);
free(cmp_data);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(ctx->user_data_ddt);
ctx->user_data_ddt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
}
@@ -203,15 +203,15 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
{
FATAL("Error decompressing block, should be {0} bytes but got {1} bytes., stopping...");
free(cmp_data);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(ctx->user_data_ddt);
ctx->user_data_ddt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
}
free(cmp_data);
cmp_data = NULL;
ctx->inMemoryDdt = true;
ctx->in_memory_ddt = true;
*found_user_data_ddt = true;
break;
@@ -219,18 +219,18 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
case None:
#ifdef __linux__
TRACE("Memory mapping deduplication table at position %" PRIu64, entry->offset + sizeof(ddt_header));
ctx->mappedMemoryDdtSize = sizeof(uint64_t) * ddt_header.entries;
ctx->userDataDdt = mmap(NULL, ctx->mappedMemoryDdtSize, PROT_READ, MAP_SHARED, fileno(ctx->imageStream),
entry->offset + sizeof(ddt_header));
ctx->mapped_memory_ddt_size = sizeof(uint64_t) * ddt_header.entries;
ctx->user_data_ddt = mmap(NULL, ctx->mapped_memory_ddt_size, PROT_READ, MAP_SHARED,
fileno(ctx->imageStream), entry->offset + sizeof(ddt_header));
if(ctx->userDataDdt == MAP_FAILED)
if(ctx->user_data_ddt == MAP_FAILED)
{
*found_user_data_ddt = false;
FATAL("Could not read map deduplication table.");
break;
}
ctx->inMemoryDdt = false;
ctx->in_memory_ddt = false;
break;
#else // TODO: Implement
TRACE("Uncompressed DDT not yet implemented...");
@@ -315,9 +315,9 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
cmp_data = NULL;
if(entry->dataType == CdSectorPrefixCorrected)
ctx->sectorPrefixDdt = cd_ddt;
ctx->sector_prefix_ddt = cd_ddt;
else if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixDdt = cd_ddt;
ctx->sector_suffix_ddt = cd_ddt;
else
free(cd_ddt);
@@ -343,9 +343,9 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
}
if(entry->dataType == CdSectorPrefixCorrected)
ctx->sectorPrefixDdt = cd_ddt;
ctx->sector_prefix_ddt = cd_ddt;
else if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixDdt = cd_ddt;
ctx->sector_suffix_ddt = cd_ddt;
else
free(cd_ddt);
@@ -402,7 +402,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
* @warning No bounds checking is performed on sector_address. Accessing beyond the DDT table
* boundaries will result in undefined behavior.
*/
int32_t decode_ddt_entry_v1(aaruformatContext *ctx, const uint64_t sector_address, uint64_t *offset,
int32_t decode_ddt_entry_v1(aaruformat_context *ctx, const uint64_t sector_address, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status)
{
TRACE("Entering decode_ddt_entry_v1(%p, %" PRIu64 ", %p, %p, %p)", ctx, sector_address, offset, block_offset,
@@ -416,7 +416,7 @@ int32_t decode_ddt_entry_v1(aaruformatContext *ctx, const uint64_t sector_addres
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->userDataDdt == NULL)
if(ctx->user_data_ddt == NULL)
{
FATAL("User data DDT not loaded.");
TRACE("Exiting decode_ddt_entry_v1() = AARUF_ERROR_NOT_AARUFORMAT");
@@ -430,7 +430,7 @@ int32_t decode_ddt_entry_v1(aaruformatContext *ctx, const uint64_t sector_addres
return AARUF_ERROR_INCORRECT_DATA_SIZE;
}
const uint64_t ddt_entry = ctx->userDataDdt[sector_address];
const uint64_t ddt_entry = ctx->user_data_ddt[sector_address];
const uint64_t offset_mask64 = (UINT64_C(1) << ctx->shift) - UINT64_C(1);
*offset = ddt_entry & offset_mask64;
*block_offset = ddt_entry >> ctx->shift;

292
src/ddt/ddt_v2.c
View File

@@ -94,7 +94,7 @@
* @warning Memory allocated for DDT data becomes part of the context and should not be freed separately.
* The context cleanup functions will handle DDT memory deallocation.
*/
int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt)
int32_t process_ddt_v2(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt)
{
TRACE("Entering process_ddt_v2(%p, %p, %d)", ctx, entry, *found_user_data_ddt);
@@ -142,17 +142,17 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
*found_user_data_ddt = false;
ctx->imageInfo.ImageSize += ddt_header.cmpLength;
ctx->image_info.ImageSize += ddt_header.cmpLength;
if(entry->dataType == UserData)
{
// User area sectors is blocks stored in DDT minus the negative and overflow displacement blocks
ctx->imageInfo.Sectors = ddt_header.blocks - ddt_header.negative - ddt_header.overflow;
ctx->image_info.Sectors = ddt_header.blocks - ddt_header.negative - ddt_header.overflow;
// We need the header later for the shift calculations
ctx->userDataDdtHeader = ddt_header;
ctx->ddtVersion = 2;
ctx->user_data_ddt_header = ddt_header;
ctx->ddt_version = 2;
// Store the primary DDT table's file offset for secondary table references
ctx->primaryDdtOffset = entry->offset;
ctx->primary_ddt_offset = entry->offset;
// Check for DDT compression
switch(ddt_header.compression)
@@ -247,9 +247,9 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
ctx->userDataDdtBig = (uint32_t *)buffer;
ctx->user_data_ddt2 = (uint32_t *)buffer;
ctx->inMemoryDdt = true;
ctx->in_memory_ddt = true;
*found_user_data_ddt = true;
break;
@@ -293,9 +293,9 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
ctx->userDataDdtBig = (uint32_t *)buffer;
ctx->user_data_ddt2 = (uint32_t *)buffer;
ctx->inMemoryDdt = true;
ctx->in_memory_ddt = true;
*found_user_data_ddt = true;
break;
@@ -399,8 +399,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixDdt = (uint32_t *)buffer; }
else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sectorSuffixDdt = (uint32_t *)buffer; }
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_ddt = (uint32_t *)buffer; }
else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sector_suffix_ddt = (uint32_t *)buffer; }
else
free(buffer);
@@ -445,8 +445,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixDdt = (uint32_t *)buffer; }
else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sectorSuffixDdt = (uint32_t *)buffer; }
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_ddt = (uint32_t *)buffer; }
else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sector_suffix_ddt = (uint32_t *)buffer; }
else
free(buffer);
@@ -505,7 +505,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
* @warning All output parameters must be valid pointers. No bounds checking is performed
* on the sector_address parameter at this level.
*/
int32_t decode_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, bool negative, uint64_t *offset,
int32_t decode_ddt_entry_v2(aaruformat_context *ctx, const uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status)
{
TRACE("Entering decode_ddt_entry_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative, *offset,
@@ -519,7 +519,7 @@ int32_t decode_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_addres
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->userDataDdtHeader.tableShift > 0)
if(ctx->user_data_ddt_header.tableShift > 0)
return decode_ddt_multi_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status);
return decode_ddt_single_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status);
@@ -585,7 +585,7 @@ int32_t decode_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_addres
* @warning This function should only be called when tableShift is 0. Calling it with
* tableShift > 0 will result in AARUF_ERROR_CANNOT_READ_BLOCK.
*/
int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
int32_t decode_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status)
{
TRACE("Entering decode_ddt_single_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative,
@@ -603,7 +603,7 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre
}
// Should not really be here
if(ctx->userDataDdtHeader.tableShift != 0)
if(ctx->user_data_ddt_header.tableShift != 0)
{
FATAL("DDT table shift is not zero, but we are in single-level DDT decoding.");
TRACE("Exiting decode_ddt_single_level_v2() = AARUF_ERROR_CANNOT_READ_BLOCK");
@@ -612,12 +612,12 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre
// Calculate positive or negative sector
if(negative)
sector_address -= ctx->userDataDdtHeader.negative;
sector_address -= ctx->user_data_ddt_header.negative;
else
sector_address += ctx->userDataDdtHeader.negative;
sector_address += ctx->user_data_ddt_header.negative;
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType)
ddt_entry = ctx->userDataDdtBig[sector_address];
if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
ddt_entry = ctx->user_data_ddt2[sector_address];
else
{
FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType);
@@ -638,9 +638,10 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre
*sector_status = ddt_entry >> 28;
ddt_entry &= 0x0fffffff;
const uint64_t offset_mask = (uint64_t)((1 << ctx->userDataDdtHeader.dataShift) - 1);
const uint64_t offset_mask = (uint64_t)((1 << ctx->user_data_ddt_header.dataShift) - 1);
*offset = ddt_entry & offset_mask;
*block_offset = (ddt_entry >> ctx->userDataDdtHeader.dataShift) * (1 << ctx->userDataDdtHeader.blockAlignmentShift);
*block_offset =
(ddt_entry >> ctx->user_data_ddt_header.dataShift) * (1 << ctx->user_data_ddt_header.blockAlignmentShift);
TRACE("Exiting decode_ddt_single_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d) = AARUF_STATUS_OK", ctx,
sector_address, negative, *offset, *block_offset, *sector_status);
@@ -735,7 +736,7 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre
* @warning No bounds checking is performed on sector_address or calculated DDT positions.
* Accessing beyond table boundaries will result in undefined behavior.
*/
int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
int32_t decode_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset,
uint64_t *block_offset, uint8_t *sector_status)
{
TRACE("Entering decode_ddt_multi_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative,
@@ -762,7 +763,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
}
// Should not really be here
if(ctx->userDataDdtHeader.tableShift == 0)
if(ctx->user_data_ddt_header.tableShift == 0)
{
FATAL("DDT table shift is zero, but we are in multi-level DDT decoding.");
TRACE("Exiting decode_ddt_multi_level_v2() = AARUF_ERROR_CANNOT_READ_BLOCK");
@@ -771,15 +772,15 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
// Calculate positive or negative sector
if(negative)
sector_address -= ctx->userDataDdtHeader.negative;
sector_address -= ctx->user_data_ddt_header.negative;
else
sector_address += ctx->userDataDdtHeader.negative;
sector_address += ctx->user_data_ddt_header.negative;
items_per_ddt_entry = 1 << ctx->userDataDdtHeader.tableShift;
items_per_ddt_entry = 1 << ctx->user_data_ddt_header.tableShift;
ddt_position = sector_address / items_per_ddt_entry;
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType)
secondary_ddt_offset = ctx->userDataDdtBig[ddt_position];
if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
secondary_ddt_offset = ctx->user_data_ddt2[ddt_position];
else
{
FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType);
@@ -788,10 +789,10 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
}
// Position in file of the child DDT table
secondary_ddt_offset *= 1 << ctx->userDataDdtHeader.blockAlignmentShift;
secondary_ddt_offset *= 1 << ctx->user_data_ddt_header.blockAlignmentShift;
// Is the one we have cached the same as the one we need to read?
if(ctx->cachedDdtOffset != secondary_ddt_offset)
if(ctx->cached_ddt_offset != secondary_ddt_offset)
{
int32_t error_no = 0;
fseek(ctx->imageStream, secondary_ddt_offset, SEEK_SET);
@@ -907,9 +908,9 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
ctx->cachedSecondaryDdtBig = (uint32_t *)buffer;
ctx->cached_secondary_ddt2 = (uint32_t *)buffer;
ctx->cachedDdtOffset = secondary_ddt_offset;
ctx->cached_ddt_offset = secondary_ddt_offset;
break;
case None:
@@ -953,9 +954,9 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
ctx->cachedSecondaryDdtBig = (uint32_t *)buffer;
ctx->cached_secondary_ddt2 = (uint32_t *)buffer;
ctx->cachedDdtOffset = secondary_ddt_offset;
ctx->cached_ddt_offset = secondary_ddt_offset;
break;
default:
@@ -965,7 +966,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
}
}
ddt_entry = ctx->cachedSecondaryDdtBig[sector_address % items_per_ddt_entry];
ddt_entry = ctx->cached_secondary_ddt2[sector_address % items_per_ddt_entry];
if(ddt_entry == 0)
{
@@ -981,9 +982,10 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
*sector_status = ddt_entry >> 28;
ddt_entry &= 0x0fffffff;
const uint64_t offset_mask = (uint64_t)((1 << ctx->userDataDdtHeader.dataShift) - 1);
const uint64_t offset_mask = (uint64_t)((1 << ctx->user_data_ddt_header.dataShift) - 1);
*offset = ddt_entry & offset_mask;
*block_offset = (ddt_entry >> ctx->userDataDdtHeader.dataShift) * (1 << ctx->userDataDdtHeader.blockAlignmentShift);
*block_offset =
(ddt_entry >> ctx->user_data_ddt_header.dataShift) * (1 << ctx->user_data_ddt_header.blockAlignmentShift);
TRACE("Exiting decode_ddt_multi_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d) = AARUF_STATUS_OK", ctx,
sector_address, negative, *offset, *block_offset, *sector_status);
@@ -1006,7 +1008,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres
* @return Returns one of the following status codes:
* @retval true if the entry was set successfully, false otherwise.
*/
bool set_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, bool negative, const uint64_t offset,
bool set_ddt_entry_v2(aaruformat_context *ctx, const uint64_t sector_address, bool negative, const uint64_t offset,
const uint64_t block_offset, const uint8_t sector_status, uint64_t *ddt_entry)
{
TRACE("Entering set_ddt_entry_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative, offset,
@@ -1019,7 +1021,7 @@ bool set_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, boo
return false;
}
if(ctx->userDataDdtHeader.tableShift > 0)
if(ctx->user_data_ddt_header.tableShift > 0)
return set_ddt_multi_level_v2(ctx, sector_address, false, offset, block_offset, sector_status, ddt_entry);
return set_ddt_single_level_v2(ctx, sector_address, false, offset, block_offset, sector_status, ddt_entry);
@@ -1041,7 +1043,7 @@ bool set_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, boo
* @return Returns one of the following status codes:
* @retval true if the entry was set successfully, false otherwise.
*/
bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, const bool negative,
bool set_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, const bool negative,
const uint64_t offset, const uint64_t block_offset, const uint8_t sector_status,
uint64_t *ddt_entry)
{
@@ -1057,7 +1059,7 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co
}
// Should not really be here
if(ctx->userDataDdtHeader.tableShift != 0)
if(ctx->user_data_ddt_header.tableShift != 0)
{
FATAL("DDT table shift is not zero, but we are in single-level DDT setting.");
TRACE("Exiting set_ddt_single_level_v2() = false");
@@ -1066,15 +1068,15 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co
// Calculate positive or negative sector
if(negative)
sector_address -= ctx->userDataDdtHeader.negative;
sector_address -= ctx->user_data_ddt_header.negative;
else
sector_address += ctx->userDataDdtHeader.negative;
sector_address += ctx->user_data_ddt_header.negative;
if(*ddt_entry == 0)
{
const uint64_t block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index
<< ctx->userDataDdtHeader.dataShift;
const uint64_t block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF)
@@ -1088,7 +1090,7 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co
}
TRACE("Setting big single-level DDT entry %d to %u", sector_address, (uint32_t)*ddt_entry);
ctx->userDataDdtBig[sector_address] = (uint32_t)*ddt_entry;
ctx->user_data_ddt2[sector_address] = (uint32_t)*ddt_entry;
TRACE("Exiting set_ddt_single_level_v2() = true");
return true;
@@ -1110,7 +1112,7 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co
* @return Returns one of the following status codes:
* @retval true if the entry was set successfully, false otherwise.
*/
bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset,
bool set_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset,
uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry)
{
TRACE("Entering set_ddt_multi_level_v2(%p, %" PRIu64 ", %d, %" PRIu64 ", %" PRIu64 ", %d)", ctx, sector_address,
@@ -1137,7 +1139,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
// Should not really be here
if(ctx->userDataDdtHeader.tableShift == 0)
if(ctx->user_data_ddt_header.tableShift == 0)
{
FATAL("DDT table shift is zero, but we are in multi-level DDT setting.");
TRACE("Exiting set_ddt_multi_level_v2() = false");
@@ -1146,16 +1148,16 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
// Calculate positive or negative sector
if(negative)
sector_address -= ctx->userDataDdtHeader.negative;
sector_address -= ctx->user_data_ddt_header.negative;
else
sector_address += ctx->userDataDdtHeader.negative;
sector_address += ctx->user_data_ddt_header.negative;
// Step 1: Calculate the corresponding secondary level table
items_per_ddt_entry = 1 << ctx->userDataDdtHeader.tableShift;
items_per_ddt_entry = 1 << ctx->user_data_ddt_header.tableShift;
ddt_position = sector_address / items_per_ddt_entry;
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType)
secondary_ddt_offset = ctx->userDataDdtBig[ddt_position];
if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
secondary_ddt_offset = ctx->user_data_ddt2[ddt_position];
else
{
FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType);
@@ -1164,17 +1166,17 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
// Position in file of the child DDT table
secondary_ddt_offset *= 1 << ctx->userDataDdtHeader.blockAlignmentShift;
secondary_ddt_offset *= 1 << ctx->user_data_ddt_header.blockAlignmentShift;
// Step 2: Check if it corresponds to the currently in-memory cached secondary level table
if(ctx->cachedDdtOffset == secondary_ddt_offset && secondary_ddt_offset != 0)
if(ctx->cached_ddt_offset == secondary_ddt_offset && secondary_ddt_offset != 0)
{
// Update the corresponding DDT entry directly in the cached table
if(*ddt_entry == 0)
{
block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 |
block_index << ctx->userDataDdtHeader.dataShift;
block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF)
@@ -1188,7 +1190,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
TRACE("Setting small secondary DDT entry %d to %u", sector_address % items_per_ddt_entry, (uint16_t)*ddt_entry);
ctx->cachedSecondaryDdtBig[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry;
ctx->cached_secondary_ddt2[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry;
TRACE("Updated cached secondary DDT entry at position %" PRIu64, sector_address % items_per_ddt_entry);
TRACE("Exiting set_ddt_multi_level_v2() = true");
@@ -1197,26 +1199,26 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
// Step 2.5: Handle case where we have a cached secondary DDT that has never been written to disk
// but does not contain the requested block
if(ctx->cachedDdtOffset == 0 && (ctx->cachedSecondaryDdtBig != NULL))
if(ctx->cached_ddt_offset == 0 && (ctx->cached_secondary_ddt2 != NULL))
{
// Only write the cached table to disk if the requested block belongs to a different DDT position
if(ddt_position != ctx->cachedDdtPosition)
if(ddt_position != ctx->cached_ddt_position)
{
TRACE("Current secondary DDT in memory belongs to position %" PRIu64
" but requested block needs position %" PRIu64,
ctx->cachedDdtPosition, ddt_position);
ctx->cached_ddt_position, ddt_position);
// Write the cached DDT to disk before proceeding with the new one
// Close the current data block first
if(ctx->writingBuffer != NULL) aaruf_close_current_block(ctx);
if(ctx->writing_buffer != NULL) aaruf_close_current_block(ctx);
// Get current position and seek to end of file
fseek(ctx->imageStream, 0, SEEK_END);
end_of_file = ftell(ctx->imageStream);
// Align to block boundary
uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1;
uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1;
end_of_file = end_of_file + alignment_mask & ~alignment_mask;
fseek(ctx->imageStream, end_of_file, SEEK_SET);
@@ -1225,17 +1227,17 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
ddt_header.identifier = DeDuplicationTable2;
ddt_header.type = UserData;
ddt_header.compression = ctx->compression_enabled ? Lzma : None; // Use no compression for simplicity
ddt_header.levels = ctx->userDataDdtHeader.levels;
ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1;
ddt_header.previousLevelOffset = ctx->primaryDdtOffset;
ddt_header.negative = ctx->userDataDdtHeader.negative;
ddt_header.levels = ctx->user_data_ddt_header.levels;
ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1;
ddt_header.previousLevelOffset = ctx->primary_ddt_offset;
ddt_header.negative = ctx->user_data_ddt_header.negative;
ddt_header.blocks = items_per_ddt_entry;
ddt_header.overflow = ctx->userDataDdtHeader.overflow;
ddt_header.start = ctx->cachedDdtPosition * items_per_ddt_entry; // Use cached position with table shift
ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift;
ddt_header.dataShift = ctx->userDataDdtHeader.dataShift;
ddt_header.overflow = ctx->user_data_ddt_header.overflow;
ddt_header.start = ctx->cached_ddt_position * items_per_ddt_entry; // Use cached position with table shift
ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift;
ddt_header.dataShift = ctx->user_data_ddt_header.dataShift;
ddt_header.tableShift = 0; // Secondary tables are single level
ddt_header.sizeType = ctx->userDataDdtHeader.sizeType;
ddt_header.sizeType = ctx->user_data_ddt_header.sizeType;
ddt_header.entries = items_per_ddt_entry;
// Calculate data size
@@ -1251,7 +1253,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
return false;
}
aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cachedSecondaryDdtBig, (uint32_t)ddt_header.length);
aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cached_secondary_ddt2, (uint32_t)ddt_header.length);
aaruf_crc64_final(crc64_context, &crc64);
ddt_header.crc64 = crc64;
@@ -1262,7 +1264,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
if(ddt_header.compression == None)
{
cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig;
cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2;
ddt_header.cmpCrc64 = ddt_header.crc64;
}
else
@@ -1276,7 +1278,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
size_t dst_size = (size_t)ddt_header.length * 2 * 2;
size_t props_size = LZMA_PROPERTIES_LENGTH;
aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cachedSecondaryDdtBig,
aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cached_secondary_ddt2,
ddt_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0,
2, 273, 8);
@@ -1287,7 +1289,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
ddt_header.compression = None;
free(cmp_buffer);
cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig;
cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2;
}
}
@@ -1328,21 +1330,21 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
new_ddt_entry.dataType = UserData;
new_ddt_entry.offset = end_of_file;
utarray_push_back(ctx->indexEntries, &new_ddt_entry);
utarray_push_back(ctx->index_entries, &new_ddt_entry);
TRACE("Added new DDT index entry for never-written table at offset %" PRIu64, end_of_file);
// Update the primary level table entry to point to the new location of the secondary table
uint64_t new_secondary_table_block_offset = end_of_file >> ctx->userDataDdtHeader.blockAlignmentShift;
uint64_t new_secondary_table_block_offset = end_of_file >> ctx->user_data_ddt_header.blockAlignmentShift;
ctx->userDataDdtBig[ctx->cachedDdtPosition] = (uint32_t)new_secondary_table_block_offset;
ctx->user_data_ddt2[ctx->cached_ddt_position] = (uint32_t)new_secondary_table_block_offset;
// Write the updated primary table back to its original position in the file
long saved_pos = ftell(ctx->imageStream);
fseek(ctx->imageStream, ctx->primaryDdtOffset + sizeof(DdtHeader2), SEEK_SET);
fseek(ctx->imageStream, ctx->primary_ddt_offset + sizeof(DdtHeader2), SEEK_SET);
size_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t);
size_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t);
written_bytes = fwrite(ctx->userDataDdtBig, primary_table_size, 1, ctx->imageStream);
written_bytes = fwrite(ctx->user_data_ddt2, primary_table_size, 1, ctx->imageStream);
if(written_bytes != 1)
{
@@ -1352,20 +1354,20 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
// Update nextBlockPosition to ensure future blocks don't overwrite the DDT
uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length;
ctx->nextBlockPosition = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask;
block_offset = ctx->nextBlockPosition;
offset = 0;
TRACE("Updated nextBlockPosition after never-written DDT write to %" PRIu64, ctx->nextBlockPosition);
uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length;
ctx->next_block_position = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask;
block_offset = ctx->next_block_position;
offset = 0;
TRACE("Updated nextBlockPosition after never-written DDT write to %" PRIu64, ctx->next_block_position);
// Free the cached table
free(ctx->cachedSecondaryDdtBig);
ctx->cachedSecondaryDdtBig = NULL;
free(ctx->cached_secondary_ddt2);
ctx->cached_secondary_ddt2 = NULL;
// Reset cached values since we've written and freed the table
ctx->cachedDdtOffset = 0;
ctx->cachedDdtPosition = 0;
ctx->cached_ddt_offset = 0;
ctx->cached_ddt_position = 0;
// Restore file position
fseek(ctx->imageStream, saved_pos, SEEK_SET);
@@ -1381,11 +1383,11 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
// Step 3: Write the currently in-memory cached secondary level table to the end of the file
if(ctx->cachedDdtOffset != 0)
if(ctx->cached_ddt_offset != 0)
{
long current_pos = 0;
// Close the current data block first
if(ctx->writingBuffer != NULL) aaruf_close_current_block(ctx);
if(ctx->writing_buffer != NULL) aaruf_close_current_block(ctx);
// Get current position and seek to end of file
current_pos = ftell(ctx->imageStream);
@@ -1393,7 +1395,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
end_of_file = ftell(ctx->imageStream);
// Align to block boundary
uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1;
uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1;
end_of_file = end_of_file + alignment_mask & ~alignment_mask;
fseek(ctx->imageStream, end_of_file, SEEK_SET);
@@ -1402,17 +1404,17 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
ddt_header.identifier = DeDuplicationTable2;
ddt_header.type = UserData;
ddt_header.compression = ctx->compression_enabled ? Lzma : None;
ddt_header.levels = ctx->userDataDdtHeader.levels;
ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1;
ddt_header.previousLevelOffset = ctx->primaryDdtOffset; // Set to primary DDT table location
ddt_header.negative = ctx->userDataDdtHeader.negative;
ddt_header.levels = ctx->user_data_ddt_header.levels;
ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1;
ddt_header.previousLevelOffset = ctx->primary_ddt_offset; // Set to primary DDT table location
ddt_header.negative = ctx->user_data_ddt_header.negative;
ddt_header.blocks = items_per_ddt_entry;
ddt_header.overflow = ctx->userDataDdtHeader.overflow;
ddt_header.overflow = ctx->user_data_ddt_header.overflow;
ddt_header.start = ddt_position * items_per_ddt_entry; // First block this DDT table references
ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift;
ddt_header.dataShift = ctx->userDataDdtHeader.dataShift;
ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift;
ddt_header.dataShift = ctx->user_data_ddt_header.dataShift;
ddt_header.tableShift = 0; // Secondary tables are single level
ddt_header.sizeType = ctx->userDataDdtHeader.sizeType;
ddt_header.sizeType = ctx->user_data_ddt_header.sizeType;
ddt_header.entries = items_per_ddt_entry;
// Calculate data size
@@ -1428,7 +1430,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
return false;
}
aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cachedSecondaryDdtBig, ddt_header.length);
aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cached_secondary_ddt2, ddt_header.length);
aaruf_crc64_final(crc64_context, &crc64);
ddt_header.crc64 = crc64;
@@ -1439,7 +1441,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
if(ddt_header.compression == None)
{
cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig;
cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2;
ddt_header.cmpCrc64 = ddt_header.crc64;
}
else
@@ -1453,7 +1455,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
size_t dst_size = (size_t)ddt_header.length * 2 * 2;
size_t props_size = LZMA_PROPERTIES_LENGTH;
aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cachedSecondaryDdtBig, ddt_header.length,
aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cached_secondary_ddt2, ddt_header.length,
lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8);
ddt_header.cmpLength = (uint32_t)dst_size;
@@ -1463,7 +1465,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
ddt_header.compression = None;
free(cmp_buffer);
cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig;
cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2;
}
}
@@ -1504,19 +1506,19 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
TRACE("Updating index for evicted secondary DDT");
// Remove old index entry for the cached DDT
if(ctx->cachedDdtOffset != 0)
if(ctx->cached_ddt_offset != 0)
{
TRACE("Removing old index entry for DDT at offset %" PRIu64, ctx->cachedDdtOffset);
TRACE("Removing old index entry for DDT at offset %" PRIu64, ctx->cached_ddt_offset);
IndexEntry *entry = NULL;
// Find and remove the old index entry
for(unsigned int i = 0; i < utarray_len(ctx->indexEntries); i++)
for(unsigned int i = 0; i < utarray_len(ctx->index_entries); i++)
{
entry = (IndexEntry *)utarray_eltptr(ctx->indexEntries, i);
if(entry && entry->offset == ctx->cachedDdtOffset && entry->blockType == DeDuplicationTable2)
entry = (IndexEntry *)utarray_eltptr(ctx->index_entries, i);
if(entry && entry->offset == ctx->cached_ddt_offset && entry->blockType == DeDuplicationTable2)
{
TRACE("Found old DDT index entry at position %u, removing", i);
utarray_erase(ctx->indexEntries, i, 1);
utarray_erase(ctx->index_entries, i, 1);
break;
}
}
@@ -1528,24 +1530,24 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
new_ddt_entry.dataType = UserData;
new_ddt_entry.offset = end_of_file;
utarray_push_back(ctx->indexEntries, &new_ddt_entry);
utarray_push_back(ctx->index_entries, &new_ddt_entry);
TRACE("Added new DDT index entry at offset %" PRIu64, end_of_file);
// Step 4: Update the primary level table entry and flush it back to file
uint64_t new_secondary_table_block_offset = end_of_file >> ctx->userDataDdtHeader.blockAlignmentShift;
uint64_t new_secondary_table_block_offset = end_of_file >> ctx->user_data_ddt_header.blockAlignmentShift;
// Update the primary table entry to point to the new location of the secondary table
// Use ddtPosition which was calculated from sectorAddress, not cachedDdtOffset
ctx->userDataDdtBig[ddt_position] = (uint32_t)new_secondary_table_block_offset;
ctx->user_data_ddt2[ddt_position] = (uint32_t)new_secondary_table_block_offset;
// Write the updated primary table back to its original position in the file
long saved_pos = ftell(ctx->imageStream);
fseek(ctx->imageStream, ctx->primaryDdtOffset + sizeof(DdtHeader2), SEEK_SET);
fseek(ctx->imageStream, ctx->primary_ddt_offset + sizeof(DdtHeader2), SEEK_SET);
size_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t);
size_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t);
written_bytes = fwrite(ctx->userDataDdtBig, primary_table_size, 1, ctx->imageStream);
written_bytes = fwrite(ctx->user_data_ddt2, primary_table_size, 1, ctx->imageStream);
if(written_bytes != 1)
{
@@ -1555,25 +1557,25 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
// Update nextBlockPosition to ensure future blocks don't overwrite the DDT
uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length;
ctx->nextBlockPosition = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask;
block_offset = ctx->nextBlockPosition;
offset = 0;
TRACE("Updated nextBlockPosition after DDT write to %" PRIu64, ctx->nextBlockPosition);
uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length;
ctx->next_block_position = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask;
block_offset = ctx->next_block_position;
offset = 0;
TRACE("Updated nextBlockPosition after DDT write to %" PRIu64, ctx->next_block_position);
fseek(ctx->imageStream, saved_pos, SEEK_SET);
// Free the cached table
free(ctx->cachedSecondaryDdtBig);
ctx->cachedSecondaryDdtBig = NULL;
free(ctx->cached_secondary_ddt2);
ctx->cached_secondary_ddt2 = NULL;
// Restore file position
fseek(ctx->imageStream, current_pos, SEEK_SET);
}
// Step 5: Check if the specified block already has an existing secondary level table
create_new_table = ctx->cachedSecondaryDdtBig == NULL;
create_new_table = ctx->cached_secondary_ddt2 == NULL;
if(!create_new_table && secondary_ddt_offset != 0)
{
@@ -1630,9 +1632,9 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
// Cache the loaded table
ctx->cachedSecondaryDdtBig = (uint32_t *)buffer;
ctx->cached_secondary_ddt2 = (uint32_t *)buffer;
ctx->cachedDdtOffset = secondary_ddt_offset;
ctx->cached_ddt_offset = secondary_ddt_offset;
}
if(create_new_table)
@@ -1648,19 +1650,19 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
return false;
}
ctx->cachedSecondaryDdtBig = (uint32_t *)buffer;
ctx->cached_secondary_ddt2 = (uint32_t *)buffer;
ctx->cachedDdtOffset = 0; // Will be set when written to file
ctx->cachedDdtPosition = ddt_position; // Track which primary DDT position this new table belongs to
ctx->cached_ddt_offset = 0; // Will be set when written to file
ctx->cached_ddt_position = ddt_position; // Track which primary DDT position this new table belongs to
TRACE("Created new secondary DDT for position %" PRIu64, ddt_position);
}
// Step 6: Update the corresponding DDT entry
if(*ddt_entry == 0)
{
block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index
<< ctx->userDataDdtHeader.dataShift;
block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF)
@@ -1674,7 +1676,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
}
TRACE("Setting big secondary DDT entry %d to %u", sector_address % items_per_ddt_entry, (uint32_t)*ddt_entry);
ctx->cachedSecondaryDdtBig[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry;
ctx->cached_secondary_ddt2[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry;
TRACE("Updated secondary DDT entry at position %" PRIu64, sector_address % items_per_ddt_entry);
TRACE("Exiting set_ddt_multi_level_v2() = true");
@@ -1797,7 +1799,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
* @see set_ddt_entry_v2() for the main DDT entry point that dispatches to this function
* @see get_ddt_tape() for retrieving tape DDT entries from the hash table
*/
bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, const uint64_t offset, const uint64_t block_offset,
bool set_ddt_tape(aaruformat_context *ctx, uint64_t sector_address, const uint64_t offset, const uint64_t block_offset,
const uint8_t sector_status, uint64_t *ddt_entry)
{
TRACE("Entering set_ddt_tape(%p, %" PRIu64 ", %llu, %llu, %d)", ctx, sector_address, offset, block_offset,
@@ -1821,9 +1823,9 @@ bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, const uint64_
if(*ddt_entry == 0)
{
const uint64_t block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index
<< ctx->userDataDdtHeader.dataShift;
const uint64_t block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF)
{
@@ -1851,7 +1853,7 @@ bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, const uint64_
new_entry->value = *ddt_entry;
// Insert entry into tape DDT
HASH_REPLACE(hh, ctx->tapeDdt, key, sizeof(uint64_t), new_entry, old_entry);
HASH_REPLACE(hh, ctx->tape_ddt, key, sizeof(uint64_t), new_entry, old_entry);
if(old_entry) free(old_entry);
TRACE("Exiting set_ddt_tape() = true");

114
src/dump.c
View File

@@ -190,7 +190,7 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length)
TRACE("Entering aaruf_get_dumphw(%p, %p, %zu)", context, buffer, length_value);
aaruformatContext *ctx = NULL;
aaruformat_context *ctx = NULL;
if(context == NULL)
{
@@ -219,8 +219,8 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->dumpHardwareEntriesWithData == NULL || ctx->dumpHardwareHeader.entries == 0 ||
ctx->dumpHardwareHeader.identifier != DumpHardwareBlock)
if(ctx->dump_hardware_entries_with_data == NULL || ctx->dump_hardware_header.entries == 0 ||
ctx->dump_hardware_header.identifier != DumpHardwareBlock)
{
FATAL("No dump hardware information present");
@@ -228,7 +228,7 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
size_t required_length = sizeof(DumpHardwareHeader) + (size_t)ctx->dumpHardwareHeader.length;
size_t required_length = sizeof(DumpHardwareHeader) + (size_t)ctx->dump_hardware_header.length;
if(required_length < sizeof(DumpHardwareHeader))
{
FATAL("Dump hardware payload length overflow");
@@ -250,11 +250,11 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length)
// Start to iterate and copy the data
size_t offset = 0;
for(uint32_t i = 0; i < ctx->dumpHardwareHeader.entries; i++)
for(uint32_t i = 0; i < ctx->dump_hardware_header.entries; i++)
{
size_t entry_size = sizeof(DumpHardwareEntry);
const DumpHardwareEntry *entry = &ctx->dumpHardwareEntriesWithData[i].entry;
const DumpHardwareEntry *entry = &ctx->dump_hardware_entries_with_data[i].entry;
const size_t extent_bytes = (size_t)entry->extents * sizeof(DumpExtent);
if(entry->extents != 0 && extent_bytes / sizeof(DumpExtent) != entry->extents)
@@ -292,77 +292,77 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length)
return AARUF_ERROR_BUFFER_TOO_SMALL;
}
memcpy(buffer + offset, &ctx->dumpHardwareEntriesWithData[i].entry, sizeof(DumpHardwareEntry));
memcpy(buffer + offset, &ctx->dump_hardware_entries_with_data[i].entry, sizeof(DumpHardwareEntry));
offset += sizeof(DumpHardwareEntry);
if(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].manufacturer != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength > 0 &&
ctx->dump_hardware_entries_with_data[i].manufacturer != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].manufacturer,
ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].manufacturer,
ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.modelLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].model != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.modelLength > 0 &&
ctx->dump_hardware_entries_with_data[i].model != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].model,
ctx->dumpHardwareEntriesWithData[i].entry.modelLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.modelLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].model,
ctx->dump_hardware_entries_with_data[i].entry.modelLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.modelLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].revision != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.revisionLength > 0 &&
ctx->dump_hardware_entries_with_data[i].revision != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].revision,
ctx->dumpHardwareEntriesWithData[i].entry.revisionLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.revisionLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].revision,
ctx->dump_hardware_entries_with_data[i].entry.revisionLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.revisionLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].firmware != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength > 0 &&
ctx->dump_hardware_entries_with_data[i].firmware != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].firmware,
ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].firmware,
ctx->dump_hardware_entries_with_data[i].entry.firmwareLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.firmwareLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.serialLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].serial != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.serialLength > 0 &&
ctx->dump_hardware_entries_with_data[i].serial != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].serial,
ctx->dumpHardwareEntriesWithData[i].entry.serialLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.serialLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].serial,
ctx->dump_hardware_entries_with_data[i].entry.serialLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.serialLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].softwareName != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength > 0 &&
ctx->dump_hardware_entries_with_data[i].softwareName != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareName,
ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareName,
ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].softwareVersion != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength > 0 &&
ctx->dump_hardware_entries_with_data[i].softwareVersion != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareVersion,
ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareVersion,
ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength;
}
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem != NULL)
if(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength > 0 &&
ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem,
ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength;
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem,
ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength);
offset += ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength;
}
if(entry->extents > 0 && ctx->dumpHardwareEntriesWithData[i].extents != NULL)
if(entry->extents > 0 && ctx->dump_hardware_entries_with_data[i].extents != NULL)
{
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].extents, extent_bytes);
memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].extents, extent_bytes);
offset += extent_bytes;
}
}
// Calculate CRC64
ctx->dumpHardwareHeader.crc64 =
aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dumpHardwareHeader.length);
ctx->dump_hardware_header.crc64 =
aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dump_hardware_header.length);
// Copy header
memcpy(buffer, &ctx->dumpHardwareHeader, sizeof(DumpHardwareHeader));
memcpy(buffer, &ctx->dump_hardware_header, sizeof(DumpHardwareHeader));
TRACE("Exiting aaruf_get_dumphw() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
@@ -541,7 +541,7 @@ int32_t aaruf_set_dumphw(void *context, uint8_t *data, size_t length)
return AARUF_ERROR_NOT_AARUFORMAT;
}
aaruformatContext *ctx = context;
aaruformat_context *ctx = context;
// Not a libaaruformat context
if(ctx->magic != AARU_MAGIC)
@@ -553,7 +553,7 @@ int32_t aaruf_set_dumphw(void *context, uint8_t *data, size_t length)
}
// Check we are writing
if(!ctx->isWriting)
if(!ctx->is_writing)
{
FATAL("Trying to write a read-only image");
@@ -674,9 +674,9 @@ int32_t aaruf_set_dumphw(void *context, uint8_t *data, size_t length)
goto invalid_data;
}
free_dump_hardware_entries(ctx->dumpHardwareEntriesWithData, ctx->dumpHardwareHeader.entries);
ctx->dumpHardwareEntriesWithData = copy;
ctx->dumpHardwareHeader = header;
free_dump_hardware_entries(ctx->dump_hardware_entries_with_data, ctx->dump_hardware_header.entries);
ctx->dump_hardware_entries_with_data = copy;
ctx->dump_hardware_header = header;
TRACE("Exiting aaruf_set_dumphw() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;

4
src/index/index_v1.c
View File

@@ -76,7 +76,7 @@
* @warning The function assumes ctx->header.indexOffset points to a valid index block.
* Invalid offsets may cause file access errors or reading incorrect data.
*/
UT_array *process_index_v1(aaruformatContext *ctx)
UT_array *process_index_v1(aaruformat_context *ctx)
{
TRACE("Entering process_index_v1(%p)", ctx);
@@ -222,7 +222,7 @@ UT_array *process_index_v1(aaruformatContext *ctx)
* @warning CRC validation failure indicates potential data corruption and may suggest
* the image file is damaged or has been modified outside of library control.
*/
int32_t verify_index_v1(aaruformatContext *ctx)
int32_t verify_index_v1(aaruformat_context *ctx)
{
TRACE("Entering verify_index_v1(%p)", ctx);

4
src/index/index_v2.c
View File

@@ -78,7 +78,7 @@
* @warning The function assumes ctx->header.indexOffset points to a valid index block.
* Invalid offsets may cause file access errors or reading incorrect data.
*/
UT_array *process_index_v2(aaruformatContext *ctx)
UT_array *process_index_v2(aaruformat_context *ctx)
{
TRACE("Entering process_index_v2(%p)", ctx);
@@ -224,7 +224,7 @@ UT_array *process_index_v2(aaruformatContext *ctx)
* @warning CRC validation failure indicates potential data corruption and may suggest
* the image file is damaged or has been modified outside of library control.
*/
int32_t verify_index_v2(aaruformatContext *ctx)
int32_t verify_index_v2(aaruformat_context *ctx)
{
TRACE("Entering verify_index_v2(%p)", ctx);

8
src/index/index_v3.c
View File

@@ -27,7 +27,7 @@
#include "log.h"
#include "utarray.h"
static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries, const IndexEntry *subindex_entry);
static bool add_subindex_entries(aaruformat_context *ctx, UT_array *index_entries, const IndexEntry *subindex_entry);
/**
* @brief Processes an index block (version 3) from the image stream.
@@ -95,7 +95,7 @@ static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries
* @warning The function assumes ctx->header.indexOffset points to a valid index block.
* Invalid offsets may cause file access errors or reading incorrect data.
*/
UT_array *process_index_v3(aaruformatContext *ctx)
UT_array *process_index_v3(aaruformat_context *ctx)
{
TRACE("Entering process_index_v3(%p)", ctx);
@@ -244,7 +244,7 @@ UT_array *process_index_v3(aaruformatContext *ctx)
* @warning No validation is performed on individual IndexEntry contents - only
* structural validation of subindex headers is done.
*/
static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries, const IndexEntry *subindex_entry)
static bool add_subindex_entries(aaruformat_context *ctx, UT_array *index_entries, const IndexEntry *subindex_entry)
{
TRACE("Entering add_subindex_entries(%p, %p, %p)", ctx, index_entries, subindex_entry);
@@ -405,7 +405,7 @@ static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries
* @warning For complete integrity verification of hierarchical indexes, additional validation
* of subindex blocks may be required beyond this function's scope.
*/
int32_t verify_index_v3(aaruformatContext *ctx)
int32_t verify_index_v3(aaruformat_context *ctx)
{
TRACE("Entering verify_index_v3(%p)", ctx);

400
src/metadata.c
View File

File diff suppressed because it is too large Load Diff

88
src/open.c
View File

@@ -31,7 +31,7 @@
#include "log.h"
#include "utarray.h"
static void cleanup_open_failure(aaruformatContext *ctx)
static void cleanup_open_failure(aaruformat_context *ctx)
{
if(ctx == NULL) return;
@@ -127,13 +127,13 @@ static void cleanup_open_failure(aaruformatContext *ctx)
*/
void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
{
aaruformatContext *ctx = NULL;
int error_no = 0;
size_t read_bytes = 0;
long pos = 0;
int i = 0;
uint32_t signature = 0;
UT_array *index_entries = NULL;
aaruformat_context *ctx = NULL;
int error_no = 0;
size_t read_bytes = 0;
long pos = 0;
int i = 0;
uint32_t signature = 0;
UT_array *index_entries = NULL;
#ifdef USE_SLOG
#include "slog.h"
@@ -146,7 +146,7 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
TRACE("Entering aaruf_open(%s)", filepath);
TRACE("Allocating memory for context");
ctx = (aaruformatContext *)malloc(sizeof(aaruformatContext));
ctx = (aaruformat_context *)malloc(sizeof(aaruformat_context));
if(ctx == NULL)
{
@@ -157,7 +157,7 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
return NULL;
}
memset(ctx, 0, sizeof(aaruformatContext));
memset(ctx, 0, sizeof(aaruformat_context));
TRACE("Opening file %s", filepath);
ctx->imageStream = fopen(filepath, "rb");
@@ -267,29 +267,29 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
// Ensure it fits in the Application buffer (64 bytes including null terminator)
if(app_name_utf8_len < 64)
{
u_strToUTF8(ctx->imageInfo.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status);
u_strToUTF8(ctx->image_info.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status);
if(U_FAILURE(status))
{
TRACE("Error converting application name to UTF-8: %d, using raw bytes", status);
// Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64);
strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63);
memset(ctx->image_info.Application, 0, 64);
strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63);
}
}
else
{
TRACE("Application name too long for buffer, truncating");
u_strToUTF8(ctx->imageInfo.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status);
ctx->imageInfo.Application[63] = '\0';
u_strToUTF8(ctx->image_info.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status);
ctx->image_info.Application[63] = '\0';
}
}
else
{
TRACE("Error getting UTF-8 length: %d, using raw bytes", status);
// Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64);
strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63);
memset(ctx->image_info.Application, 0, 64);
strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63);
}
free(app_name_utf16);
@@ -298,20 +298,20 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
{
TRACE("Could not allocate memory for UTF-16 conversion, using raw bytes");
// Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64);
strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63);
memset(ctx->image_info.Application, 0, 64);
strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63);
}
// Set application version string directly in the fixed-size array
memset(ctx->imageInfo.ApplicationVersion, 0, 32);
sprintf(ctx->imageInfo.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion,
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->imageInfo.Version, 0, 32);
sprintf(ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
memset(ctx->image_info.Version, 0, 32);
sprintf(ctx->image_info.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
ctx->imageInfo.MediaType = ctx->header.mediaType;
ctx->image_info.MediaType = ctx->header.mediaType;
// Read the index header
TRACE("Reading index header at position %" PRIu64, ctx->header.indexOffset);
@@ -373,8 +373,8 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
entry->dataType, entry->offset);
}
bool found_user_data_ddt = false;
ctx->imageInfo.ImageSize = 0;
bool found_user_data_ddt = false;
ctx->image_info.ImageSize = 0;
for(i = 0; i < utarray_len(index_entries); i++)
{
IndexEntry *entry = utarray_eltptr(index_entries, i);
@@ -486,43 +486,43 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
return NULL;
}
ctx->imageInfo.CreationTime = ctx->header.creationTime;
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime;
ctx->imageInfo.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType);
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);
if(ctx->geometryBlock.identifier != GeometryBlock && ctx->imageInfo.MetadataMediaType == BlockMedia)
if(ctx->geometry_block.identifier != GeometryBlock && ctx->image_info.MetadataMediaType == BlockMedia)
{
ctx->Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->Heads = 16;
ctx->SectorsPerTrack = 63;
ctx->cylinders = (uint32_t)(ctx->image_info.Sectors / 16 / 63);
ctx->heads = 16;
ctx->sectors_per_track = 63;
}
// Initialize caches
TRACE("Initializing caches");
ctx->blockHeaderCache.cache = NULL;
ctx->blockCache.cache = NULL;
ctx->block_header_cache.cache = NULL;
ctx->block_cache.cache = NULL;
const uint64_t cache_divisor = (uint64_t)ctx->imageInfo.SectorSize * (1ULL << ctx->shift);
const uint64_t cache_divisor = (uint64_t)ctx->image_info.SectorSize * (1ULL << ctx->shift);
if(cache_divisor == 0)
{
ctx->blockHeaderCache.max_items = 0;
ctx->blockCache.max_items = 0;
ctx->block_header_cache.max_items = 0;
ctx->block_cache.max_items = 0;
}
else
{
ctx->blockHeaderCache.max_items = MAX_CACHE_SIZE / cache_divisor;
ctx->blockCache.max_items = ctx->blockHeaderCache.max_items;
ctx->block_header_cache.max_items = MAX_CACHE_SIZE / cache_divisor;
ctx->block_cache.max_items = ctx->block_header_cache.max_items;
}
// TODO: Cache tracks and sessions?
// Initialize ECC for Compact Disc
TRACE("Initializing ECC for Compact Disc");
ctx->eccCdContext = (CdEccContext *)aaruf_ecc_cd_init();
ctx->ecc_cd_context = (CdEccContext *)aaruf_ecc_cd_init();
ctx->magic = AARU_MAGIC;
ctx->libraryMajorVersion = LIBAARUFORMAT_MAJOR_VERSION;
ctx->libraryMinorVersion = LIBAARUFORMAT_MINOR_VERSION;
ctx->magic = AARU_MAGIC;
ctx->library_major_version = LIBAARUFORMAT_MAJOR_VERSION;
ctx->library_minor_version = LIBAARUFORMAT_MINOR_VERSION;
TRACE("Exiting aaruf_open() = %p", ctx);
return ctx;

202
src/read.c
View File

@@ -104,7 +104,7 @@ int32_t aaruf_read_media_tag(void *context, uint8_t *data, const int32_t tag, ui
return AARUF_ERROR_INCORRECT_DATA_SIZE;
}
const aaruformatContext *ctx = context;
const aaruformat_context *ctx = context;
// Not a libaaruformat context
if(ctx->magic != AARU_MAGIC)
@@ -254,17 +254,17 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
TRACE("Entering aaruf_read_sector(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, negative, data,
initial_length);
aaruformatContext *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;
uint8_t sector_status = 0;
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;
uint8_t sector_status = 0;
if(context == NULL)
{
@@ -293,7 +293,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(negative && sector_address > ctx->userDataDdtHeader.negative - 1)
if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
{
FATAL("Sector address out of bounds");
@@ -301,7 +301,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
}
if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1)
if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
{
FATAL("Sector address out of bounds");
@@ -309,7 +309,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
}
if(ctx->ddtVersion == 1)
if(ctx->ddt_version == 1)
{
if(negative)
{
@@ -319,7 +319,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
error_no = decode_ddt_entry_v1(ctx, sector_address, &offset, &block_offset, &sector_status);
}
else if(ctx->ddtVersion == 2)
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)
@@ -333,7 +333,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
// Partially written image... as we can't know the real sector size just assume it's common :/
if(sector_status == SectorStatusNotDumped)
{
*length = ctx->imageInfo.SectorSize;
*length = ctx->image_info.SectorSize;
TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_SECTOR_NOT_DUMPED");
return AARUF_STATUS_SECTOR_NOT_DUMPED;
@@ -341,7 +341,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
// Check if block header is cached
TRACE("Checking if block header is cached");
block_header = find_in_cache_uint64(&ctx->blockHeaderCache, block_offset);
block_header = find_in_cache_uint64(&ctx->block_header_cache, block_offset);
// Read block header
if(block_header == NULL)
@@ -378,7 +378,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
}
TRACE("Adding block header to cache");
add_to_cache_uint64(&ctx->blockHeaderCache, block_offset, block_header);
add_to_cache_uint64(&ctx->block_header_cache, block_offset, block_header);
}
else if(fseek(ctx->imageStream, block_offset + sizeof(BlockHeader), SEEK_SET) != 0)
{
@@ -399,7 +399,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
// Check if block is cached
TRACE("Checking if block is cached");
block = find_in_cache_uint64(&ctx->blockCache, block_offset);
block = find_in_cache_uint64(&ctx->block_cache, block_offset);
if(block != NULL)
{
@@ -582,7 +582,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg
// Add block to cache
TRACE("Adding block to cache");
add_to_cache_uint64(&ctx->blockCache, block_offset, block);
add_to_cache_uint64(&ctx->block_cache, block_offset, block);
memcpy(data, block + offset * block_header->sectorSize, block_header->sectorSize);
*length = block_header->sectorSize;
@@ -676,7 +676,7 @@ int32_t aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sec
return AARUF_ERROR_NOT_AARUFORMAT;
}
aaruformatContext *ctx = context;
aaruformat_context *ctx = context;
if(length == NULL)
{
@@ -695,7 +695,7 @@ int32_t aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sec
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Incorrect media type %d, expected OpticalDisc", ctx->imageInfo.XmlMediaType);
@@ -703,9 +703,9 @@ int32_t aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sec
return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
}
for(int i = 0; i < ctx->numberOfDataTracks; i++)
if(ctx->dataTracks[i].sequence == track)
return aaruf_read_sector(context, ctx->dataTracks[i].start + sector_address, false, data, length);
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);
TRACE("Track %d not found", track);
TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_TRACK_NOT_FOUND");
@@ -820,15 +820,15 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
TRACE("Entering aaruf_read_sector_long(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, data,
initial_length);
const aaruformatContext *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;
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)
{
@@ -857,7 +857,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(negative && sector_address > ctx->userDataDdtHeader.negative - 1)
if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
{
FATAL("Sector address out of bounds");
@@ -865,7 +865,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
}
if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1)
if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
{
FATAL("Sector address out of bounds");
@@ -877,21 +877,21 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
// Calculate positive or negative sector
if(negative)
corrected_sector_address -= ctx->userDataDdtHeader.negative;
corrected_sector_address -= ctx->user_data_ddt_header.negative;
else
corrected_sector_address += ctx->userDataDdtHeader.negative;
corrected_sector_address += ctx->user_data_ddt_header.negative;
switch(ctx->imageInfo.MetadataMediaType)
switch(ctx->image_info.MetadataMediaType)
{
case OpticalDisc:
if(ctx->imageInfo.MediaType == DVDROM || ctx->imageInfo.MediaType == PS2DVD ||
ctx->imageInfo.MediaType == SACD || ctx->imageInfo.MediaType == PS3DVD ||
ctx->imageInfo.MediaType == DVDR || ctx->imageInfo.MediaType == DVDRW ||
ctx->imageInfo.MediaType == DVDPR || ctx->imageInfo.MediaType == DVDPRW ||
ctx->imageInfo.MediaType == DVDPRWDL || ctx->imageInfo.MediaType == DVDRDL ||
ctx->imageInfo.MediaType == DVDPRDL || ctx->imageInfo.MediaType == DVDRAM ||
ctx->imageInfo.MediaType == DVDRWDL || ctx->imageInfo.MediaType == DVDDownload ||
ctx->imageInfo.MediaType == Nuon)
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)
@@ -967,7 +967,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
}
if((ctx->sector_suffix == NULL || ctx->sector_prefix == NULL) &&
(ctx->sectorSuffixCorrected == NULL || ctx->sectorPrefixCorrected == NULL))
(ctx->sector_suffix_corrected == NULL || ctx->sector_prefix_corrected == NULL))
return aaruf_read_sector(context, sector_address, negative, data, length);
bare_length = 0;
@@ -1010,11 +1010,11 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
trk_found = false;
for(i = 0; i < ctx->numberOfDataTracks; i++)
if(sector_address >= ctx->dataTracks[i].start && sector_address <= ctx->dataTracks[i].end)
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->dataTracks[i];
trk = ctx->data_tracks[i];
break;
}
@@ -1040,19 +1040,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
if(ctx->sector_prefix != NULL)
memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16);
else if(ctx->sectorPrefixDdt != NULL)
else if(ctx->sector_prefix_ddt != NULL)
{
if((ctx->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
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->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
else if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else
memcpy(data,
ctx->sectorPrefixCorrected +
((ctx->sectorPrefixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
ctx->sector_prefix_corrected +
((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
16);
}
else
@@ -1071,19 +1071,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
if(ctx->sector_suffix != NULL)
memcpy(data + 2064, ctx->sector_suffix + corrected_sector_address * 288, 288);
else if(ctx->sectorSuffixDdt != NULL)
else if(ctx->sector_suffix_ddt != NULL)
{
if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
{
aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, trk.type);
aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, trk.type);
res = AARUF_STATUS_OK;
}
else if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else
memcpy(data + 2064,
ctx->sectorSuffixCorrected +
((ctx->sectorSuffixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288,
ctx->sector_suffix_corrected +
((ctx->sector_suffix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288,
288);
}
else
@@ -1101,19 +1101,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
case CdMode2Form2:
if(ctx->sector_prefix != NULL)
memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16);
else if(ctx->sectorPrefixDdt != NULL)
else if(ctx->sector_prefix_ddt != NULL)
{
if((ctx->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == Correct)
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->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
else if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else
memcpy(data,
ctx->sectorPrefixCorrected +
((ctx->sectorPrefixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
ctx->sector_prefix_corrected +
((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
16);
}
else
@@ -1130,23 +1130,23 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
return res;
}
if(ctx->mode2_subheaders != NULL && ctx->sectorSuffixDdt != NULL)
if(ctx->mode2_subheaders != NULL && ctx->sector_suffix_ddt != NULL)
{
memcpy(data + 16, ctx->mode2_subheaders + corrected_sector_address * 8, 8);
if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form1Ok)
if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form1Ok)
{
memcpy(data + 24, bare_data, 2048);
aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, CdMode2Form1);
aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form1);
}
else if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok ||
(ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2NoCrc)
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->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok)
aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, CdMode2Form2);
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->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped)
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
@@ -1171,7 +1171,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
return AARUF_ERROR_INVALID_TRACK_FORMAT;
}
case BlockMedia:
switch(ctx->imageInfo.MediaType)
switch(ctx->image_info.MediaType)
{
case AppleFileWare:
case AppleProfile:
@@ -1182,7 +1182,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
if(ctx->sector_subchannel == NULL)
return aaruf_read_sector(context, sector_address, negative, data, length);
switch(ctx->imageInfo.MediaType)
switch(ctx->image_info.MediaType)
{
case AppleFileWare:
case AppleProfile:
@@ -1394,7 +1394,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Entering aaruf_read_sector_tag(%p, %" PRIu64 ", %d, %p, %u, %d)", context, sector_address, negative, buffer,
initial_length, tag);
const aaruformatContext *ctx = NULL;
const aaruformat_context *ctx = NULL;
if(context == NULL)
{
@@ -1423,7 +1423,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(negative && sector_address > ctx->userDataDdtHeader.negative - 1)
if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
{
FATAL("Sector address out of bounds");
@@ -1431,7 +1431,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
}
if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1)
if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1)
{
FATAL("Sector address out of bounds");
@@ -1443,14 +1443,14 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
// Calculate positive or negative sector
if(negative)
corrected_sector_address -= ctx->userDataDdtHeader.negative;
corrected_sector_address -= ctx->user_data_ddt_header.negative;
else
corrected_sector_address += ctx->userDataDdtHeader.negative;
corrected_sector_address += ctx->user_data_ddt_header.negative;
switch(tag)
{
case CdTrackFlags:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1465,10 +1465,10 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
return AARUF_ERROR_INCORRECT_DATA_SIZE;
}
for(int i = 0; i < ctx->tracksHeader.entries; i++)
if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end)
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->trackEntries[i].flags;
buffer[0] = ctx->track_entries[i].flags;
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
}
@@ -1476,7 +1476,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
FATAL("Track not found");
return AARUF_ERROR_TRACK_NOT_FOUND;
case CdTrackIsrc:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1491,10 +1491,10 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
return AARUF_ERROR_INCORRECT_DATA_SIZE;
}
for(int i = 0; i < ctx->tracksHeader.entries; i++)
if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end)
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->trackEntries[i].isrc, 12);
memcpy(buffer, ctx->track_entries[i].isrc, 12);
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
}
@@ -1502,7 +1502,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
FATAL("Track not found");
return AARUF_ERROR_TRACK_NOT_FOUND;
case CdSectorSubchannel:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1528,7 +1528,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case DvdCmi:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1554,7 +1554,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case DvdSectorInformation:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1580,7 +1580,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case DvdSectorNumber:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1606,7 +1606,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case DvdSectorIed:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1632,7 +1632,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case DvdSectorEdc:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1658,7 +1658,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case DvdTitleKeyDecrypted:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1684,7 +1684,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case AppleSonyTag:
if(ctx->imageInfo.MetadataMediaType != BlockMedia)
if(ctx->image_info.MetadataMediaType != BlockMedia)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1710,7 +1710,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case AppleProfileTag:
if(ctx->imageInfo.MetadataMediaType != BlockMedia)
if(ctx->image_info.MetadataMediaType != BlockMedia)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");
@@ -1736,7 +1736,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address
TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK;
case PriamDataTowerTag:
if(ctx->imageInfo.MetadataMediaType != BlockMedia)
if(ctx->image_info.MetadataMediaType != BlockMedia)
{
FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE");

24
src/verify.c
View File

@@ -131,18 +131,18 @@ int32_t aaruf_verify_image(void *context)
{
TRACE("Entering aaruf_verify_image(%p)", context);
aaruformatContext *ctx = NULL;
uint64_t crc64 = 0;
size_t read_bytes = 0;
void *buffer = NULL;
crc64_ctx *crc64_context = NULL;
BlockHeader block_header;
DdtHeader ddt_header;
DdtHeader2 ddt2_header;
TracksHeader tracks_header;
uint32_t signature = 0;
UT_array *index_entries = NULL;
int32_t status = AARUF_STATUS_OK;
aaruformat_context *ctx = NULL;
uint64_t crc64 = 0;
size_t read_bytes = 0;
void *buffer = NULL;
crc64_ctx *crc64_context = NULL;
BlockHeader block_header;
DdtHeader ddt_header;
DdtHeader2 ddt2_header;
TracksHeader tracks_header;
uint32_t signature = 0;
UT_array *index_entries = NULL;
int32_t status = AARUF_STATUS_OK;
if(context == NULL)
{

419
src/write.c
View File

File diff suppressed because it is too large Load Diff

52
tool/cli_compare.c
View File

@@ -28,18 +28,18 @@
int cli_compare(const char *path1, const char *path2)
{
aaruformatContext *ctx1 = NULL;
aaruformatContext *ctx2 = NULL;
uint8_t *buffer1 = NULL;
uint8_t *buffer2 = NULL;
uint32_t buffer1_length = 0;
uint32_t buffer2_length = 0;
uint64_t total_sectors = 0;
uint64_t different_sectors = 0;
uint64_t sectors_processed = 0;
int result = 0;
int32_t read_result1 = 0;
int32_t read_result2 = 0;
aaruformat_context *ctx1 = NULL;
aaruformat_context *ctx2 = NULL;
uint8_t *buffer1 = NULL;
uint8_t *buffer2 = NULL;
uint32_t buffer1_length = 0;
uint32_t buffer2_length = 0;
uint64_t total_sectors = 0;
uint64_t different_sectors = 0;
uint64_t sectors_processed = 0;
int result = 0;
int32_t read_result1 = 0;
int32_t read_result2 = 0;
printf("Opening first image: %s\n", path1);
ctx1 = aaruf_open(path1);
@@ -60,32 +60,32 @@ int cli_compare(const char *path1, const char *path2)
// Access image information through context structure
printf("\nImage Information:\n");
printf("Image 1: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx1->imageInfo.Sectors,
ctx1->imageInfo.SectorSize);
printf("Image 2: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx2->imageInfo.Sectors,
ctx2->imageInfo.SectorSize);
printf("Image 1: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx1->image_info.Sectors,
ctx1->image_info.SectorSize);
printf("Image 2: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx2->image_info.Sectors,
ctx2->image_info.SectorSize);
if(ctx1->imageInfo.Sectors != ctx2->imageInfo.Sectors)
if(ctx1->image_info.Sectors != ctx2->image_info.Sectors)
{
fprintf(stderr, "Warning: Images have different number of sectors\n");
total_sectors =
ctx1->imageInfo.Sectors < ctx2->imageInfo.Sectors ? ctx1->imageInfo.Sectors : ctx2->imageInfo.Sectors;
ctx1->image_info.Sectors < ctx2->image_info.Sectors ? ctx1->image_info.Sectors : ctx2->image_info.Sectors;
printf("Will compare first %llu sectors\n", (unsigned long long)total_sectors);
}
else { total_sectors = ctx1->imageInfo.Sectors; }
else { total_sectors = ctx1->image_info.Sectors; }
if(ctx1->imageInfo.SectorSize != ctx2->imageInfo.SectorSize)
if(ctx1->image_info.SectorSize != ctx2->image_info.SectorSize)
{
fprintf(stderr, "Error: Images have different sector sizes (%u vs %u)\n", ctx1->imageInfo.SectorSize,
ctx2->imageInfo.SectorSize);
fprintf(stderr, "Error: Images have different sector sizes (%u vs %u)\n", ctx1->image_info.SectorSize,
ctx2->image_info.SectorSize);
aaruf_close(ctx1);
aaruf_close(ctx2);
return -1;
}
// Allocate buffers for sector data
buffer1 = malloc(ctx1->imageInfo.SectorSize);
buffer2 = malloc(ctx2->imageInfo.SectorSize);
buffer1 = malloc(ctx1->image_info.SectorSize);
buffer2 = malloc(ctx2->image_info.SectorSize);
if(buffer1 == NULL || buffer2 == NULL)
{
fprintf(stderr, "Error: Could not allocate memory for sector buffers\n");
@@ -103,8 +103,8 @@ int cli_compare(const char *path1, const char *path2)
// Compare sectors
for(uint64_t sector = 0; sector < total_sectors; sector++)
{
buffer1_length = ctx1->imageInfo.SectorSize;
buffer2_length = ctx2->imageInfo.SectorSize;
buffer1_length = ctx1->image_info.SectorSize;
buffer2_length = ctx2->image_info.SectorSize;
read_result1 = aaruf_read_sector(ctx1, sector, false, buffer1, &buffer1_length);
read_result2 = aaruf_read_sector(ctx2, sector, false, buffer2, &buffer2_length);

195
tool/compare.c
View File

@@ -44,24 +44,24 @@ void draw_progress_bar(int row, int percent)
int compare(const char *path1, const char *path2)
{
int ret = AARUF_STATUS_OK;
aaruformatContext *ctx1 = NULL;
aaruformatContext *ctx2 = NULL;
bool imagesAreDifferent = false;
char *strBuffer = NULL;
UErrorCode u_error_code = U_ZERO_ERROR;
int lr = 0;
int rr = 0;
uintattr_t appVerColor = TB_WHITE;
uintattr_t imageVerColor = TB_WHITE;
uintattr_t mediaTypeColor = TB_WHITE;
uintattr_t creationTimeColor = TB_WHITE;
uintattr_t lastWrittenTimeColor = TB_WHITE;
uintattr_t partitionsColor = TB_WHITE;
uintattr_t sessionsColor = TB_WHITE;
uintattr_t sectorsColor = TB_WHITE;
uintattr_t sectorSizeColor = TB_WHITE;
uintattr_t versionColor = TB_WHITE;
int ret = AARUF_STATUS_OK;
aaruformat_context *ctx1 = NULL;
aaruformat_context *ctx2 = NULL;
bool imagesAreDifferent = false;
char *strBuffer = NULL;
UErrorCode u_error_code = U_ZERO_ERROR;
int lr = 0;
int rr = 0;
uintattr_t appVerColor = TB_WHITE;
uintattr_t imageVerColor = TB_WHITE;
uintattr_t mediaTypeColor = TB_WHITE;
uintattr_t creationTimeColor = TB_WHITE;
uintattr_t lastWrittenTimeColor = TB_WHITE;
uintattr_t partitionsColor = TB_WHITE;
uintattr_t sessionsColor = TB_WHITE;
uintattr_t sectorsColor = TB_WHITE;
uintattr_t sectorSizeColor = TB_WHITE;
uintattr_t versionColor = TB_WHITE;
// Initialize termbox2
if(tb_init() != 0) return 1;
@@ -229,8 +229,8 @@ int compare(const char *path1, const char *path2)
// Compare ImageInfo
u_error_code = U_ZERO_ERROR;
u_error_code = u_strCompare((const UChar *)ctx1->imageInfo.Application, -1,
(const UChar *)ctx2->imageInfo.Application, -1, false);
u_error_code = u_strCompare((const UChar *)ctx1->image_info.Application, -1,
(const UChar *)ctx2->image_info.Application, -1, false);
if(u_error_code != U_ZERO_ERROR) imagesAreDifferent = true;
// Current left row
@@ -238,73 +238,73 @@ int compare(const char *path1, const char *path2)
// Current right row
rr = 9;
if(ctx1->imageInfo.HasPartitions != ctx2->imageInfo.HasPartitions)
if(ctx1->image_info.HasPartitions != ctx2->image_info.HasPartitions)
{
imagesAreDifferent = true;
partitionsColor = TB_RED;
}
if(ctx1->imageInfo.HasSessions != ctx2->imageInfo.HasSessions)
if(ctx1->image_info.HasSessions != ctx2->image_info.HasSessions)
{
imagesAreDifferent = true;
sessionsColor = TB_RED;
}
if(ctx1->imageInfo.Sectors != ctx2->imageInfo.Sectors)
if(ctx1->image_info.Sectors != ctx2->image_info.Sectors)
{
imagesAreDifferent = true;
sectorsColor = TB_RED;
}
if(ctx1->imageInfo.SectorSize != ctx2->imageInfo.SectorSize)
if(ctx1->image_info.SectorSize != ctx2->image_info.SectorSize)
{
imagesAreDifferent = true;
sectorSizeColor = TB_RED;
}
if(ctx1->imageInfo.Version != ctx2->imageInfo.Version)
if(ctx1->image_info.Version != ctx2->image_info.Version)
{
imagesAreDifferent = true;
versionColor = TB_RED;
}
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Has partitions?: ");
tb_printf(19, lr++, partitionsColor, TB_BLUE, "%s", ctx1->imageInfo.HasPartitions ? "yes" : "no");
tb_printf(19, lr++, partitionsColor, TB_BLUE, "%s", ctx1->image_info.HasPartitions ? "yes" : "no");
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Has sessions?: ");
tb_printf(17, lr++, sessionsColor, TB_BLUE, "%s", ctx1->imageInfo.HasSessions ? "yes" : "no");
tb_printf(17, lr++, sessionsColor, TB_BLUE, "%s", ctx1->image_info.HasSessions ? "yes" : "no");
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Image size without headers: ");
tb_printf(30, lr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx1->imageInfo.ImageSize);
tb_printf(30, lr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx1->image_info.ImageSize);
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Image contains: ");
tb_printf(18, lr++, sectorsColor, TB_BLUE, "%llu sectors", ctx1->imageInfo.Sectors);
tb_printf(18, lr++, sectorsColor, TB_BLUE, "%llu sectors", ctx1->image_info.Sectors);
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Biggest sector is: ");
tb_printf(21, lr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx1->imageInfo.SectorSize);
tb_printf(21, lr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx1->image_info.SectorSize);
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Image version: ");
tb_printf(17, lr++, versionColor, TB_BLUE, "%s", ctx1->imageInfo.Version);
tb_printf(17, lr++, versionColor, TB_BLUE, "%s", ctx1->image_info.Version);
tb_present();
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Has partitions?: ");
tb_printf(mid_x + 19, rr++, partitionsColor, TB_BLUE, "%s", ctx2->imageInfo.HasPartitions ? "yes" : "no");
tb_printf(mid_x + 19, rr++, partitionsColor, TB_BLUE, "%s", ctx2->image_info.HasPartitions ? "yes" : "no");
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Has sessions?: ");
tb_printf(mid_x + 17, rr++, sessionsColor, TB_BLUE, "%s", ctx2->imageInfo.HasSessions ? "yes" : "no");
tb_printf(mid_x + 17, rr++, sessionsColor, TB_BLUE, "%s", ctx2->image_info.HasSessions ? "yes" : "no");
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Image size without headers: ");
tb_printf(mid_x + 30, rr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx2->imageInfo.ImageSize);
tb_printf(mid_x + 30, rr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx2->image_info.ImageSize);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Image contains: ");
tb_printf(mid_x + 18, rr++, sectorsColor, TB_BLUE, "%llu sectors", ctx2->imageInfo.Sectors);
tb_printf(mid_x + 18, rr++, sectorsColor, TB_BLUE, "%llu sectors", ctx2->image_info.Sectors);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Biggest sector is: ");
tb_printf(mid_x + 21, rr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx2->imageInfo.SectorSize);
tb_printf(mid_x + 21, rr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx2->image_info.SectorSize);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Image version: ");
tb_printf(mid_x + 17, rr++, versionColor, TB_BLUE, "%s", ctx2->imageInfo.Version);
tb_printf(mid_x + 17, rr++, versionColor, TB_BLUE, "%s", ctx2->image_info.Version);
tb_present();
if(ctx1->imageInfo.Application != NULL || ctx2->imageInfo.Application != NULL)
if(ctx1->image_info.Application != NULL || ctx2->image_info.Application != NULL)
{
strBuffer = malloc(65);
memset(strBuffer, 0, 65);
u_error_code = U_ZERO_ERROR; // Reset error code before conversion
ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx1->imageInfo.Application, 64, &u_error_code);
ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx1->image_info.Application, 64, &u_error_code);
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Application: ");
if(u_error_code == U_ZERO_ERROR) tb_printf(15, lr, TB_WHITE, TB_BLUE, "%s", strBuffer);
lr++;
memset(strBuffer, 0, 65);
u_error_code = U_ZERO_ERROR; // Reset error code before conversion
ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx2->imageInfo.Application, 64, &u_error_code);
ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx2->image_info.Application, 64, &u_error_code);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Application: ");
if(u_error_code == U_ZERO_ERROR) tb_printf(mid_x + 15, rr, TB_WHITE, TB_BLUE, "%s", strBuffer);
rr++;
@@ -313,155 +313,156 @@ int compare(const char *path1, const char *path2)
tb_present();
}
if(ctx1->imageInfo.ApplicationVersion != NULL || ctx2->imageInfo.ApplicationVersion != NULL)
if(ctx1->image_info.ApplicationVersion != NULL || ctx2->image_info.ApplicationVersion != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Application version: ");
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.ApplicationVersion);
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->image_info.ApplicationVersion);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Application version: ");
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->imageInfo.ApplicationVersion);
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->image_info.ApplicationVersion);
}
if(ctx1->Creator != NULL || ctx2->Creator != NULL)
if(ctx1->creator != NULL || ctx2->creator != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Creator: ");
tb_printf(11, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->Creator);
tb_printf(11, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->creator);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Creator: ");
tb_printf(mid_x + 11, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->Creator);
tb_printf(mid_x + 11, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->creator);
}
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Creation time: ");
tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->imageInfo.CreationTime);
tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->image_info.CreationTime);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Creation time: ");
tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->imageInfo.CreationTime);
tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->image_info.CreationTime);
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Last written time: ");
tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->imageInfo.LastModificationTime);
tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->image_info.LastModificationTime);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Last written time: ");
tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->imageInfo.LastModificationTime);
tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->image_info.LastModificationTime);
if(ctx1->Comments != NULL || ctx2->Comments != NULL)
if(ctx1->comments != NULL || ctx2->comments != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Comments: ");
tb_printf(12, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->Comments);
tb_printf(12, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->comments);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Comments: ");
tb_printf(mid_x + 12, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->Comments);
tb_printf(mid_x + 12, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->comments);
}
if(ctx1->MediaTitle != NULL || ctx2->MediaTitle != NULL)
if(ctx1->media_title != NULL || ctx2->media_title != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media title: ");
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaTitle);
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_title);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media title: ");
tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaTitle);
tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_title);
}
if(ctx1->MediaManufacturer != NULL || ctx2->MediaManufacturer != NULL)
if(ctx1->media_manufacturer != NULL || ctx2->media_manufacturer != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media manufacturer: ");
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaManufacturer);
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_manufacturer);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media manufacturer: ");
tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaManufacturer);
tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_manufacturer);
}
if(ctx1->MediaSerialNumber != NULL || ctx2->MediaSerialNumber != NULL)
if(ctx1->media_serial_number != NULL || ctx2->media_serial_number != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media serial number: ");
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaSerialNumber);
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_serial_number);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media serial number: ");
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaSerialNumber);
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_serial_number);
}
if(ctx1->MediaBarcode != NULL || ctx2->MediaBarcode != NULL)
if(ctx1->media_barcode != NULL || ctx2->media_barcode != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media barcode: ");
tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaBarcode);
tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_barcode);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media barcode: ");
tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaBarcode);
tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_barcode);
}
if(ctx1->MediaPartNumber != NULL || ctx2->MediaPartNumber != NULL)
if(ctx1->media_part_number != NULL || ctx2->media_part_number != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media part number: ");
tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaPartNumber);
tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_part_number);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media part number: ");
tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaPartNumber);
tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_part_number);
}
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media type: ");
tb_printf(14, lr++, TB_WHITE, TB_BLUE, "%u", ctx1->imageInfo.MediaType);
tb_printf(14, lr++, TB_WHITE, TB_BLUE, "%u", ctx1->image_info.MediaType);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media type: ");
tb_printf(mid_x + 14, rr++, TB_WHITE, TB_BLUE, "%u", ctx2->imageInfo.MediaType);
tb_printf(mid_x + 14, rr++, TB_WHITE, TB_BLUE, "%u", ctx2->image_info.MediaType);
if(ctx1->MediaSequence > 0 || ctx1->LastMediaSequence > 0 || ctx2->MediaSequence > 0 || ctx2->LastMediaSequence > 0)
if(ctx1->media_sequence > 0 || ctx1->last_media_sequence > 0 || ctx2->media_sequence > 0 ||
ctx2->last_media_sequence > 0)
{
tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media", ctx1->MediaSequence,
ctx1->LastMediaSequence);
tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media", ctx1->media_sequence,
ctx1->last_media_sequence);
tb_printf(mid_x + 2, rr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media",
ctx2->MediaSequence, ctx2->LastMediaSequence);
ctx2->media_sequence, ctx2->last_media_sequence);
}
if(ctx1->DriveManufacturer != NULL || ctx2->DriveManufacturer != NULL)
if(ctx1->drive_manufacturer != NULL || ctx2->drive_manufacturer != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive manufacturer: ");
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveManufacturer);
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_manufacturer);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive manufacturer: ");
tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveManufacturer);
tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_manufacturer);
}
if(ctx1->DriveModel != NULL || ctx2->DriveModel != NULL)
if(ctx1->drive_model != NULL || ctx2->drive_model != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive model: ");
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveModel);
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_model);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive model: ");
tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveModel);
tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_model);
}
if(ctx1->DriveSerialNumber != NULL || ctx2->DriveSerialNumber != NULL)
if(ctx1->drive_serial_number != NULL || ctx2->drive_serial_number != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive serial number: ");
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveSerialNumber);
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_serial_number);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive serial number: ");
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveSerialNumber);
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_serial_number);
}
if(ctx1->DriveFirmwareRevision != NULL || ctx2->DriveFirmwareRevision != NULL)
if(ctx1->drive_firmware_revision != NULL || ctx2->drive_firmware_revision != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive firmware revision: ");
tb_printf(27, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveFirmwareRevision);
tb_printf(27, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_firmware_revision);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive firmware revision: ");
tb_printf(mid_x + 27, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveFirmwareRevision);
tb_printf(mid_x + 27, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_firmware_revision);
}
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "XML media type: ");
tb_printf(18, lr++, TB_WHITE, TB_BLUE, "%d", ctx1->imageInfo.MetadataMediaType);
tb_printf(18, lr++, TB_WHITE, TB_BLUE, "%d", ctx1->image_info.MetadataMediaType);
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "XML media type: ");
tb_printf(mid_x + 18, rr++, TB_WHITE, TB_BLUE, "%d", ctx2->imageInfo.MetadataMediaType);
tb_printf(mid_x + 18, rr++, TB_WHITE, TB_BLUE, "%d", ctx2->image_info.MetadataMediaType);
if(ctx1->Cylinders > 0 || ctx1->Heads > 0 || ctx1->SectorsPerTrack > 0 || ctx2->Cylinders > 0 || ctx2->Heads > 0 ||
ctx2->SectorsPerTrack > 0)
if(ctx1->cylinders > 0 || ctx1->heads > 0 || ctx1->sectors_per_track > 0 || ctx2->cylinders > 0 ||
ctx2->heads > 0 || ctx2->sectors_per_track > 0)
{
tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media has %d cylinders, %d heads and %d sectors per track",
ctx1->Cylinders, ctx1->Heads, ctx1->SectorsPerTrack);
ctx1->cylinders, ctx1->heads, ctx1->sectors_per_track);
tb_printf(mid_x + 2, rr++, TB_WHITE | TB_BOLD, TB_BLUE,
"Media has %d cylinders, %d heads and %d sectors per track", ctx2->Cylinders, ctx2->Heads,
ctx2->SectorsPerTrack);
"Media has %d cylinders, %d heads and %d sectors per track", ctx2->cylinders, ctx2->heads,
ctx2->sectors_per_track);
}
tb_present();
lr++;
uint64_t sectors = ctx1->imageInfo.Sectors;
if(ctx2->imageInfo.Sectors < sectors) sectors = ctx2->imageInfo.Sectors;
uint64_t sectors = ctx1->image_info.Sectors;
if(ctx2->image_info.Sectors < sectors) sectors = ctx2->image_info.Sectors;
bool imageContentsAreDifferent = false;
uint32_t sectorSize = ctx1->imageInfo.SectorSize;
if(ctx2->imageInfo.SectorSize > sectorSize) sectorSize = ctx2->imageInfo.SectorSize;
uint32_t sectorSize = ctx1->image_info.SectorSize;
if(ctx2->image_info.SectorSize > sectorSize) sectorSize = ctx2->image_info.SectorSize;
uint8_t *buffer1 = malloc(sectorSize);
if(buffer1 == NULL)

18
tool/convert.c
View File

@@ -30,12 +30,12 @@
int convert(const char *input_path, const char *output_path)
{
aaruformatContext *input_ctx = NULL;
aaruformatContext *output_ctx = NULL;
int32_t res = 0;
uint32_t sector_size = 0;
uint64_t total_sectors = 0;
uint8_t *sector_data = NULL;
aaruformat_context *input_ctx = NULL;
aaruformat_context *output_ctx = NULL;
int32_t res = 0;
uint32_t sector_size = 0;
uint64_t total_sectors = 0;
uint8_t *sector_data = NULL;
printf("Converting image from %s to %s...\n", input_path, output_path);
@@ -48,8 +48,8 @@ int convert(const char *input_path, const char *output_path)
}
// Get image information from input
total_sectors = input_ctx->imageInfo.Sectors;
sector_size = input_ctx->imageInfo.SectorSize;
total_sectors = input_ctx->image_info.Sectors;
sector_size = input_ctx->image_info.SectorSize;
printf("Input image has %llu sectors of %u bytes each.\n", total_sectors, sector_size);
@@ -93,7 +93,7 @@ int convert(const char *input_path, const char *output_path)
free(app_name_utf16);
// Create output image
output_ctx = aaruf_create(output_path, input_ctx->imageInfo.MediaType, sector_size, total_sectors,
output_ctx = aaruf_create(output_path, input_ctx->image_info.MediaType, sector_size, total_sectors,
0, // negative sectors
0, // overflow sectors
NULL, // options

194
tool/info.c
View File

@@ -69,7 +69,7 @@ static const char *format_filetime(uint64_t filetime)
int info(const char *path)
{
aaruformatContext *ctx = NULL;
aaruformat_context *ctx = NULL;
char *strBuffer = NULL;
UErrorCode u_error_code = U_ZERO_ERROR;
uint i = 0;
@@ -86,7 +86,7 @@ int info(const char *path)
printf("AaruFormat context information:\n");
printf("Magic number: %8.8s\n", (char *)&ctx->magic);
printf("Library version: %d.%d\n", ctx->libraryMajorVersion, ctx->libraryMinorVersion);
printf("Library version: %d.%d\n", ctx->library_major_version, ctx->library_minor_version);
printf("AaruFormat header:\n");
printf("\tIdentifier: %8.8s\n", (char *)&ctx->header.identifier);
@@ -107,11 +107,11 @@ int info(const char *path)
if(ctx->sector_prefix != NULL) printf("Sector prefix array has been read.\n");
if(ctx->sectorPrefixCorrected != NULL) printf("Sector prefix corrected array has been read.\n");
if(ctx->sector_prefix_corrected != NULL) printf("Sector prefix corrected array has been read.\n");
if(ctx->sector_suffix != NULL) printf("Sector suffix array has been read.\n");
if(ctx->sectorSuffixCorrected != NULL) printf("Sector suffix corrected array has been read.\n");
if(ctx->sector_suffix_corrected != NULL) printf("Sector suffix corrected array has been read.\n");
if(ctx->sector_subchannel != NULL) printf("Sector subchannel array has been read.\n");
@@ -119,15 +119,15 @@ int info(const char *path)
printf("Shift is %d (%d bytes).\n", ctx->shift, 1 << ctx->shift);
if(ctx->inMemoryDdt) printf("User-data DDT resides in memory.\n");
if(ctx->in_memory_ddt) printf("User-data DDT resides in memory.\n");
if(ctx->userDataDdt != NULL) printf("User-data DDT has been read to memory.\n");
if(ctx->user_data_ddt != NULL) printf("User-data DDT has been read to memory.\n");
if(ctx->mappedMemoryDdtSize > 0) printf("Mapped memory DDT has %zu bytes", ctx->mappedMemoryDdtSize);
if(ctx->mapped_memory_ddt_size > 0) printf("Mapped memory DDT has %zu bytes", ctx->mapped_memory_ddt_size);
if(ctx->sectorPrefixDdt != NULL) printf("Sector prefix DDT has been read to memory.\n");
if(ctx->sector_prefix_ddt != NULL) printf("Sector prefix DDT has been read to memory.\n");
if(ctx->sectorPrefixDdt != NULL) printf("Sector suffix DDT has been read to memory.\n");
if(ctx->sector_prefix_ddt != NULL) printf("Sector suffix DDT has been read to memory.\n");
uint32_t cylinders = 0;
uint32_t heads = 0;
@@ -421,181 +421,183 @@ int info(const char *path)
}
// TODO: Table format?
if(ctx->tracksHeader.identifier == TracksBlock)
if(ctx->tracks_header.identifier == TracksBlock)
{
printf("Tracks block:\n");
for(i = 0; i < ctx->tracksHeader.entries; i++)
for(i = 0; i < ctx->tracks_header.entries; i++)
{
printf("\tTrack entry %d:\n", i);
printf("\t\tSequence: %d\n", ctx->trackEntries[i].sequence);
printf("\t\tType: %d\n", ctx->trackEntries[i].type);
printf("\t\tStart: %lld\n", ctx->trackEntries[i].start);
printf("\t\tEnd: %lld\n", ctx->trackEntries[i].end);
printf("\t\tPregap: %lld\n", ctx->trackEntries[i].pregap);
printf("\t\tSession: %d\n", ctx->trackEntries[i].session);
printf("\t\tISRC: %.13s\n", ctx->trackEntries[i].isrc);
printf("\t\tFlags: %d\n", ctx->trackEntries[i].flags);
printf("\t\tSequence: %d\n", ctx->track_entries[i].sequence);
printf("\t\tType: %d\n", ctx->track_entries[i].type);
printf("\t\tStart: %lld\n", ctx->track_entries[i].start);
printf("\t\tEnd: %lld\n", ctx->track_entries[i].end);
printf("\t\tPregap: %lld\n", ctx->track_entries[i].pregap);
printf("\t\tSession: %d\n", ctx->track_entries[i].session);
printf("\t\tISRC: %.13s\n", ctx->track_entries[i].isrc);
printf("\t\tFlags: %d\n", ctx->track_entries[i].flags);
}
}
if(ctx->cicmBlockHeader.identifier == CicmBlock)
if(ctx->cicm_block_header.identifier == CicmBlock)
{
printf("CICM block:\n");
printf("%s", ctx->cicmBlock);
printf("%s", ctx->cicm_block);
}
// TODO: Table format?
if(ctx->dumpHardwareHeader.identifier == DumpHardwareBlock)
if(ctx->dump_hardware_header.identifier == DumpHardwareBlock)
{
printf("Dump hardware block:\n");
for(i = 0; i < ctx->dumpHardwareHeader.entries; i++)
for(i = 0; i < ctx->dump_hardware_header.entries; i++)
{
printf("\tDump hardware entry %d\n", i);
if(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength + 1);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength,
(char *)ctx->dumpHardwareEntriesWithData[i].manufacturer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength, &u_error_code);
(int)ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength,
(char *)ctx->dump_hardware_entries_with_data[i].manufacturer,
(int)ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength, &u_error_code);
printf("\t\tManufacturer: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.modelLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.modelLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.modelLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.modelLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.modelLength,
(char *)ctx->dumpHardwareEntriesWithData[i].model,
(int)ctx->dumpHardwareEntriesWithData[i].entry.modelLength, &u_error_code);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.modelLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.modelLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dump_hardware_entries_with_data[i].entry.modelLength,
(char *)ctx->dump_hardware_entries_with_data[i].model,
(int)ctx->dump_hardware_entries_with_data[i].entry.modelLength, &u_error_code);
printf("\t\tModel: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.revisionLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.revisionLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.revisionLength,
(char *)ctx->dumpHardwareEntriesWithData[i].revision,
(int)ctx->dumpHardwareEntriesWithData[i].entry.revisionLength, &u_error_code);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.revisionLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.revisionLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dump_hardware_entries_with_data[i].entry.revisionLength,
(char *)ctx->dump_hardware_entries_with_data[i].revision,
(int)ctx->dump_hardware_entries_with_data[i].entry.revisionLength, &u_error_code);
printf("\t\tRevision: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength,
(char *)ctx->dumpHardwareEntriesWithData[i].firmware,
(int)ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength, &u_error_code);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.firmwareLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dump_hardware_entries_with_data[i].entry.firmwareLength,
(char *)ctx->dump_hardware_entries_with_data[i].firmware,
(int)ctx->dump_hardware_entries_with_data[i].entry.firmwareLength, &u_error_code);
printf("\t\tFirmware version: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.serialLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.serialLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.serialLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.serialLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.serialLength,
(char *)ctx->dumpHardwareEntriesWithData[i].serial,
(int)ctx->dumpHardwareEntriesWithData[i].entry.serialLength, &u_error_code);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.serialLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.serialLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dump_hardware_entries_with_data[i].entry.serialLength,
(char *)ctx->dump_hardware_entries_with_data[i].serial,
(int)ctx->dump_hardware_entries_with_data[i].entry.serialLength, &u_error_code);
printf("\t\tSerial number: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength + 1);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength,
(char *)ctx->dumpHardwareEntriesWithData[i].softwareName,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength, &u_error_code);
(int)ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength,
(char *)ctx->dump_hardware_entries_with_data[i].softwareName,
(int)ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength, &u_error_code);
printf("\t\tSoftware name: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength + 1);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength,
(char *)ctx->dumpHardwareEntriesWithData[i].softwareVersion,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength, &u_error_code);
(int)ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength,
(char *)ctx->dump_hardware_entries_with_data[i].softwareVersion,
(int)ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength, &u_error_code);
printf("\t\tSoftware version: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength > 0)
if(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength > 0)
{
strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength + 1);
strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + 1);
memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength,
(char *)ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength,
(int)ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength,
(char *)ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem,
(int)ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength,
&u_error_code);
printf("\t\tSoftware operating system: %s\n", strBuffer);
free(strBuffer);
}
for(uint j = 0; j < ctx->dumpHardwareEntriesWithData[i].entry.extents; j++)
for(uint j = 0; j < ctx->dump_hardware_entries_with_data[i].entry.extents; j++)
{
printf("\t\tExtent %d:\n", j);
printf("\t\t\tStart: %llu\n", ctx->dumpHardwareEntriesWithData[i].extents[j].start);
printf("\t\t\tEnd: %llu\n", ctx->dumpHardwareEntriesWithData[i].extents[j].end);
printf("\t\t\tStart: %llu\n", ctx->dump_hardware_entries_with_data[i].extents[j].start);
printf("\t\t\tEnd: %llu\n", ctx->dump_hardware_entries_with_data[i].extents[j].end);
}
}
}
if(ctx->eccCdContext != NULL) printf("CD ECC has been initialized.\n");
if(ctx->ecc_cd_context != NULL) printf("CD ECC has been initialized.\n");
printf("There are %d data tracks.\n", ctx->numberOfDataTracks);
printf("There are %d data tracks.\n", ctx->number_of_data_tracks);
// TODO: ctx->readableSectorTags;
if(ctx->blockHeaderCache.max_items > 0)
if(ctx->block_header_cache.max_items > 0)
{
if(ctx->blockHeaderCache.cache != NULL) printf("Block header cache has been initialized.\n");
printf("Block header cache can contain a maximum of %llu items.\n", ctx->blockHeaderCache.max_items);
if(ctx->block_header_cache.cache != NULL) printf("Block header cache has been initialized.\n");
printf("Block header cache can contain a maximum of %llu items.\n", ctx->block_header_cache.max_items);
}
if(ctx->blockCache.max_items > 0)
if(ctx->block_cache.max_items > 0)
{
if(ctx->blockCache.cache != NULL) printf("Block cache has been initialized.\n");
printf("Block cache can contain a maximum of %llu items.\n", ctx->blockCache.max_items);
if(ctx->block_cache.cache != NULL) printf("Block cache has been initialized.\n");
printf("Block cache can contain a maximum of %llu items.\n", ctx->block_cache.max_items);
}
printf("Aaru's ImageInfo:\n");
printf("\tHas partitions?: %s\n", ctx->imageInfo.HasPartitions ? "yes" : "no");
printf("\tHas sessions?: %s\n", ctx->imageInfo.HasSessions ? "yes" : "no");
printf("\tImage size without headers: %llu bytes\n", ctx->imageInfo.ImageSize);
printf("\tImage contains %llu sectors\n", ctx->imageInfo.Sectors);
printf("\tBiggest sector is %d bytes\n", ctx->imageInfo.SectorSize);
printf("\tImage version: %s\n", ctx->imageInfo.Version);
printf("\tHas partitions?: %s\n", ctx->image_info.HasPartitions ? "yes" : "no");
printf("\tHas sessions?: %s\n", ctx->image_info.HasSessions ? "yes" : "no");
printf("\tImage size without headers: %llu bytes\n", ctx->image_info.ImageSize);
printf("\tImage contains %llu sectors\n", ctx->image_info.Sectors);
printf("\tBiggest sector is %d bytes\n", ctx->image_info.SectorSize);
printf("\tImage version: %s\n", ctx->image_info.Version);
if(ctx->imageInfo.Application != NULL)
if(ctx->image_info.Application != NULL)
{
strBuffer = malloc(65);
memset(strBuffer, 0, 65);
ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx->imageInfo.Application, 64, &u_error_code);
ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx->image_info.Application, 64, &u_error_code);
if(u_error_code == U_ZERO_ERROR) printf("\tApplication: %s\n", strBuffer);
free(strBuffer);
}
if(ctx->imageInfo.ApplicationVersion != NULL)
printf("\tApplication version: %s\n", ctx->imageInfo.ApplicationVersion);
printf("\tCreation time: %s\n", format_filetime(ctx->imageInfo.CreationTime));
printf("\tLast written time: %s\n", format_filetime(ctx->imageInfo.LastModificationTime));
printf("\tMedia type: %u (%s)\n", ctx->imageInfo.MediaType, media_type_to_string(ctx->imageInfo.MediaType));
printf("\tXML media type: %d\n", ctx->imageInfo.MetadataMediaType);
if(ctx->image_info.ApplicationVersion != NULL)
printf("\tApplication version: %s\n", ctx->image_info.ApplicationVersion);
printf("\tCreation time: %s\n", format_filetime(ctx->image_info.CreationTime));
printf("\tLast written time: %s\n", format_filetime(ctx->image_info.LastModificationTime));
printf("\tMedia type: %u (%s)\n", ctx->image_info.MediaType, media_type_to_string(ctx->image_info.MediaType));
printf("\tXML media type: %d\n", ctx->image_info.MetadataMediaType);
if(ctx->checksums.hasMd5)
{

16
tool/read.c
View File

@@ -26,10 +26,10 @@
int read(const unsigned long long sector_no, const char *path)
{
aaruformatContext *ctx = NULL;
int32_t res = 0;
uint32_t length = 0;
uint8_t *data = NULL;
aaruformat_context *ctx = NULL;
int32_t res = 0;
uint32_t length = 0;
uint8_t *data = NULL;
ctx = aaruf_open(path);
@@ -78,10 +78,10 @@ int read(const unsigned long long sector_no, const char *path)
int read_long(const unsigned long long sector_no, const char *path)
{
aaruformatContext *ctx = NULL;
int32_t res = 0;
uint32_t length = 0;
uint8_t *data = NULL;
aaruformat_context *ctx = NULL;
int32_t res = 0;
uint32_t length = 0;
uint8_t *data = NULL;
ctx = aaruf_open(path);

24
tool/verify.c
View File

@@ -25,8 +25,8 @@
int verify(const char *path)
{
aaruformatContext *ctx = NULL;
uint32_t res = 0;
aaruformat_context *ctx = NULL;
uint32_t res = 0;
ctx = aaruf_open(path);
@@ -50,13 +50,13 @@ int verify(const char *path)
int verify_sectors(const char *path)
{
aaruformatContext *ctx = NULL;
uint8_t *buffer = NULL;
uint32_t buffer_len = 2352;
int32_t res = 0;
CdEccContext *cd_ecc_context = NULL;
ctx = aaruf_open(path);
bool verify_result = false;
aaruformat_context *ctx = NULL;
uint8_t *buffer = NULL;
uint32_t buffer_len = 2352;
int32_t res = 0;
CdEccContext *cd_ecc_context = NULL;
ctx = aaruf_open(path);
bool verify_result = false;
bool has_edc = false, has_ecc_p = false, ecc_p_correct = false, has_ecc_q = false, ecc_q_correct = false;
bool edc_correct = false;
bool unknown = false;
@@ -69,7 +69,7 @@ int verify_sectors(const char *path)
return errno;
}
if(ctx->imageInfo.MetadataMediaType != OpticalDisc)
if(ctx->image_info.MetadataMediaType != OpticalDisc)
{
printf("Image sectors do not contain checksums, cannot verify.\n");
return 0;
@@ -80,7 +80,7 @@ int verify_sectors(const char *path)
unknowns = 0;
any_error = false;
for(uint64_t s = 0; s < ctx->imageInfo.Sectors; s++)
for(uint64_t s = 0; s < ctx->image_info.Sectors; s++)
{
printf("\rVerifying sector %llu...", s);
res = aaruf_read_sector_long(ctx, s, buffer, false, &buffer_len);
@@ -118,7 +118,7 @@ int verify_sectors(const char *path)
else
printf("\rAll sector checksums are correct.\n");
printf("Total sectors........... %llu\n", ctx->imageInfo.Sectors);
printf("Total sectors........... %llu\n", ctx->image_info.Sectors);
printf("Total errors............ %llu\n", errors);
printf("Total unknowns.......... %llu\n", unknowns);
printf("Total errors+unknowns... %llu\n", errors + unknowns);