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

2
src/blocks/checksum.c
View File

@@ -36,7 +36,7 @@
* @param ctx Pointer to the aaruformat context. * @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the checksum block. * @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); 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. * 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); TRACE("Entering process_data_block(%p, %p)", ctx, entry);
BlockHeader block_header; BlockHeader block_header;
@@ -119,15 +119,15 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
} }
ctx->imageInfo.ImageSize += block_header.cmpLength; ctx->image_info.ImageSize += block_header.cmpLength;
// Unused, skip // Unused, skip
if(entry->dataType == UserData) 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); 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"); TRACE("Exiting process_data_block() = AARUF_STATUS_OK");
@@ -339,7 +339,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
{ {
case CdSectorPrefix: case CdSectorPrefix:
case CdSectorPrefixCorrected: case CdSectorPrefixCorrected:
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixCorrected = data; } if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_corrected = data; }
else else
ctx->sector_prefix = data; ctx->sector_prefix = data;
@@ -350,7 +350,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
case CdSectorSuffix: case CdSectorSuffix:
case CdSectorSuffixCorrected: case CdSectorSuffixCorrected:
if(entry->dataType == CdSectorSuffixCorrected) if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixCorrected = data; ctx->sector_suffix_corrected = data;
else else
ctx->sector_suffix = data; 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; if(ctx == NULL) return;
free_dump_hardware_entries_array(ctx->dumpHardwareEntriesWithData, ctx->dumpHardwareHeader.entries); free_dump_hardware_entries_array(ctx->dump_hardware_entries_with_data, ctx->dump_hardware_header.entries);
free(ctx->dumpHardwareEntriesWithData); free(ctx->dump_hardware_entries_with_data);
ctx->dumpHardwareEntriesWithData = NULL; ctx->dump_hardware_entries_with_data = NULL;
memset(&ctx->dumpHardwareHeader, 0, sizeof(ctx->dumpHardwareHeader)); 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, 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 ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the dump hardware block. * @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); TRACE("Entering process_dumphw_block(%p, %p)", ctx, entry);
size_t read_bytes = 0; size_t read_bytes = 0;
@@ -214,7 +214,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(header.entries == 0) if(header.entries == 0)
{ {
reset_dump_hardware_context(ctx); reset_dump_hardware_context(ctx);
ctx->dumpHardwareHeader = header; ctx->dump_hardware_header = header;
TRACE("Dump hardware block contains no entries. Clearing existing metadata."); TRACE("Dump hardware block contains no entries. Clearing existing metadata.");
TRACE("Exiting process_dumphw_block()"); TRACE("Exiting process_dumphw_block()");
return; return;
@@ -336,8 +336,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
} }
reset_dump_hardware_context(ctx); reset_dump_hardware_context(ctx);
ctx->dumpHardwareEntriesWithData = entries; ctx->dump_hardware_entries_with_data = entries;
ctx->dumpHardwareHeader = header; ctx->dump_hardware_header = header;
if(remaining_payload != 0) if(remaining_payload != 0)
{ {

285
src/blocks/metadata.c
View File

@@ -32,7 +32,7 @@
* @param ctx Pointer to the aaruformat context. * @param ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the metadata block. * @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); TRACE("Entering process_metadata_block(%p, %p)", ctx, entry);
int pos = 0; 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 // Even if those two checks shall have been done before
TRACE("Reading metadata block header at position %" PRIu64, entry->offset); 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)) 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..."); FATAL("Could not read metadata block header, continuing...");
TRACE("Exiting process_metadata_block()"); TRACE("Exiting process_metadata_block()");
return; 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("Incorrect identifier for data block at position %" PRIu64 "", entry->offset);
TRACE("Exiting process_metadata_block()"); TRACE("Exiting process_metadata_block()");
return; 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..."); FATAL("Could not allocate memory for metadata block, continuing...");
TRACE("Exiting process_metadata_block()"); TRACE("Exiting process_metadata_block()");
return; 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)); 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)); memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader));
free(ctx->metadataBlock); free(ctx->metadata_block);
FATAL("Could not read metadata block, continuing..."); 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->media_sequence = ctx->metadata_block_header.mediaSequence;
ctx->LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence; ctx->last_media_sequence = ctx->metadata_block_header.lastMediaSequence;
TRACE("Setting media sequence as %d of %d", ctx->MediaSequence, ctx->LastMediaSequence); TRACE("Setting media sequence as %d of %d", ctx->media_sequence, ctx->last_media_sequence);
} }
if(ctx->metadataBlockHeader.creatorLength > 0 && if(ctx->metadata_block_header.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <= ctx->metadata_block_header.creatorOffset + ctx->metadata_block_header.creatorLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength); ctx->creator = (uint8_t *)malloc(ctx->metadata_block_header.creatorLength);
if(ctx->Creator != NULL) if(ctx->creator != NULL)
memcpy(ctx->Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset, memcpy(ctx->creator, ctx->metadata_block + ctx->metadata_block_header.creatorOffset,
ctx->metadataBlockHeader.creatorLength); ctx->metadata_block_header.creatorLength);
} }
if(ctx->metadataBlockHeader.commentsLength > 0 && if(ctx->metadata_block_header.commentsLength > 0 &&
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <= ctx->metadata_block_header.commentsOffset + ctx->metadata_block_header.commentsLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength); ctx->comments = (uint8_t *)malloc(ctx->metadata_block_header.commentsLength);
if(ctx->Comments != NULL) if(ctx->comments != NULL)
memcpy(ctx->Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset, memcpy(ctx->comments, ctx->metadata_block + ctx->metadata_block_header.commentsOffset,
ctx->metadataBlockHeader.commentsLength); ctx->metadata_block_header.commentsLength);
} }
if(ctx->metadataBlockHeader.mediaTitleLength > 0 && if(ctx->metadata_block_header.mediaTitleLength > 0 &&
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <= ctx->metadata_block_header.mediaTitleOffset + ctx->metadata_block_header.mediaTitleLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength); ctx->media_title = (uint8_t *)malloc(ctx->metadata_block_header.mediaTitleLength);
if(ctx->MediaTitle != NULL) if(ctx->media_title != NULL)
memcpy(ctx->MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset, memcpy(ctx->media_title, ctx->metadata_block + ctx->metadata_block_header.mediaTitleOffset,
ctx->metadataBlockHeader.mediaTitleLength); ctx->metadata_block_header.mediaTitleLength);
} }
if(ctx->metadataBlockHeader.mediaManufacturerLength > 0 && if(ctx->metadata_block_header.mediaManufacturerLength > 0 &&
ctx->metadataBlockHeader.mediaManufacturerOffset + ctx->metadataBlockHeader.mediaManufacturerLength <= ctx->metadata_block_header.mediaManufacturerOffset + ctx->metadata_block_header.mediaManufacturerLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength); ctx->media_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.mediaManufacturerLength);
if(ctx->MediaManufacturer != NULL) if(ctx->media_manufacturer != NULL)
memcpy(ctx->MediaManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset, memcpy(ctx->media_manufacturer, ctx->metadata_block + ctx->metadata_block_header.mediaManufacturerOffset,
ctx->metadataBlockHeader.mediaManufacturerLength); ctx->metadata_block_header.mediaManufacturerLength);
} }
if(ctx->metadataBlockHeader.mediaModelLength > 0 && if(ctx->metadata_block_header.mediaModelLength > 0 &&
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <= ctx->metadata_block_header.mediaModelOffset + ctx->metadata_block_header.mediaModelLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength); ctx->media_model = (uint8_t *)malloc(ctx->metadata_block_header.mediaModelLength);
if(ctx->MediaModel != NULL) if(ctx->media_model != NULL)
memcpy(ctx->MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset, memcpy(ctx->media_model, ctx->metadata_block + ctx->metadata_block_header.mediaModelOffset,
ctx->metadataBlockHeader.mediaModelLength); ctx->metadata_block_header.mediaModelLength);
} }
if(ctx->metadataBlockHeader.mediaSerialNumberLength > 0 && if(ctx->metadata_block_header.mediaSerialNumberLength > 0 &&
ctx->metadataBlockHeader.mediaSerialNumberOffset + ctx->metadataBlockHeader.mediaSerialNumberLength <= ctx->metadata_block_header.mediaSerialNumberOffset + ctx->metadata_block_header.mediaSerialNumberLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength); ctx->media_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaSerialNumberLength);
if(ctx->MediaSerialNumber != NULL) if(ctx->media_serial_number != NULL)
memcpy(ctx->MediaSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset, memcpy(ctx->media_serial_number, ctx->metadata_block + ctx->metadata_block_header.mediaSerialNumberOffset,
ctx->metadataBlockHeader.mediaSerialNumberLength); ctx->metadata_block_header.mediaSerialNumberLength);
} }
if(ctx->metadataBlockHeader.mediaBarcodeLength > 0 && if(ctx->metadata_block_header.mediaBarcodeLength > 0 &&
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <= ctx->metadata_block_header.mediaBarcodeOffset + ctx->metadata_block_header.mediaBarcodeLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength); ctx->media_barcode = (uint8_t *)malloc(ctx->metadata_block_header.mediaBarcodeLength);
if(ctx->MediaBarcode != NULL) if(ctx->media_barcode != NULL)
memcpy(ctx->MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset, memcpy(ctx->media_barcode, ctx->metadata_block + ctx->metadata_block_header.mediaBarcodeOffset,
ctx->metadataBlockHeader.mediaBarcodeLength); ctx->metadata_block_header.mediaBarcodeLength);
} }
if(ctx->metadataBlockHeader.mediaPartNumberLength > 0 && if(ctx->metadata_block_header.mediaPartNumberLength > 0 &&
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <= ctx->metadata_block_header.mediaPartNumberOffset + ctx->metadata_block_header.mediaPartNumberLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength); ctx->media_part_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaPartNumberLength);
if(ctx->MediaPartNumber != NULL) if(ctx->media_part_number != NULL)
memcpy(ctx->MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset, memcpy(ctx->media_part_number, ctx->metadata_block + ctx->metadata_block_header.mediaPartNumberOffset,
ctx->metadataBlockHeader.mediaPartNumberLength); ctx->metadata_block_header.mediaPartNumberLength);
} }
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 && if(ctx->metadata_block_header.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveManufacturerOffset + ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadata_block_header.driveManufacturerOffset + ctx->metadata_block_header.driveManufacturerLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength); ctx->drive_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.driveManufacturerLength);
if(ctx->DriveManufacturer != NULL) if(ctx->drive_manufacturer != NULL)
memcpy(ctx->DriveManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset, memcpy(ctx->drive_manufacturer, ctx->metadata_block + ctx->metadata_block_header.driveManufacturerOffset,
ctx->metadataBlockHeader.driveManufacturerLength); ctx->metadata_block_header.driveManufacturerLength);
} }
if(ctx->metadataBlockHeader.driveModelLength > 0 && if(ctx->metadata_block_header.driveModelLength > 0 &&
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <= ctx->metadata_block_header.driveModelOffset + ctx->metadata_block_header.driveModelLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength); ctx->drive_model = (uint8_t *)malloc(ctx->metadata_block_header.driveModelLength);
if(ctx->DriveModel != NULL) if(ctx->drive_model != NULL)
memcpy(ctx->DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset, memcpy(ctx->drive_model, ctx->metadata_block + ctx->metadata_block_header.driveModelOffset,
ctx->metadataBlockHeader.driveModelLength); ctx->metadata_block_header.driveModelLength);
} }
if(ctx->metadataBlockHeader.driveSerialNumberLength > 0 && if(ctx->metadata_block_header.driveSerialNumberLength > 0 &&
ctx->metadataBlockHeader.driveSerialNumberOffset + ctx->metadataBlockHeader.driveSerialNumberLength <= ctx->metadata_block_header.driveSerialNumberOffset + ctx->metadata_block_header.driveSerialNumberLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.blockSize)
{ {
ctx->DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength); ctx->drive_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.driveSerialNumberLength);
if(ctx->DriveSerialNumber != NULL) if(ctx->drive_serial_number != NULL)
memcpy(ctx->DriveSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset, memcpy(ctx->drive_serial_number, ctx->metadata_block + ctx->metadata_block_header.driveSerialNumberOffset,
ctx->metadataBlockHeader.driveSerialNumberLength); ctx->metadata_block_header.driveSerialNumberLength);
} }
if(ctx->metadataBlockHeader.driveFirmwareRevisionLength > 0 && if(ctx->metadata_block_header.driveFirmwareRevisionLength > 0 &&
ctx->metadataBlockHeader.driveFirmwareRevisionOffset + ctx->metadataBlockHeader.driveFirmwareRevisionLength <= ctx->metadata_block_header.driveFirmwareRevisionOffset +
ctx->metadataBlockHeader.blockSize) ctx->metadata_block_header.driveFirmwareRevisionLength <=
ctx->metadata_block_header.blockSize)
{ {
ctx->DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength); ctx->drive_firmware_revision = (uint8_t *)malloc(ctx->metadata_block_header.driveFirmwareRevisionLength);
if(ctx->DriveFirmwareRevision != NULL) if(ctx->drive_firmware_revision != NULL)
memcpy(ctx->DriveFirmwareRevision, memcpy(ctx->drive_firmware_revision,
ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionOffset, ctx->metadata_block + ctx->metadata_block_header.driveFirmwareRevisionOffset,
ctx->metadataBlockHeader.driveFirmwareRevisionLength); ctx->metadata_block_header.driveFirmwareRevisionLength);
} }
TRACE("Exiting process_metadata_block()"); 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 ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the geometry block. * @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); TRACE("Entering process_geometry_block(%p, %p)", ctx, entry);
size_t read_bytes = 0; 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); 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)) 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..."); TRACE("Could not read geometry block header, continuing...");
return; 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); TRACE("Incorrect identifier for geometry block at position %" PRIu64 "", entry->offset);
return; 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, TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometry_block.cylinders,
ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack); ctx->geometry_block.heads, ctx->geometry_block.sectorsPerTrack);
ctx->Cylinders = ctx->geometryBlock.cylinders; ctx->cylinders = ctx->geometry_block.cylinders;
ctx->Heads = ctx->geometryBlock.heads; ctx->heads = ctx->geometry_block.heads;
ctx->SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack; ctx->sectors_per_track = ctx->geometry_block.sectorsPerTrack;
TRACE("Exiting process_geometry_block()"); 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 ctx Pointer to the aaruformat context.
* @param entry Pointer to the index entry describing the CICM block. * @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); TRACE("Entering process_cicm_block(%p, %p)", ctx, entry);
int pos = 0; 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 // Even if those two checks shall have been done before
TRACE("Reading CICM XML metadata block header at position %" PRIu64, entry->offset); 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)) 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..."); TRACE("Could not read CICM XML metadata header, continuing...");
return; 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); 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("Could not allocate memory for CICM XML metadata block, continuing...");
TRACE("Exiting process_cicm_block()"); TRACE("Exiting process_cicm_block()");
return; 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)); 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)); memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock));
free(ctx->cicmBlock); free(ctx->cicm_block);
TRACE("Could not read CICM XML metadata block, continuing..."); TRACE("Could not read CICM XML metadata block, continuing...");
} }
@@ -466,7 +467,7 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
* *
* @internal * @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); TRACE("Entering process_aaru_metadata_json_block(%p, %p)", ctx, entry);
int pos = 0; 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 // Even if those two checks shall have been done before
TRACE("Reading Aaru metadata JSON block header at position %" PRIu64, entry->offset); 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)) 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..."); TRACE("Could not read Aaru metadata JSON header, continuing...");
return; 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); 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("Could not allocate memory for Aaru metadata JSON block, continuing...");
TRACE("Exiting process_aaru_metadata_json_block()"); TRACE("Exiting process_aaru_metadata_json_block()");
return; 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)); 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)); memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader));
free(ctx->jsonBlock); free(ctx->json_block);
TRACE("Could not read Aaru metadata JSON block, continuing..."); 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_get_tracks()
* @see aaruf_set_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; int pos = 0;
size_t read_bytes = 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 // 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)) 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"); TRACE("Could not read tracks header, continuing...\n");
return; 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); 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"); FATAL("Could not allocate memory for metadata block, continuing...\n");
return; 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)); memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
free(ctx->trackEntries); free(ctx->track_entries);
ctx->trackEntries = NULL; ctx->track_entries = NULL;
FATAL("Could not read metadata block, continuing...\n"); FATAL("Could not read metadata block, continuing...\n");
return; 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 // Due to how C# wrote it, it is effectively reversed
if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64); 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, TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", crc64,
ctx->tracksHeader.crc64); ctx->tracks_header.crc64);
return; 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->image_info.HasPartitions = true;
ctx->imageInfo.HasSessions = 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); ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks);
if(ctx->dataTracks == NULL) if(ctx->data_tracks == NULL)
{ {
FATAL("Could not allocate memory for data tracks, continuing without filtered list.\n"); FATAL("Could not allocate memory for data tracks, continuing without filtered list.\n");
ctx->numberOfDataTracks = 0; ctx->number_of_data_tracks = 0;
} }
} }
else else
ctx->dataTracks = NULL; ctx->data_tracks = NULL;
if(ctx->dataTracks != NULL) if(ctx->data_tracks != NULL)
{ {
k = 0; 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) if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99)
memcpy(&ctx->dataTracks[k++], &ctx->trackEntries[j], sizeof(TrackEntry)); 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; return AARUF_ERROR_NOT_AARUFORMAT;
} }
const aaruformatContext *ctx = context; const aaruformat_context *ctx = context;
// Not a libaaruformat context // Not a libaaruformat context
if(ctx->magic != AARU_MAGIC) 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; 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"); 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; 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) 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; return AARUF_ERROR_BUFFER_TOO_SMALL;
} }
memcpy(buffer, ctx->trackEntries, required_length); memcpy(buffer, ctx->track_entries, required_length);
*length = required_length; *length = required_length;
TRACE("Exiting aaruf_get_tracks(%p, %p, %zu) = AARUF_STATUS_OK", context, buffer, *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; return AARUF_ERROR_NOT_AARUFORMAT;
} }
aaruformatContext *ctx = context; aaruformat_context *ctx = context;
// Not a libaaruformat context // Not a libaaruformat context
if(ctx->magic != AARU_MAGIC) if(ctx->magic != AARU_MAGIC)
@@ -417,12 +417,12 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count)
// Clearing existing tracks // Clearing existing tracks
if(count == 0) if(count == 0)
{ {
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
free(ctx->trackEntries); free(ctx->track_entries);
ctx->trackEntries = NULL; ctx->track_entries = NULL;
free(ctx->dataTracks); free(ctx->data_tracks);
ctx->dataTracks = NULL; ctx->data_tracks = NULL;
ctx->numberOfDataTracks = 0; ctx->number_of_data_tracks = 0;
TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK"); TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK");
return 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; return AARUF_ERROR_INVALID_TRACK_FORMAT;
} }
ctx->tracksHeader.identifier = TracksBlock; ctx->tracks_header.identifier = TracksBlock;
ctx->tracksHeader.entries = (uint16_t)count; ctx->tracks_header.entries = (uint16_t)count;
free(ctx->trackEntries); free(ctx->track_entries);
ctx->trackEntries = malloc(sizeof(TrackEntry) * count); ctx->track_entries = malloc(sizeof(TrackEntry) * count);
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 tracks"); FATAL("Could not allocate memory for tracks");
TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY"); TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY");
return AARUF_ERROR_NOT_ENOUGH_MEMORY; return AARUF_ERROR_NOT_ENOUGH_MEMORY;
} }
memcpy(ctx->trackEntries, tracks, sizeof(TrackEntry) * count); memcpy(ctx->track_entries, tracks, sizeof(TrackEntry) * count);
ctx->tracksHeader.crc64 = aaruf_crc64_data((const uint8_t *)ctx->trackEntries, sizeof(TrackEntry) * count); ctx->tracks_header.crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, sizeof(TrackEntry) * count);
ctx->imageInfo.HasPartitions = true; ctx->image_info.HasPartitions = true;
ctx->imageInfo.HasSessions = true; ctx->image_info.HasSessions = true;
free(ctx->dataTracks); free(ctx->data_tracks);
ctx->dataTracks = NULL; ctx->data_tracks = NULL;
ctx->numberOfDataTracks = 0; ctx->number_of_data_tracks = 0;
for(int j = 0; j < ctx->tracksHeader.entries; j++) for(int 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); ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks);
if(ctx->dataTracks == NULL) if(ctx->data_tracks == NULL)
{ {
free(ctx->trackEntries); free(ctx->track_entries);
ctx->trackEntries = NULL; ctx->track_entries = NULL;
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); memset(&ctx->tracks_header, 0, sizeof(TracksHeader));
ctx->numberOfDataTracks = 0; ctx->number_of_data_tracks = 0;
FATAL("Could not allocate memory for data tracks"); FATAL("Could not allocate memory for data tracks");
TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY"); 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; int k = 0;
for(int j = 0; j < ctx->tracksHeader.entries; j++) for(int j = 0; j < ctx->tracks_header.entries; j++)
if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99)
memcpy(&ctx->dataTracks[k++], &ctx->trackEntries[j], sizeof(TrackEntry)); memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry));
} }
TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK"); 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 tapeFileHashEntry for the hash table entry structure
* @see process_tape_partition_block() for partition metadata processing * @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; long pos = 0;
size_t read_bytes = 0; size_t read_bytes = 0;
@@ -160,7 +160,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry)
return; 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); uint8_t *buffer = malloc(sizeof(TapeFileEntry) * tape_file_header.entries);
if(buffer == NULL) if(buffer == NULL)
@@ -207,7 +207,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry)
// Replace if exists, add if new // Replace if exists, add if new
tapeFileHashEntry *old_entry = NULL; 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 // Free old entry if it was replaced
if(old_entry != NULL) 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 TapePartitionHashEntry for the hash table entry structure
* @see process_tape_files_block() for tape file metadata processing * @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; long pos = 0;
size_t read_bytes = 0; size_t read_bytes = 0;
@@ -380,7 +380,7 @@ void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *ent
return; 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); uint8_t *buffer = malloc(sizeof(TapePartitionEntry) * tape_partition_header.entries);
if(buffer == NULL) if(buffer == NULL)
@@ -427,7 +427,7 @@ void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *ent
// Replace if exists, add if new // Replace if exists, add if new
TapePartitionHashEntry *old_entry = NULL; 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 // Free old entry if it was replaced
if(old_entry != NULL) 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, TRACE("Entering aaruf_get_tape_file(%p, %d, %d, %llu, %llu)", context, partition, file, *starting_block,
*ending_block); *ending_block);
const aaruformatContext *ctx = NULL; const aaruformat_context *ctx = NULL;
if(context == 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; uint64_t key = (uint64_t)partition << 32 | file;
tapeFileHashEntry *entry = NULL; 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) 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, TRACE("Entering aaruf_set_tape_file(%p, %d, %d, %llu, %llu)", context, partition, file, starting_block,
ending_block); ending_block);
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
if(context == 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 // Check we are writing
if(!ctx->isWriting) if(!ctx->is_writing)
{ {
FATAL("Trying to write a read-only image"); 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 // Replace if exists, add if new
tapeFileHashEntry *old_entry = NULL; 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 // Free old entry if it was replaced
if(old_entry != NULL) 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); 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) 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; uint8_t key = partition;
TapePartitionHashEntry *entry = NULL; 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) 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); 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) 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 // Check we are writing
if(!ctx->isWriting) if(!ctx->is_writing)
{ {
FATAL("Trying to write a read-only image"); 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 // Replace if exists, add if new
TapePartitionHashEntry *old_entry = NULL; 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 // Free old entry if it was replaced
if(old_entry != NULL) 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 "internal.h"
#include "log.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 == NULL) return;
if(ctx->sectorHashMap != NULL) if(ctx->sector_hash_map != NULL)
{ {
free_map(ctx->sectorHashMap); free_map(ctx->sector_hash_map);
ctx->sectorHashMap = NULL; ctx->sector_hash_map = NULL;
} }
if(ctx->indexEntries != NULL) if(ctx->index_entries != NULL)
{ {
utarray_free(ctx->indexEntries); utarray_free(ctx->index_entries);
ctx->indexEntries = NULL; ctx->index_entries = NULL;
} }
if(ctx->userDataDdtBig != NULL) if(ctx->user_data_ddt2 != NULL)
{ {
free(ctx->userDataDdtBig); free(ctx->user_data_ddt2);
ctx->userDataDdtBig = NULL; ctx->user_data_ddt2 = NULL;
} }
if(ctx->spamsum_context != NULL) if(ctx->spamsum_context != NULL)
@@ -64,10 +64,10 @@ static void cleanup_failed_create(aaruformatContext *ctx)
ctx->blake3_context = NULL; ctx->blake3_context = NULL;
} }
if(ctx->eccCdContext != NULL) if(ctx->ecc_cd_context != NULL)
{ {
free(ctx->eccCdContext); free(ctx->ecc_cd_context);
ctx->eccCdContext = NULL; ctx->ecc_cd_context = NULL;
} }
if(ctx->readableSectorTags != NULL) if(ctx->readableSectorTags != NULL)
@@ -297,7 +297,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
// Allocate context // Allocate context
TRACE("Allocating memory for context"); TRACE("Allocating memory for context");
aaruformatContext *ctx = malloc(sizeof(aaruformatContext)); aaruformat_context *ctx = malloc(sizeof(aaruformat_context));
if(ctx == NULL) if(ctx == NULL)
{ {
FATAL("Not enough memory to create context"); 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; return NULL;
} }
memset(ctx, 0, sizeof(aaruformatContext)); memset(ctx, 0, sizeof(aaruformat_context));
// Create the image file // Create the image file
TRACE("Creating image file %s", filepath); 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) // Ensure it fits in the Application buffer (64 bytes including null terminator)
if(app_name_utf8_len < 64) 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)) if(U_FAILURE(status))
{ {
TRACE("Error converting application name to UTF-8: %d, using raw bytes", status); TRACE("Error converting application name to UTF-8: %d, using raw bytes", status);
// Fallback: just copy what we can // Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64); memset(ctx->image_info.Application, 0, 64);
memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
} }
} }
else else
{ {
TRACE("Application name too long for buffer, truncating"); TRACE("Application name too long for buffer, truncating");
u_strToUTF8(ctx->imageInfo.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status); u_strToUTF8(ctx->image_info.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status);
ctx->imageInfo.Application[63] = '\0'; ctx->image_info.Application[63] = '\0';
} }
} }
else else
{ {
TRACE("Error getting UTF-8 length: %d, using raw bytes", status); TRACE("Error getting UTF-8 length: %d, using raw bytes", status);
// Fallback: just copy what we can // Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64); memset(ctx->image_info.Application, 0, 64);
memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
} }
free(app_name_utf16); 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"); TRACE("Could not allocate memory for UTF-16 conversion, using raw bytes");
// Fallback: just copy what we can // Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64); memset(ctx->image_info.Application, 0, 64);
memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN);
} }
// Set application version string directly in the fixed-size array // Set application version string directly in the fixed-size array
memset(ctx->imageInfo.ApplicationVersion, 0, 32); memset(ctx->image_info.ApplicationVersion, 0, 32);
sprintf(ctx->imageInfo.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion, sprintf(ctx->image_info.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion,
ctx->header.applicationMinorVersion); ctx->header.applicationMinorVersion);
// Set image version string directly in the fixed-size array // Set image version string directly in the fixed-size array
memset(ctx->imageInfo.Version, 0, 32); memset(ctx->image_info.Version, 0, 32);
sprintf(ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion); 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;
ctx->imageInfo.ImageSize = 0; ctx->image_info.ImageSize = 0;
ctx->imageInfo.CreationTime = ctx->header.creationTime; ctx->image_info.CreationTime = ctx->header.creationTime;
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime; ctx->image_info.LastModificationTime = ctx->header.lastWrittenTime;
ctx->imageInfo.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType); ctx->image_info.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType);
ctx->imageInfo.SectorSize = sector_size; ctx->image_info.SectorSize = sector_size;
// Initialize caches // Initialize caches
TRACE("Initializing caches"); TRACE("Initializing caches");
ctx->blockHeaderCache.cache = NULL; ctx->block_header_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);
ctx->blockHeaderCache.max_items = cache_divisor == 0 ? 0 : MAX_CACHE_SIZE / cache_divisor; ctx->block_header_cache.max_items = cache_divisor == 0 ? 0 : MAX_CACHE_SIZE / cache_divisor;
ctx->blockCache.cache = NULL; ctx->block_cache.cache = NULL;
ctx->blockCache.max_items = ctx->blockHeaderCache.max_items; ctx->block_cache.max_items = ctx->block_header_cache.max_items;
// TODO: Cache tracks and sessions? // TODO: Cache tracks and sessions?
// Initialize ECC for Compact Disc // Initialize ECC for Compact Disc
TRACE("Initializing Compact Disc ECC"); 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->magic = AARU_MAGIC;
ctx->libraryMajorVersion = LIBAARUFORMAT_MAJOR_VERSION; ctx->library_major_version = LIBAARUFORMAT_MAJOR_VERSION;
ctx->libraryMinorVersion = LIBAARUFORMAT_MINOR_VERSION; ctx->library_minor_version = LIBAARUFORMAT_MINOR_VERSION;
if(!is_tape) if(!is_tape)
{ // Initialize DDT2 { // Initialize DDT2
TRACE("Initializing DDT2"); TRACE("Initializing DDT2");
ctx->inMemoryDdt = true; ctx->in_memory_ddt = true;
ctx->userDataDdtHeader.identifier = DeDuplicationTable2; ctx->user_data_ddt_header.identifier = DeDuplicationTable2;
ctx->userDataDdtHeader.type = UserData; ctx->user_data_ddt_header.type = UserData;
ctx->userDataDdtHeader.compression = None; ctx->user_data_ddt_header.compression = None;
ctx->userDataDdtHeader.tableLevel = 0; ctx->user_data_ddt_header.tableLevel = 0;
ctx->userDataDdtHeader.previousLevelOffset = 0; ctx->user_data_ddt_header.previousLevelOffset = 0;
ctx->userDataDdtHeader.negative = negative_sectors; ctx->user_data_ddt_header.negative = negative_sectors;
ctx->userDataDdtHeader.blocks = user_sectors + overflow_sectors + negative_sectors; ctx->user_data_ddt_header.blocks = user_sectors + overflow_sectors + negative_sectors;
ctx->userDataDdtHeader.overflow = overflow_sectors; ctx->user_data_ddt_header.overflow = overflow_sectors;
ctx->userDataDdtHeader.start = 0; ctx->user_data_ddt_header.start = 0;
ctx->userDataDdtHeader.blockAlignmentShift = parsed_options.block_alignment; ctx->user_data_ddt_header.blockAlignmentShift = parsed_options.block_alignment;
ctx->userDataDdtHeader.dataShift = parsed_options.data_shift; ctx->user_data_ddt_header.dataShift = parsed_options.data_shift;
ctx->userDataDdtHeader.sizeType = BigDdtSizeType; ctx->user_data_ddt_header.sizeType = BigDdtSizeType;
if(parsed_options.table_shift == -1) if(parsed_options.table_shift == -1)
{ {
const uint64_t total_sectors = user_sectors + overflow_sectors + negative_sectors; const uint64_t total_sectors = user_sectors + overflow_sectors + negative_sectors;
if(total_sectors < 0x8388608ULL) if(total_sectors < 0x8388608ULL)
ctx->userDataDdtHeader.tableShift = 0; ctx->user_data_ddt_header.tableShift = 0;
else else
ctx->userDataDdtHeader.tableShift = 22; ctx->user_data_ddt_header.tableShift = 22;
} }
else else
ctx->userDataDdtHeader.tableShift = ctx->user_data_ddt_header.tableShift =
parsed_options.table_shift > 0 ? (uint8_t)parsed_options.table_shift : 0; 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) if(effective_table_shift >= 63)
{ {
TRACE("Clamping table shift from %u to 62 to avoid overflow", effective_table_shift); TRACE("Clamping table shift from %u to 62 to avoid overflow", effective_table_shift);
effective_table_shift = 62; effective_table_shift = 62;
ctx->userDataDdtHeader.tableShift = effective_table_shift; ctx->user_data_ddt_header.tableShift = effective_table_shift;
} }
const uint64_t sectors_per_entry = 1ULL << effective_table_shift; const uint64_t sectors_per_entry = 1ULL << effective_table_shift;
ctx->userDataDdtHeader.entries = ctx->userDataDdtHeader.blocks / sectors_per_entry; ctx->user_data_ddt_header.entries = ctx->user_data_ddt_header.blocks / sectors_per_entry;
if(ctx->userDataDdtHeader.blocks % sectors_per_entry != 0 || ctx->userDataDdtHeader.entries == 0) if(ctx->user_data_ddt_header.blocks % sectors_per_entry != 0 || ctx->user_data_ddt_header.entries == 0)
ctx->userDataDdtHeader.entries++; ctx->user_data_ddt_header.entries++;
TRACE("Initializing primary/single DDT"); TRACE("Initializing primary/single DDT");
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
{ {
ctx->userDataDdtBig = ctx->user_data_ddt2 =
(uint32_t *)calloc(ctx->userDataDdtHeader.entries, sizeof(uint32_t)); // All entries to zero (uint32_t *)calloc(ctx->user_data_ddt_header.entries, sizeof(uint32_t)); // All entries to zero
if(ctx->userDataDdtBig == NULL) if(ctx->user_data_ddt2 == NULL)
{ {
FATAL("Not enough memory to allocate primary DDT (big)"); FATAL("Not enough memory to allocate primary DDT (big)");
errno = AARUF_ERROR_NOT_ENOUGH_MEMORY; 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) // Set the primary DDT offset (just after the header, block aligned)
ctx->primaryDdtOffset = sizeof(AaruHeaderV2); // Start just after the header ctx->primary_ddt_offset = sizeof(AaruHeaderV2); // Start just after the header
const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1;
ctx->primaryDdtOffset = ctx->primaryDdtOffset + alignment_mask & ~alignment_mask; 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 // 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) // 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; const uint64_t data_start_position = ctx->primary_ddt_offset + sizeof(DdtHeader2) + primary_table_size;
ctx->nextBlockPosition = data_start_position + alignment_mask & ~alignment_mask; ctx->next_block_position = data_start_position + alignment_mask & ~alignment_mask;
} }
else 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 else
{ {
// Fill needed values // Fill needed values
ctx->userDataDdtHeader.blockAlignmentShift = parsed_options.block_alignment; ctx->user_data_ddt_header.blockAlignmentShift = parsed_options.block_alignment;
ctx->userDataDdtHeader.dataShift = parsed_options.data_shift; ctx->user_data_ddt_header.dataShift = parsed_options.data_shift;
// Calculate aligned next block position // Calculate aligned next block position
const uint64_t alignment_mask = (1ULL << parsed_options.block_alignment) - 1; const uint64_t alignment_mask = (1ULL << parsed_options.block_alignment) - 1;
ctx->nextBlockPosition = sizeof(AaruHeaderV2); // Start just after the header ctx->next_block_position = sizeof(AaruHeaderV2); // Start just after the header
ctx->nextBlockPosition = ctx->nextBlockPosition + alignment_mask & ~alignment_mask; ctx->next_block_position = ctx->next_block_position + alignment_mask & ~alignment_mask;
ctx->is_tape = 1; 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 // 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"); FATAL("Could not seek to data start position");
errno = AARUF_ERROR_CANNOT_CREATE_FILE; 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 // Initialize index entries array
TRACE("Initializing index entries array"); TRACE("Initializing index entries array");
const UT_icd index_entry_icd = {sizeof(IndexEntry), NULL, NULL, NULL}; 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"); FATAL("Not enough memory to create index entries array");
errno = AARUF_ERROR_NOT_ENOUGH_MEMORY; 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->lzma_dict_size = parsed_options.dictionary;
ctx->deduplicate = parsed_options.deduplicate; ctx->deduplicate = parsed_options.deduplicate;
if(ctx->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->rewinded = false;
ctx->last_written_block = 0; ctx->last_written_block = 0;
@@ -615,7 +615,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32
} }
// Is writing // Is writing
ctx->isWriting = true; ctx->is_writing = true;
TRACE("Exiting aaruf_create() = %p", ctx); TRACE("Exiting aaruf_create() = %p", ctx);
// Return context // 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. * @warning The function modifies context state including sector count, shift value, and DDT version.
* Ensure proper context cleanup when the function completes. * 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); 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; *found_user_data_ddt = true;
ctx->imageInfo.ImageSize += ddt_header.cmpLength; ctx->image_info.ImageSize += ddt_header.cmpLength;
if(entry->dataType == UserData) if(entry->dataType == UserData)
{ {
ctx->imageInfo.Sectors = ddt_header.entries; ctx->image_info.Sectors = ddt_header.entries;
ctx->shift = ddt_header.shift; ctx->shift = ddt_header.shift;
ctx->ddtVersion = 1; ctx->ddt_version = 1;
// Check for DDT compression // Check for DDT compression
switch(ddt_header.compression) switch(ddt_header.compression)
@@ -157,8 +157,8 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
break; break;
} }
ctx->userDataDdt = (uint64_t *)malloc(ddt_header.length); ctx->user_data_ddt = (uint64_t *)malloc(ddt_header.length);
if(ctx->userDataDdt == NULL) if(ctx->user_data_ddt == NULL)
{ {
TRACE("Cannot allocate memory for DDT, continuing..."); TRACE("Cannot allocate memory for DDT, continuing...");
free(cmp_data); 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..."); TRACE("Could not read LZMA properties, continuing...");
free(cmp_data); free(cmp_data);
free(ctx->userDataDdt); free(ctx->user_data_ddt);
ctx->userDataDdt = NULL; ctx->user_data_ddt = NULL;
break; break;
} }
@@ -180,22 +180,22 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
{ {
TRACE("Could not read compressed block, continuing..."); TRACE("Could not read compressed block, continuing...");
free(cmp_data); free(cmp_data);
free(ctx->userDataDdt); free(ctx->user_data_ddt);
ctx->userDataDdt = NULL; ctx->user_data_ddt = NULL;
break; break;
} }
read_bytes = ddt_header.length; read_bytes = ddt_header.length;
TRACE("Decompressing block of size %zu 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); lzma_properties, LZMA_PROPERTIES_LENGTH);
if(error_no != 0) if(error_no != 0)
{ {
FATAL("Got error %d from LZMA, stopping...", error_no); FATAL("Got error %d from LZMA, stopping...", error_no);
free(cmp_data); free(cmp_data);
free(ctx->userDataDdt); free(ctx->user_data_ddt);
ctx->userDataDdt = NULL; ctx->user_data_ddt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; 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..."); FATAL("Error decompressing block, should be {0} bytes but got {1} bytes., stopping...");
free(cmp_data); free(cmp_data);
free(ctx->userDataDdt); free(ctx->user_data_ddt);
ctx->userDataDdt = NULL; ctx->user_data_ddt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
} }
free(cmp_data); free(cmp_data);
cmp_data = NULL; cmp_data = NULL;
ctx->inMemoryDdt = true; ctx->in_memory_ddt = true;
*found_user_data_ddt = true; *found_user_data_ddt = true;
break; break;
@@ -219,18 +219,18 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
case None: case None:
#ifdef __linux__ #ifdef __linux__
TRACE("Memory mapping deduplication table at position %" PRIu64, entry->offset + sizeof(ddt_header)); TRACE("Memory mapping deduplication table at position %" PRIu64, entry->offset + sizeof(ddt_header));
ctx->mappedMemoryDdtSize = sizeof(uint64_t) * ddt_header.entries; ctx->mapped_memory_ddt_size = sizeof(uint64_t) * ddt_header.entries;
ctx->userDataDdt = mmap(NULL, ctx->mappedMemoryDdtSize, PROT_READ, MAP_SHARED, fileno(ctx->imageStream), ctx->user_data_ddt = mmap(NULL, ctx->mapped_memory_ddt_size, PROT_READ, MAP_SHARED,
entry->offset + sizeof(ddt_header)); 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; *found_user_data_ddt = false;
FATAL("Could not read map deduplication table."); FATAL("Could not read map deduplication table.");
break; break;
} }
ctx->inMemoryDdt = false; ctx->in_memory_ddt = false;
break; break;
#else // TODO: Implement #else // TODO: Implement
TRACE("Uncompressed DDT not yet implemented..."); 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; cmp_data = NULL;
if(entry->dataType == CdSectorPrefixCorrected) if(entry->dataType == CdSectorPrefixCorrected)
ctx->sectorPrefixDdt = cd_ddt; ctx->sector_prefix_ddt = cd_ddt;
else if(entry->dataType == CdSectorSuffixCorrected) else if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixDdt = cd_ddt; ctx->sector_suffix_ddt = cd_ddt;
else else
free(cd_ddt); free(cd_ddt);
@@ -343,9 +343,9 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
} }
if(entry->dataType == CdSectorPrefixCorrected) if(entry->dataType == CdSectorPrefixCorrected)
ctx->sectorPrefixDdt = cd_ddt; ctx->sector_prefix_ddt = cd_ddt;
else if(entry->dataType == CdSectorSuffixCorrected) else if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixDdt = cd_ddt; ctx->sector_suffix_ddt = cd_ddt;
else else
free(cd_ddt); 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 * @warning No bounds checking is performed on sector_address. Accessing beyond the DDT table
* boundaries will result in undefined behavior. * 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) 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, 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; return AARUF_ERROR_NOT_AARUFORMAT;
} }
if(ctx->userDataDdt == NULL) if(ctx->user_data_ddt == NULL)
{ {
FATAL("User data DDT not loaded."); FATAL("User data DDT not loaded.");
TRACE("Exiting decode_ddt_entry_v1() = AARUF_ERROR_NOT_AARUFORMAT"); 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; 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); const uint64_t offset_mask64 = (UINT64_C(1) << ctx->shift) - UINT64_C(1);
*offset = ddt_entry & offset_mask64; *offset = ddt_entry & offset_mask64;
*block_offset = ddt_entry >> ctx->shift; *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. * @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. * 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); 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; *found_user_data_ddt = false;
ctx->imageInfo.ImageSize += ddt_header.cmpLength; ctx->image_info.ImageSize += ddt_header.cmpLength;
if(entry->dataType == UserData) if(entry->dataType == UserData)
{ {
// User area sectors is blocks stored in DDT minus the negative and overflow displacement blocks // 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 // We need the header later for the shift calculations
ctx->userDataDdtHeader = ddt_header; ctx->user_data_ddt_header = ddt_header;
ctx->ddtVersion = 2; ctx->ddt_version = 2;
// Store the primary DDT table's file offset for secondary table references // 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 // Check for DDT compression
switch(ddt_header.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; 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; *found_user_data_ddt = true;
break; break;
@@ -293,9 +293,9 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC; 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; *found_user_data_ddt = true;
break; break;
@@ -399,8 +399,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC; return AARUF_ERROR_INVALID_BLOCK_CRC;
} }
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixDdt = (uint32_t *)buffer; } if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_ddt = (uint32_t *)buffer; }
else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sectorSuffixDdt = (uint32_t *)buffer; } else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sector_suffix_ddt = (uint32_t *)buffer; }
else else
free(buffer); free(buffer);
@@ -445,8 +445,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us
return AARUF_ERROR_INVALID_BLOCK_CRC; return AARUF_ERROR_INVALID_BLOCK_CRC;
} }
if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixDdt = (uint32_t *)buffer; } if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_ddt = (uint32_t *)buffer; }
else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sectorSuffixDdt = (uint32_t *)buffer; } else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sector_suffix_ddt = (uint32_t *)buffer; }
else else
free(buffer); 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 * @warning All output parameters must be valid pointers. No bounds checking is performed
* on the sector_address parameter at this level. * 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) 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, 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; 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_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); 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 * @warning This function should only be called when tableShift is 0. Calling it with
* tableShift > 0 will result in AARUF_ERROR_CANNOT_READ_BLOCK. * 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) 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, 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 // 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."); 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"); 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 // Calculate positive or negative sector
if(negative) if(negative)
sector_address -= ctx->userDataDdtHeader.negative; sector_address -= ctx->user_data_ddt_header.negative;
else else
sector_address += ctx->userDataDdtHeader.negative; sector_address += ctx->user_data_ddt_header.negative;
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
ddt_entry = ctx->userDataDdtBig[sector_address]; ddt_entry = ctx->user_data_ddt2[sector_address];
else else
{ {
FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType); 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; *sector_status = ddt_entry >> 28;
ddt_entry &= 0x0fffffff; 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; *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, 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); 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. * @warning No bounds checking is performed on sector_address or calculated DDT positions.
* Accessing beyond table boundaries will result in undefined behavior. * 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) 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, 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 // 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."); 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"); 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 // Calculate positive or negative sector
if(negative) if(negative)
sector_address -= ctx->userDataDdtHeader.negative; sector_address -= ctx->user_data_ddt_header.negative;
else 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; ddt_position = sector_address / items_per_ddt_entry;
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
secondary_ddt_offset = ctx->userDataDdtBig[ddt_position]; secondary_ddt_offset = ctx->user_data_ddt2[ddt_position];
else else
{ {
FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType); 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 // 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? // 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; int32_t error_no = 0;
fseek(ctx->imageStream, secondary_ddt_offset, SEEK_SET); 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; 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; break;
case None: 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; 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; break;
default: 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) 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; *sector_status = ddt_entry >> 28;
ddt_entry &= 0x0fffffff; 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; *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, 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); 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: * @return Returns one of the following status codes:
* @retval true if the entry was set successfully, false otherwise. * @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) 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, 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; 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_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); 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: * @return Returns one of the following status codes:
* @retval true if the entry was set successfully, false otherwise. * @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, const uint64_t offset, const uint64_t block_offset, const uint8_t sector_status,
uint64_t *ddt_entry) 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 // 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."); FATAL("DDT table shift is not zero, but we are in single-level DDT setting.");
TRACE("Exiting set_ddt_single_level_v2() = false"); 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 // Calculate positive or negative sector
if(negative) if(negative)
sector_address -= ctx->userDataDdtHeader.negative; sector_address -= ctx->user_data_ddt_header.negative;
else else
sector_address += ctx->userDataDdtHeader.negative; sector_address += ctx->user_data_ddt_header.negative;
if(*ddt_entry == 0) if(*ddt_entry == 0)
{ {
const uint64_t block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; const uint64_t block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
<< ctx->userDataDdtHeader.dataShift; block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry // Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF) 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); 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"); TRACE("Exiting set_ddt_single_level_v2() = true");
return 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: * @return Returns one of the following status codes:
* @retval true if the entry was set successfully, false otherwise. * @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) 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, 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 // 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."); FATAL("DDT table shift is zero, but we are in multi-level DDT setting.");
TRACE("Exiting set_ddt_multi_level_v2() = false"); 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 // Calculate positive or negative sector
if(negative) if(negative)
sector_address -= ctx->userDataDdtHeader.negative; sector_address -= ctx->user_data_ddt_header.negative;
else else
sector_address += ctx->userDataDdtHeader.negative; sector_address += ctx->user_data_ddt_header.negative;
// Step 1: Calculate the corresponding secondary level table // 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; ddt_position = sector_address / items_per_ddt_entry;
if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType)
secondary_ddt_offset = ctx->userDataDdtBig[ddt_position]; secondary_ddt_offset = ctx->user_data_ddt2[ddt_position];
else else
{ {
FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType); 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 // 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 // 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 // Update the corresponding DDT entry directly in the cached table
if(*ddt_entry == 0) if(*ddt_entry == 0)
{ {
block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
block_index << ctx->userDataDdtHeader.dataShift; block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry // Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF) 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); 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("Updated cached secondary DDT entry at position %" PRIu64, sector_address % items_per_ddt_entry);
TRACE("Exiting set_ddt_multi_level_v2() = true"); 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 // 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 // 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 // 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 TRACE("Current secondary DDT in memory belongs to position %" PRIu64
" but requested block needs 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 // Write the cached DDT to disk before proceeding with the new one
// Close the current data block first // 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 // Get current position and seek to end of file
fseek(ctx->imageStream, 0, SEEK_END); fseek(ctx->imageStream, 0, SEEK_END);
end_of_file = ftell(ctx->imageStream); end_of_file = ftell(ctx->imageStream);
// Align to block boundary // 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; end_of_file = end_of_file + alignment_mask & ~alignment_mask;
fseek(ctx->imageStream, end_of_file, SEEK_SET); 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.identifier = DeDuplicationTable2;
ddt_header.type = UserData; ddt_header.type = UserData;
ddt_header.compression = ctx->compression_enabled ? Lzma : None; // Use no compression for simplicity ddt_header.compression = ctx->compression_enabled ? Lzma : None; // Use no compression for simplicity
ddt_header.levels = ctx->userDataDdtHeader.levels; ddt_header.levels = ctx->user_data_ddt_header.levels;
ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1; ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1;
ddt_header.previousLevelOffset = ctx->primaryDdtOffset; ddt_header.previousLevelOffset = ctx->primary_ddt_offset;
ddt_header.negative = ctx->userDataDdtHeader.negative; ddt_header.negative = ctx->user_data_ddt_header.negative;
ddt_header.blocks = items_per_ddt_entry; 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 = ctx->cachedDdtPosition * items_per_ddt_entry; // Use cached position with table shift ddt_header.start = ctx->cached_ddt_position * items_per_ddt_entry; // Use cached position with table shift
ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift;
ddt_header.dataShift = ctx->userDataDdtHeader.dataShift; ddt_header.dataShift = ctx->user_data_ddt_header.dataShift;
ddt_header.tableShift = 0; // Secondary tables are single level 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; ddt_header.entries = items_per_ddt_entry;
// Calculate data size // Calculate data size
@@ -1251,7 +1253,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
return false; 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); aaruf_crc64_final(crc64_context, &crc64);
ddt_header.crc64 = 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) 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; ddt_header.cmpCrc64 = ddt_header.crc64;
} }
else 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 dst_size = (size_t)ddt_header.length * 2 * 2;
size_t props_size = LZMA_PROPERTIES_LENGTH; 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, ddt_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0,
2, 273, 8); 2, 273, 8);
@@ -1287,7 +1289,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
ddt_header.compression = None; ddt_header.compression = None;
free(cmp_buffer); 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.dataType = UserData;
new_ddt_entry.offset = end_of_file; 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); 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 // 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 // Write the updated primary table back to its original position in the file
long saved_pos = ftell(ctx->imageStream); 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) 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 // Update nextBlockPosition to ensure future blocks don't overwrite the DDT
uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length; uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length;
ctx->nextBlockPosition = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask; ctx->next_block_position = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask;
block_offset = ctx->nextBlockPosition; block_offset = ctx->next_block_position;
offset = 0; offset = 0;
TRACE("Updated nextBlockPosition after never-written DDT write to %" PRIu64, ctx->nextBlockPosition); TRACE("Updated nextBlockPosition after never-written DDT write to %" PRIu64, ctx->next_block_position);
// Free the cached table // Free the cached table
free(ctx->cachedSecondaryDdtBig); free(ctx->cached_secondary_ddt2);
ctx->cachedSecondaryDdtBig = NULL; ctx->cached_secondary_ddt2 = NULL;
// Reset cached values since we've written and freed the table // Reset cached values since we've written and freed the table
ctx->cachedDdtOffset = 0; ctx->cached_ddt_offset = 0;
ctx->cachedDdtPosition = 0; ctx->cached_ddt_position = 0;
// Restore file position // Restore file position
fseek(ctx->imageStream, saved_pos, SEEK_SET); 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 // 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; long current_pos = 0;
// Close the current data block first // 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 // Get current position and seek to end of file
current_pos = ftell(ctx->imageStream); 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); end_of_file = ftell(ctx->imageStream);
// Align to block boundary // 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; end_of_file = end_of_file + alignment_mask & ~alignment_mask;
fseek(ctx->imageStream, end_of_file, SEEK_SET); 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.identifier = DeDuplicationTable2;
ddt_header.type = UserData; ddt_header.type = UserData;
ddt_header.compression = ctx->compression_enabled ? Lzma : None; ddt_header.compression = ctx->compression_enabled ? Lzma : None;
ddt_header.levels = ctx->userDataDdtHeader.levels; ddt_header.levels = ctx->user_data_ddt_header.levels;
ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1; ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1;
ddt_header.previousLevelOffset = ctx->primaryDdtOffset; // Set to primary DDT table location ddt_header.previousLevelOffset = ctx->primary_ddt_offset; // Set to primary DDT table location
ddt_header.negative = ctx->userDataDdtHeader.negative; ddt_header.negative = ctx->user_data_ddt_header.negative;
ddt_header.blocks = items_per_ddt_entry; 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.start = ddt_position * items_per_ddt_entry; // First block this DDT table references
ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift;
ddt_header.dataShift = ctx->userDataDdtHeader.dataShift; ddt_header.dataShift = ctx->user_data_ddt_header.dataShift;
ddt_header.tableShift = 0; // Secondary tables are single level 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; ddt_header.entries = items_per_ddt_entry;
// Calculate data size // Calculate data size
@@ -1428,7 +1430,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
return false; 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); aaruf_crc64_final(crc64_context, &crc64);
ddt_header.crc64 = 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) 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; ddt_header.cmpCrc64 = ddt_header.crc64;
} }
else 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 dst_size = (size_t)ddt_header.length * 2 * 2;
size_t props_size = LZMA_PROPERTIES_LENGTH; 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); lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8);
ddt_header.cmpLength = (uint32_t)dst_size; 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; ddt_header.compression = None;
free(cmp_buffer); 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"); TRACE("Updating index for evicted secondary DDT");
// Remove old index entry for the cached 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; IndexEntry *entry = NULL;
// Find and remove the old index entry // 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); entry = (IndexEntry *)utarray_eltptr(ctx->index_entries, i);
if(entry && entry->offset == ctx->cachedDdtOffset && entry->blockType == DeDuplicationTable2) if(entry && entry->offset == ctx->cached_ddt_offset && entry->blockType == DeDuplicationTable2)
{ {
TRACE("Found old DDT index entry at position %u, removing", i); 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; 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.dataType = UserData;
new_ddt_entry.offset = end_of_file; 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); 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 // 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 // Update the primary table entry to point to the new location of the secondary table
// Use ddtPosition which was calculated from sectorAddress, not cachedDdtOffset // 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 // Write the updated primary table back to its original position in the file
long saved_pos = ftell(ctx->imageStream); 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) 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 // Update nextBlockPosition to ensure future blocks don't overwrite the DDT
uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length; uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length;
ctx->nextBlockPosition = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask; ctx->next_block_position = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask;
block_offset = ctx->nextBlockPosition; block_offset = ctx->next_block_position;
offset = 0; offset = 0;
TRACE("Updated nextBlockPosition after DDT write to %" PRIu64, ctx->nextBlockPosition); TRACE("Updated nextBlockPosition after DDT write to %" PRIu64, ctx->next_block_position);
fseek(ctx->imageStream, saved_pos, SEEK_SET); fseek(ctx->imageStream, saved_pos, SEEK_SET);
// Free the cached table // Free the cached table
free(ctx->cachedSecondaryDdtBig); free(ctx->cached_secondary_ddt2);
ctx->cachedSecondaryDdtBig = NULL; ctx->cached_secondary_ddt2 = NULL;
// Restore file position // Restore file position
fseek(ctx->imageStream, current_pos, SEEK_SET); fseek(ctx->imageStream, current_pos, SEEK_SET);
} }
// Step 5: Check if the specified block already has an existing secondary level table // 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) 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 // 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) if(create_new_table)
@@ -1648,19 +1650,19 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo
return false; 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->cached_ddt_offset = 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_position = ddt_position; // Track which primary DDT position this new table belongs to
TRACE("Created new secondary DDT for position %" PRIu64, ddt_position); TRACE("Created new secondary DDT for position %" PRIu64, ddt_position);
} }
// Step 6: Update the corresponding DDT entry // Step 6: Update the corresponding DDT entry
if(*ddt_entry == 0) if(*ddt_entry == 0)
{ {
block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
<< ctx->userDataDdtHeader.dataShift; block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry // Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF) 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); 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("Updated secondary DDT entry at position %" PRIu64, sector_address % items_per_ddt_entry);
TRACE("Exiting set_ddt_multi_level_v2() = true"); 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 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 * @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) 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, 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) if(*ddt_entry == 0)
{ {
const uint64_t block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; const uint64_t block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift;
*ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 |
<< ctx->userDataDdtHeader.dataShift; block_index << ctx->user_data_ddt_header.dataShift;
// Overflow detection for DDT entry // Overflow detection for DDT entry
if(*ddt_entry > 0xFFFFFFF) 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; new_entry->value = *ddt_entry;
// Insert entry into tape DDT // 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); if(old_entry) free(old_entry);
TRACE("Exiting set_ddt_tape() = true"); 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); TRACE("Entering aaruf_get_dumphw(%p, %p, %zu)", context, buffer, length_value);
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
if(context == 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; return AARUF_ERROR_NOT_AARUFORMAT;
} }
if(ctx->dumpHardwareEntriesWithData == NULL || ctx->dumpHardwareHeader.entries == 0 || if(ctx->dump_hardware_entries_with_data == NULL || ctx->dump_hardware_header.entries == 0 ||
ctx->dumpHardwareHeader.identifier != DumpHardwareBlock) ctx->dump_hardware_header.identifier != DumpHardwareBlock)
{ {
FATAL("No dump hardware information present"); 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; 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)) if(required_length < sizeof(DumpHardwareHeader))
{ {
FATAL("Dump hardware payload length overflow"); 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 // Start to iterate and copy the data
size_t offset = 0; 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); 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); const size_t extent_bytes = (size_t)entry->extents * sizeof(DumpExtent);
if(entry->extents != 0 && extent_bytes / sizeof(DumpExtent) != entry->extents) 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; 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); offset += sizeof(DumpHardwareEntry);
if(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].manufacturer != NULL) ctx->dump_hardware_entries_with_data[i].manufacturer != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].manufacturer, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].manufacturer,
ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength); ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength; offset += ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.modelLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.modelLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].model != NULL) ctx->dump_hardware_entries_with_data[i].model != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].model, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].model,
ctx->dumpHardwareEntriesWithData[i].entry.modelLength); ctx->dump_hardware_entries_with_data[i].entry.modelLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.modelLength; offset += ctx->dump_hardware_entries_with_data[i].entry.modelLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.revisionLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].revision != NULL) ctx->dump_hardware_entries_with_data[i].revision != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].revision, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].revision,
ctx->dumpHardwareEntriesWithData[i].entry.revisionLength); ctx->dump_hardware_entries_with_data[i].entry.revisionLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.revisionLength; offset += ctx->dump_hardware_entries_with_data[i].entry.revisionLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].firmware != NULL) ctx->dump_hardware_entries_with_data[i].firmware != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].firmware, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].firmware,
ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength); ctx->dump_hardware_entries_with_data[i].entry.firmwareLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength; offset += ctx->dump_hardware_entries_with_data[i].entry.firmwareLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.serialLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.serialLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].serial != NULL) ctx->dump_hardware_entries_with_data[i].serial != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].serial, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].serial,
ctx->dumpHardwareEntriesWithData[i].entry.serialLength); ctx->dump_hardware_entries_with_data[i].entry.serialLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.serialLength; offset += ctx->dump_hardware_entries_with_data[i].entry.serialLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].softwareName != NULL) ctx->dump_hardware_entries_with_data[i].softwareName != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareName, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareName,
ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength); ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength; offset += ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].softwareVersion != NULL) ctx->dump_hardware_entries_with_data[i].softwareVersion != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareVersion, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareVersion,
ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength); ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength);
offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength; offset += ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength;
} }
if(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength > 0 && if(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength > 0 &&
ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem != NULL) ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem != NULL)
{ {
memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem, memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem,
ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength); ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength);
offset += ctx->dumpHardwareEntriesWithData[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; offset += extent_bytes;
} }
} }
// Calculate CRC64 // Calculate CRC64
ctx->dumpHardwareHeader.crc64 = ctx->dump_hardware_header.crc64 =
aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dumpHardwareHeader.length); aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dump_hardware_header.length);
// Copy header // Copy header
memcpy(buffer, &ctx->dumpHardwareHeader, sizeof(DumpHardwareHeader)); memcpy(buffer, &ctx->dump_hardware_header, sizeof(DumpHardwareHeader));
TRACE("Exiting aaruf_get_dumphw() = AARUF_STATUS_OK"); TRACE("Exiting aaruf_get_dumphw() = AARUF_STATUS_OK");
return 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; return AARUF_ERROR_NOT_AARUFORMAT;
} }
aaruformatContext *ctx = context; aaruformat_context *ctx = context;
// Not a libaaruformat context // Not a libaaruformat context
if(ctx->magic != AARU_MAGIC) 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 // Check we are writing
if(!ctx->isWriting) if(!ctx->is_writing)
{ {
FATAL("Trying to write a read-only image"); 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; goto invalid_data;
} }
free_dump_hardware_entries(ctx->dumpHardwareEntriesWithData, ctx->dumpHardwareHeader.entries); free_dump_hardware_entries(ctx->dump_hardware_entries_with_data, ctx->dump_hardware_header.entries);
ctx->dumpHardwareEntriesWithData = copy; ctx->dump_hardware_entries_with_data = copy;
ctx->dumpHardwareHeader = header; ctx->dump_hardware_header = header;
TRACE("Exiting aaruf_set_dumphw() = AARUF_STATUS_OK"); TRACE("Exiting aaruf_set_dumphw() = AARUF_STATUS_OK");
return 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. * @warning The function assumes ctx->header.indexOffset points to a valid index block.
* Invalid offsets may cause file access errors or reading incorrect data. * 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); 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 * @warning CRC validation failure indicates potential data corruption and may suggest
* the image file is damaged or has been modified outside of library control. * 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); 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. * @warning The function assumes ctx->header.indexOffset points to a valid index block.
* Invalid offsets may cause file access errors or reading incorrect data. * 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); 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 * @warning CRC validation failure indicates potential data corruption and may suggest
* the image file is damaged or has been modified outside of library control. * 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); TRACE("Entering verify_index_v2(%p)", ctx);

8
src/index/index_v3.c
View File

@@ -27,7 +27,7 @@
#include "log.h" #include "log.h"
#include "utarray.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. * @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. * @warning The function assumes ctx->header.indexOffset points to a valid index block.
* Invalid offsets may cause file access errors or reading incorrect data. * 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); 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 * @warning No validation is performed on individual IndexEntry contents - only
* structural validation of subindex headers is done. * 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); 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 * @warning For complete integrity verification of hierarchical indexes, additional validation
* of subindex blocks may be required beyond this function's scope. * 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); 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 "log.h"
#include "utarray.h" #include "utarray.h"
static void cleanup_open_failure(aaruformatContext *ctx) static void cleanup_open_failure(aaruformat_context *ctx)
{ {
if(ctx == NULL) return; 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) void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
{ {
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
int error_no = 0; int error_no = 0;
size_t read_bytes = 0; size_t read_bytes = 0;
long pos = 0; long pos = 0;
int i = 0; int i = 0;
uint32_t signature = 0; uint32_t signature = 0;
UT_array *index_entries = NULL; UT_array *index_entries = NULL;
#ifdef USE_SLOG #ifdef USE_SLOG
#include "slog.h" #include "slog.h"
@@ -146,7 +146,7 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
TRACE("Entering aaruf_open(%s)", filepath); TRACE("Entering aaruf_open(%s)", filepath);
TRACE("Allocating memory for context"); TRACE("Allocating memory for context");
ctx = (aaruformatContext *)malloc(sizeof(aaruformatContext)); ctx = (aaruformat_context *)malloc(sizeof(aaruformat_context));
if(ctx == NULL) if(ctx == NULL)
{ {
@@ -157,7 +157,7 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
return NULL; return NULL;
} }
memset(ctx, 0, sizeof(aaruformatContext)); memset(ctx, 0, sizeof(aaruformat_context));
TRACE("Opening file %s", filepath); TRACE("Opening file %s", filepath);
ctx->imageStream = fopen(filepath, "rb"); 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) // Ensure it fits in the Application buffer (64 bytes including null terminator)
if(app_name_utf8_len < 64) 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)) if(U_FAILURE(status))
{ {
TRACE("Error converting application name to UTF-8: %d, using raw bytes", status); TRACE("Error converting application name to UTF-8: %d, using raw bytes", status);
// Fallback: just copy what we can // Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64); memset(ctx->image_info.Application, 0, 64);
strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63); strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63);
} }
} }
else else
{ {
TRACE("Application name too long for buffer, truncating"); TRACE("Application name too long for buffer, truncating");
u_strToUTF8(ctx->imageInfo.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status); u_strToUTF8(ctx->image_info.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status);
ctx->imageInfo.Application[63] = '\0'; ctx->image_info.Application[63] = '\0';
} }
} }
else else
{ {
TRACE("Error getting UTF-8 length: %d, using raw bytes", status); TRACE("Error getting UTF-8 length: %d, using raw bytes", status);
// Fallback: just copy what we can // Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64); memset(ctx->image_info.Application, 0, 64);
strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63); strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63);
} }
free(app_name_utf16); 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"); TRACE("Could not allocate memory for UTF-16 conversion, using raw bytes");
// Fallback: just copy what we can // Fallback: just copy what we can
memset(ctx->imageInfo.Application, 0, 64); memset(ctx->image_info.Application, 0, 64);
strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63); strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63);
} }
// Set application version string directly in the fixed-size array // Set application version string directly in the fixed-size array
memset(ctx->imageInfo.ApplicationVersion, 0, 32); memset(ctx->image_info.ApplicationVersion, 0, 32);
sprintf(ctx->imageInfo.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion, sprintf(ctx->image_info.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion,
ctx->header.applicationMinorVersion); ctx->header.applicationMinorVersion);
// Set image version string directly in the fixed-size array // Set image version string directly in the fixed-size array
memset(ctx->imageInfo.Version, 0, 32); memset(ctx->image_info.Version, 0, 32);
sprintf(ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion); 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 // Read the index header
TRACE("Reading index header at position %" PRIu64, ctx->header.indexOffset); 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); entry->dataType, entry->offset);
} }
bool found_user_data_ddt = false; bool found_user_data_ddt = false;
ctx->imageInfo.ImageSize = 0; ctx->image_info.ImageSize = 0;
for(i = 0; i < utarray_len(index_entries); i++) for(i = 0; i < utarray_len(index_entries); i++)
{ {
IndexEntry *entry = utarray_eltptr(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; return NULL;
} }
ctx->imageInfo.CreationTime = ctx->header.creationTime; ctx->image_info.CreationTime = ctx->header.creationTime;
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime; ctx->image_info.LastModificationTime = ctx->header.lastWrittenTime;
ctx->imageInfo.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType); 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->cylinders = (uint32_t)(ctx->image_info.Sectors / 16 / 63);
ctx->Heads = 16; ctx->heads = 16;
ctx->SectorsPerTrack = 63; ctx->sectors_per_track = 63;
} }
// Initialize caches // Initialize caches
TRACE("Initializing caches"); TRACE("Initializing caches");
ctx->blockHeaderCache.cache = NULL; ctx->block_header_cache.cache = NULL;
ctx->blockCache.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) if(cache_divisor == 0)
{ {
ctx->blockHeaderCache.max_items = 0; ctx->block_header_cache.max_items = 0;
ctx->blockCache.max_items = 0; ctx->block_cache.max_items = 0;
} }
else else
{ {
ctx->blockHeaderCache.max_items = MAX_CACHE_SIZE / cache_divisor; ctx->block_header_cache.max_items = MAX_CACHE_SIZE / cache_divisor;
ctx->blockCache.max_items = ctx->blockHeaderCache.max_items; ctx->block_cache.max_items = ctx->block_header_cache.max_items;
} }
// TODO: Cache tracks and sessions? // TODO: Cache tracks and sessions?
// Initialize ECC for Compact Disc // Initialize ECC for Compact Disc
TRACE("Initializing 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->magic = AARU_MAGIC;
ctx->libraryMajorVersion = LIBAARUFORMAT_MAJOR_VERSION; ctx->library_major_version = LIBAARUFORMAT_MAJOR_VERSION;
ctx->libraryMinorVersion = LIBAARUFORMAT_MINOR_VERSION; ctx->library_minor_version = LIBAARUFORMAT_MINOR_VERSION;
TRACE("Exiting aaruf_open() = %p", ctx); TRACE("Exiting aaruf_open() = %p", ctx);
return 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; return AARUF_ERROR_INCORRECT_DATA_SIZE;
} }
const aaruformatContext *ctx = context; const aaruformat_context *ctx = context;
// Not a libaaruformat context // Not a libaaruformat context
if(ctx->magic != AARU_MAGIC) 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, TRACE("Entering aaruf_read_sector(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, negative, data,
initial_length); initial_length);
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
uint64_t offset = 0; uint64_t offset = 0;
uint64_t block_offset = 0; uint64_t block_offset = 0;
BlockHeader *block_header = NULL; BlockHeader *block_header = NULL;
uint8_t *block = NULL; uint8_t *block = NULL;
size_t read_bytes = 0; size_t read_bytes = 0;
uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH]; uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH];
size_t lzma_size = 0; size_t lzma_size = 0;
uint8_t *cmp_data = NULL; uint8_t *cmp_data = NULL;
int error_no = 0; int error_no = 0;
uint8_t sector_status = 0; uint8_t sector_status = 0;
if(context == NULL) 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; 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"); 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; 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"); 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; return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS;
} }
if(ctx->ddtVersion == 1) if(ctx->ddt_version == 1)
{ {
if(negative) 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); 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); error_no = decode_ddt_entry_v2(ctx, sector_address, negative, &offset, &block_offset, &sector_status);
if(error_no != AARUF_STATUS_OK) 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 :/ // Partially written image... as we can't know the real sector size just assume it's common :/
if(sector_status == SectorStatusNotDumped) if(sector_status == SectorStatusNotDumped)
{ {
*length = ctx->imageInfo.SectorSize; *length = ctx->image_info.SectorSize;
TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_SECTOR_NOT_DUMPED"); TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_SECTOR_NOT_DUMPED");
return 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 // Check if block header is cached
TRACE("Checking 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 // Read block header
if(block_header == NULL) 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"); 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) 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 // Check if block is cached
TRACE("Checking 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) 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 // Add block to cache
TRACE("Adding 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); memcpy(data, block + offset * block_header->sectorSize, block_header->sectorSize);
*length = 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; return AARUF_ERROR_NOT_AARUFORMAT;
} }
aaruformatContext *ctx = context; aaruformat_context *ctx = context;
if(length == NULL) 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; 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); 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; return AARUF_ERROR_INCORRECT_MEDIA_TYPE;
} }
for(int i = 0; i < ctx->numberOfDataTracks; i++) for(int i = 0; i < ctx->number_of_data_tracks; i++)
if(ctx->dataTracks[i].sequence == track) if(ctx->data_tracks[i].sequence == track)
return aaruf_read_sector(context, ctx->dataTracks[i].start + sector_address, false, data, length); return aaruf_read_sector(context, ctx->data_tracks[i].start + sector_address, false, data, length);
TRACE("Track %d not found", track); TRACE("Track %d not found", track);
TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_TRACK_NOT_FOUND"); 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, TRACE("Entering aaruf_read_sector_long(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, data,
initial_length); initial_length);
const aaruformatContext *ctx = NULL; const aaruformat_context *ctx = NULL;
uint32_t bare_length = 0; uint32_t bare_length = 0;
uint32_t tag_length = 0; uint32_t tag_length = 0;
uint8_t *bare_data = NULL; uint8_t *bare_data = NULL;
int32_t res = 0; int32_t res = 0;
int32_t query_status; int32_t query_status;
TrackEntry trk; TrackEntry trk;
int i = 0; int i = 0;
bool trk_found = false; bool trk_found = false;
if(context == NULL) 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; 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"); 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; 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"); 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 // Calculate positive or negative sector
if(negative) if(negative)
corrected_sector_address -= ctx->userDataDdtHeader.negative; corrected_sector_address -= ctx->user_data_ddt_header.negative;
else 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: case OpticalDisc:
if(ctx->imageInfo.MediaType == DVDROM || ctx->imageInfo.MediaType == PS2DVD || if(ctx->image_info.MediaType == DVDROM || ctx->image_info.MediaType == PS2DVD ||
ctx->imageInfo.MediaType == SACD || ctx->imageInfo.MediaType == PS3DVD || ctx->image_info.MediaType == SACD || ctx->image_info.MediaType == PS3DVD ||
ctx->imageInfo.MediaType == DVDR || ctx->imageInfo.MediaType == DVDRW || ctx->image_info.MediaType == DVDR || ctx->image_info.MediaType == DVDRW ||
ctx->imageInfo.MediaType == DVDPR || ctx->imageInfo.MediaType == DVDPRW || ctx->image_info.MediaType == DVDPR || ctx->image_info.MediaType == DVDPRW ||
ctx->imageInfo.MediaType == DVDPRWDL || ctx->imageInfo.MediaType == DVDRDL || ctx->image_info.MediaType == DVDPRWDL || ctx->image_info.MediaType == DVDRDL ||
ctx->imageInfo.MediaType == DVDPRDL || ctx->imageInfo.MediaType == DVDRAM || ctx->image_info.MediaType == DVDPRDL || ctx->image_info.MediaType == DVDRAM ||
ctx->imageInfo.MediaType == DVDRWDL || ctx->imageInfo.MediaType == DVDDownload || ctx->image_info.MediaType == DVDRWDL || ctx->image_info.MediaType == DVDDownload ||
ctx->imageInfo.MediaType == Nuon) ctx->image_info.MediaType == Nuon)
{ {
if(ctx->sector_id == NULL || ctx->sector_ied == NULL || ctx->sector_cpr_mai == NULL || if(ctx->sector_id == NULL || ctx->sector_ied == NULL || ctx->sector_cpr_mai == NULL ||
ctx->sector_edc == 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) && 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); return aaruf_read_sector(context, sector_address, negative, data, length);
bare_length = 0; bare_length = 0;
@@ -1010,11 +1010,11 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
trk_found = false; trk_found = false;
for(i = 0; i < ctx->numberOfDataTracks; i++) for(i = 0; i < ctx->number_of_data_tracks; i++)
if(sector_address >= ctx->dataTracks[i].start && sector_address <= ctx->dataTracks[i].end) if(sector_address >= ctx->data_tracks[i].start && sector_address <= ctx->data_tracks[i].end)
{ {
trk_found = true; trk_found = true;
trk = ctx->dataTracks[i]; trk = ctx->data_tracks[i];
break; break;
} }
@@ -1040,19 +1040,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
if(ctx->sector_prefix != NULL) if(ctx->sector_prefix != NULL)
memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16); 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); aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address);
res = AARUF_STATUS_OK; 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; res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else else
memcpy(data, memcpy(data,
ctx->sectorPrefixCorrected + ctx->sector_prefix_corrected +
((ctx->sectorPrefixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16, ((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
16); 16);
} }
else else
@@ -1071,19 +1071,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
if(ctx->sector_suffix != NULL) if(ctx->sector_suffix != NULL)
memcpy(data + 2064, ctx->sector_suffix + corrected_sector_address * 288, 288); 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; 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; res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else else
memcpy(data + 2064, memcpy(data + 2064,
ctx->sectorSuffixCorrected + ctx->sector_suffix_corrected +
((ctx->sectorSuffixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288, ((ctx->sector_suffix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288,
288); 288);
} }
else else
@@ -1101,19 +1101,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
case CdMode2Form2: case CdMode2Form2:
if(ctx->sector_prefix != NULL) if(ctx->sector_prefix != NULL)
memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16); 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); aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address);
res = AARUF_STATUS_OK; 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; res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else else
memcpy(data, memcpy(data,
ctx->sectorPrefixCorrected + ctx->sector_prefix_corrected +
((ctx->sectorPrefixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16, ((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16,
16); 16);
} }
else else
@@ -1130,23 +1130,23 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo
return res; 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); 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); 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 || else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok ||
(ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2NoCrc) (ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2NoCrc)
{ {
memcpy(data + 24, bare_data, 2324); memcpy(data + 24, bare_data, 2324);
if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok) if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok)
aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, CdMode2Form2); 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; res = AARUF_STATUS_SECTOR_NOT_DUMPED;
else else
// Mode 2 where ECC failed // 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; return AARUF_ERROR_INVALID_TRACK_FORMAT;
} }
case BlockMedia: case BlockMedia:
switch(ctx->imageInfo.MediaType) switch(ctx->image_info.MediaType)
{ {
case AppleFileWare: case AppleFileWare:
case AppleProfile: 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) if(ctx->sector_subchannel == NULL)
return aaruf_read_sector(context, sector_address, negative, data, length); return aaruf_read_sector(context, sector_address, negative, data, length);
switch(ctx->imageInfo.MediaType) switch(ctx->image_info.MediaType)
{ {
case AppleFileWare: case AppleFileWare:
case AppleProfile: 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, TRACE("Entering aaruf_read_sector_tag(%p, %" PRIu64 ", %d, %p, %u, %d)", context, sector_address, negative, buffer,
initial_length, tag); initial_length, tag);
const aaruformatContext *ctx = NULL; const aaruformat_context *ctx = NULL;
if(context == 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; 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"); 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; 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"); 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 // Calculate positive or negative sector
if(negative) if(negative)
corrected_sector_address -= ctx->userDataDdtHeader.negative; corrected_sector_address -= ctx->user_data_ddt_header.negative;
else else
corrected_sector_address += ctx->userDataDdtHeader.negative; corrected_sector_address += ctx->user_data_ddt_header.negative;
switch(tag) switch(tag)
{ {
case CdTrackFlags: case CdTrackFlags:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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; return AARUF_ERROR_INCORRECT_DATA_SIZE;
} }
for(int i = 0; i < ctx->tracksHeader.entries; i++) for(int i = 0; i < ctx->tracks_header.entries; i++)
if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return 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"); FATAL("Track not found");
return AARUF_ERROR_TRACK_NOT_FOUND; return AARUF_ERROR_TRACK_NOT_FOUND;
case CdTrackIsrc: case CdTrackIsrc:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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; return AARUF_ERROR_INCORRECT_DATA_SIZE;
} }
for(int i = 0; i < ctx->tracksHeader.entries; i++) for(int i = 0; i < ctx->tracks_header.entries; i++)
if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return 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"); FATAL("Track not found");
return AARUF_ERROR_TRACK_NOT_FOUND; return AARUF_ERROR_TRACK_NOT_FOUND;
case CdSectorSubchannel: case CdSectorSubchannel:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case DvdCmi: case DvdCmi:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case DvdSectorInformation: case DvdSectorInformation:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case DvdSectorNumber: case DvdSectorNumber:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case DvdSectorIed: case DvdSectorIed:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case DvdSectorEdc: case DvdSectorEdc:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case DvdTitleKeyDecrypted: case DvdTitleKeyDecrypted:
if(ctx->imageInfo.MetadataMediaType != OpticalDisc) if(ctx->image_info.MetadataMediaType != OpticalDisc)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case AppleSonyTag: case AppleSonyTag:
if(ctx->imageInfo.MetadataMediaType != BlockMedia) if(ctx->image_info.MetadataMediaType != BlockMedia)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case AppleProfileTag: case AppleProfileTag:
if(ctx->imageInfo.MetadataMediaType != BlockMedia) if(ctx->image_info.MetadataMediaType != BlockMedia)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK");
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
case PriamDataTowerTag: case PriamDataTowerTag:
if(ctx->imageInfo.MetadataMediaType != BlockMedia) if(ctx->image_info.MetadataMediaType != BlockMedia)
{ {
FATAL("Invalid media type for tag"); FATAL("Invalid media type for tag");
TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); 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); TRACE("Entering aaruf_verify_image(%p)", context);
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
uint64_t crc64 = 0; uint64_t crc64 = 0;
size_t read_bytes = 0; size_t read_bytes = 0;
void *buffer = NULL; void *buffer = NULL;
crc64_ctx *crc64_context = NULL; crc64_ctx *crc64_context = NULL;
BlockHeader block_header; BlockHeader block_header;
DdtHeader ddt_header; DdtHeader ddt_header;
DdtHeader2 ddt2_header; DdtHeader2 ddt2_header;
TracksHeader tracks_header; TracksHeader tracks_header;
uint32_t signature = 0; uint32_t signature = 0;
UT_array *index_entries = NULL; UT_array *index_entries = NULL;
int32_t status = AARUF_STATUS_OK; int32_t status = AARUF_STATUS_OK;
if(context == NULL) 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) int cli_compare(const char *path1, const char *path2)
{ {
aaruformatContext *ctx1 = NULL; aaruformat_context *ctx1 = NULL;
aaruformatContext *ctx2 = NULL; aaruformat_context *ctx2 = NULL;
uint8_t *buffer1 = NULL; uint8_t *buffer1 = NULL;
uint8_t *buffer2 = NULL; uint8_t *buffer2 = NULL;
uint32_t buffer1_length = 0; uint32_t buffer1_length = 0;
uint32_t buffer2_length = 0; uint32_t buffer2_length = 0;
uint64_t total_sectors = 0; uint64_t total_sectors = 0;
uint64_t different_sectors = 0; uint64_t different_sectors = 0;
uint64_t sectors_processed = 0; uint64_t sectors_processed = 0;
int result = 0; int result = 0;
int32_t read_result1 = 0; int32_t read_result1 = 0;
int32_t read_result2 = 0; int32_t read_result2 = 0;
printf("Opening first image: %s\n", path1); printf("Opening first image: %s\n", path1);
ctx1 = aaruf_open(path1); ctx1 = aaruf_open(path1);
@@ -60,32 +60,32 @@ int cli_compare(const char *path1, const char *path2)
// Access image information through context structure // Access image information through context structure
printf("\nImage Information:\n"); printf("\nImage Information:\n");
printf("Image 1: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx1->imageInfo.Sectors, printf("Image 1: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx1->image_info.Sectors,
ctx1->imageInfo.SectorSize); ctx1->image_info.SectorSize);
printf("Image 2: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx2->imageInfo.Sectors, printf("Image 2: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx2->image_info.Sectors,
ctx2->imageInfo.SectorSize); 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"); fprintf(stderr, "Warning: Images have different number of sectors\n");
total_sectors = 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); 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, fprintf(stderr, "Error: Images have different sector sizes (%u vs %u)\n", ctx1->image_info.SectorSize,
ctx2->imageInfo.SectorSize); ctx2->image_info.SectorSize);
aaruf_close(ctx1); aaruf_close(ctx1);
aaruf_close(ctx2); aaruf_close(ctx2);
return -1; return -1;
} }
// Allocate buffers for sector data // Allocate buffers for sector data
buffer1 = malloc(ctx1->imageInfo.SectorSize); buffer1 = malloc(ctx1->image_info.SectorSize);
buffer2 = malloc(ctx2->imageInfo.SectorSize); buffer2 = malloc(ctx2->image_info.SectorSize);
if(buffer1 == NULL || buffer2 == NULL) if(buffer1 == NULL || buffer2 == NULL)
{ {
fprintf(stderr, "Error: Could not allocate memory for sector buffers\n"); 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 // Compare sectors
for(uint64_t sector = 0; sector < total_sectors; sector++) for(uint64_t sector = 0; sector < total_sectors; sector++)
{ {
buffer1_length = ctx1->imageInfo.SectorSize; buffer1_length = ctx1->image_info.SectorSize;
buffer2_length = ctx2->imageInfo.SectorSize; buffer2_length = ctx2->image_info.SectorSize;
read_result1 = aaruf_read_sector(ctx1, sector, false, buffer1, &buffer1_length); read_result1 = aaruf_read_sector(ctx1, sector, false, buffer1, &buffer1_length);
read_result2 = aaruf_read_sector(ctx2, sector, false, buffer2, &buffer2_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 compare(const char *path1, const char *path2)
{ {
int ret = AARUF_STATUS_OK; int ret = AARUF_STATUS_OK;
aaruformatContext *ctx1 = NULL; aaruformat_context *ctx1 = NULL;
aaruformatContext *ctx2 = NULL; aaruformat_context *ctx2 = NULL;
bool imagesAreDifferent = false; bool imagesAreDifferent = false;
char *strBuffer = NULL; char *strBuffer = NULL;
UErrorCode u_error_code = U_ZERO_ERROR; UErrorCode u_error_code = U_ZERO_ERROR;
int lr = 0; int lr = 0;
int rr = 0; int rr = 0;
uintattr_t appVerColor = TB_WHITE; uintattr_t appVerColor = TB_WHITE;
uintattr_t imageVerColor = TB_WHITE; uintattr_t imageVerColor = TB_WHITE;
uintattr_t mediaTypeColor = TB_WHITE; uintattr_t mediaTypeColor = TB_WHITE;
uintattr_t creationTimeColor = TB_WHITE; uintattr_t creationTimeColor = TB_WHITE;
uintattr_t lastWrittenTimeColor = TB_WHITE; uintattr_t lastWrittenTimeColor = TB_WHITE;
uintattr_t partitionsColor = TB_WHITE; uintattr_t partitionsColor = TB_WHITE;
uintattr_t sessionsColor = TB_WHITE; uintattr_t sessionsColor = TB_WHITE;
uintattr_t sectorsColor = TB_WHITE; uintattr_t sectorsColor = TB_WHITE;
uintattr_t sectorSizeColor = TB_WHITE; uintattr_t sectorSizeColor = TB_WHITE;
uintattr_t versionColor = TB_WHITE; uintattr_t versionColor = TB_WHITE;
// Initialize termbox2 // Initialize termbox2
if(tb_init() != 0) return 1; if(tb_init() != 0) return 1;
@@ -229,8 +229,8 @@ int compare(const char *path1, const char *path2)
// Compare ImageInfo // Compare ImageInfo
u_error_code = U_ZERO_ERROR; u_error_code = U_ZERO_ERROR;
u_error_code = u_strCompare((const UChar *)ctx1->imageInfo.Application, -1, u_error_code = u_strCompare((const UChar *)ctx1->image_info.Application, -1,
(const UChar *)ctx2->imageInfo.Application, -1, false); (const UChar *)ctx2->image_info.Application, -1, false);
if(u_error_code != U_ZERO_ERROR) imagesAreDifferent = true; if(u_error_code != U_ZERO_ERROR) imagesAreDifferent = true;
// Current left row // Current left row
@@ -238,73 +238,73 @@ int compare(const char *path1, const char *path2)
// Current right row // Current right row
rr = 9; rr = 9;
if(ctx1->imageInfo.HasPartitions != ctx2->imageInfo.HasPartitions) if(ctx1->image_info.HasPartitions != ctx2->image_info.HasPartitions)
{ {
imagesAreDifferent = true; imagesAreDifferent = true;
partitionsColor = TB_RED; partitionsColor = TB_RED;
} }
if(ctx1->imageInfo.HasSessions != ctx2->imageInfo.HasSessions) if(ctx1->image_info.HasSessions != ctx2->image_info.HasSessions)
{ {
imagesAreDifferent = true; imagesAreDifferent = true;
sessionsColor = TB_RED; sessionsColor = TB_RED;
} }
if(ctx1->imageInfo.Sectors != ctx2->imageInfo.Sectors) if(ctx1->image_info.Sectors != ctx2->image_info.Sectors)
{ {
imagesAreDifferent = true; imagesAreDifferent = true;
sectorsColor = TB_RED; sectorsColor = TB_RED;
} }
if(ctx1->imageInfo.SectorSize != ctx2->imageInfo.SectorSize) if(ctx1->image_info.SectorSize != ctx2->image_info.SectorSize)
{ {
imagesAreDifferent = true; imagesAreDifferent = true;
sectorSizeColor = TB_RED; sectorSizeColor = TB_RED;
} }
if(ctx1->imageInfo.Version != ctx2->imageInfo.Version) if(ctx1->image_info.Version != ctx2->image_info.Version)
{ {
imagesAreDifferent = true; imagesAreDifferent = true;
versionColor = TB_RED; versionColor = TB_RED;
} }
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Has partitions?: "); 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(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(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(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(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(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_present();
tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Has partitions?: "); 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 + 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 + 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 + 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 + 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 + 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(); 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); strBuffer = malloc(65);
memset(strBuffer, 0, 65); memset(strBuffer, 0, 65);
u_error_code = U_ZERO_ERROR; // Reset error code before conversion 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: "); 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); if(u_error_code == U_ZERO_ERROR) tb_printf(15, lr, TB_WHITE, TB_BLUE, "%s", strBuffer);
lr++; lr++;
memset(strBuffer, 0, 65); memset(strBuffer, 0, 65);
u_error_code = U_ZERO_ERROR; // Reset error code before conversion 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: "); 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); if(u_error_code == U_ZERO_ERROR) tb_printf(mid_x + 15, rr, TB_WHITE, TB_BLUE, "%s", strBuffer);
rr++; rr++;
@@ -313,155 +313,156 @@ int compare(const char *path1, const char *path2)
tb_present(); 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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, tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media", ctx1->media_sequence,
ctx1->LastMediaSequence); 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", 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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 || if(ctx1->cylinders > 0 || ctx1->heads > 0 || ctx1->sectors_per_track > 0 || ctx2->cylinders > 0 ||
ctx2->SectorsPerTrack > 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", 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, 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, "Media has %d cylinders, %d heads and %d sectors per track", ctx2->cylinders, ctx2->heads,
ctx2->SectorsPerTrack); ctx2->sectors_per_track);
} }
tb_present(); tb_present();
lr++; lr++;
uint64_t sectors = ctx1->imageInfo.Sectors; uint64_t sectors = ctx1->image_info.Sectors;
if(ctx2->imageInfo.Sectors < sectors) sectors = ctx2->imageInfo.Sectors; if(ctx2->image_info.Sectors < sectors) sectors = ctx2->image_info.Sectors;
bool imageContentsAreDifferent = false; bool imageContentsAreDifferent = false;
uint32_t sectorSize = ctx1->imageInfo.SectorSize; uint32_t sectorSize = ctx1->image_info.SectorSize;
if(ctx2->imageInfo.SectorSize > sectorSize) sectorSize = ctx2->imageInfo.SectorSize; if(ctx2->image_info.SectorSize > sectorSize) sectorSize = ctx2->image_info.SectorSize;
uint8_t *buffer1 = malloc(sectorSize); uint8_t *buffer1 = malloc(sectorSize);
if(buffer1 == NULL) if(buffer1 == NULL)

18
tool/convert.c
View File

@@ -30,12 +30,12 @@
int convert(const char *input_path, const char *output_path) int convert(const char *input_path, const char *output_path)
{ {
aaruformatContext *input_ctx = NULL; aaruformat_context *input_ctx = NULL;
aaruformatContext *output_ctx = NULL; aaruformat_context *output_ctx = NULL;
int32_t res = 0; int32_t res = 0;
uint32_t sector_size = 0; uint32_t sector_size = 0;
uint64_t total_sectors = 0; uint64_t total_sectors = 0;
uint8_t *sector_data = NULL; uint8_t *sector_data = NULL;
printf("Converting image from %s to %s...\n", input_path, output_path); 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 // Get image information from input
total_sectors = input_ctx->imageInfo.Sectors; total_sectors = input_ctx->image_info.Sectors;
sector_size = input_ctx->imageInfo.SectorSize; sector_size = input_ctx->image_info.SectorSize;
printf("Input image has %llu sectors of %u bytes each.\n", total_sectors, sector_size); 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); free(app_name_utf16);
// Create output image // 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, // negative sectors
0, // overflow sectors 0, // overflow sectors
NULL, // options 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) int info(const char *path)
{ {
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
char *strBuffer = NULL; char *strBuffer = NULL;
UErrorCode u_error_code = U_ZERO_ERROR; UErrorCode u_error_code = U_ZERO_ERROR;
uint i = 0; uint i = 0;
@@ -86,7 +86,7 @@ int info(const char *path)
printf("AaruFormat context information:\n"); printf("AaruFormat context information:\n");
printf("Magic number: %8.8s\n", (char *)&ctx->magic); 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("AaruFormat header:\n");
printf("\tIdentifier: %8.8s\n", (char *)&ctx->header.identifier); 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->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->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"); 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); 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 cylinders = 0;
uint32_t heads = 0; uint32_t heads = 0;
@@ -421,181 +421,183 @@ int info(const char *path)
} }
// TODO: Table format? // TODO: Table format?
if(ctx->tracksHeader.identifier == TracksBlock) if(ctx->tracks_header.identifier == TracksBlock)
{ {
printf("Tracks block:\n"); 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("\tTrack entry %d:\n", i);
printf("\t\tSequence: %d\n", ctx->trackEntries[i].sequence); printf("\t\tSequence: %d\n", ctx->track_entries[i].sequence);
printf("\t\tType: %d\n", ctx->trackEntries[i].type); printf("\t\tType: %d\n", ctx->track_entries[i].type);
printf("\t\tStart: %lld\n", ctx->trackEntries[i].start); printf("\t\tStart: %lld\n", ctx->track_entries[i].start);
printf("\t\tEnd: %lld\n", ctx->trackEntries[i].end); printf("\t\tEnd: %lld\n", ctx->track_entries[i].end);
printf("\t\tPregap: %lld\n", ctx->trackEntries[i].pregap); printf("\t\tPregap: %lld\n", ctx->track_entries[i].pregap);
printf("\t\tSession: %d\n", ctx->trackEntries[i].session); printf("\t\tSession: %d\n", ctx->track_entries[i].session);
printf("\t\tISRC: %.13s\n", ctx->trackEntries[i].isrc); printf("\t\tISRC: %.13s\n", ctx->track_entries[i].isrc);
printf("\t\tFlags: %d\n", ctx->trackEntries[i].flags); 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("CICM block:\n");
printf("%s", ctx->cicmBlock); printf("%s", ctx->cicm_block);
} }
// TODO: Table format? // TODO: Table format?
if(ctx->dumpHardwareHeader.identifier == DumpHardwareBlock) if(ctx->dump_hardware_header.identifier == DumpHardwareBlock)
{ {
printf("Dump hardware block:\n"); 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); 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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength + 1); memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength, (int)ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength,
(char *)ctx->dumpHardwareEntriesWithData[i].manufacturer, (char *)ctx->dump_hardware_entries_with_data[i].manufacturer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength, &u_error_code); (int)ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength, &u_error_code);
printf("\t\tManufacturer: %s\n", strBuffer); printf("\t\tManufacturer: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.modelLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[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->dumpHardwareEntriesWithData[i].entry.modelLength, ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dump_hardware_entries_with_data[i].entry.modelLength,
(char *)ctx->dumpHardwareEntriesWithData[i].model, (char *)ctx->dump_hardware_entries_with_data[i].model,
(int)ctx->dumpHardwareEntriesWithData[i].entry.modelLength, &u_error_code); (int)ctx->dump_hardware_entries_with_data[i].entry.modelLength, &u_error_code);
printf("\t\tModel: %s\n", strBuffer); printf("\t\tModel: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.revisionLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[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->dumpHardwareEntriesWithData[i].entry.revisionLength, ucnv_convert(NULL, "UTF-8", strBuffer,
(char *)ctx->dumpHardwareEntriesWithData[i].revision, (int)ctx->dump_hardware_entries_with_data[i].entry.revisionLength,
(int)ctx->dumpHardwareEntriesWithData[i].entry.revisionLength, &u_error_code); (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); printf("\t\tRevision: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[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->dumpHardwareEntriesWithData[i].entry.firmwareLength, ucnv_convert(NULL, "UTF-8", strBuffer,
(char *)ctx->dumpHardwareEntriesWithData[i].firmware, (int)ctx->dump_hardware_entries_with_data[i].entry.firmwareLength,
(int)ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength, &u_error_code); (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); printf("\t\tFirmware version: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.serialLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[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->dumpHardwareEntriesWithData[i].entry.serialLength, ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dump_hardware_entries_with_data[i].entry.serialLength,
(char *)ctx->dumpHardwareEntriesWithData[i].serial, (char *)ctx->dump_hardware_entries_with_data[i].serial,
(int)ctx->dumpHardwareEntriesWithData[i].entry.serialLength, &u_error_code); (int)ctx->dump_hardware_entries_with_data[i].entry.serialLength, &u_error_code);
printf("\t\tSerial number: %s\n", strBuffer); printf("\t\tSerial number: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength + 1); memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength, (int)ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength,
(char *)ctx->dumpHardwareEntriesWithData[i].softwareName, (char *)ctx->dump_hardware_entries_with_data[i].softwareName,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength, &u_error_code); (int)ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength, &u_error_code);
printf("\t\tSoftware name: %s\n", strBuffer); printf("\t\tSoftware name: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength + 1); memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength, (int)ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength,
(char *)ctx->dumpHardwareEntriesWithData[i].softwareVersion, (char *)ctx->dump_hardware_entries_with_data[i].softwareVersion,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength, &u_error_code); (int)ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength, &u_error_code);
printf("\t\tSoftware version: %s\n", strBuffer); printf("\t\tSoftware version: %s\n", strBuffer);
free(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); strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + 1);
memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength + 1); memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + 1);
ucnv_convert(NULL, "UTF-8", strBuffer, ucnv_convert(NULL, "UTF-8", strBuffer,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength, (int)ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength,
(char *)ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem, (char *)ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem,
(int)ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength, (int)ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength,
&u_error_code); &u_error_code);
printf("\t\tSoftware operating system: %s\n", strBuffer); printf("\t\tSoftware operating system: %s\n", strBuffer);
free(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\tExtent %d:\n", j);
printf("\t\t\tStart: %llu\n", ctx->dumpHardwareEntriesWithData[i].extents[j].start); printf("\t\t\tStart: %llu\n", ctx->dump_hardware_entries_with_data[i].extents[j].start);
printf("\t\t\tEnd: %llu\n", ctx->dumpHardwareEntriesWithData[i].extents[j].end); 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; // 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"); 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->blockHeaderCache.max_items); 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"); 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->blockCache.max_items); printf("Block cache can contain a maximum of %llu items.\n", ctx->block_cache.max_items);
} }
printf("Aaru's ImageInfo:\n"); printf("Aaru's ImageInfo:\n");
printf("\tHas partitions?: %s\n", ctx->imageInfo.HasPartitions ? "yes" : "no"); printf("\tHas partitions?: %s\n", ctx->image_info.HasPartitions ? "yes" : "no");
printf("\tHas sessions?: %s\n", ctx->imageInfo.HasSessions ? "yes" : "no"); printf("\tHas sessions?: %s\n", ctx->image_info.HasSessions ? "yes" : "no");
printf("\tImage size without headers: %llu bytes\n", ctx->imageInfo.ImageSize); printf("\tImage size without headers: %llu bytes\n", ctx->image_info.ImageSize);
printf("\tImage contains %llu sectors\n", ctx->imageInfo.Sectors); printf("\tImage contains %llu sectors\n", ctx->image_info.Sectors);
printf("\tBiggest sector is %d bytes\n", ctx->imageInfo.SectorSize); printf("\tBiggest sector is %d bytes\n", ctx->image_info.SectorSize);
printf("\tImage version: %s\n", ctx->imageInfo.Version); printf("\tImage version: %s\n", ctx->image_info.Version);
if(ctx->imageInfo.Application != NULL) if(ctx->image_info.Application != NULL)
{ {
strBuffer = malloc(65); strBuffer = malloc(65);
memset(strBuffer, 0, 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); if(u_error_code == U_ZERO_ERROR) printf("\tApplication: %s\n", strBuffer);
free(strBuffer); free(strBuffer);
} }
if(ctx->imageInfo.ApplicationVersion != NULL) if(ctx->image_info.ApplicationVersion != NULL)
printf("\tApplication version: %s\n", ctx->imageInfo.ApplicationVersion); printf("\tApplication version: %s\n", ctx->image_info.ApplicationVersion);
printf("\tCreation time: %s\n", format_filetime(ctx->imageInfo.CreationTime)); printf("\tCreation time: %s\n", format_filetime(ctx->image_info.CreationTime));
printf("\tLast written time: %s\n", format_filetime(ctx->imageInfo.LastModificationTime)); printf("\tLast written time: %s\n", format_filetime(ctx->image_info.LastModificationTime));
printf("\tMedia type: %u (%s)\n", ctx->imageInfo.MediaType, media_type_to_string(ctx->imageInfo.MediaType)); 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->imageInfo.MetadataMediaType); printf("\tXML media type: %d\n", ctx->image_info.MetadataMediaType);
if(ctx->checksums.hasMd5) 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) int read(const unsigned long long sector_no, const char *path)
{ {
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
int32_t res = 0; int32_t res = 0;
uint32_t length = 0; uint32_t length = 0;
uint8_t *data = NULL; uint8_t *data = NULL;
ctx = aaruf_open(path); 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) int read_long(const unsigned long long sector_no, const char *path)
{ {
aaruformatContext *ctx = NULL; aaruformat_context *ctx = NULL;
int32_t res = 0; int32_t res = 0;
uint32_t length = 0; uint32_t length = 0;
uint8_t *data = NULL; uint8_t *data = NULL;
ctx = aaruf_open(path); ctx = aaruf_open(path);

24
tool/verify.c
View File

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