diff --git a/include/aaruformat/context.h b/include/aaruformat/context.h index f659363..834b1a7 100644 --- a/include/aaruformat/context.h +++ b/include/aaruformat/context.h @@ -144,7 +144,7 @@ typedef struct TapeDdtHashEntry UT_hash_handle hh; ///< UTHASH handle } TapeDdtHashEntry; -/** \struct aaruformatContext +/** \struct aaruformat_context * \brief Master context representing an open or in‑creation Aaru image. * * Contains stream handle, parsed headers, deduplication structures, optical extras, metadata blocks, checksum @@ -168,38 +168,38 @@ typedef struct TapeDdtHashEntry * - shift retained for backward compatibility with earlier single‑level address shift semantics. * - mappedMemoryDdtSize is meaningful only if userDataDdt references an mmapped region. */ -typedef struct aaruformatContext +typedef struct aaruformat_context { /* Core & header */ - uint64_t magic; ///< File magic (AARU_MAGIC) post-open. - AaruHeaderV2 header; ///< Parsed container header (v2). - uint8_t libraryMajorVersion; ///< Linked library major version. - uint8_t libraryMinorVersion; ///< Linked library minor version. - FILE *imageStream; ///< Underlying FILE* stream (binary mode). + uint64_t magic; ///< File magic (AARU_MAGIC) post-open. + AaruHeaderV2 header; ///< Parsed container header (v2). + uint8_t library_major_version; ///< Linked library major version. + uint8_t library_minor_version; ///< Linked library minor version. + FILE *imageStream; ///< Underlying FILE* stream (binary mode). /* Deduplication tables (DDT) */ - uint8_t shift; ///< Legacy overall shift (deprecated by data_shift/table_shift). - bool inMemoryDdt; ///< True if primary (and possibly secondary) DDT loaded. - uint64_t *userDataDdt; ///< Legacy flat DDT pointer (NULL when using v2 mini/big arrays). - size_t mappedMemoryDdtSize; ///< Length of mmapped DDT if userDataDdt is mmapped. - uint32_t *sectorPrefixDdt; ///< Legacy CD sector prefix DDT (deprecated by *2). - uint32_t *sectorSuffixDdt; ///< Legacy CD sector suffix DDT. - uint32_t *sectorPrefixDdt2; ///< CD sector prefix DDT V2. - uint32_t *sectorSuffixDdt2; ///< CD sector suffix DDT V2. - TapeDdtHashEntry *tapeDdt; ///< Hash table root for tape DDT entries - DdtHeader2 userDataDdtHeader; ///< Active user data DDT v2 header (primary table meta). - int ddtVersion; ///< DDT version in use (1=legacy, 2=v2 hierarchical). - uint32_t *userDataDdtBig; ///< DDT entries (big variant) primary/secondary current. - uint64_t cachedDdtOffset; ///< File offset of currently cached secondary DDT (0=none). - uint64_t cachedDdtPosition; ///< Position index of cached secondary DDT. - uint64_t primaryDdtOffset; ///< File offset of the primary DDT v2 table. - uint32_t *cachedSecondaryDdtBig; ///< Cached secondary table (big entries) or NULL. + uint8_t shift; ///< Legacy overall shift (deprecated by data_shift/table_shift). + bool in_memory_ddt; ///< True if primary (and possibly secondary) DDT loaded. + uint64_t *user_data_ddt; ///< Legacy flat DDT pointer (NULL when using v2 mini/big arrays). + size_t mapped_memory_ddt_size; ///< Length of mmapped DDT if userDataDdt is mmapped. + uint32_t *sector_prefix_ddt; ///< Legacy CD sector prefix DDT (deprecated by *2). + uint32_t *sector_suffix_ddt; ///< Legacy CD sector suffix DDT. + uint32_t *sector_prefix_ddt2; ///< CD sector prefix DDT V2. + uint32_t *sector_suffix_ddt2; ///< CD sector suffix DDT V2. + TapeDdtHashEntry *tape_ddt; ///< Hash table root for tape DDT entries + DdtHeader2 user_data_ddt_header; ///< Active user data DDT v2 header (primary table meta). + int ddt_version; ///< DDT version in use (1=legacy, 2=v2 hierarchical). + uint32_t *user_data_ddt2; ///< DDT entries (big variant) primary/secondary current. + uint64_t cached_ddt_offset; ///< File offset of currently cached secondary DDT (0=none). + uint64_t cached_ddt_position; ///< Position index of cached secondary DDT. + uint64_t primary_ddt_offset; ///< File offset of the primary DDT v2 table. + uint32_t *cached_secondary_ddt2; ///< Cached secondary table (big entries) or NULL. /* Optical auxiliary buffers (NULL if not present) */ uint8_t *sector_prefix; ///< Raw per-sector prefix (e.g., sync+header) uncorrected. - uint8_t *sectorPrefixCorrected; ///< Corrected variant (post error correction) if stored. + uint8_t *sector_prefix_corrected; ///< Corrected variant (post error correction) if stored. uint8_t *sector_suffix; ///< Raw per-sector suffix (EDC/ECC) uncorrected. - uint8_t *sectorSuffixCorrected; ///< Corrected suffix if stored separately. + uint8_t *sector_suffix_corrected; ///< Corrected suffix if stored separately. uint8_t *sector_subchannel; ///< Raw 96-byte subchannel (if captured). uint8_t *mode2_subheaders; ///< MODE2 Form1/Form2 8-byte subheaders (concatenated). uint8_t *sector_id; ///< DVD sector ID (4 bytes) if present. @@ -209,54 +209,55 @@ typedef struct aaruformatContext uint8_t *sector_decrypted_title_key; ///< DVD decrypted title key (5 bytes) if present. /* Metadata & geometry */ - GeometryBlockHeader geometryBlock; ///< Logical geometry block (if present). - MetadataBlockHeader metadataBlockHeader; ///< Metadata block header. - uint8_t *metadataBlock; ///< Raw metadata UTF-16LE concatenated strings. - CicmMetadataBlock cicmBlockHeader; ///< CICM metadata header (if present). - uint8_t *cicmBlock; ///< CICM XML payload. - DumpHardwareHeader dumpHardwareHeader; ///< Dump hardware header. - struct DumpHardwareEntriesWithData *dumpHardwareEntriesWithData; ///< Array of dump hardware entries + strings. - AaruMetadataJsonBlockHeader jsonBlockHeader; ///< JSON metadata block header (if present). - uint8_t *jsonBlock; ///< JSON metadata block payload (UTF-8). - uint8_t *Creator; ///< Who (person) created the image? - uint8_t *MediaTitle; ///< Title of the media represented by the image - uint8_t *Comments; ///< Image comments - uint8_t *MediaManufacturer; ///< Manufacturer of the media represented by the image - uint8_t *MediaModel; ///< Model of the media represented by the image - uint8_t *MediaSerialNumber; ///< Serial number of the media represented by the image - uint8_t *MediaBarcode; ///< Barcode of the media represented by the image - uint8_t *MediaPartNumber; ///< Part number of the media represented by the image - uint8_t *DriveManufacturer; ///< Manufacturer of the drive used to read the media represented by the image - uint8_t *DriveModel; ///< Model of the drive used to read the media represented by the image - uint8_t *DriveSerialNumber; ///< Serial number of the drive used to read the media represented by the image - uint8_t *DriveFirmwareRevision; ///< Firmware revision of the drive used to read the media represented by the image - int32_t MediaSequence; ///< Number in sequence for the media represented by the image - int32_t LastMediaSequence; ///< Last media of the sequence the media represented by the image corresponds to - uint32_t Cylinders; ///< Cylinders of the media represented by the image - uint32_t Heads; ///< Heads of the media represented by the image - uint32_t SectorsPerTrack; ///< Sectors per track of the media represented by the image (for variable image, the - ///< smallest) + GeometryBlockHeader geometry_block; ///< Logical geometry block (if present). + MetadataBlockHeader metadata_block_header; ///< Metadata block header. + uint8_t *metadata_block; ///< Raw metadata UTF-16LE concatenated strings. + CicmMetadataBlock cicm_block_header; ///< CICM metadata header (if present). + uint8_t *cicm_block; ///< CICM XML payload. + DumpHardwareHeader dump_hardware_header; ///< Dump hardware header. + struct DumpHardwareEntriesWithData *dump_hardware_entries_with_data; ///< Array of dump hardware entries + strings. + AaruMetadataJsonBlockHeader json_block_header; ///< JSON metadata block header (if present). + uint8_t *json_block; ///< JSON metadata block payload (UTF-8). + uint8_t *creator; ///< Who (person) created the image? + uint8_t *media_title; ///< Title of the media represented by the image + uint8_t *comments; ///< Image comments + uint8_t *media_manufacturer; ///< Manufacturer of the media represented by the image + uint8_t *media_model; ///< Model of the media represented by the image + uint8_t *media_serial_number; ///< Serial number of the media represented by the image + uint8_t *media_barcode; ///< Barcode of the media represented by the image + uint8_t *media_part_number; ///< Part number of the media represented by the image + uint8_t *drive_manufacturer; ///< Manufacturer of the drive used to read the media represented by the image + uint8_t *drive_model; ///< Model of the drive used to read the media represented by the image + uint8_t *drive_serial_number; ///< Serial number of the drive used to read the media represented by the image + uint8_t + *drive_firmware_revision; ///< Firmware revision of the drive used to read the media represented by the image + int32_t media_sequence; ///< Number in sequence for the media represented by the image + int32_t last_media_sequence; ///< Last media of the sequence the media represented by the image corresponds to + uint32_t cylinders; ///< Cylinders of the media represented by the image + uint32_t heads; ///< Heads of the media represented by the image + uint32_t sectors_per_track; ///< Sectors per track of the media represented by the image (for variable image, the + ///< smallest) /* Optical information */ - TracksHeader tracksHeader; ///< Tracks header (optical) if present. - TrackEntry *trackEntries; ///< Full track list (tracksHeader.entries elements). - uint8_t numberOfDataTracks; ///< Count of tracks considered "data" (sequence 1..99 heuristics). - TrackEntry *dataTracks; ///< Filtered list of data tracks (subset of trackEntries). + TracksHeader tracks_header; ///< Tracks header (optical) if present. + TrackEntry *track_entries; ///< Full track list (tracksHeader.entries elements). + uint8_t number_of_data_tracks; ///< Count of tracks considered "data" (sequence 1..99 heuristics). + TrackEntry *data_tracks; ///< Filtered list of data tracks (subset of trackEntries). /* Integrity & ECC */ - CdEccContext *eccCdContext; ///< CD ECC/EDC helper tables (allocated on demand). - crc64_ctx *crc64Context; ///< Opaque CRC64 context for streaming updates. + CdEccContext *ecc_cd_context; ///< CD ECC/EDC helper tables (allocated on demand). + crc64_ctx *crc64_context; ///< Opaque CRC64 context for streaming updates. /* Index & deduplication lookup */ - UT_array *indexEntries; ///< Flattened index entries (UT_array of IndexEntry). - hash_map_t *sectorHashMap; ///< Deduplication hash map (fingerprint->entry mapping). + UT_array *index_entries; ///< Flattened index entries (UT_array of IndexEntry). + hash_map_t *sector_hash_map; ///< Deduplication hash map (fingerprint->entry mapping). /* Caches */ - struct CacheHeader blockHeaderCache; ///< LRU/Cache header for block headers. - struct CacheHeader blockCache; ///< LRU/Cache header for block payloads. + struct CacheHeader block_header_cache; ///< LRU/Cache header for block headers. + struct CacheHeader block_cache; ///< LRU/Cache header for block payloads. /* High-level summary */ - ImageInfo imageInfo; ///< Exposed high-level image info summary. + ImageInfo image_info; ///< Exposed high-level image info summary. /* Tags */ bool *readableSectorTags; ///< Per-sector boolean array (optical tags read successfully?). @@ -276,17 +277,17 @@ typedef struct aaruformatContext blake3_hasher *blake3_context; ///< Opaque BLAKE3 context for streaming updates /* Write path */ - bool isWriting; ///< True if context opened/created for writing. - BlockHeader currentBlockHeader; ///< Header for block currently being assembled (write path). - uint8_t *writingBuffer; ///< Accumulation buffer for current block data. - int currentBlockOffset; ///< Logical offset inside block (units: bytes or sectors depending on path). - int writingBufferPosition; ///< Current size / position within writingBuffer. - uint64_t nextBlockPosition; ///< Absolute file offset where next block will be written. - bool rewinded; ///< True if stream has been rewound after open (write path). - uint64_t last_written_block; ///< Last written block number (write path). - uint8_t currentTrackType; ///< Current track type (when writing optical images with tracks, needed for block - ///< compression type). - bool writingLong; ///< True if writing long sectors + bool is_writing; ///< True if context opened/created for writing. + BlockHeader current_block_header; ///< Header for block currently being assembled (write path). + uint8_t *writing_buffer; ///< Accumulation buffer for current block data. + int current_block_offset; ///< Logical offset inside block (units: bytes or sectors depending on path). + int writing_buffer_position; ///< Current size / position within writingBuffer. + uint64_t next_block_position; ///< Absolute file offset where next block will be written. + bool rewinded; ///< True if stream has been rewound after open (write path). + uint64_t last_written_block; ///< Last written block number (write path). + uint8_t current_track_type; ///< Current track type (when writing optical images with tracks, needed for block + ///< compression type). + bool writing_long; ///< True if writing long sectors size_t sector_prefix_length; ///< Length of sector_prefix size_t sector_suffix_length; ///< Length of sector_suffix size_t sector_prefix_offset; ///< Current position in sector_prefix @@ -298,10 +299,10 @@ typedef struct aaruformatContext uint32_t lzma_dict_size; ///< LZMA dictionary size (writing path). /* Tape-specific structures */ - tapeFileHashEntry *tapeFiles; ///< Hash table root for tape files - TapePartitionHashEntry *tapePartitions; ///< Hash table root for tape partitions - bool is_tape; ///< True if the image is a tape image -} aaruformatContext; + tapeFileHashEntry *tape_files; ///< Hash table root for tape files + TapePartitionHashEntry *tape_partitions; ///< Hash table root for tape partitions + bool is_tape; ///< True if the image is a tape image +} aaruformat_context; /** \struct DumpHardwareEntriesWithData * \brief In-memory representation of a dump hardware entry plus decoded variable-length fields & extents. diff --git a/include/internal.h b/include/internal.h index 946859e..4f46205 100644 --- a/include/internal.h +++ b/include/internal.h @@ -21,43 +21,43 @@ #include "utarray.h" -UT_array *process_index_v1(aaruformatContext *ctx); -int32_t verify_index_v1(aaruformatContext *ctx); -UT_array *process_index_v2(aaruformatContext *ctx); -int32_t verify_index_v2(aaruformatContext *ctx); -UT_array *process_index_v3(aaruformatContext *ctx); -int32_t verify_index_v3(aaruformatContext *ctx); -int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry); -int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt); -int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt); -void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_aaru_metadata_json_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry); -void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *entry); -int32_t decode_ddt_entry_v1(aaruformatContext *ctx, uint64_t sector_address, uint64_t *offset, uint64_t *block_offset, - uint8_t *sector_status); -int32_t decode_ddt_entry_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset, - uint64_t *block_offset, uint8_t *sector_status); -int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset, - uint64_t *block_offset, uint8_t *sector_status); -int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset, - uint64_t *block_offset, uint8_t *sector_status); -bool set_ddt_entry_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset, - uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry); -bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset, - uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry); -bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset, - uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry); -bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, uint64_t offset, uint64_t block_offset, - uint8_t sector_status, uint64_t *ddt_entry); +UT_array *process_index_v1(aaruformat_context *ctx); +int32_t verify_index_v1(aaruformat_context *ctx); +UT_array *process_index_v2(aaruformat_context *ctx); +int32_t verify_index_v2(aaruformat_context *ctx); +UT_array *process_index_v3(aaruformat_context *ctx); +int32_t verify_index_v3(aaruformat_context *ctx); +int32_t process_data_block(aaruformat_context *ctx, IndexEntry *entry); +int32_t process_ddt_v1(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt); +int32_t process_ddt_v2(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt); +void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_geometry_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_tracks_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_cicm_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_aaru_metadata_json_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_dumphw_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_checksum_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_tape_files_block(aaruformat_context *ctx, const IndexEntry *entry); +void process_tape_partitions_block(aaruformat_context *ctx, const IndexEntry *entry); +int32_t decode_ddt_entry_v1(aaruformat_context *ctx, uint64_t sector_address, uint64_t *offset, uint64_t *block_offset, + uint8_t *sector_status); +int32_t decode_ddt_entry_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset, + uint64_t *block_offset, uint8_t *sector_status); +int32_t decode_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset, + uint64_t *block_offset, uint8_t *sector_status); +int32_t decode_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset, + uint64_t *block_offset, uint8_t *sector_status); +bool set_ddt_entry_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset, + uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry); +bool set_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset, + uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry); +bool set_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset, + uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry); +bool set_ddt_tape(aaruformat_context *ctx, uint64_t sector_address, uint64_t offset, uint64_t block_offset, + uint8_t sector_status, uint64_t *ddt_entry); aaru_options parse_options(const char *options); uint64_t get_filetime_uint64(); -int32_t aaruf_close_current_block(aaruformatContext *ctx); +int32_t aaruf_close_current_block(aaruformat_context *ctx); int compare_extents(const void *a, const void *b); #endif // LIBAARUFORMAT_INTERNAL_H diff --git a/src/blocks/checksum.c b/src/blocks/checksum.c index c2a9f9c..5773e39 100644 --- a/src/blocks/checksum.c +++ b/src/blocks/checksum.c @@ -36,7 +36,7 @@ * @param ctx Pointer to the aaruformat context. * @param entry Pointer to the index entry describing the checksum block. */ -void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_checksum_block(aaruformat_context *ctx, const IndexEntry *entry) { TRACE("Entering process_checksum_block(%p, %p)", ctx, entry); diff --git a/src/blocks/data.c b/src/blocks/data.c index b53e1e1..fba35ee 100644 --- a/src/blocks/data.c +++ b/src/blocks/data.c @@ -68,7 +68,7 @@ * the context is destroyed. The function may replace existing data in the context. */ -int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry) +int32_t process_data_block(aaruformat_context *ctx, IndexEntry *entry) { TRACE("Entering process_data_block(%p, %p)", ctx, entry); BlockHeader block_header; @@ -119,15 +119,15 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry) return AARUF_STATUS_OK; } - ctx->imageInfo.ImageSize += block_header.cmpLength; + ctx->image_info.ImageSize += block_header.cmpLength; // Unused, skip if(entry->dataType == UserData) { - if(block_header.sectorSize > ctx->imageInfo.SectorSize) + if(block_header.sectorSize > ctx->image_info.SectorSize) { TRACE("Setting sector size to %" PRIu64 " bytes", block_header.sectorSize); - ctx->imageInfo.SectorSize = block_header.sectorSize; + ctx->image_info.SectorSize = block_header.sectorSize; } TRACE("Exiting process_data_block() = AARUF_STATUS_OK"); @@ -339,7 +339,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry) { case CdSectorPrefix: case CdSectorPrefixCorrected: - if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixCorrected = data; } + if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_corrected = data; } else ctx->sector_prefix = data; @@ -350,7 +350,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry) case CdSectorSuffix: case CdSectorSuffixCorrected: if(entry->dataType == CdSectorSuffixCorrected) - ctx->sectorSuffixCorrected = data; + ctx->sector_suffix_corrected = data; else ctx->sector_suffix = data; diff --git a/src/blocks/dump.c b/src/blocks/dump.c index 19af0d5..95b2bb3 100644 --- a/src/blocks/dump.c +++ b/src/blocks/dump.c @@ -51,14 +51,14 @@ static void free_dump_hardware_entries_array(DumpHardwareEntriesWithData *entrie } } -static void reset_dump_hardware_context(aaruformatContext *ctx) +static void reset_dump_hardware_context(aaruformat_context *ctx) { if(ctx == NULL) return; - free_dump_hardware_entries_array(ctx->dumpHardwareEntriesWithData, ctx->dumpHardwareHeader.entries); - free(ctx->dumpHardwareEntriesWithData); - ctx->dumpHardwareEntriesWithData = NULL; - memset(&ctx->dumpHardwareHeader, 0, sizeof(ctx->dumpHardwareHeader)); + free_dump_hardware_entries_array(ctx->dump_hardware_entries_with_data, ctx->dump_hardware_header.entries); + free(ctx->dump_hardware_entries_with_data); + ctx->dump_hardware_entries_with_data = NULL; + memset(&ctx->dump_hardware_header, 0, sizeof(ctx->dump_hardware_header)); } static bool read_dump_string(FILE *stream, const char *field_name, uint32_t length, uint32_t *remaining, @@ -105,7 +105,7 @@ static bool read_dump_string(FILE *stream, const char *field_name, uint32_t leng * @param ctx Pointer to the aaruformat context. * @param entry Pointer to the index entry describing the dump hardware block. */ -void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_dumphw_block(aaruformat_context *ctx, const IndexEntry *entry) { TRACE("Entering process_dumphw_block(%p, %p)", ctx, entry); size_t read_bytes = 0; @@ -214,7 +214,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry) if(header.entries == 0) { reset_dump_hardware_context(ctx); - ctx->dumpHardwareHeader = header; + ctx->dump_hardware_header = header; TRACE("Dump hardware block contains no entries. Clearing existing metadata."); TRACE("Exiting process_dumphw_block()"); return; @@ -336,8 +336,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry) } reset_dump_hardware_context(ctx); - ctx->dumpHardwareEntriesWithData = entries; - ctx->dumpHardwareHeader = header; + ctx->dump_hardware_entries_with_data = entries; + ctx->dump_hardware_header = header; if(remaining_payload != 0) { diff --git a/src/blocks/metadata.c b/src/blocks/metadata.c index 4534124..a6e1ed9 100644 --- a/src/blocks/metadata.c +++ b/src/blocks/metadata.c @@ -32,7 +32,7 @@ * @param ctx Pointer to the aaruformat context. * @param entry Pointer to the index entry describing the metadata block. */ -void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_metadata_block(aaruformat_context *ctx, const IndexEntry *entry) { TRACE("Entering process_metadata_block(%p, %p)", ctx, entry); int pos = 0; @@ -59,176 +59,177 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry) // Even if those two checks shall have been done before TRACE("Reading metadata block header at position %" PRIu64, entry->offset); - read_bytes = fread(&ctx->metadataBlockHeader, 1, sizeof(MetadataBlockHeader), ctx->imageStream); + read_bytes = fread(&ctx->metadata_block_header, 1, sizeof(MetadataBlockHeader), ctx->imageStream); if(read_bytes != sizeof(MetadataBlockHeader)) { - memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); + memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader)); FATAL("Could not read metadata block header, continuing..."); TRACE("Exiting process_metadata_block()"); return; } - if(ctx->metadataBlockHeader.identifier != entry->blockType) + if(ctx->metadata_block_header.identifier != entry->blockType) { - memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); + memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader)); TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset); TRACE("Exiting process_metadata_block()"); return; } - ctx->imageInfo.ImageSize += ctx->metadataBlockHeader.blockSize; + ctx->image_info.ImageSize += ctx->metadata_block_header.blockSize; - ctx->metadataBlock = (uint8_t *)malloc(ctx->metadataBlockHeader.blockSize); + ctx->metadata_block = (uint8_t *)malloc(ctx->metadata_block_header.blockSize); - if(ctx->metadataBlock == NULL) + if(ctx->metadata_block == NULL) { - memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); + memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader)); FATAL("Could not allocate memory for metadata block, continuing..."); TRACE("Exiting process_metadata_block()"); return; } - TRACE("Reading metadata block of size %u at position %" PRIu64, ctx->metadataBlockHeader.blockSize, + TRACE("Reading metadata block of size %u at position %" PRIu64, ctx->metadata_block_header.blockSize, entry->offset + sizeof(MetadataBlockHeader)); - read_bytes = fread(ctx->metadataBlock, 1, ctx->metadataBlockHeader.blockSize, ctx->imageStream); + read_bytes = fread(ctx->metadata_block, 1, ctx->metadata_block_header.blockSize, ctx->imageStream); - if(read_bytes != ctx->metadataBlockHeader.blockSize) + if(read_bytes != ctx->metadata_block_header.blockSize) { - memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); - free(ctx->metadataBlock); + memset(&ctx->metadata_block_header, 0, sizeof(MetadataBlockHeader)); + free(ctx->metadata_block); FATAL("Could not read metadata block, continuing..."); } - if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0) + if(ctx->metadata_block_header.mediaSequence > 0 && ctx->metadata_block_header.lastMediaSequence > 0) { - ctx->MediaSequence = ctx->metadataBlockHeader.mediaSequence; - ctx->LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence; - TRACE("Setting media sequence as %d of %d", ctx->MediaSequence, ctx->LastMediaSequence); + ctx->media_sequence = ctx->metadata_block_header.mediaSequence; + ctx->last_media_sequence = ctx->metadata_block_header.lastMediaSequence; + TRACE("Setting media sequence as %d of %d", ctx->media_sequence, ctx->last_media_sequence); } - if(ctx->metadataBlockHeader.creatorLength > 0 && - ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.creatorLength > 0 && + ctx->metadata_block_header.creatorOffset + ctx->metadata_block_header.creatorLength <= + ctx->metadata_block_header.blockSize) { - ctx->Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength); - if(ctx->Creator != NULL) - memcpy(ctx->Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset, - ctx->metadataBlockHeader.creatorLength); + ctx->creator = (uint8_t *)malloc(ctx->metadata_block_header.creatorLength); + if(ctx->creator != NULL) + memcpy(ctx->creator, ctx->metadata_block + ctx->metadata_block_header.creatorOffset, + ctx->metadata_block_header.creatorLength); } - if(ctx->metadataBlockHeader.commentsLength > 0 && - ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.commentsLength > 0 && + ctx->metadata_block_header.commentsOffset + ctx->metadata_block_header.commentsLength <= + ctx->metadata_block_header.blockSize) { - ctx->Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength); - if(ctx->Comments != NULL) - memcpy(ctx->Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset, - ctx->metadataBlockHeader.commentsLength); + ctx->comments = (uint8_t *)malloc(ctx->metadata_block_header.commentsLength); + if(ctx->comments != NULL) + memcpy(ctx->comments, ctx->metadata_block + ctx->metadata_block_header.commentsOffset, + ctx->metadata_block_header.commentsLength); } - if(ctx->metadataBlockHeader.mediaTitleLength > 0 && - ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.mediaTitleLength > 0 && + ctx->metadata_block_header.mediaTitleOffset + ctx->metadata_block_header.mediaTitleLength <= + ctx->metadata_block_header.blockSize) { - ctx->MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength); - if(ctx->MediaTitle != NULL) - memcpy(ctx->MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset, - ctx->metadataBlockHeader.mediaTitleLength); + ctx->media_title = (uint8_t *)malloc(ctx->metadata_block_header.mediaTitleLength); + if(ctx->media_title != NULL) + memcpy(ctx->media_title, ctx->metadata_block + ctx->metadata_block_header.mediaTitleOffset, + ctx->metadata_block_header.mediaTitleLength); } - if(ctx->metadataBlockHeader.mediaManufacturerLength > 0 && - ctx->metadataBlockHeader.mediaManufacturerOffset + ctx->metadataBlockHeader.mediaManufacturerLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.mediaManufacturerLength > 0 && + ctx->metadata_block_header.mediaManufacturerOffset + ctx->metadata_block_header.mediaManufacturerLength <= + ctx->metadata_block_header.blockSize) { - ctx->MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength); - if(ctx->MediaManufacturer != NULL) - memcpy(ctx->MediaManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset, - ctx->metadataBlockHeader.mediaManufacturerLength); + ctx->media_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.mediaManufacturerLength); + if(ctx->media_manufacturer != NULL) + memcpy(ctx->media_manufacturer, ctx->metadata_block + ctx->metadata_block_header.mediaManufacturerOffset, + ctx->metadata_block_header.mediaManufacturerLength); } - if(ctx->metadataBlockHeader.mediaModelLength > 0 && - ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.mediaModelLength > 0 && + ctx->metadata_block_header.mediaModelOffset + ctx->metadata_block_header.mediaModelLength <= + ctx->metadata_block_header.blockSize) { - ctx->MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength); - if(ctx->MediaModel != NULL) - memcpy(ctx->MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset, - ctx->metadataBlockHeader.mediaModelLength); + ctx->media_model = (uint8_t *)malloc(ctx->metadata_block_header.mediaModelLength); + if(ctx->media_model != NULL) + memcpy(ctx->media_model, ctx->metadata_block + ctx->metadata_block_header.mediaModelOffset, + ctx->metadata_block_header.mediaModelLength); } - if(ctx->metadataBlockHeader.mediaSerialNumberLength > 0 && - ctx->metadataBlockHeader.mediaSerialNumberOffset + ctx->metadataBlockHeader.mediaSerialNumberLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.mediaSerialNumberLength > 0 && + ctx->metadata_block_header.mediaSerialNumberOffset + ctx->metadata_block_header.mediaSerialNumberLength <= + ctx->metadata_block_header.blockSize) { - ctx->MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength); - if(ctx->MediaSerialNumber != NULL) - memcpy(ctx->MediaSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset, - ctx->metadataBlockHeader.mediaSerialNumberLength); + ctx->media_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaSerialNumberLength); + if(ctx->media_serial_number != NULL) + memcpy(ctx->media_serial_number, ctx->metadata_block + ctx->metadata_block_header.mediaSerialNumberOffset, + ctx->metadata_block_header.mediaSerialNumberLength); } - if(ctx->metadataBlockHeader.mediaBarcodeLength > 0 && - ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.mediaBarcodeLength > 0 && + ctx->metadata_block_header.mediaBarcodeOffset + ctx->metadata_block_header.mediaBarcodeLength <= + ctx->metadata_block_header.blockSize) { - ctx->MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength); - if(ctx->MediaBarcode != NULL) - memcpy(ctx->MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset, - ctx->metadataBlockHeader.mediaBarcodeLength); + ctx->media_barcode = (uint8_t *)malloc(ctx->metadata_block_header.mediaBarcodeLength); + if(ctx->media_barcode != NULL) + memcpy(ctx->media_barcode, ctx->metadata_block + ctx->metadata_block_header.mediaBarcodeOffset, + ctx->metadata_block_header.mediaBarcodeLength); } - if(ctx->metadataBlockHeader.mediaPartNumberLength > 0 && - ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.mediaPartNumberLength > 0 && + ctx->metadata_block_header.mediaPartNumberOffset + ctx->metadata_block_header.mediaPartNumberLength <= + ctx->metadata_block_header.blockSize) { - ctx->MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength); - if(ctx->MediaPartNumber != NULL) - memcpy(ctx->MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset, - ctx->metadataBlockHeader.mediaPartNumberLength); + ctx->media_part_number = (uint8_t *)malloc(ctx->metadata_block_header.mediaPartNumberLength); + if(ctx->media_part_number != NULL) + memcpy(ctx->media_part_number, ctx->metadata_block + ctx->metadata_block_header.mediaPartNumberOffset, + ctx->metadata_block_header.mediaPartNumberLength); } - if(ctx->metadataBlockHeader.driveManufacturerLength > 0 && - ctx->metadataBlockHeader.driveManufacturerOffset + ctx->metadataBlockHeader.driveManufacturerLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.driveManufacturerLength > 0 && + ctx->metadata_block_header.driveManufacturerOffset + ctx->metadata_block_header.driveManufacturerLength <= + ctx->metadata_block_header.blockSize) { - ctx->DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength); - if(ctx->DriveManufacturer != NULL) - memcpy(ctx->DriveManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset, - ctx->metadataBlockHeader.driveManufacturerLength); + ctx->drive_manufacturer = (uint8_t *)malloc(ctx->metadata_block_header.driveManufacturerLength); + if(ctx->drive_manufacturer != NULL) + memcpy(ctx->drive_manufacturer, ctx->metadata_block + ctx->metadata_block_header.driveManufacturerOffset, + ctx->metadata_block_header.driveManufacturerLength); } - if(ctx->metadataBlockHeader.driveModelLength > 0 && - ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.driveModelLength > 0 && + ctx->metadata_block_header.driveModelOffset + ctx->metadata_block_header.driveModelLength <= + ctx->metadata_block_header.blockSize) { - ctx->DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength); - if(ctx->DriveModel != NULL) - memcpy(ctx->DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset, - ctx->metadataBlockHeader.driveModelLength); + ctx->drive_model = (uint8_t *)malloc(ctx->metadata_block_header.driveModelLength); + if(ctx->drive_model != NULL) + memcpy(ctx->drive_model, ctx->metadata_block + ctx->metadata_block_header.driveModelOffset, + ctx->metadata_block_header.driveModelLength); } - if(ctx->metadataBlockHeader.driveSerialNumberLength > 0 && - ctx->metadataBlockHeader.driveSerialNumberOffset + ctx->metadataBlockHeader.driveSerialNumberLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.driveSerialNumberLength > 0 && + ctx->metadata_block_header.driveSerialNumberOffset + ctx->metadata_block_header.driveSerialNumberLength <= + ctx->metadata_block_header.blockSize) { - ctx->DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength); - if(ctx->DriveSerialNumber != NULL) - memcpy(ctx->DriveSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset, - ctx->metadataBlockHeader.driveSerialNumberLength); + ctx->drive_serial_number = (uint8_t *)malloc(ctx->metadata_block_header.driveSerialNumberLength); + if(ctx->drive_serial_number != NULL) + memcpy(ctx->drive_serial_number, ctx->metadata_block + ctx->metadata_block_header.driveSerialNumberOffset, + ctx->metadata_block_header.driveSerialNumberLength); } - if(ctx->metadataBlockHeader.driveFirmwareRevisionLength > 0 && - ctx->metadataBlockHeader.driveFirmwareRevisionOffset + ctx->metadataBlockHeader.driveFirmwareRevisionLength <= - ctx->metadataBlockHeader.blockSize) + if(ctx->metadata_block_header.driveFirmwareRevisionLength > 0 && + ctx->metadata_block_header.driveFirmwareRevisionOffset + + ctx->metadata_block_header.driveFirmwareRevisionLength <= + ctx->metadata_block_header.blockSize) { - ctx->DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength); - if(ctx->DriveFirmwareRevision != NULL) - memcpy(ctx->DriveFirmwareRevision, - ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionOffset, - ctx->metadataBlockHeader.driveFirmwareRevisionLength); + ctx->drive_firmware_revision = (uint8_t *)malloc(ctx->metadata_block_header.driveFirmwareRevisionLength); + if(ctx->drive_firmware_revision != NULL) + memcpy(ctx->drive_firmware_revision, + ctx->metadata_block + ctx->metadata_block_header.driveFirmwareRevisionOffset, + ctx->metadata_block_header.driveFirmwareRevisionLength); } TRACE("Exiting process_metadata_block()"); @@ -242,7 +243,7 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry) * @param ctx Pointer to the aaruformat context. * @param entry Pointer to the index entry describing the geometry block. */ -void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_geometry_block(aaruformat_context *ctx, const IndexEntry *entry) { TRACE("Entering process_geometry_block(%p, %p)", ctx, entry); size_t read_bytes = 0; @@ -266,30 +267,30 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry) } TRACE("Reading geometry block header at position %" PRIu64, entry->offset); - read_bytes = fread(&ctx->geometryBlock, 1, sizeof(GeometryBlockHeader), ctx->imageStream); + read_bytes = fread(&ctx->geometry_block, 1, sizeof(GeometryBlockHeader), ctx->imageStream); if(read_bytes != sizeof(GeometryBlockHeader)) { - memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader)); + memset(&ctx->geometry_block, 0, sizeof(GeometryBlockHeader)); TRACE("Could not read geometry block header, continuing..."); return; } - if(ctx->geometryBlock.identifier != GeometryBlock) + if(ctx->geometry_block.identifier != GeometryBlock) { - memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader)); + memset(&ctx->geometry_block, 0, sizeof(GeometryBlockHeader)); TRACE("Incorrect identifier for geometry block at position %" PRIu64 "", entry->offset); return; } - ctx->imageInfo.ImageSize += sizeof(GeometryBlockHeader); + ctx->image_info.ImageSize += sizeof(GeometryBlockHeader); - TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometryBlock.cylinders, - ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack); + TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometry_block.cylinders, + ctx->geometry_block.heads, ctx->geometry_block.sectorsPerTrack); - ctx->Cylinders = ctx->geometryBlock.cylinders; - ctx->Heads = ctx->geometryBlock.heads; - ctx->SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack; + ctx->cylinders = ctx->geometry_block.cylinders; + ctx->heads = ctx->geometry_block.heads; + ctx->sectors_per_track = ctx->geometry_block.sectorsPerTrack; TRACE("Exiting process_geometry_block()"); } @@ -302,7 +303,7 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry) * @param ctx Pointer to the aaruformat context. * @param entry Pointer to the index entry describing the CICM block. */ -void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_cicm_block(aaruformat_context *ctx, const IndexEntry *entry) { TRACE("Entering process_cicm_block(%p, %p)", ctx, entry); int pos = 0; @@ -330,42 +331,42 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry) // Even if those two checks shall have been done before TRACE("Reading CICM XML metadata block header at position %" PRIu64, entry->offset); - read_bytes = fread(&ctx->cicmBlockHeader, 1, sizeof(CicmMetadataBlock), ctx->imageStream); + read_bytes = fread(&ctx->cicm_block_header, 1, sizeof(CicmMetadataBlock), ctx->imageStream); if(read_bytes != sizeof(CicmMetadataBlock)) { - memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); + memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock)); TRACE("Could not read CICM XML metadata header, continuing..."); return; } - if(ctx->cicmBlockHeader.identifier != CicmBlock) + if(ctx->cicm_block_header.identifier != CicmBlock) { - memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); + memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock)); TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset); } - ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length; + ctx->image_info.ImageSize += ctx->cicm_block_header.length; - ctx->cicmBlock = (uint8_t *)malloc(ctx->cicmBlockHeader.length); + ctx->cicm_block = (uint8_t *)malloc(ctx->cicm_block_header.length); - if(ctx->cicmBlock == NULL) + if(ctx->cicm_block == NULL) { - memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); + memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock)); TRACE("Could not allocate memory for CICM XML metadata block, continuing..."); TRACE("Exiting process_cicm_block()"); return; } - TRACE("Reading CICM XML metadata block of size %u at position %" PRIu64, ctx->cicmBlockHeader.length, + TRACE("Reading CICM XML metadata block of size %u at position %" PRIu64, ctx->cicm_block_header.length, entry->offset + sizeof(CicmMetadataBlock)); - read_bytes = fread(ctx->cicmBlock, 1, ctx->cicmBlockHeader.length, ctx->imageStream); + read_bytes = fread(ctx->cicm_block, 1, ctx->cicm_block_header.length, ctx->imageStream); - if(read_bytes != ctx->cicmBlockHeader.length) + if(read_bytes != ctx->cicm_block_header.length) { - memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); - free(ctx->cicmBlock); + memset(&ctx->cicm_block_header, 0, sizeof(CicmMetadataBlock)); + free(ctx->cicm_block); TRACE("Could not read CICM XML metadata block, continuing..."); } @@ -466,7 +467,7 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry) * * @internal */ -void process_aaru_metadata_json_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_aaru_metadata_json_block(aaruformat_context *ctx, const IndexEntry *entry) { TRACE("Entering process_aaru_metadata_json_block(%p, %p)", ctx, entry); int pos = 0; @@ -494,42 +495,42 @@ void process_aaru_metadata_json_block(aaruformatContext *ctx, const IndexEntry * // Even if those two checks shall have been done before TRACE("Reading Aaru metadata JSON block header at position %" PRIu64, entry->offset); - read_bytes = fread(&ctx->jsonBlockHeader, 1, sizeof(AaruMetadataJsonBlockHeader), ctx->imageStream); + read_bytes = fread(&ctx->json_block_header, 1, sizeof(AaruMetadataJsonBlockHeader), ctx->imageStream); if(read_bytes != sizeof(AaruMetadataJsonBlockHeader)) { - memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader)); + memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader)); TRACE("Could not read Aaru metadata JSON header, continuing..."); return; } - if(ctx->jsonBlockHeader.identifier != AaruMetadataJsonBlock) + if(ctx->json_block_header.identifier != AaruMetadataJsonBlock) { - memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader)); + memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader)); TRACE("Incorrect identifier for data block at position %" PRIu64 "", entry->offset); } - ctx->imageInfo.ImageSize += ctx->jsonBlockHeader.length; + ctx->image_info.ImageSize += ctx->json_block_header.length; - ctx->jsonBlock = (uint8_t *)malloc(ctx->jsonBlockHeader.length); + ctx->json_block = (uint8_t *)malloc(ctx->json_block_header.length); - if(ctx->jsonBlock == NULL) + if(ctx->json_block == NULL) { - memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader)); + memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader)); TRACE("Could not allocate memory for Aaru metadata JSON block, continuing..."); TRACE("Exiting process_aaru_metadata_json_block()"); return; } - TRACE("Reading Aaru metadata JSON block of size %u at position %" PRIu64, ctx->jsonBlockHeader.length, + TRACE("Reading Aaru metadata JSON block of size %u at position %" PRIu64, ctx->json_block_header.length, entry->offset + sizeof(AaruMetadataJsonBlockHeader)); - read_bytes = fread(ctx->jsonBlock, 1, ctx->jsonBlockHeader.length, ctx->imageStream); + read_bytes = fread(ctx->json_block, 1, ctx->json_block_header.length, ctx->imageStream); - if(read_bytes != ctx->jsonBlockHeader.length) + if(read_bytes != ctx->json_block_header.length) { - memset(&ctx->jsonBlockHeader, 0, sizeof(AaruMetadataJsonBlockHeader)); - free(ctx->jsonBlock); + memset(&ctx->json_block_header, 0, sizeof(AaruMetadataJsonBlockHeader)); + free(ctx->json_block); TRACE("Could not read Aaru metadata JSON block, continuing..."); } diff --git a/src/blocks/optical.c b/src/blocks/optical.c index 7a97d47..22f7ccb 100644 --- a/src/blocks/optical.c +++ b/src/blocks/optical.c @@ -108,7 +108,7 @@ * @see aaruf_get_tracks() * @see aaruf_set_tracks() */ -void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_tracks_block(aaruformat_context *ctx, const IndexEntry *entry) { int pos = 0; size_t read_bytes = 0; @@ -132,87 +132,87 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry) } // Even if those two checks shall have been done before - read_bytes = fread(&ctx->tracksHeader, 1, sizeof(TracksHeader), ctx->imageStream); + read_bytes = fread(&ctx->tracks_header, 1, sizeof(TracksHeader), ctx->imageStream); if(read_bytes != sizeof(TracksHeader)) { - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); TRACE("Could not read tracks header, continuing...\n"); return; } - if(ctx->tracksHeader.identifier != TracksBlock) + if(ctx->tracks_header.identifier != TracksBlock) { - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset); } - ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries; + ctx->image_info.ImageSize += sizeof(TrackEntry) * ctx->tracks_header.entries; - ctx->trackEntries = (TrackEntry *)malloc(sizeof(TrackEntry) * ctx->tracksHeader.entries); + ctx->track_entries = (TrackEntry *)malloc(sizeof(TrackEntry) * ctx->tracks_header.entries); - if(ctx->trackEntries == NULL) + if(ctx->track_entries == NULL) { - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); FATAL("Could not allocate memory for metadata block, continuing...\n"); return; } - read_bytes = fread(ctx->trackEntries, sizeof(TrackEntry), ctx->tracksHeader.entries, ctx->imageStream); + read_bytes = fread(ctx->track_entries, sizeof(TrackEntry), ctx->tracks_header.entries, ctx->imageStream); - if(read_bytes != ctx->tracksHeader.entries) + if(read_bytes != ctx->tracks_header.entries) { - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); - free(ctx->trackEntries); - ctx->trackEntries = NULL; + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); + free(ctx->track_entries); + ctx->track_entries = NULL; FATAL("Could not read metadata block, continuing...\n"); return; } - crc64 = aaruf_crc64_data((const uint8_t *)ctx->trackEntries, ctx->tracksHeader.entries * sizeof(TrackEntry)); + crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, ctx->tracks_header.entries * sizeof(TrackEntry)); // Due to how C# wrote it, it is effectively reversed if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64); - if(crc64 != ctx->tracksHeader.crc64) + if(crc64 != ctx->tracks_header.crc64) { TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", crc64, - ctx->tracksHeader.crc64); + ctx->tracks_header.crc64); return; } - TRACE("Found %d tracks at position %" PRIu64 ".\n", ctx->tracksHeader.entries, entry->offset); + TRACE("Found %d tracks at position %" PRIu64 ".\n", ctx->tracks_header.entries, entry->offset); - ctx->imageInfo.HasPartitions = true; - ctx->imageInfo.HasSessions = true; + ctx->image_info.HasPartitions = true; + ctx->image_info.HasSessions = true; - ctx->numberOfDataTracks = 0; + ctx->number_of_data_tracks = 0; - for(j = 0; j < ctx->tracksHeader.entries; j++) + for(j = 0; j < ctx->tracks_header.entries; j++) { - if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) ctx->numberOfDataTracks++; + if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99) ctx->number_of_data_tracks++; } - if(ctx->numberOfDataTracks > 0) + if(ctx->number_of_data_tracks > 0) { - ctx->dataTracks = malloc(sizeof(TrackEntry) * ctx->numberOfDataTracks); - if(ctx->dataTracks == NULL) + ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks); + if(ctx->data_tracks == NULL) { FATAL("Could not allocate memory for data tracks, continuing without filtered list.\n"); - ctx->numberOfDataTracks = 0; + ctx->number_of_data_tracks = 0; } } else - ctx->dataTracks = NULL; + ctx->data_tracks = NULL; - if(ctx->dataTracks != NULL) + if(ctx->data_tracks != NULL) { k = 0; - for(j = 0; j < ctx->tracksHeader.entries; j++) + for(j = 0; j < ctx->tracks_header.entries; j++) { - if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) - memcpy(&ctx->dataTracks[k++], &ctx->trackEntries[j], sizeof(TrackEntry)); + if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99) + memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry)); } } } @@ -291,7 +291,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -302,7 +302,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->tracksHeader.entries == 0 || ctx->trackEntries == NULL) + if(ctx->tracks_header.entries == 0 || ctx->track_entries == NULL) { FATAL("Image contains no tracks"); @@ -310,7 +310,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_TRACK_NOT_FOUND; } - size_t required_length = ctx->tracksHeader.entries * sizeof(TrackEntry); + size_t required_length = ctx->tracks_header.entries * sizeof(TrackEntry); if(buffer == NULL || length == NULL || *length < required_length) { @@ -321,7 +321,7 @@ int32_t aaruf_get_tracks(const void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_BUFFER_TOO_SMALL; } - memcpy(buffer, ctx->trackEntries, required_length); + memcpy(buffer, ctx->track_entries, required_length); *length = required_length; TRACE("Exiting aaruf_get_tracks(%p, %p, %zu) = AARUF_STATUS_OK", context, buffer, *length); @@ -403,7 +403,7 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count) return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -417,12 +417,12 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count) // Clearing existing tracks if(count == 0) { - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); - free(ctx->trackEntries); - ctx->trackEntries = NULL; - free(ctx->dataTracks); - ctx->dataTracks = NULL; - ctx->numberOfDataTracks = 0; + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); + free(ctx->track_entries); + ctx->track_entries = NULL; + free(ctx->data_tracks); + ctx->data_tracks = NULL; + ctx->number_of_data_tracks = 0; TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; @@ -436,41 +436,41 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count) return AARUF_ERROR_INVALID_TRACK_FORMAT; } - ctx->tracksHeader.identifier = TracksBlock; - ctx->tracksHeader.entries = (uint16_t)count; - free(ctx->trackEntries); - ctx->trackEntries = malloc(sizeof(TrackEntry) * count); - if(ctx->trackEntries == NULL) + ctx->tracks_header.identifier = TracksBlock; + ctx->tracks_header.entries = (uint16_t)count; + free(ctx->track_entries); + ctx->track_entries = malloc(sizeof(TrackEntry) * count); + if(ctx->track_entries == NULL) { - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); FATAL("Could not allocate memory for tracks"); TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY"); return AARUF_ERROR_NOT_ENOUGH_MEMORY; } - memcpy(ctx->trackEntries, tracks, sizeof(TrackEntry) * count); - ctx->tracksHeader.crc64 = aaruf_crc64_data((const uint8_t *)ctx->trackEntries, sizeof(TrackEntry) * count); + memcpy(ctx->track_entries, tracks, sizeof(TrackEntry) * count); + ctx->tracks_header.crc64 = aaruf_crc64_data((const uint8_t *)ctx->track_entries, sizeof(TrackEntry) * count); - ctx->imageInfo.HasPartitions = true; - ctx->imageInfo.HasSessions = true; + ctx->image_info.HasPartitions = true; + ctx->image_info.HasSessions = true; - free(ctx->dataTracks); - ctx->dataTracks = NULL; + free(ctx->data_tracks); + ctx->data_tracks = NULL; - ctx->numberOfDataTracks = 0; + ctx->number_of_data_tracks = 0; - for(int j = 0; j < ctx->tracksHeader.entries; j++) - if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) ctx->numberOfDataTracks++; + for(int j = 0; j < ctx->tracks_header.entries; j++) + if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99) ctx->number_of_data_tracks++; - if(ctx->numberOfDataTracks > 0) + if(ctx->number_of_data_tracks > 0) { - ctx->dataTracks = malloc(sizeof(TrackEntry) * ctx->numberOfDataTracks); - if(ctx->dataTracks == NULL) + ctx->data_tracks = malloc(sizeof(TrackEntry) * ctx->number_of_data_tracks); + if(ctx->data_tracks == NULL) { - free(ctx->trackEntries); - ctx->trackEntries = NULL; - memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); - ctx->numberOfDataTracks = 0; + free(ctx->track_entries); + ctx->track_entries = NULL; + memset(&ctx->tracks_header, 0, sizeof(TracksHeader)); + ctx->number_of_data_tracks = 0; FATAL("Could not allocate memory for data tracks"); TRACE("Exiting aaruf_set_tracks() = AARUF_ERROR_NOT_ENOUGH_MEMORY"); @@ -478,12 +478,12 @@ int32_t aaruf_set_tracks(void *context, TrackEntry *tracks, const int count) } } - if(ctx->dataTracks != NULL) + if(ctx->data_tracks != NULL) { int k = 0; - for(int j = 0; j < ctx->tracksHeader.entries; j++) - if(ctx->trackEntries[j].sequence > 0 && ctx->trackEntries[j].sequence <= 99) - memcpy(&ctx->dataTracks[k++], &ctx->trackEntries[j], sizeof(TrackEntry)); + for(int j = 0; j < ctx->tracks_header.entries; j++) + if(ctx->track_entries[j].sequence > 0 && ctx->track_entries[j].sequence <= 99) + memcpy(&ctx->data_tracks[k++], &ctx->track_entries[j], sizeof(TrackEntry)); } TRACE("Exiting aaruf_set_tracks() = AARUF_STATUS_OK"); diff --git a/src/blocks/tape.c b/src/blocks/tape.c index 7f29a0a..d5ace15 100644 --- a/src/blocks/tape.c +++ b/src/blocks/tape.c @@ -123,7 +123,7 @@ * @see tapeFileHashEntry for the hash table entry structure * @see process_tape_partition_block() for partition metadata processing */ -void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_tape_files_block(aaruformat_context *ctx, const IndexEntry *entry) { long pos = 0; size_t read_bytes = 0; @@ -160,7 +160,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry) return; } - ctx->imageInfo.ImageSize += sizeof(TapeFileEntry) * tape_file_header.entries; + ctx->image_info.ImageSize += sizeof(TapeFileEntry) * tape_file_header.entries; uint8_t *buffer = malloc(sizeof(TapeFileEntry) * tape_file_header.entries); if(buffer == NULL) @@ -207,7 +207,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry) // Replace if exists, add if new tapeFileHashEntry *old_entry = NULL; - HASH_REPLACE(hh, ctx->tapeFiles, key, sizeof(uint64_t), hash_entry, old_entry); + HASH_REPLACE(hh, ctx->tape_files, key, sizeof(uint64_t), hash_entry, old_entry); // Free old entry if it was replaced if(old_entry != NULL) @@ -343,7 +343,7 @@ void process_tape_files_block(aaruformatContext *ctx, const IndexEntry *entry) * @see TapePartitionHashEntry for the hash table entry structure * @see process_tape_files_block() for tape file metadata processing */ -void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *entry) +void process_tape_partitions_block(aaruformat_context *ctx, const IndexEntry *entry) { long pos = 0; size_t read_bytes = 0; @@ -380,7 +380,7 @@ void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *ent return; } - ctx->imageInfo.ImageSize += sizeof(TapePartitionEntry) * tape_partition_header.entries; + ctx->image_info.ImageSize += sizeof(TapePartitionEntry) * tape_partition_header.entries; uint8_t *buffer = malloc(sizeof(TapePartitionEntry) * tape_partition_header.entries); if(buffer == NULL) @@ -427,7 +427,7 @@ void process_tape_partitions_block(aaruformatContext *ctx, const IndexEntry *ent // Replace if exists, add if new TapePartitionHashEntry *old_entry = NULL; - HASH_REPLACE(hh, ctx->tapePartitions, key, sizeof(uint8_t), hash_entry, old_entry); + HASH_REPLACE(hh, ctx->tape_partitions, key, sizeof(uint8_t), hash_entry, old_entry); // Free old entry if it was replaced if(old_entry != NULL) @@ -572,7 +572,7 @@ int32_t aaruf_get_tape_file(const void *context, const uint8_t partition, const TRACE("Entering aaruf_get_tape_file(%p, %d, %d, %llu, %llu)", context, partition, file, *starting_block, *ending_block); - const aaruformatContext *ctx = NULL; + const aaruformat_context *ctx = NULL; if(context == NULL) { @@ -595,7 +595,7 @@ int32_t aaruf_get_tape_file(const void *context, const uint8_t partition, const uint64_t key = (uint64_t)partition << 32 | file; tapeFileHashEntry *entry = NULL; - HASH_FIND(hh, ctx->tapeFiles, &key, sizeof(uint64_t), entry); + HASH_FIND(hh, ctx->tape_files, &key, sizeof(uint64_t), entry); if(entry == NULL) { @@ -773,7 +773,7 @@ int32_t aaruf_set_tape_file(void *context, const uint8_t partition, const uint32 TRACE("Entering aaruf_set_tape_file(%p, %d, %d, %llu, %llu)", context, partition, file, starting_block, ending_block); - aaruformatContext *ctx = NULL; + aaruformat_context *ctx = NULL; if(context == NULL) { @@ -795,7 +795,7 @@ int32_t aaruf_set_tape_file(void *context, const uint8_t partition, const uint32 } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -824,7 +824,7 @@ int32_t aaruf_set_tape_file(void *context, const uint8_t partition, const uint32 // Replace if exists, add if new tapeFileHashEntry *old_entry = NULL; - HASH_REPLACE(hh, ctx->tapeFiles, key, sizeof(uint64_t), hash_entry, old_entry); + HASH_REPLACE(hh, ctx->tape_files, key, sizeof(uint64_t), hash_entry, old_entry); // Free old entry if it was replaced if(old_entry != NULL) @@ -984,7 +984,7 @@ int32_t aaruf_get_tape_partition(const void *context, const uint8_t partition, u { TRACE("Entering aaruf_get_tape_partition(%p, %d, %llu, %llu)", context, partition, *starting_block, *ending_block); - const aaruformatContext *ctx = NULL; + const aaruformat_context *ctx = NULL; if(context == NULL) { @@ -1007,7 +1007,7 @@ int32_t aaruf_get_tape_partition(const void *context, const uint8_t partition, u uint8_t key = partition; TapePartitionHashEntry *entry = NULL; - HASH_FIND(hh, ctx->tapePartitions, &key, sizeof(uint8_t), entry); + HASH_FIND(hh, ctx->tape_partitions, &key, sizeof(uint8_t), entry); if(entry == NULL) { @@ -1198,7 +1198,7 @@ int32_t aaruf_set_tape_partition(void *context, const uint8_t partition, const u { TRACE("Entering aaruf_set_tape_partition(%p, %d, %llu, %llu)", context, partition, starting_block, ending_block); - aaruformatContext *ctx = NULL; + aaruformat_context *ctx = NULL; if(context == NULL) { @@ -1220,7 +1220,7 @@ int32_t aaruf_set_tape_partition(void *context, const uint8_t partition, const u } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1248,7 +1248,7 @@ int32_t aaruf_set_tape_partition(void *context, const uint8_t partition, const u // Replace if exists, add if new TapePartitionHashEntry *old_entry = NULL; - HASH_REPLACE(hh, ctx->tapePartitions, key, sizeof(uint8_t), hash_entry, old_entry); + HASH_REPLACE(hh, ctx->tape_partitions, key, sizeof(uint8_t), hash_entry, old_entry); // Free old entry if it was replaced if(old_entry != NULL) diff --git a/src/close.c b/src/close.c index 6693690..b8214fe 100644 --- a/src/close.c +++ b/src/close.c @@ -74,12 +74,12 @@ * the function is a no-op returning AARUF_STATUS_OK. * @internal */ -static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) +static int32_t write_cached_secondary_ddt(aaruformat_context *ctx) { // Write cached secondary table to file end and update primary table entry with its position // Check if we have a cached table that needs to be written (either it has an offset or exists in memory) bool has_cached_secondary_ddt = - ctx->userDataDdtHeader.tableShift > 0 && (ctx->cachedDdtOffset != 0 || ctx->cachedSecondaryDdtBig != NULL); + ctx->user_data_ddt_header.tableShift > 0 && (ctx->cached_ddt_offset != 0 || ctx->cached_secondary_ddt2 != NULL); if(!has_cached_secondary_ddt) return AARUF_STATUS_OK; @@ -89,7 +89,7 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) long end_of_file = ftell(ctx->imageStream); // Align the position according to block alignment shift - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(end_of_file & alignment_mask) { // Calculate the next aligned position @@ -101,7 +101,7 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) TRACE("Aligned DDT write position from %ld to %" PRIu64 " (alignment shift: %d)", ftell(ctx->imageStream) - (aligned_position - end_of_file), aligned_position, - ctx->userDataDdtHeader.blockAlignmentShift); + ctx->user_data_ddt_header.blockAlignmentShift); } // Prepare DDT header for the cached table @@ -109,20 +109,20 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) ddt_header.identifier = DeDuplicationTable2; ddt_header.type = UserData; ddt_header.compression = ctx->compression_enabled ? Lzma : None; - ddt_header.levels = ctx->userDataDdtHeader.levels; - ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1; - ddt_header.previousLevelOffset = ctx->primaryDdtOffset; - ddt_header.negative = ctx->userDataDdtHeader.negative; - ddt_header.overflow = ctx->userDataDdtHeader.overflow; - ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; - ddt_header.dataShift = ctx->userDataDdtHeader.dataShift; + ddt_header.levels = ctx->user_data_ddt_header.levels; + ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1; + ddt_header.previousLevelOffset = ctx->primary_ddt_offset; + ddt_header.negative = ctx->user_data_ddt_header.negative; + ddt_header.overflow = ctx->user_data_ddt_header.overflow; + ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift; + ddt_header.dataShift = ctx->user_data_ddt_header.dataShift; ddt_header.tableShift = 0; // Secondary tables are single level - ddt_header.sizeType = ctx->userDataDdtHeader.sizeType; + ddt_header.sizeType = ctx->user_data_ddt_header.sizeType; - uint64_t items_per_ddt_entry = 1 << ctx->userDataDdtHeader.tableShift; + uint64_t items_per_ddt_entry = 1 << ctx->user_data_ddt_header.tableShift; ddt_header.blocks = items_per_ddt_entry; ddt_header.entries = items_per_ddt_entry; - ddt_header.start = ctx->cachedDdtPosition * items_per_ddt_entry; + ddt_header.start = ctx->cached_ddt_position * items_per_ddt_entry; // Calculate data size ddt_header.length = items_per_ddt_entry * sizeof(uint32_t); @@ -131,7 +131,7 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) crc64_ctx *crc64_context = aaruf_crc64_init(); if(crc64_context != NULL) { - 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); uint64_t crc64; aaruf_crc64_final(crc64_context, &crc64); @@ -143,7 +143,7 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) if(ddt_header.compression == None) { - buffer = (uint8_t *)ctx->cachedSecondaryDdtBig; + buffer = (uint8_t *)ctx->cached_secondary_ddt2; ddt_header.cmpCrc64 = ddt_header.crc64; } else @@ -159,7 +159,7 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) size_t props_size = LZMA_PROPERTIES_LENGTH; aaruf_lzma_encode_buffer(buffer, &dst_size, - (uint8_t *)ctx->cachedSecondaryDdtBig, ddt_header.length, lzma_properties, &props_size, + (uint8_t *)ctx->cached_secondary_ddt2, ddt_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); ddt_header.cmpLength = (uint32_t)dst_size; @@ -168,7 +168,7 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) { ddt_header.compression = None; free(buffer); - buffer = (uint8_t *)ctx->cachedSecondaryDdtBig; + buffer = (uint8_t *)ctx->cached_secondary_ddt2; } } @@ -191,27 +191,28 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) if(fwrite(buffer, ddt_header.cmpLength, 1, ctx->imageStream) == 1) { // Update primary table entry to point to new location - const uint64_t new_secondary_table_block_offset = end_of_file >> ctx->userDataDdtHeader.blockAlignmentShift; + const 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; // Update index: remove old entry for cached DDT and add new one TRACE("Updating index for cached secondary DDT"); // Remove old index entry for the cached DDT - if(ctx->cachedDdtOffset != 0) + if(ctx->cached_ddt_offset != 0) { - TRACE("Removing old index entry for DDT at offset %" PRIu64, ctx->cachedDdtOffset); + TRACE("Removing old index entry for DDT at offset %" PRIu64, ctx->cached_ddt_offset); const IndexEntry *entry = NULL; // Find and remove the old index entry - for(unsigned int k = 0; k < utarray_len(ctx->indexEntries); k++) + for(unsigned int k = 0; k < utarray_len(ctx->index_entries); k++) { - entry = (IndexEntry *)utarray_eltptr(ctx->indexEntries, k); - if(entry && entry->offset == ctx->cachedDdtOffset && entry->blockType == DeDuplicationTable2) + entry = (IndexEntry *)utarray_eltptr(ctx->index_entries, k); + if(entry && entry->offset == ctx->cached_ddt_offset && entry->blockType == DeDuplicationTable2) { TRACE("Found old DDT index entry at position %u, removing", k); - utarray_erase(ctx->indexEntries, k, 1); + utarray_erase(ctx->index_entries, k, 1); break; } } @@ -223,17 +224,17 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) new_ddt_entry.dataType = UserData; new_ddt_entry.offset = end_of_file; - utarray_push_back(ctx->indexEntries, &new_ddt_entry); + utarray_push_back(ctx->index_entries, &new_ddt_entry); TRACE("Added new DDT index entry at offset %" PRIu64, end_of_file); // Write the updated primary table back to its original position in the file long saved_pos = ftell(ctx->imageStream); - fseek(ctx->imageStream, ctx->primaryDdtOffset + sizeof(DdtHeader2), SEEK_SET); + fseek(ctx->imageStream, ctx->primary_ddt_offset + sizeof(DdtHeader2), SEEK_SET); - size_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t); + size_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t); size_t primary_written_bytes = 0; - primary_written_bytes = fwrite(ctx->userDataDdtBig, primary_table_size, 1, ctx->imageStream); + primary_written_bytes = fwrite(ctx->user_data_ddt2, primary_table_size, 1, ctx->imageStream); if(primary_written_bytes != 1) { @@ -250,9 +251,9 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) TRACE("Failed to write cached secondary DDT header"); // Free the cached table - free(ctx->cachedSecondaryDdtBig); - ctx->cachedSecondaryDdtBig = NULL; - ctx->cachedDdtOffset = 0; + free(ctx->cached_secondary_ddt2); + ctx->cached_secondary_ddt2 = NULL; + ctx->cached_ddt_offset = 0; // Set position fseek(ctx->imageStream, 0, SEEK_END); @@ -279,10 +280,10 @@ static int32_t write_cached_secondary_ddt(aaruformatContext *ctx) * @retval AARUF_ERROR_CANNOT_WRITE_HEADER Failed writing header or primary table data. * @internal */ -static int32_t write_primary_ddt(aaruformatContext *ctx) +static int32_t write_primary_ddt(aaruformat_context *ctx) { // Write the cached primary DDT table back to its position in the file - if(ctx->userDataDdtHeader.tableShift <= 0 || ctx->userDataDdtBig == NULL) return AARUF_STATUS_OK; + if(ctx->user_data_ddt_header.tableShift <= 0 || ctx->user_data_ddt2 == NULL) return AARUF_STATUS_OK; TRACE("Writing cached primary DDT table back to file"); @@ -290,31 +291,31 @@ static int32_t write_primary_ddt(aaruformatContext *ctx) crc64_ctx *crc64_context = aaruf_crc64_init(); if(crc64_context != NULL) { - 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); - aaruf_crc64_update(crc64_context, (uint8_t *)ctx->userDataDdtBig, primary_table_size); + aaruf_crc64_update(crc64_context, (uint8_t *)ctx->user_data_ddt2, primary_table_size); uint64_t crc64; aaruf_crc64_final(crc64_context, &crc64); // Properly populate all header fields for multi-level DDT primary table - ctx->userDataDdtHeader.identifier = DeDuplicationTable2; - ctx->userDataDdtHeader.type = UserData; - ctx->userDataDdtHeader.compression = None; + ctx->user_data_ddt_header.identifier = DeDuplicationTable2; + ctx->user_data_ddt_header.type = UserData; + ctx->user_data_ddt_header.compression = None; // levels, tableLevel, previousLevelOffset, negative, overflow, blockAlignmentShift, // dataShift, tableShift, sizeType, entries, blocks, start are already set during creation - ctx->userDataDdtHeader.crc64 = crc64; - ctx->userDataDdtHeader.cmpCrc64 = crc64; - ctx->userDataDdtHeader.length = primary_table_size; - ctx->userDataDdtHeader.cmpLength = primary_table_size; + ctx->user_data_ddt_header.crc64 = crc64; + ctx->user_data_ddt_header.cmpCrc64 = crc64; + ctx->user_data_ddt_header.length = primary_table_size; + ctx->user_data_ddt_header.cmpLength = primary_table_size; TRACE("Calculated CRC64 for primary DDT: 0x%16lX", crc64); } // First write the DDT header - fseek(ctx->imageStream, ctx->primaryDdtOffset, SEEK_SET); + fseek(ctx->imageStream, ctx->primary_ddt_offset, SEEK_SET); - size_t headerWritten = fwrite(&ctx->userDataDdtHeader, sizeof(DdtHeader2), 1, ctx->imageStream); + size_t headerWritten = fwrite(&ctx->user_data_ddt_header, sizeof(DdtHeader2), 1, ctx->imageStream); if(headerWritten != 1) { TRACE("Failed to write primary DDT header to file"); @@ -322,26 +323,26 @@ static int32_t write_primary_ddt(aaruformatContext *ctx) } // Then write the table data (position is already after the header) - 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); // Write the primary table data size_t written_bytes = 0; - 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) { TRACE("Successfully wrote primary DDT header and table to file (%" PRIu64 " entries, %zu bytes)", - ctx->userDataDdtHeader.entries, primary_table_size); + ctx->user_data_ddt_header.entries, primary_table_size); // Add primary DDT to index TRACE("Adding primary DDT to index"); IndexEntry primary_ddt_entry; primary_ddt_entry.blockType = DeDuplicationTable2; primary_ddt_entry.dataType = UserData; - primary_ddt_entry.offset = ctx->primaryDdtOffset; + primary_ddt_entry.offset = ctx->primary_ddt_offset; - utarray_push_back(ctx->indexEntries, &primary_ddt_entry); - TRACE("Added primary DDT index entry at offset %" PRIu64, ctx->primaryDdtOffset); + utarray_push_back(ctx->index_entries, &primary_ddt_entry); + TRACE("Added primary DDT index entry at offset %" PRIu64, ctx->primary_ddt_offset); } else TRACE("Failed to write primary DDT table to file"); @@ -365,81 +366,83 @@ static int32_t write_primary_ddt(aaruformatContext *ctx) * @retval AARUF_ERROR_CANNOT_WRITE_HEADER Failed writing header or table data. * @internal */ -static int32_t write_single_level_ddt(aaruformatContext *ctx) +static int32_t write_single_level_ddt(aaruformat_context *ctx) { // Write the single level DDT table block aligned just after the header - if(ctx->userDataDdtHeader.tableShift != 0 || ctx->userDataDdtBig == NULL) return AARUF_STATUS_OK; + if(ctx->user_data_ddt_header.tableShift != 0 || ctx->user_data_ddt2 == NULL) return AARUF_STATUS_OK; TRACE("Writing single-level DDT table to file"); // Calculate CRC64 of the primary DDT table data - const size_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t); + const size_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t); // Properly populate all header fields - ctx->userDataDdtHeader.identifier = DeDuplicationTable2; - ctx->userDataDdtHeader.type = UserData; - ctx->userDataDdtHeader.compression = ctx->compression_enabled ? Lzma : None; - ctx->userDataDdtHeader.levels = 1; // Single level - ctx->userDataDdtHeader.tableLevel = 0; // Top level - ctx->userDataDdtHeader.previousLevelOffset = 0; // No previous level for single-level DDT + ctx->user_data_ddt_header.identifier = DeDuplicationTable2; + ctx->user_data_ddt_header.type = UserData; + ctx->user_data_ddt_header.compression = ctx->compression_enabled ? Lzma : None; + ctx->user_data_ddt_header.levels = 1; // Single level + ctx->user_data_ddt_header.tableLevel = 0; // Top level + ctx->user_data_ddt_header.previousLevelOffset = 0; // No previous level for single-level DDT // negative and overflow are already set during creation // blockAlignmentShift, dataShift, tableShift, sizeType, entries, blocks, start are already set - ctx->userDataDdtHeader.length = primary_table_size; - ctx->userDataDdtHeader.cmpLength = primary_table_size; + ctx->user_data_ddt_header.length = primary_table_size; + ctx->user_data_ddt_header.cmpLength = primary_table_size; - ctx->userDataDdtHeader.crc64 = aaruf_crc64_data((uint8_t *)ctx->userDataDdtBig, primary_table_size); + ctx->user_data_ddt_header.crc64 = aaruf_crc64_data((uint8_t *)ctx->user_data_ddt2, primary_table_size); - TRACE("Calculated CRC64 for single-level DDT: 0x%16lX", ctx->userDataDdtHeader.crc64); + TRACE("Calculated CRC64 for single-level DDT: 0x%16lX", ctx->user_data_ddt_header.crc64); uint8_t *cmp_buffer = NULL; uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH] = {0}; - if(ctx->userDataDdtHeader.compression == None) + if(ctx->user_data_ddt_header.compression == None) { - cmp_buffer = (uint8_t *)ctx->userDataDdtBig; - ctx->userDataDdtHeader.cmpCrc64 = ctx->userDataDdtHeader.crc64; + cmp_buffer = (uint8_t *)ctx->user_data_ddt2; + ctx->user_data_ddt_header.cmpCrc64 = ctx->user_data_ddt_header.crc64; } else { - cmp_buffer = malloc((size_t)ctx->userDataDdtHeader.length * 2); // Allocate double size for compression + cmp_buffer = malloc((size_t)ctx->user_data_ddt_header.length * 2); // Allocate double size for compression if(cmp_buffer == NULL) { TRACE("Failed to allocate memory for secondary DDT v2 compression"); return AARUF_ERROR_NOT_ENOUGH_MEMORY; } - size_t dst_size = (size_t)ctx->userDataDdtHeader.length * 2 * 2; + size_t dst_size = (size_t)ctx->user_data_ddt_header.length * 2 * 2; size_t props_size = LZMA_PROPERTIES_LENGTH; - aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->userDataDdtBig, ctx->userDataDdtHeader.length, - lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); + aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->user_data_ddt2, + ctx->user_data_ddt_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, + 4, 0, 2, 273, 8); - ctx->userDataDdtHeader.cmpLength = (uint32_t)dst_size; + ctx->user_data_ddt_header.cmpLength = (uint32_t)dst_size; - if(ctx->userDataDdtHeader.cmpLength >= ctx->userDataDdtHeader.length) + if(ctx->user_data_ddt_header.cmpLength >= ctx->user_data_ddt_header.length) { - ctx->userDataDdtHeader.compression = None; + ctx->user_data_ddt_header.compression = None; free(cmp_buffer); - cmp_buffer = (uint8_t *)ctx->userDataDdtBig; + cmp_buffer = (uint8_t *)ctx->user_data_ddt2; } } - if(ctx->userDataDdtHeader.compression == None) + if(ctx->user_data_ddt_header.compression == None) { - ctx->userDataDdtHeader.cmpLength = ctx->userDataDdtHeader.length; - ctx->userDataDdtHeader.cmpCrc64 = ctx->userDataDdtHeader.crc64; + ctx->user_data_ddt_header.cmpLength = ctx->user_data_ddt_header.length; + ctx->user_data_ddt_header.cmpCrc64 = ctx->user_data_ddt_header.crc64; } else - ctx->userDataDdtHeader.cmpCrc64 = aaruf_crc64_data(cmp_buffer, (uint32_t)ctx->userDataDdtHeader.cmpLength); + ctx->user_data_ddt_header.cmpCrc64 = + aaruf_crc64_data(cmp_buffer, (uint32_t)ctx->user_data_ddt_header.cmpLength); - if(ctx->userDataDdtHeader.compression == Lzma) ctx->userDataDdtHeader.cmpLength += LZMA_PROPERTIES_LENGTH; + if(ctx->user_data_ddt_header.compression == Lzma) ctx->user_data_ddt_header.cmpLength += LZMA_PROPERTIES_LENGTH; // Write the DDT header first fseek(ctx->imageStream, 0, SEEK_END); long ddt_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(ddt_position & alignment_mask) { const uint64_t aligned_position = ddt_position + alignment_mask & ~alignment_mask; @@ -447,7 +450,7 @@ static int32_t write_single_level_ddt(aaruformatContext *ctx) ddt_position = aligned_position; } - const size_t header_written = fwrite(&ctx->userDataDdtHeader, sizeof(DdtHeader2), 1, ctx->imageStream); + const size_t header_written = fwrite(&ctx->user_data_ddt_header, sizeof(DdtHeader2), 1, ctx->imageStream); if(header_written != 1) { TRACE("Failed to write single-level DDT header to file"); @@ -456,15 +459,16 @@ static int32_t write_single_level_ddt(aaruformatContext *ctx) // Write the primary table data size_t written_bytes = 0; - if(ctx->userDataDdtHeader.compression == Lzma) fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream); + if(ctx->user_data_ddt_header.compression == Lzma) + fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream); - written_bytes = fwrite(cmp_buffer, ctx->userDataDdtHeader.cmpLength, 1, ctx->imageStream); + written_bytes = fwrite(cmp_buffer, ctx->user_data_ddt_header.cmpLength, 1, ctx->imageStream); if(written_bytes == 1) { TRACE("Successfully wrote single-level DDT header and table to file (%" PRIu64 " entries, %zu bytes, %zu compressed bytes)", - ctx->userDataDdtHeader.entries, ctx->userDataDdtHeader.length, ctx->userDataDdtHeader.cmpLength); + ctx->user_data_ddt_header.entries, ctx->user_data_ddt_header.length, ctx->user_data_ddt_header.cmpLength); // Add single-level DDT to index TRACE("Adding single-level DDT to index"); @@ -473,7 +477,7 @@ static int32_t write_single_level_ddt(aaruformatContext *ctx) single_ddt_entry.dataType = UserData; single_ddt_entry.offset = ddt_position; - utarray_push_back(ctx->indexEntries, &single_ddt_entry); + utarray_push_back(ctx->index_entries, &single_ddt_entry); TRACE("Added single-level DDT index entry at offset %" PRIu64, ddt_position); } else @@ -589,44 +593,44 @@ static int32_t write_single_level_ddt(aaruformatContext *ctx) * @see TapeDdtHashEntry for the hash table entry structure * @internal */ -static int32_t write_tape_ddt(aaruformatContext *ctx) +static int32_t write_tape_ddt(aaruformat_context *ctx) { if(!ctx->is_tape) return AARUF_STATUS_INVALID_CONTEXT; // Traverse the tape DDT uthash and find the biggest key uint64_t max_key = 0; TapeDdtHashEntry *entry, *tmp; - HASH_ITER(hh, ctx->tapeDdt, entry, tmp) + HASH_ITER(hh, ctx->tape_ddt, entry, tmp) if(entry->key > max_key) max_key = entry->key; // Initialize context user data DDT header - ctx->userDataDdtHeader.identifier = DeDuplicationTable2; - ctx->userDataDdtHeader.type = UserData; - ctx->userDataDdtHeader.compression = ctx->compression_enabled ? Lzma : None; - ctx->userDataDdtHeader.levels = 1; // Single level - ctx->userDataDdtHeader.tableLevel = 0; // Top level - ctx->userDataDdtHeader.previousLevelOffset = 0; // No previous level for single-level DDT - ctx->userDataDdtHeader.negative = 0; - ctx->userDataDdtHeader.overflow = 0; - ctx->userDataDdtHeader.tableShift = 0; // Single level - ctx->userDataDdtHeader.sizeType = BigDdtSizeType; - ctx->userDataDdtHeader.entries = max_key + 1; - ctx->userDataDdtHeader.blocks = max_key + 1; - ctx->userDataDdtHeader.start = 0; - ctx->userDataDdtHeader.length = ctx->userDataDdtHeader.entries * sizeof(uint32_t); - ctx->userDataDdtHeader.cmpLength = ctx->userDataDdtHeader.length; + ctx->user_data_ddt_header.identifier = DeDuplicationTable2; + ctx->user_data_ddt_header.type = UserData; + ctx->user_data_ddt_header.compression = ctx->compression_enabled ? Lzma : None; + ctx->user_data_ddt_header.levels = 1; // Single level + ctx->user_data_ddt_header.tableLevel = 0; // Top level + ctx->user_data_ddt_header.previousLevelOffset = 0; // No previous level for single-level DDT + ctx->user_data_ddt_header.negative = 0; + ctx->user_data_ddt_header.overflow = 0; + ctx->user_data_ddt_header.tableShift = 0; // Single level + ctx->user_data_ddt_header.sizeType = BigDdtSizeType; + ctx->user_data_ddt_header.entries = max_key + 1; + ctx->user_data_ddt_header.blocks = max_key + 1; + ctx->user_data_ddt_header.start = 0; + ctx->user_data_ddt_header.length = ctx->user_data_ddt_header.entries * sizeof(uint32_t); + ctx->user_data_ddt_header.cmpLength = ctx->user_data_ddt_header.length; // Initialize memory for user data DDT - ctx->userDataDdtBig = calloc(ctx->userDataDdtHeader.entries, sizeof(uint32_t)); - if(ctx->userDataDdtBig == NULL) + ctx->user_data_ddt2 = calloc(ctx->user_data_ddt_header.entries, sizeof(uint32_t)); + if(ctx->user_data_ddt2 == NULL) { TRACE("Failed to allocate memory for tape DDT table"); return AARUF_ERROR_NOT_ENOUGH_MEMORY; } // Populate user data DDT from tape DDT uthash - HASH_ITER(hh, ctx->tapeDdt, entry, tmp) - if(entry->key < ctx->userDataDdtHeader.blocks) ctx->userDataDdtBig[entry->key] = entry->value; + HASH_ITER(hh, ctx->tape_ddt, entry, tmp) + if(entry->key < ctx->user_data_ddt_header.blocks) ctx->user_data_ddt2[entry->key] = entry->value; // Do not repeat code return write_single_level_ddt(ctx); @@ -648,7 +652,7 @@ static int32_t write_tape_ddt(aaruformatContext *ctx) * @param ctx Pointer to an initialized aaruformatContext in write mode. * @internal */ -static void write_checksum_block(aaruformatContext *ctx) +static void write_checksum_block(aaruformat_context *ctx) { uint64_t alignment_mask; uint64_t aligned_position; @@ -695,7 +699,7 @@ static void write_checksum_block(aaruformatContext *ctx) fseek(ctx->imageStream, 0, SEEK_END); long checksum_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(checksum_position & alignment_mask) { aligned_position = checksum_position + alignment_mask & ~alignment_mask; @@ -778,7 +782,7 @@ static void write_checksum_block(aaruformatContext *ctx) checksum_index_entry.dataType = 0; checksum_index_entry.offset = checksum_position; - utarray_push_back(ctx->indexEntries, &checksum_index_entry); + utarray_push_back(ctx->index_entries, &checksum_index_entry); TRACE("Added checksum block index entry at offset %" PRIu64, checksum_position); } @@ -792,15 +796,15 @@ static void write_checksum_block(aaruformatContext *ctx) * @param ctx Pointer to an initialized aaruformatContext in write mode. * @internal */ -static void write_tracks_block(aaruformatContext *ctx) +static void write_tracks_block(aaruformat_context *ctx) { // Write tracks block - if(ctx->tracksHeader.entries <= 0 || ctx->trackEntries == NULL) return; + if(ctx->tracks_header.entries <= 0 || ctx->track_entries == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long tracks_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(tracks_position & alignment_mask) { uint64_t aligned_position = tracks_position + alignment_mask & ~alignment_mask; @@ -810,15 +814,15 @@ static void write_tracks_block(aaruformatContext *ctx) TRACE("Writing tracks block at position %ld", tracks_position); // Write header - if(fwrite(&ctx->tracksHeader, sizeof(TracksHeader), 1, ctx->imageStream) == 1) + if(fwrite(&ctx->tracks_header, sizeof(TracksHeader), 1, ctx->imageStream) == 1) { // Write entries size_t written_entries = - fwrite(ctx->trackEntries, sizeof(TrackEntry), ctx->tracksHeader.entries, ctx->imageStream); + fwrite(ctx->track_entries, sizeof(TrackEntry), ctx->tracks_header.entries, ctx->imageStream); - if(written_entries == ctx->tracksHeader.entries) + if(written_entries == ctx->tracks_header.entries) { - TRACE("Successfully wrote tracks block with %u entries", ctx->tracksHeader.entries); + TRACE("Successfully wrote tracks block with %u entries", ctx->tracks_header.entries); // Add tracks block to index TRACE("Adding tracks block to index"); @@ -826,7 +830,7 @@ static void write_tracks_block(aaruformatContext *ctx) tracks_index_entry.blockType = TracksBlock; tracks_index_entry.dataType = 0; tracks_index_entry.offset = tracks_position; - utarray_push_back(ctx->indexEntries, &tracks_index_entry); + utarray_push_back(ctx->index_entries, &tracks_index_entry); TRACE("Added tracks block index entry at offset %" PRIu64, tracks_position); } } @@ -844,7 +848,7 @@ static void write_tracks_block(aaruformatContext *ctx) * point to a buffer sized for the described sector span. * @internal */ -static void write_mode2_subheaders_block(aaruformatContext *ctx) +static void write_mode2_subheaders_block(aaruformat_context *ctx) { // Write MODE 2 subheader data block if(ctx->mode2_subheaders == NULL) return; @@ -852,7 +856,7 @@ static void write_mode2_subheaders_block(aaruformatContext *ctx) fseek(ctx->imageStream, 0, SEEK_END); long mode2_subheaders_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(mode2_subheaders_position & alignment_mask) { uint64_t aligned_position = mode2_subheaders_position + alignment_mask & ~alignment_mask; @@ -866,7 +870,8 @@ static void write_mode2_subheaders_block(aaruformatContext *ctx) subheaders_block.type = CompactDiscMode2Subheader; subheaders_block.compression = ctx->compression_enabled ? Lzma : None; subheaders_block.length = - (uint32_t)(ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow) * 8; + (uint32_t)(ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow) * + 8; // Calculate CRC64 subheaders_block.crc64 = aaruf_crc64_data(ctx->mode2_subheaders, subheaders_block.length); @@ -929,7 +934,7 @@ static void write_mode2_subheaders_block(aaruformatContext *ctx) mode2_subheaders_index_entry.blockType = DataBlock; mode2_subheaders_index_entry.dataType = CompactDiscMode2Subheader; mode2_subheaders_index_entry.offset = mode2_subheaders_position; - utarray_push_back(ctx->indexEntries, &mode2_subheaders_index_entry); + utarray_push_back(ctx->index_entries, &mode2_subheaders_index_entry); TRACE("Added MODE 2 subheaders block index entry at offset %" PRIu64, mode2_subheaders_position); } } @@ -959,14 +964,14 @@ static void write_mode2_subheaders_block(aaruformatContext *ctx) * @param ctx Pointer to an initialized aaruformatContext in write mode. * @internal */ -static void write_sector_prefix(aaruformatContext *ctx) +static void write_sector_prefix(aaruformat_context *ctx) { if(ctx->sector_prefix == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long prefix_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(prefix_position & alignment_mask) { uint64_t aligned_position = prefix_position + alignment_mask & ~alignment_mask; @@ -1042,7 +1047,7 @@ static void write_sector_prefix(aaruformatContext *ctx) prefix_index_entry.blockType = DataBlock; prefix_index_entry.dataType = CdSectorPrefix; prefix_index_entry.offset = prefix_position; - utarray_push_back(ctx->indexEntries, &prefix_index_entry); + utarray_push_back(ctx->index_entries, &prefix_index_entry); TRACE("Added CD sector prefix block index entry at offset %" PRIu64, prefix_position); } } @@ -1081,14 +1086,14 @@ static void write_sector_prefix(aaruformatContext *ctx) * @param ctx Pointer to an initialized aaruformatContext in write mode. Must not be NULL. * @internal */ -static void write_sector_suffix(aaruformatContext *ctx) +static void write_sector_suffix(aaruformat_context *ctx) { if(ctx->sector_suffix == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long suffix_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(suffix_position & alignment_mask) { const uint64_t aligned_position = suffix_position + alignment_mask & ~alignment_mask; @@ -1164,7 +1169,7 @@ static void write_sector_suffix(aaruformatContext *ctx) suffix_index_entry.blockType = DataBlock; suffix_index_entry.dataType = CdSectorSuffix; suffix_index_entry.offset = suffix_position; - utarray_push_back(ctx->indexEntries, &suffix_index_entry); + utarray_push_back(ctx->index_entries, &suffix_index_entry); TRACE("Added CD sector suffix block index entry at offset %" PRIu64, suffix_position); } } @@ -1201,14 +1206,14 @@ static void write_sector_suffix(aaruformatContext *ctx) * @param ctx Pointer to a valid aaruformatContext in write mode (must not be NULL). * @internal */ -static void write_sector_prefix_ddt(aaruformatContext *ctx) +static void write_sector_prefix_ddt(aaruformat_context *ctx) { - if(ctx->sectorPrefixDdt2 == NULL) return; + if(ctx->sector_prefix_ddt2 == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long prefix_ddt_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(prefix_ddt_position & alignment_mask) { const uint64_t aligned_position = prefix_ddt_position + alignment_mask & ~alignment_mask; @@ -1223,25 +1228,26 @@ static void write_sector_prefix_ddt(aaruformatContext *ctx) ddt_header2.compression = ctx->compression_enabled ? Lzma : None; ddt_header2.levels = 1; ddt_header2.tableLevel = 0; - ddt_header2.negative = ctx->userDataDdtHeader.negative; - ddt_header2.overflow = ctx->userDataDdtHeader.overflow; - ddt_header2.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; - ddt_header2.dataShift = ctx->userDataDdtHeader.dataShift; + ddt_header2.negative = ctx->user_data_ddt_header.negative; + ddt_header2.overflow = ctx->user_data_ddt_header.overflow; + ddt_header2.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift; + ddt_header2.dataShift = ctx->user_data_ddt_header.dataShift; ddt_header2.tableShift = 0; // Single-level DDT ddt_header2.sizeType = BigDdtSizeType; - ddt_header2.entries = ctx->imageInfo.Sectors + ctx->userDataDdtHeader.negative + ctx->userDataDdtHeader.overflow; - ddt_header2.blocks = ctx->userDataDdtHeader.blocks; - ddt_header2.start = 0; - ddt_header2.length = ddt_header2.entries * sizeof(uint32_t); + ddt_header2.entries = + ctx->image_info.Sectors + ctx->user_data_ddt_header.negative + ctx->user_data_ddt_header.overflow; + ddt_header2.blocks = ctx->user_data_ddt_header.blocks; + ddt_header2.start = 0; + ddt_header2.length = ddt_header2.entries * sizeof(uint32_t); // Calculate CRC64 - ddt_header2.crc64 = aaruf_crc64_data((uint8_t *)ctx->sectorPrefixDdt2, (uint32_t)ddt_header2.length); + ddt_header2.crc64 = aaruf_crc64_data((uint8_t *)ctx->sector_prefix_ddt2, (uint32_t)ddt_header2.length); uint8_t *buffer = NULL; uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH] = {0}; if(ddt_header2.compression == None) { - buffer = (uint8_t *)ctx->sectorPrefixDdt2; + buffer = (uint8_t *)ctx->sector_prefix_ddt2; ddt_header2.cmpCrc64 = ddt_header2.crc64; } else @@ -1255,7 +1261,7 @@ static void write_sector_prefix_ddt(aaruformatContext *ctx) size_t dst_size = (size_t)ddt_header2.length * 2 * 2; size_t props_size = LZMA_PROPERTIES_LENGTH; - aaruf_lzma_encode_buffer(buffer, &dst_size, (uint8_t *)ctx->sectorPrefixDdt2, ddt_header2.length, + aaruf_lzma_encode_buffer(buffer, &dst_size, (uint8_t *)ctx->sector_prefix_ddt2, ddt_header2.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); ddt_header2.cmpLength = (uint32_t)dst_size; @@ -1264,7 +1270,7 @@ static void write_sector_prefix_ddt(aaruformatContext *ctx) { ddt_header2.compression = None; free(buffer); - buffer = (uint8_t *)ctx->sectorPrefixDdt2; + buffer = (uint8_t *)ctx->sector_prefix_ddt2; } } @@ -1294,7 +1300,7 @@ static void write_sector_prefix_ddt(aaruformatContext *ctx) prefix_ddt_index_entry.blockType = DeDuplicationTable2; prefix_ddt_index_entry.dataType = CdSectorPrefix; prefix_ddt_index_entry.offset = prefix_ddt_position; - utarray_push_back(ctx->indexEntries, &prefix_ddt_index_entry); + utarray_push_back(ctx->index_entries, &prefix_ddt_index_entry); TRACE("Added sector prefix DDT v2 index entry at offset %" PRIu64, prefix_ddt_position); } } @@ -1346,14 +1352,14 @@ static void write_sector_prefix_ddt(aaruformatContext *ctx) * @param ctx Active aaruformatContext being finalized. * @internal */ -static void write_sector_suffix_ddt(aaruformatContext *ctx) +static void write_sector_suffix_ddt(aaruformat_context *ctx) { - if(ctx->sectorSuffixDdt2 == NULL) return; + if(ctx->sector_suffix_ddt2 == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long suffix_ddt_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(suffix_ddt_position & alignment_mask) { const uint64_t aligned_position = suffix_ddt_position + alignment_mask & ~alignment_mask; @@ -1368,25 +1374,26 @@ static void write_sector_suffix_ddt(aaruformatContext *ctx) ddt_header2.compression = ctx->compression_enabled ? Lzma : None; ddt_header2.levels = 1; ddt_header2.tableLevel = 0; - ddt_header2.negative = ctx->userDataDdtHeader.negative; - ddt_header2.overflow = ctx->userDataDdtHeader.overflow; - ddt_header2.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; - ddt_header2.dataShift = ctx->userDataDdtHeader.dataShift; + ddt_header2.negative = ctx->user_data_ddt_header.negative; + ddt_header2.overflow = ctx->user_data_ddt_header.overflow; + ddt_header2.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift; + ddt_header2.dataShift = ctx->user_data_ddt_header.dataShift; ddt_header2.tableShift = 0; // Single-level DDT ddt_header2.sizeType = BigDdtSizeType; - ddt_header2.entries = ctx->imageInfo.Sectors + ctx->userDataDdtHeader.negative + ctx->userDataDdtHeader.overflow; - ddt_header2.blocks = ctx->userDataDdtHeader.blocks; - ddt_header2.start = 0; - ddt_header2.length = ddt_header2.entries * sizeof(uint32_t); + ddt_header2.entries = + ctx->image_info.Sectors + ctx->user_data_ddt_header.negative + ctx->user_data_ddt_header.overflow; + ddt_header2.blocks = ctx->user_data_ddt_header.blocks; + ddt_header2.start = 0; + ddt_header2.length = ddt_header2.entries * sizeof(uint32_t); // Calculate CRC64 - ddt_header2.crc64 = aaruf_crc64_data((uint8_t *)ctx->sectorSuffixDdt2, (uint32_t)ddt_header2.length); + ddt_header2.crc64 = aaruf_crc64_data((uint8_t *)ctx->sector_suffix_ddt2, (uint32_t)ddt_header2.length); uint8_t *buffer = NULL; uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH] = {0}; if(ddt_header2.compression == None) { - buffer = (uint8_t *)ctx->sectorSuffixDdt2; + buffer = (uint8_t *)ctx->sector_suffix_ddt2; ddt_header2.cmpCrc64 = ddt_header2.crc64; } else @@ -1400,7 +1407,7 @@ static void write_sector_suffix_ddt(aaruformatContext *ctx) size_t dst_size = (size_t)ddt_header2.length * 2 * 2; size_t props_size = LZMA_PROPERTIES_LENGTH; - aaruf_lzma_encode_buffer(buffer, &dst_size, (uint8_t *)ctx->sectorSuffixDdt2, ddt_header2.length, + aaruf_lzma_encode_buffer(buffer, &dst_size, (uint8_t *)ctx->sector_suffix_ddt2, ddt_header2.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); ddt_header2.cmpLength = (uint32_t)dst_size; @@ -1409,7 +1416,7 @@ static void write_sector_suffix_ddt(aaruformatContext *ctx) { ddt_header2.compression = None; free(buffer); - buffer = (uint8_t *)ctx->sectorSuffixDdt2; + buffer = (uint8_t *)ctx->sector_suffix_ddt2; } } @@ -1439,7 +1446,7 @@ static void write_sector_suffix_ddt(aaruformatContext *ctx) suffix_ddt_index_entry.blockType = DeDuplicationTable2; suffix_ddt_index_entry.dataType = CdSectorSuffix; suffix_ddt_index_entry.offset = suffix_ddt_position; - utarray_push_back(ctx->indexEntries, &suffix_ddt_index_entry); + utarray_push_back(ctx->index_entries, &suffix_ddt_index_entry); TRACE("Added sector suffix DDT v2 index entry at offset %" PRIu64, suffix_ddt_position); } } @@ -1504,14 +1511,14 @@ static void write_sector_suffix_ddt(aaruformatContext *ctx) * * @internal */ -static void write_sector_subchannel(const aaruformatContext *ctx) +static void write_sector_subchannel(const aaruformat_context *ctx) { if(ctx->sector_subchannel == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -1530,11 +1537,12 @@ static void write_sector_subchannel(const aaruformatContext *ctx) subchannel_block.cmpLength = subchannel_block.length; - if(ctx->imageInfo.MetadataMediaType == OpticalDisc) + if(ctx->image_info.MetadataMediaType == OpticalDisc) { - subchannel_block.type = CdSectorSubchannel; - subchannel_block.length = - (uint32_t)(ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow) * 96; + subchannel_block.type = CdSectorSubchannel; + subchannel_block.length = (uint32_t)(ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow) * + 96; if(ctx->compression_enabled) { @@ -1579,23 +1587,23 @@ static void write_sector_subchannel(const aaruformatContext *ctx) } } } - else if(ctx->imageInfo.MetadataMediaType == BlockMedia) + else if(ctx->image_info.MetadataMediaType == BlockMedia) { - switch(ctx->imageInfo.MediaType) + switch(ctx->image_info.MediaType) { case AppleProfile: case AppleFileWare: subchannel_block.type = AppleProfileTag; - subchannel_block.length = (uint32_t)(ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow) * 20; + subchannel_block.length = (uint32_t)(ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow) * 20; break; case AppleSonyDS: case AppleSonySS: subchannel_block.type = AppleSonyTag; - subchannel_block.length = (uint32_t)(ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow) * 12; + subchannel_block.length = (uint32_t)(ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow) * 12; break; case PriamDataTower: subchannel_block.type = PriamDataTowerTag; - subchannel_block.length = (uint32_t)(ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow) * 24; + subchannel_block.length = (uint32_t)(ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow) * 24; break; default: TRACE("Incorrect media type, not writing sector subchannel block"); @@ -1659,7 +1667,7 @@ static void write_sector_subchannel(const aaruformatContext *ctx) subchannel_index_entry.blockType = DataBlock; subchannel_index_entry.dataType = subchannel_block.type; subchannel_index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &subchannel_index_entry); + utarray_push_back(ctx->index_entries, &subchannel_index_entry); TRACE("Added sector subchannel block index entry at offset %" PRIu64, block_position); } } @@ -1803,17 +1811,18 @@ static void write_sector_subchannel(const aaruformatContext *ctx) * * @internal */ -void write_dvd_long_sector_blocks(aaruformatContext *ctx) +void write_dvd_long_sector_blocks(aaruformat_context *ctx) { if(ctx->sector_id == NULL || ctx->sector_ied == NULL || ctx->sector_cpr_mai == NULL || ctx->sector_edc == NULL) return; - uint64_t total_sectors = ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow; + uint64_t total_sectors = + ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow; // Write DVD sector ID block fseek(ctx->imageStream, 0, SEEK_END); long id_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(id_position & alignment_mask) { const uint64_t aligned_position = id_position + alignment_mask & ~alignment_mask; @@ -1888,7 +1897,7 @@ void write_dvd_long_sector_blocks(aaruformatContext *ctx) id_index_entry.blockType = DataBlock; id_index_entry.dataType = DvdSectorId; id_index_entry.offset = id_position; - utarray_push_back(ctx->indexEntries, &id_index_entry); + utarray_push_back(ctx->index_entries, &id_index_entry); TRACE("Added DVD sector ID block index entry at offset %" PRIu64, id_position); } } @@ -1970,7 +1979,7 @@ void write_dvd_long_sector_blocks(aaruformatContext *ctx) ied_index_entry.blockType = DataBlock; ied_index_entry.dataType = DvdSectorIed; ied_index_entry.offset = ied_position; - utarray_push_back(ctx->indexEntries, &ied_index_entry); + utarray_push_back(ctx->index_entries, &ied_index_entry); TRACE("Added DVD sector IED block index entry at offset %" PRIu64, ied_position); } } @@ -2052,7 +2061,7 @@ void write_dvd_long_sector_blocks(aaruformatContext *ctx) cpr_mai_index_entry.blockType = DataBlock; cpr_mai_index_entry.dataType = DvdSectorCprMai; cpr_mai_index_entry.offset = cpr_mai_position; - utarray_push_back(ctx->indexEntries, &cpr_mai_index_entry); + utarray_push_back(ctx->index_entries, &cpr_mai_index_entry); TRACE("Added DVD sector CPR/MAI block index entry at offset %" PRIu64, cpr_mai_position); } } @@ -2134,7 +2143,7 @@ void write_dvd_long_sector_blocks(aaruformatContext *ctx) edc_index_entry.blockType = DataBlock; edc_index_entry.dataType = DvdSectorEdc; edc_index_entry.offset = edc_position; - utarray_push_back(ctx->indexEntries, &edc_index_entry); + utarray_push_back(ctx->index_entries, &edc_index_entry); TRACE("Added DVD sector EDC block index entry at offset %" PRIu64, edc_position); } } @@ -2239,13 +2248,13 @@ void write_dvd_long_sector_blocks(aaruformatContext *ctx) * * @internal */ -static void write_dvd_title_key_decrypted_block(const aaruformatContext *ctx) +static void write_dvd_title_key_decrypted_block(const aaruformat_context *ctx) { if(ctx->sector_decrypted_title_key == NULL) return; fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -2258,7 +2267,8 @@ static void write_dvd_title_key_decrypted_block(const aaruformatContext *ctx) decrypted_title_key_block.type = DvdSectorTitleKeyDecrypted; decrypted_title_key_block.compression = ctx->compression_enabled ? Lzma : None; decrypted_title_key_block.length = - (uint32_t)(ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow) * 5; + (uint32_t)(ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow) * + 5; // Calculate CRC64 decrypted_title_key_block.crc64 = aaruf_crc64_data(ctx->sector_decrypted_title_key, decrypted_title_key_block.length); @@ -2323,7 +2333,7 @@ static void write_dvd_title_key_decrypted_block(const aaruformatContext *ctx) decrypted_title_key_index_entry.blockType = DataBlock; decrypted_title_key_index_entry.dataType = DvdSectorTitleKeyDecrypted; decrypted_title_key_index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &decrypted_title_key_index_entry); + utarray_push_back(ctx->index_entries, &decrypted_title_key_index_entry); TRACE("Added DVD decrypted title key block index entry at offset %" PRIu64, block_position); } } @@ -2402,7 +2412,7 @@ static void write_dvd_title_key_decrypted_block(const aaruformatContext *ctx) * * @internal */ -static void write_media_tags(const aaruformatContext *ctx) +static void write_media_tags(const aaruformat_context *ctx) { if(ctx->mediaTags == NULL) return; @@ -2413,7 +2423,7 @@ static void write_media_tags(const aaruformatContext *ctx) { fseek(ctx->imageStream, 0, SEEK_END); long tag_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(tag_position & alignment_mask) { const uint64_t aligned_position = tag_position + alignment_mask & ~alignment_mask; @@ -2491,7 +2501,7 @@ static void write_media_tags(const aaruformatContext *ctx) tag_index_entry.blockType = DataBlock; tag_index_entry.dataType = tag_block.type; tag_index_entry.offset = tag_position; - utarray_push_back(ctx->indexEntries, &tag_index_entry); + utarray_push_back(ctx->index_entries, &tag_index_entry); TRACE("Added media tag block type %d index entry at offset %" PRIu64, tag_block.type, tag_position); } } @@ -2662,15 +2672,15 @@ static void write_media_tags(const aaruformatContext *ctx) * * @internal */ -static void write_tape_file_block(const aaruformatContext *ctx) +static void write_tape_file_block(const aaruformat_context *ctx) { - if(ctx->tapeFiles == NULL) return; + if(ctx->tape_files == NULL) return; // Iterate the uthash and count how many entries do we have const tapeFileHashEntry *tape_file = NULL; const tapeFileHashEntry *tmp_tape_file = NULL; size_t tape_file_count = 0; - HASH_ITER(hh, ctx->tapeFiles, tape_file, tmp_tape_file) tape_file_count++; + HASH_ITER(hh, ctx->tape_files, tape_file, tmp_tape_file) tape_file_count++; // Create a memory buffer to copy all the file entries const size_t buffer_size = tape_file_count * sizeof(TapeFileEntry); @@ -2682,7 +2692,7 @@ static void write_tape_file_block(const aaruformatContext *ctx) } memset(buffer, 0, buffer_size); size_t index = 0; - HASH_ITER(hh, ctx->tapeFiles, tape_file, tmp_tape_file) + HASH_ITER(hh, ctx->tape_files, tape_file, tmp_tape_file) { if(index >= tape_file_count) break; memcpy(&buffer[index], &tape_file->fileEntry, sizeof(TapeFileEntry)); @@ -2698,7 +2708,7 @@ static void write_tape_file_block(const aaruformatContext *ctx) // Write tape file block to file, block aligned fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -2718,7 +2728,7 @@ static void write_tape_file_block(const aaruformatContext *ctx) index_entry.blockType = TapeFileBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added tape file block index entry at offset %" PRIu64, block_position); } } @@ -2894,15 +2904,15 @@ static void write_tape_file_block(const aaruformatContext *ctx) * * @internal */ -static void write_tape_partition_block(const aaruformatContext *ctx) +static void write_tape_partition_block(const aaruformat_context *ctx) { - if(ctx->tapePartitions == NULL) return; + if(ctx->tape_partitions == NULL) return; // Iterate the uthash and count how many entries do we have const TapePartitionHashEntry *tape_partition = NULL; const TapePartitionHashEntry *tmp_tape_partition = NULL; size_t tape_partition_count = 0; - HASH_ITER(hh, ctx->tapePartitions, tape_partition, tmp_tape_partition) tape_partition_count++; + HASH_ITER(hh, ctx->tape_partitions, tape_partition, tmp_tape_partition) tape_partition_count++; // Create a memory buffer to copy all the partition entries const size_t buffer_size = tape_partition_count * sizeof(TapePartitionEntry); @@ -2914,7 +2924,7 @@ static void write_tape_partition_block(const aaruformatContext *ctx) } memset(buffer, 0, buffer_size); size_t index = 0; - HASH_ITER(hh, ctx->tapePartitions, tape_partition, tmp_tape_partition) + HASH_ITER(hh, ctx->tape_partitions, tape_partition, tmp_tape_partition) { if(index >= tape_partition_count) break; memcpy(&buffer[index], &tape_partition->partitionEntry, sizeof(TapePartitionEntry)); @@ -2930,7 +2940,7 @@ static void write_tape_partition_block(const aaruformatContext *ctx) // Write tape partition block to partition, block aligned fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -2950,7 +2960,7 @@ static void write_tape_partition_block(const aaruformatContext *ctx) index_entry.blockType = TapePartitionBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added tape partition block index entry at offset %" PRIu64, block_position); } } @@ -3019,13 +3029,13 @@ static void write_tape_partition_block(const aaruformatContext *ctx) * @see GeometryBlockHeader * @see aaruf_set_geometry() for setting geometry values before closing. */ -static void write_geometry_block(const aaruformatContext *ctx) +static void write_geometry_block(const aaruformat_context *ctx) { - if(ctx->geometryBlock.identifier != GeometryBlock) return; + if(ctx->geometry_block.identifier != GeometryBlock) return; fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -3036,7 +3046,7 @@ static void write_geometry_block(const aaruformatContext *ctx) TRACE("Writing geometry block at position %ld", block_position); // Write header - if(fwrite(&ctx->geometryBlock, sizeof(GeometryBlockHeader), 1, ctx->imageStream) == 1) + if(fwrite(&ctx->geometry_block, sizeof(GeometryBlockHeader), 1, ctx->imageStream) == 1) { TRACE("Successfully wrote geometry block"); @@ -3046,7 +3056,7 @@ static void write_geometry_block(const aaruformatContext *ctx) index_entry.blockType = GeometryBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added geometry block index entry at offset %" PRIu64, block_position); } } @@ -3155,117 +3165,118 @@ static void write_geometry_block(const aaruformatContext *ctx) * * @internal */ -static void write_metadata_block(aaruformatContext *ctx) +static void write_metadata_block(aaruformat_context *ctx) { - if(ctx->metadataBlockHeader.identifier != MetadataBlock && ctx->metadataBlockHeader.mediaSequence == 0 && - ctx->metadataBlockHeader.lastMediaSequence == 0 && ctx->Creator == NULL && ctx->Comments == NULL && - ctx->MediaTitle == NULL && ctx->MediaManufacturer == NULL && ctx->MediaModel == NULL && - ctx->MediaSerialNumber == NULL && ctx->MediaBarcode == NULL && ctx->MediaPartNumber == NULL && - ctx->DriveManufacturer == NULL && ctx->DriveModel == NULL && ctx->DriveSerialNumber == NULL && - ctx->DriveFirmwareRevision == NULL) + if(ctx->metadata_block_header.identifier != MetadataBlock && ctx->metadata_block_header.mediaSequence == 0 && + ctx->metadata_block_header.lastMediaSequence == 0 && ctx->creator == NULL && ctx->comments == NULL && + ctx->media_title == NULL && ctx->media_manufacturer == NULL && ctx->media_model == NULL && + ctx->media_serial_number == NULL && ctx->media_barcode == NULL && ctx->media_part_number == NULL && + ctx->drive_manufacturer == NULL && ctx->drive_model == NULL && ctx->drive_serial_number == NULL && + ctx->drive_firmware_revision == NULL) return; - ctx->metadataBlockHeader.blockSize = - sizeof(MetadataBlockHeader) + ctx->metadataBlockHeader.creatorLength + ctx->metadataBlockHeader.commentsLength + - ctx->metadataBlockHeader.mediaTitleLength + ctx->metadataBlockHeader.mediaManufacturerLength + - ctx->metadataBlockHeader.mediaModelLength + ctx->metadataBlockHeader.mediaSerialNumberLength + - ctx->metadataBlockHeader.mediaBarcodeLength + ctx->metadataBlockHeader.mediaPartNumberLength + - ctx->metadataBlockHeader.driveManufacturerLength + ctx->metadataBlockHeader.driveModelLength + - ctx->metadataBlockHeader.driveSerialNumberLength + ctx->metadataBlockHeader.driveFirmwareRevisionLength; + ctx->metadata_block_header.blockSize = + sizeof(MetadataBlockHeader) + ctx->metadata_block_header.creatorLength + + ctx->metadata_block_header.commentsLength + ctx->metadata_block_header.mediaTitleLength + + ctx->metadata_block_header.mediaManufacturerLength + ctx->metadata_block_header.mediaModelLength + + ctx->metadata_block_header.mediaSerialNumberLength + ctx->metadata_block_header.mediaBarcodeLength + + ctx->metadata_block_header.mediaPartNumberLength + ctx->metadata_block_header.driveManufacturerLength + + ctx->metadata_block_header.driveModelLength + ctx->metadata_block_header.driveSerialNumberLength + + ctx->metadata_block_header.driveFirmwareRevisionLength; - ctx->metadataBlockHeader.identifier = MetadataBlock; + ctx->metadata_block_header.identifier = MetadataBlock; int pos = sizeof(MetadataBlockHeader); - uint8_t *buffer = calloc(1, ctx->metadataBlockHeader.blockSize); + uint8_t *buffer = calloc(1, ctx->metadata_block_header.blockSize); if(buffer == NULL) return; - if(ctx->Creator != NULL && ctx->metadataBlockHeader.creatorLength > 0) + if(ctx->creator != NULL && ctx->metadata_block_header.creatorLength > 0) { - memcpy(buffer + pos, ctx->Creator, ctx->metadataBlockHeader.creatorLength); - ctx->metadataBlockHeader.creatorOffset = pos; - pos += ctx->metadataBlockHeader.creatorLength; + memcpy(buffer + pos, ctx->creator, ctx->metadata_block_header.creatorLength); + ctx->metadata_block_header.creatorOffset = pos; + pos += ctx->metadata_block_header.creatorLength; } - if(ctx->Comments != NULL && ctx->metadataBlockHeader.commentsLength > 0) + if(ctx->comments != NULL && ctx->metadata_block_header.commentsLength > 0) { - memcpy(buffer + pos, ctx->Comments, ctx->metadataBlockHeader.commentsLength); - ctx->metadataBlockHeader.commentsOffset = pos; - pos += ctx->metadataBlockHeader.commentsLength; + memcpy(buffer + pos, ctx->comments, ctx->metadata_block_header.commentsLength); + ctx->metadata_block_header.commentsOffset = pos; + pos += ctx->metadata_block_header.commentsLength; } - if(ctx->MediaTitle != NULL && ctx->metadataBlockHeader.mediaTitleLength > 0) + if(ctx->media_title != NULL && ctx->metadata_block_header.mediaTitleLength > 0) { - memcpy(buffer + pos, ctx->MediaTitle, ctx->metadataBlockHeader.mediaTitleLength); - ctx->metadataBlockHeader.mediaTitleOffset = pos; - pos += ctx->metadataBlockHeader.mediaTitleLength; + memcpy(buffer + pos, ctx->media_title, ctx->metadata_block_header.mediaTitleLength); + ctx->metadata_block_header.mediaTitleOffset = pos; + pos += ctx->metadata_block_header.mediaTitleLength; } - if(ctx->MediaManufacturer != NULL && ctx->metadataBlockHeader.mediaManufacturerLength > 0) + if(ctx->media_manufacturer != NULL && ctx->metadata_block_header.mediaManufacturerLength > 0) { - memcpy(buffer + pos, ctx->MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength); - ctx->metadataBlockHeader.mediaManufacturerOffset = pos; - pos += ctx->metadataBlockHeader.mediaManufacturerLength; + memcpy(buffer + pos, ctx->media_manufacturer, ctx->metadata_block_header.mediaManufacturerLength); + ctx->metadata_block_header.mediaManufacturerOffset = pos; + pos += ctx->metadata_block_header.mediaManufacturerLength; } - if(ctx->MediaModel != NULL && ctx->metadataBlockHeader.mediaModelLength > 0) + if(ctx->media_model != NULL && ctx->metadata_block_header.mediaModelLength > 0) { - memcpy(buffer + pos, ctx->MediaModel, ctx->metadataBlockHeader.mediaModelLength); - ctx->metadataBlockHeader.mediaModelOffset = pos; - pos += ctx->metadataBlockHeader.mediaModelLength; + memcpy(buffer + pos, ctx->media_model, ctx->metadata_block_header.mediaModelLength); + ctx->metadata_block_header.mediaModelOffset = pos; + pos += ctx->metadata_block_header.mediaModelLength; } - if(ctx->MediaSerialNumber != NULL && ctx->metadataBlockHeader.mediaSerialNumberLength > 0) + if(ctx->media_serial_number != NULL && ctx->metadata_block_header.mediaSerialNumberLength > 0) { - memcpy(buffer + pos, ctx->MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength); - ctx->metadataBlockHeader.mediaSerialNumberOffset = pos; - pos += ctx->metadataBlockHeader.mediaSerialNumberLength; + memcpy(buffer + pos, ctx->media_serial_number, ctx->metadata_block_header.mediaSerialNumberLength); + ctx->metadata_block_header.mediaSerialNumberOffset = pos; + pos += ctx->metadata_block_header.mediaSerialNumberLength; } - if(ctx->MediaBarcode != NULL && ctx->metadataBlockHeader.mediaBarcodeLength > 0) + if(ctx->media_barcode != NULL && ctx->metadata_block_header.mediaBarcodeLength > 0) { - memcpy(buffer + pos, ctx->MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength); - ctx->metadataBlockHeader.mediaBarcodeOffset = pos; - pos += ctx->metadataBlockHeader.mediaBarcodeLength; + memcpy(buffer + pos, ctx->media_barcode, ctx->metadata_block_header.mediaBarcodeLength); + ctx->metadata_block_header.mediaBarcodeOffset = pos; + pos += ctx->metadata_block_header.mediaBarcodeLength; } - if(ctx->MediaPartNumber != NULL && ctx->metadataBlockHeader.mediaPartNumberLength > 0) + if(ctx->media_part_number != NULL && ctx->metadata_block_header.mediaPartNumberLength > 0) { - memcpy(buffer + pos, ctx->MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength); - ctx->metadataBlockHeader.mediaPartNumberOffset = pos; - pos += ctx->metadataBlockHeader.mediaPartNumberLength; + memcpy(buffer + pos, ctx->media_part_number, ctx->metadata_block_header.mediaPartNumberLength); + ctx->metadata_block_header.mediaPartNumberOffset = pos; + pos += ctx->metadata_block_header.mediaPartNumberLength; } - if(ctx->DriveManufacturer != NULL && ctx->metadataBlockHeader.driveManufacturerLength > 0) + if(ctx->drive_manufacturer != NULL && ctx->metadata_block_header.driveManufacturerLength > 0) { - memcpy(buffer + pos, ctx->DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength); - ctx->metadataBlockHeader.driveManufacturerOffset = pos; - pos += ctx->metadataBlockHeader.driveManufacturerLength; + memcpy(buffer + pos, ctx->drive_manufacturer, ctx->metadata_block_header.driveManufacturerLength); + ctx->metadata_block_header.driveManufacturerOffset = pos; + pos += ctx->metadata_block_header.driveManufacturerLength; } - if(ctx->DriveModel != NULL && ctx->metadataBlockHeader.driveModelLength > 0) + if(ctx->drive_model != NULL && ctx->metadata_block_header.driveModelLength > 0) { - memcpy(buffer + pos, ctx->DriveModel, ctx->metadataBlockHeader.driveModelLength); - ctx->metadataBlockHeader.driveModelOffset = pos; - pos += ctx->metadataBlockHeader.driveModelLength; + memcpy(buffer + pos, ctx->drive_model, ctx->metadata_block_header.driveModelLength); + ctx->metadata_block_header.driveModelOffset = pos; + pos += ctx->metadata_block_header.driveModelLength; } - if(ctx->DriveSerialNumber != NULL && ctx->metadataBlockHeader.driveSerialNumberLength > 0) + if(ctx->drive_serial_number != NULL && ctx->metadata_block_header.driveSerialNumberLength > 0) { - memcpy(buffer + pos, ctx->DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength); - ctx->metadataBlockHeader.driveSerialNumberOffset = pos; - pos += ctx->metadataBlockHeader.driveSerialNumberLength; + memcpy(buffer + pos, ctx->drive_serial_number, ctx->metadata_block_header.driveSerialNumberLength); + ctx->metadata_block_header.driveSerialNumberOffset = pos; + pos += ctx->metadata_block_header.driveSerialNumberLength; } - if(ctx->DriveFirmwareRevision != NULL && ctx->metadataBlockHeader.driveFirmwareRevisionLength > 0) + if(ctx->drive_firmware_revision != NULL && ctx->metadata_block_header.driveFirmwareRevisionLength > 0) { - memcpy(buffer + pos, ctx->DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength); - ctx->metadataBlockHeader.driveFirmwareRevisionOffset = pos; + memcpy(buffer + pos, ctx->drive_firmware_revision, ctx->metadata_block_header.driveFirmwareRevisionLength); + ctx->metadata_block_header.driveFirmwareRevisionOffset = pos; } fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -3275,7 +3286,7 @@ static void write_metadata_block(aaruformatContext *ctx) TRACE("Writing metadata block at position %ld", block_position); - if(fwrite(buffer, ctx->metadataBlockHeader.blockSize, 1, ctx->imageStream) == 1) + if(fwrite(buffer, ctx->metadata_block_header.blockSize, 1, ctx->imageStream) == 1) { TRACE("Successfully wrote metadata block"); @@ -3285,7 +3296,7 @@ static void write_metadata_block(aaruformatContext *ctx) index_entry.blockType = MetadataBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added metadata block index entry at offset %" PRIu64, block_position); } @@ -3437,14 +3448,14 @@ static void write_metadata_block(aaruformatContext *ctx) * * @internal */ -static void write_dumphw_block(aaruformatContext *ctx) +static void write_dumphw_block(aaruformat_context *ctx) { - if(ctx->dumpHardwareEntriesWithData == NULL || ctx->dumpHardwareHeader.entries == 0 || - ctx->dumpHardwareHeader.identifier != DumpHardwareBlock) + if(ctx->dump_hardware_entries_with_data == NULL || ctx->dump_hardware_header.entries == 0 || + ctx->dump_hardware_header.identifier != DumpHardwareBlock) return; - const size_t required_length = sizeof(DumpHardwareHeader) + ctx->dumpHardwareHeader.length; + const size_t required_length = sizeof(DumpHardwareHeader) + ctx->dump_hardware_header.length; uint8_t *buffer = calloc(1, required_length); @@ -3452,17 +3463,18 @@ static void write_dumphw_block(aaruformatContext *ctx) // Start to iterate and copy the data size_t offset = 0; - for(int i = 0; i < ctx->dumpHardwareHeader.entries; i++) + for(int i = 0; i < ctx->dump_hardware_header.entries; i++) { - size_t entry_size = sizeof(DumpHardwareEntry) + ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength + - ctx->dumpHardwareEntriesWithData[i].entry.modelLength + - ctx->dumpHardwareEntriesWithData[i].entry.revisionLength + - ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength + - ctx->dumpHardwareEntriesWithData[i].entry.serialLength + - ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength + - ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength + - ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength + - ctx->dumpHardwareEntriesWithData[i].entry.extents * sizeof(DumpExtent); + size_t entry_size = sizeof(DumpHardwareEntry) + + ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + + ctx->dump_hardware_entries_with_data[i].entry.modelLength + + ctx->dump_hardware_entries_with_data[i].entry.revisionLength + + ctx->dump_hardware_entries_with_data[i].entry.firmwareLength + + ctx->dump_hardware_entries_with_data[i].entry.serialLength + + ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + + ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + + ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + + ctx->dump_hardware_entries_with_data[i].entry.extents * sizeof(DumpExtent); if(offset + entry_size > required_length) { @@ -3471,82 +3483,83 @@ static void write_dumphw_block(aaruformatContext *ctx) return; } - memcpy(buffer + offset, &ctx->dumpHardwareEntriesWithData[i].entry, sizeof(DumpHardwareEntry)); + memcpy(buffer + offset, &ctx->dump_hardware_entries_with_data[i].entry, sizeof(DumpHardwareEntry)); offset += sizeof(DumpHardwareEntry); - if(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength > 0 && - ctx->dumpHardwareEntriesWithData[i].manufacturer != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength > 0 && + ctx->dump_hardware_entries_with_data[i].manufacturer != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].manufacturer, - ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].manufacturer, + ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.modelLength > 0 && - ctx->dumpHardwareEntriesWithData[i].model != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.modelLength > 0 && + ctx->dump_hardware_entries_with_data[i].model != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].model, - ctx->dumpHardwareEntriesWithData[i].entry.modelLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.modelLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].model, + ctx->dump_hardware_entries_with_data[i].entry.modelLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.modelLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength > 0 && - ctx->dumpHardwareEntriesWithData[i].revision != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.revisionLength > 0 && + ctx->dump_hardware_entries_with_data[i].revision != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].revision, - ctx->dumpHardwareEntriesWithData[i].entry.revisionLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.revisionLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].revision, + ctx->dump_hardware_entries_with_data[i].entry.revisionLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.revisionLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength > 0 && - ctx->dumpHardwareEntriesWithData[i].firmware != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength > 0 && + ctx->dump_hardware_entries_with_data[i].firmware != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].firmware, - ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].firmware, + ctx->dump_hardware_entries_with_data[i].entry.firmwareLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.firmwareLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.serialLength > 0 && - ctx->dumpHardwareEntriesWithData[i].serial != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.serialLength > 0 && + ctx->dump_hardware_entries_with_data[i].serial != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].serial, - ctx->dumpHardwareEntriesWithData[i].entry.serialLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.serialLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].serial, + ctx->dump_hardware_entries_with_data[i].entry.serialLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.serialLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength > 0 && - ctx->dumpHardwareEntriesWithData[i].softwareName != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength > 0 && + ctx->dump_hardware_entries_with_data[i].softwareName != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareName, - ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareName, + ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength > 0 && - ctx->dumpHardwareEntriesWithData[i].softwareVersion != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength > 0 && + ctx->dump_hardware_entries_with_data[i].softwareVersion != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareVersion, - ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareVersion, + ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength > 0 && - ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength > 0 && + ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem, - ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem, + ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.extents > 0 && ctx->dumpHardwareEntriesWithData[i].extents != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.extents > 0 && + ctx->dump_hardware_entries_with_data[i].extents != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].extents, - ctx->dumpHardwareEntriesWithData[i].entry.extents * sizeof(DumpExtent)); - offset += ctx->dumpHardwareEntriesWithData[i].entry.extents * sizeof(DumpExtent); + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].extents, + ctx->dump_hardware_entries_with_data[i].entry.extents * sizeof(DumpExtent)); + offset += ctx->dump_hardware_entries_with_data[i].entry.extents * sizeof(DumpExtent); } } // Calculate CRC64 - ctx->dumpHardwareHeader.crc64 = - aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dumpHardwareHeader.length); + ctx->dump_hardware_header.crc64 = + aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dump_hardware_header.length); // Copy header - memcpy(buffer, &ctx->dumpHardwareHeader, sizeof(DumpHardwareHeader)); + memcpy(buffer, &ctx->dump_hardware_header, sizeof(DumpHardwareHeader)); fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { const uint64_t aligned_position = block_position + alignment_mask & ~alignment_mask; @@ -3564,7 +3577,7 @@ static void write_dumphw_block(aaruformatContext *ctx) index_entry.blockType = DumpHardwareBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added dump hardware block index entry at offset %" PRIu64, block_position); } @@ -3665,14 +3678,14 @@ static void write_dumphw_block(aaruformatContext *ctx) * * @internal */ -static void write_cicm_block(const aaruformatContext *ctx) +static void write_cicm_block(const aaruformat_context *ctx) { - if(ctx->cicmBlock == NULL || ctx->cicmBlockHeader.length == 0 || ctx->cicmBlockHeader.identifier != CicmBlock) + if(ctx->cicm_block == NULL || ctx->cicm_block_header.length == 0 || ctx->cicm_block_header.identifier != CicmBlock) return; fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { @@ -3682,8 +3695,8 @@ static void write_cicm_block(const aaruformatContext *ctx) } TRACE("Writing CICM XML block at position %ld", block_position); - if(fwrite(&ctx->cicmBlockHeader, sizeof(CicmMetadataBlock), 1, ctx->imageStream) == 1) - if(fwrite(ctx->cicmBlock, ctx->cicmBlockHeader.length, 1, ctx->imageStream) == 1) + if(fwrite(&ctx->cicm_block_header, sizeof(CicmMetadataBlock), 1, ctx->imageStream) == 1) + if(fwrite(ctx->cicm_block, ctx->cicm_block_header.length, 1, ctx->imageStream) == 1) { TRACE("Successfully wrote CICM XML block"); @@ -3693,7 +3706,7 @@ static void write_cicm_block(const aaruformatContext *ctx) index_entry.blockType = CicmBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added CICM XML block index entry at offset %" PRIu64, block_position); } } @@ -3802,15 +3815,15 @@ static void write_cicm_block(const aaruformatContext *ctx) * * @internal */ -static void write_aaru_json_block(const aaruformatContext *ctx) +static void write_aaru_json_block(const aaruformat_context *ctx) { - if(ctx->jsonBlock == NULL || ctx->jsonBlockHeader.length == 0 || - ctx->jsonBlockHeader.identifier != AaruMetadataJsonBlock) + if(ctx->json_block == NULL || ctx->json_block_header.length == 0 || + ctx->json_block_header.identifier != AaruMetadataJsonBlock) return; fseek(ctx->imageStream, 0, SEEK_END); long block_position = ftell(ctx->imageStream); - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(block_position & alignment_mask) { @@ -3820,8 +3833,8 @@ static void write_aaru_json_block(const aaruformatContext *ctx) } TRACE("Writing Aaru metadata JSON block at position %ld", block_position); - if(fwrite(&ctx->jsonBlockHeader, sizeof(AaruMetadataJsonBlockHeader), 1, ctx->imageStream) == 1) - if(fwrite(ctx->jsonBlock, ctx->jsonBlockHeader.length, 1, ctx->imageStream) == 1) + if(fwrite(&ctx->json_block_header, sizeof(AaruMetadataJsonBlockHeader), 1, ctx->imageStream) == 1) + if(fwrite(ctx->json_block, ctx->json_block_header.length, 1, ctx->imageStream) == 1) { TRACE("Successfully wrote Aaru metadata JSON block"); @@ -3831,7 +3844,7 @@ static void write_aaru_json_block(const aaruformatContext *ctx) index_entry.blockType = AaruMetadataJsonBlock; index_entry.dataType = 0; index_entry.offset = block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Added Aaru metadata JSON block index entry at offset %" PRIu64, block_position); } } @@ -3852,7 +3865,7 @@ static void write_aaru_json_block(const aaruformatContext *ctx) * @retval AARUF_ERROR_CANNOT_WRITE_HEADER Failed writing index header, entries, or updating main header. * @internal */ -static int32_t write_index_block(aaruformatContext *ctx) +static int32_t write_index_block(aaruformat_context *ctx) { // Write the complete index at the end of the file TRACE("Writing index at the end of the file"); @@ -3860,7 +3873,7 @@ static int32_t write_index_block(aaruformatContext *ctx) long index_position = ftell(ctx->imageStream); // Align index position to block boundary if needed - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; if(index_position & alignment_mask) { uint64_t aligned_position = index_position + alignment_mask & ~alignment_mask; @@ -3872,7 +3885,7 @@ static int32_t write_index_block(aaruformatContext *ctx) // Prepare index header IndexHeader3 index_header; index_header.identifier = IndexBlock3; - index_header.entries = utarray_len(ctx->indexEntries); + index_header.entries = utarray_len(ctx->index_entries); index_header.previous = 0; // No previous index for now TRACE("Writing index with %" PRIu64 " entries at position %ld", index_header.entries, index_position); @@ -3882,7 +3895,7 @@ static int32_t write_index_block(aaruformatContext *ctx) if(index_crc64_context != NULL && index_header.entries > 0) { size_t index_data_size = index_header.entries * sizeof(IndexEntry); - aaruf_crc64_update(index_crc64_context, utarray_front(ctx->indexEntries), index_data_size); + aaruf_crc64_update(index_crc64_context, utarray_front(ctx->index_entries), index_data_size); aaruf_crc64_final(index_crc64_context, &index_header.crc64); TRACE("Calculated index CRC64: 0x%16lX", index_header.crc64); } @@ -3900,8 +3913,8 @@ static int32_t write_index_block(aaruformatContext *ctx) size_t entries_written = 0; IndexEntry *entry = NULL; - for(entry = (IndexEntry *)utarray_front(ctx->indexEntries); entry != NULL; - entry = (IndexEntry *)utarray_next(ctx->indexEntries, entry)) + for(entry = (IndexEntry *)utarray_front(ctx->index_entries); entry != NULL; + entry = (IndexEntry *)utarray_next(ctx->index_entries, entry)) if(fwrite(entry, sizeof(IndexEntry), 1, ctx->imageStream) == 1) { entries_written++; @@ -3999,7 +4012,7 @@ int aaruf_close(void *context) return -1; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -4009,7 +4022,7 @@ int aaruf_close(void *context) return -1; } - if(ctx->isWriting) + if(ctx->is_writing) { TRACE("File is writing"); @@ -4028,7 +4041,7 @@ int aaruf_close(void *context) // Close current block first TRACE("Closing current block if any"); - if(ctx->writingBuffer != NULL) + if(ctx->writing_buffer != NULL) { int error = aaruf_close_current_block(ctx); @@ -4115,12 +4128,12 @@ int aaruf_close(void *context) res = write_index_block(ctx); if(res != AARUF_STATUS_OK) return res; - if(ctx->deduplicate && ctx->sectorHashMap != NULL) + if(ctx->deduplicate && ctx->sector_hash_map != NULL) { TRACE("Clearing sector hash map"); // Clear sector hash map - free_map(ctx->sectorHashMap); - ctx->sectorHashMap = NULL; + free_map(ctx->sector_hash_map); + ctx->sector_hash_map = NULL; } } @@ -4133,20 +4146,20 @@ int aaruf_close(void *context) } // Free index entries array - if(ctx->indexEntries != NULL) + if(ctx->index_entries != NULL) { - utarray_free(ctx->indexEntries); - ctx->indexEntries = NULL; + utarray_free(ctx->index_entries); + ctx->index_entries = NULL; } free(ctx->sector_prefix); ctx->sector_prefix = NULL; - free(ctx->sectorPrefixCorrected); - ctx->sectorPrefixCorrected = NULL; + free(ctx->sector_prefix_corrected); + ctx->sector_prefix_corrected = NULL; free(ctx->sector_suffix); ctx->sector_suffix = NULL; - free(ctx->sectorSuffixCorrected); - ctx->sectorSuffixCorrected = NULL; + free(ctx->sector_suffix_corrected); + ctx->sector_suffix_corrected = NULL; free(ctx->sector_subchannel); ctx->sector_subchannel = NULL; free(ctx->mode2_subheaders); @@ -4162,60 +4175,60 @@ int aaruf_close(void *context) #ifdef __linux__ // TODO: Implement TRACE("Unmapping user data DDT if it is not in memory"); - if(!ctx->inMemoryDdt) + if(!ctx->in_memory_ddt) { - munmap(ctx->userDataDdt, ctx->mappedMemoryDdtSize); - ctx->userDataDdt = NULL; + munmap(ctx->user_data_ddt, ctx->mapped_memory_ddt_size); + ctx->user_data_ddt = NULL; } #endif - free(ctx->sectorPrefixDdt2); - ctx->sectorPrefixDdt2 = NULL; - free(ctx->sectorPrefixDdt); - ctx->sectorPrefixDdt = NULL; - free(ctx->sectorSuffixDdt2); - ctx->sectorSuffixDdt2 = NULL; - free(ctx->sectorSuffixDdt); - ctx->sectorSuffixDdt = NULL; + free(ctx->sector_prefix_ddt2); + ctx->sector_prefix_ddt2 = NULL; + free(ctx->sector_prefix_ddt); + ctx->sector_prefix_ddt = NULL; + free(ctx->sector_suffix_ddt2); + ctx->sector_suffix_ddt2 = NULL; + free(ctx->sector_suffix_ddt); + ctx->sector_suffix_ddt = NULL; - free(ctx->metadataBlock); - ctx->metadataBlock = NULL; - free(ctx->trackEntries); - ctx->trackEntries = NULL; - free(ctx->cicmBlock); - ctx->cicmBlock = NULL; + free(ctx->metadata_block); + ctx->metadata_block = NULL; + free(ctx->track_entries); + ctx->track_entries = NULL; + free(ctx->cicm_block); + ctx->cicm_block = NULL; - if(ctx->dumpHardwareEntriesWithData != NULL) + if(ctx->dump_hardware_entries_with_data != NULL) { - for(int i = 0; i < ctx->dumpHardwareHeader.entries; i++) + for(int i = 0; i < ctx->dump_hardware_header.entries; i++) { - free(ctx->dumpHardwareEntriesWithData[i].extents); - ctx->dumpHardwareEntriesWithData[i].extents = NULL; - free(ctx->dumpHardwareEntriesWithData[i].manufacturer); - ctx->dumpHardwareEntriesWithData[i].manufacturer = NULL; - free(ctx->dumpHardwareEntriesWithData[i].model); - ctx->dumpHardwareEntriesWithData[i].model = NULL; - free(ctx->dumpHardwareEntriesWithData[i].revision); - ctx->dumpHardwareEntriesWithData[i].revision = NULL; - free(ctx->dumpHardwareEntriesWithData[i].firmware); - ctx->dumpHardwareEntriesWithData[i].firmware = NULL; - free(ctx->dumpHardwareEntriesWithData[i].serial); - ctx->dumpHardwareEntriesWithData[i].serial = NULL; - free(ctx->dumpHardwareEntriesWithData[i].softwareName); - ctx->dumpHardwareEntriesWithData[i].softwareName = NULL; - free(ctx->dumpHardwareEntriesWithData[i].softwareVersion); - ctx->dumpHardwareEntriesWithData[i].softwareVersion = NULL; - free(ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem); - ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem = NULL; + free(ctx->dump_hardware_entries_with_data[i].extents); + ctx->dump_hardware_entries_with_data[i].extents = NULL; + free(ctx->dump_hardware_entries_with_data[i].manufacturer); + ctx->dump_hardware_entries_with_data[i].manufacturer = NULL; + free(ctx->dump_hardware_entries_with_data[i].model); + ctx->dump_hardware_entries_with_data[i].model = NULL; + free(ctx->dump_hardware_entries_with_data[i].revision); + ctx->dump_hardware_entries_with_data[i].revision = NULL; + free(ctx->dump_hardware_entries_with_data[i].firmware); + ctx->dump_hardware_entries_with_data[i].firmware = NULL; + free(ctx->dump_hardware_entries_with_data[i].serial); + ctx->dump_hardware_entries_with_data[i].serial = NULL; + free(ctx->dump_hardware_entries_with_data[i].softwareName); + ctx->dump_hardware_entries_with_data[i].softwareName = NULL; + free(ctx->dump_hardware_entries_with_data[i].softwareVersion); + ctx->dump_hardware_entries_with_data[i].softwareVersion = NULL; + free(ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem); + ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem = NULL; } - ctx->dumpHardwareEntriesWithData = NULL; + ctx->dump_hardware_entries_with_data = NULL; } free(ctx->readableSectorTags); ctx->readableSectorTags = NULL; - free(ctx->eccCdContext); - ctx->eccCdContext = NULL; + free(ctx->ecc_cd_context); + ctx->ecc_cd_context = NULL; free(ctx->checksums.spamsum); ctx->checksums.spamsum = NULL; diff --git a/src/create.c b/src/create.c index 0666536..04df572 100644 --- a/src/create.c +++ b/src/create.c @@ -30,26 +30,26 @@ #include "internal.h" #include "log.h" -static void cleanup_failed_create(aaruformatContext *ctx) +static void cleanup_failed_create(aaruformat_context *ctx) { if(ctx == NULL) return; - if(ctx->sectorHashMap != NULL) + if(ctx->sector_hash_map != NULL) { - free_map(ctx->sectorHashMap); - ctx->sectorHashMap = NULL; + free_map(ctx->sector_hash_map); + ctx->sector_hash_map = NULL; } - if(ctx->indexEntries != NULL) + if(ctx->index_entries != NULL) { - utarray_free(ctx->indexEntries); - ctx->indexEntries = NULL; + utarray_free(ctx->index_entries); + ctx->index_entries = NULL; } - if(ctx->userDataDdtBig != NULL) + if(ctx->user_data_ddt2 != NULL) { - free(ctx->userDataDdtBig); - ctx->userDataDdtBig = NULL; + free(ctx->user_data_ddt2); + ctx->user_data_ddt2 = NULL; } if(ctx->spamsum_context != NULL) @@ -64,10 +64,10 @@ static void cleanup_failed_create(aaruformatContext *ctx) ctx->blake3_context = NULL; } - if(ctx->eccCdContext != NULL) + if(ctx->ecc_cd_context != NULL) { - free(ctx->eccCdContext); - ctx->eccCdContext = NULL; + free(ctx->ecc_cd_context); + ctx->ecc_cd_context = NULL; } if(ctx->readableSectorTags != NULL) @@ -297,7 +297,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 // Allocate context TRACE("Allocating memory for context"); - aaruformatContext *ctx = malloc(sizeof(aaruformatContext)); + aaruformat_context *ctx = malloc(sizeof(aaruformat_context)); if(ctx == NULL) { FATAL("Not enough memory to create context"); @@ -307,7 +307,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 return NULL; } - memset(ctx, 0, sizeof(aaruformatContext)); + memset(ctx, 0, sizeof(aaruformat_context)); // Create the image file TRACE("Creating image file %s", filepath); @@ -386,29 +386,29 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 // Ensure it fits in the Application buffer (64 bytes including null terminator) if(app_name_utf8_len < 64) { - u_strToUTF8(ctx->imageInfo.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status); + u_strToUTF8(ctx->image_info.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status); if(U_FAILURE(status)) { TRACE("Error converting application name to UTF-8: %d, using raw bytes", status); // Fallback: just copy what we can - memset(ctx->imageInfo.Application, 0, 64); - memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); + memset(ctx->image_info.Application, 0, 64); + memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); } } else { TRACE("Application name too long for buffer, truncating"); - u_strToUTF8(ctx->imageInfo.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status); - ctx->imageInfo.Application[63] = '\0'; + u_strToUTF8(ctx->image_info.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status); + ctx->image_info.Application[63] = '\0'; } } else { TRACE("Error getting UTF-8 length: %d, using raw bytes", status); // Fallback: just copy what we can - memset(ctx->imageInfo.Application, 0, 64); - memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); + memset(ctx->image_info.Application, 0, 64); + memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); } free(app_name_utf16); @@ -417,95 +417,95 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 { TRACE("Could not allocate memory for UTF-16 conversion, using raw bytes"); // Fallback: just copy what we can - memset(ctx->imageInfo.Application, 0, 64); - memcpy(ctx->imageInfo.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); + memset(ctx->image_info.Application, 0, 64); + memcpy(ctx->image_info.Application, ctx->header.application, AARU_HEADER_APP_NAME_LEN); } // Set application version string directly in the fixed-size array - memset(ctx->imageInfo.ApplicationVersion, 0, 32); - sprintf(ctx->imageInfo.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion, + memset(ctx->image_info.ApplicationVersion, 0, 32); + sprintf(ctx->image_info.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion, ctx->header.applicationMinorVersion); // Set image version string directly in the fixed-size array - memset(ctx->imageInfo.Version, 0, 32); - sprintf(ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion); + memset(ctx->image_info.Version, 0, 32); + sprintf(ctx->image_info.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion); - ctx->imageInfo.MediaType = ctx->header.mediaType; - ctx->imageInfo.ImageSize = 0; - ctx->imageInfo.CreationTime = ctx->header.creationTime; - ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime; - ctx->imageInfo.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType); - ctx->imageInfo.SectorSize = sector_size; + ctx->image_info.MediaType = ctx->header.mediaType; + ctx->image_info.ImageSize = 0; + ctx->image_info.CreationTime = ctx->header.creationTime; + ctx->image_info.LastModificationTime = ctx->header.lastWrittenTime; + ctx->image_info.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType); + ctx->image_info.SectorSize = sector_size; // Initialize caches TRACE("Initializing caches"); - ctx->blockHeaderCache.cache = NULL; - const uint64_t cache_divisor = (uint64_t)ctx->imageInfo.SectorSize * (1ULL << ctx->shift); - ctx->blockHeaderCache.max_items = cache_divisor == 0 ? 0 : MAX_CACHE_SIZE / cache_divisor; - ctx->blockCache.cache = NULL; - ctx->blockCache.max_items = ctx->blockHeaderCache.max_items; + ctx->block_header_cache.cache = NULL; + const uint64_t cache_divisor = (uint64_t)ctx->image_info.SectorSize * (1ULL << ctx->shift); + ctx->block_header_cache.max_items = cache_divisor == 0 ? 0 : MAX_CACHE_SIZE / cache_divisor; + ctx->block_cache.cache = NULL; + ctx->block_cache.max_items = ctx->block_header_cache.max_items; // TODO: Cache tracks and sessions? // Initialize ECC for Compact Disc TRACE("Initializing Compact Disc ECC"); - ctx->eccCdContext = (CdEccContext *)aaruf_ecc_cd_init(); + ctx->ecc_cd_context = (CdEccContext *)aaruf_ecc_cd_init(); - ctx->magic = AARU_MAGIC; - ctx->libraryMajorVersion = LIBAARUFORMAT_MAJOR_VERSION; - ctx->libraryMinorVersion = LIBAARUFORMAT_MINOR_VERSION; + ctx->magic = AARU_MAGIC; + ctx->library_major_version = LIBAARUFORMAT_MAJOR_VERSION; + ctx->library_minor_version = LIBAARUFORMAT_MINOR_VERSION; if(!is_tape) { // Initialize DDT2 TRACE("Initializing DDT2"); - ctx->inMemoryDdt = true; - ctx->userDataDdtHeader.identifier = DeDuplicationTable2; - ctx->userDataDdtHeader.type = UserData; - ctx->userDataDdtHeader.compression = None; - ctx->userDataDdtHeader.tableLevel = 0; - ctx->userDataDdtHeader.previousLevelOffset = 0; - ctx->userDataDdtHeader.negative = negative_sectors; - ctx->userDataDdtHeader.blocks = user_sectors + overflow_sectors + negative_sectors; - ctx->userDataDdtHeader.overflow = overflow_sectors; - ctx->userDataDdtHeader.start = 0; - ctx->userDataDdtHeader.blockAlignmentShift = parsed_options.block_alignment; - ctx->userDataDdtHeader.dataShift = parsed_options.data_shift; - ctx->userDataDdtHeader.sizeType = BigDdtSizeType; + ctx->in_memory_ddt = true; + ctx->user_data_ddt_header.identifier = DeDuplicationTable2; + ctx->user_data_ddt_header.type = UserData; + ctx->user_data_ddt_header.compression = None; + ctx->user_data_ddt_header.tableLevel = 0; + ctx->user_data_ddt_header.previousLevelOffset = 0; + ctx->user_data_ddt_header.negative = negative_sectors; + ctx->user_data_ddt_header.blocks = user_sectors + overflow_sectors + negative_sectors; + ctx->user_data_ddt_header.overflow = overflow_sectors; + ctx->user_data_ddt_header.start = 0; + ctx->user_data_ddt_header.blockAlignmentShift = parsed_options.block_alignment; + ctx->user_data_ddt_header.dataShift = parsed_options.data_shift; + ctx->user_data_ddt_header.sizeType = BigDdtSizeType; if(parsed_options.table_shift == -1) { const uint64_t total_sectors = user_sectors + overflow_sectors + negative_sectors; if(total_sectors < 0x8388608ULL) - ctx->userDataDdtHeader.tableShift = 0; + ctx->user_data_ddt_header.tableShift = 0; else - ctx->userDataDdtHeader.tableShift = 22; + ctx->user_data_ddt_header.tableShift = 22; } else - ctx->userDataDdtHeader.tableShift = + ctx->user_data_ddt_header.tableShift = parsed_options.table_shift > 0 ? (uint8_t)parsed_options.table_shift : 0; - ctx->userDataDdtHeader.levels = ctx->userDataDdtHeader.tableShift > 0 ? 2 : 1; + ctx->user_data_ddt_header.levels = ctx->user_data_ddt_header.tableShift > 0 ? 2 : 1; - uint8_t effective_table_shift = ctx->userDataDdtHeader.tableShift; + uint8_t effective_table_shift = ctx->user_data_ddt_header.tableShift; if(effective_table_shift >= 63) { TRACE("Clamping table shift from %u to 62 to avoid overflow", effective_table_shift); - effective_table_shift = 62; - ctx->userDataDdtHeader.tableShift = effective_table_shift; + effective_table_shift = 62; + ctx->user_data_ddt_header.tableShift = effective_table_shift; } - const uint64_t sectors_per_entry = 1ULL << effective_table_shift; - ctx->userDataDdtHeader.entries = ctx->userDataDdtHeader.blocks / sectors_per_entry; - if(ctx->userDataDdtHeader.blocks % sectors_per_entry != 0 || ctx->userDataDdtHeader.entries == 0) - ctx->userDataDdtHeader.entries++; + const uint64_t sectors_per_entry = 1ULL << effective_table_shift; + ctx->user_data_ddt_header.entries = ctx->user_data_ddt_header.blocks / sectors_per_entry; + if(ctx->user_data_ddt_header.blocks % sectors_per_entry != 0 || ctx->user_data_ddt_header.entries == 0) + ctx->user_data_ddt_header.entries++; TRACE("Initializing primary/single DDT"); - if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) + if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType) { - ctx->userDataDdtBig = - (uint32_t *)calloc(ctx->userDataDdtHeader.entries, sizeof(uint32_t)); // All entries to zero - if(ctx->userDataDdtBig == NULL) + ctx->user_data_ddt2 = + (uint32_t *)calloc(ctx->user_data_ddt_header.entries, sizeof(uint32_t)); // All entries to zero + if(ctx->user_data_ddt2 == NULL) { FATAL("Not enough memory to allocate primary DDT (big)"); errno = AARUF_ERROR_NOT_ENOUGH_MEMORY; @@ -516,42 +516,42 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 } // Set the primary DDT offset (just after the header, block aligned) - ctx->primaryDdtOffset = sizeof(AaruHeaderV2); // Start just after the header - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; - ctx->primaryDdtOffset = ctx->primaryDdtOffset + alignment_mask & ~alignment_mask; + ctx->primary_ddt_offset = sizeof(AaruHeaderV2); // Start just after the header + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; + ctx->primary_ddt_offset = ctx->primary_ddt_offset + alignment_mask & ~alignment_mask; - TRACE("Primary DDT will be placed at offset %" PRIu64, ctx->primaryDdtOffset); + TRACE("Primary DDT will be placed at offset %" PRIu64, ctx->primary_ddt_offset); // Calculate size of primary DDT table - const uint64_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t); + const uint64_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t); // Calculate where data blocks can start (after primary DDT + header) - if(ctx->userDataDdtHeader.tableShift > 0) + if(ctx->user_data_ddt_header.tableShift > 0) { - const uint64_t data_start_position = ctx->primaryDdtOffset + sizeof(DdtHeader2) + primary_table_size; - ctx->nextBlockPosition = data_start_position + alignment_mask & ~alignment_mask; + const uint64_t data_start_position = ctx->primary_ddt_offset + sizeof(DdtHeader2) + primary_table_size; + ctx->next_block_position = data_start_position + alignment_mask & ~alignment_mask; } else - ctx->nextBlockPosition = ctx->primaryDdtOffset; // Single-level DDT can start anywhere + ctx->next_block_position = ctx->primary_ddt_offset; // Single-level DDT can start anywhere } else { // Fill needed values - ctx->userDataDdtHeader.blockAlignmentShift = parsed_options.block_alignment; - ctx->userDataDdtHeader.dataShift = parsed_options.data_shift; + ctx->user_data_ddt_header.blockAlignmentShift = parsed_options.block_alignment; + ctx->user_data_ddt_header.dataShift = parsed_options.data_shift; // Calculate aligned next block position const uint64_t alignment_mask = (1ULL << parsed_options.block_alignment) - 1; - ctx->nextBlockPosition = sizeof(AaruHeaderV2); // Start just after the header - ctx->nextBlockPosition = ctx->nextBlockPosition + alignment_mask & ~alignment_mask; + ctx->next_block_position = sizeof(AaruHeaderV2); // Start just after the header + ctx->next_block_position = ctx->next_block_position + alignment_mask & ~alignment_mask; ctx->is_tape = 1; - ctx->tapeDdt = NULL; + ctx->tape_ddt = NULL; } - TRACE("Data blocks will start at position %" PRIu64, ctx->nextBlockPosition); + TRACE("Data blocks will start at position %" PRIu64, ctx->next_block_position); // Position file pointer at the data start position - if(fseek(ctx->imageStream, ctx->nextBlockPosition, SEEK_SET) != 0) + if(fseek(ctx->imageStream, ctx->next_block_position, SEEK_SET) != 0) { FATAL("Could not seek to data start position"); errno = AARUF_ERROR_CANNOT_CREATE_FILE; @@ -563,9 +563,9 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 // Initialize index entries array TRACE("Initializing index entries array"); const UT_icd index_entry_icd = {sizeof(IndexEntry), NULL, NULL, NULL}; - utarray_new(ctx->indexEntries, &index_entry_icd); + utarray_new(ctx->index_entries, &index_entry_icd); - if(ctx->indexEntries == NULL) + if(ctx->index_entries == NULL) { FATAL("Not enough memory to create index entries array"); errno = AARUF_ERROR_NOT_ENOUGH_MEMORY; @@ -579,7 +579,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 ctx->lzma_dict_size = parsed_options.dictionary; ctx->deduplicate = parsed_options.deduplicate; if(ctx->deduplicate) - ctx->sectorHashMap = create_map(ctx->userDataDdtHeader.blocks * 25 / 100); // 25% of total sectors + ctx->sector_hash_map = create_map(ctx->user_data_ddt_header.blocks * 25 / 100); // 25% of total sectors ctx->rewinded = false; ctx->last_written_block = 0; @@ -615,7 +615,7 @@ void *aaruf_create(const char *filepath, const uint32_t media_type, const uint32 } // Is writing - ctx->isWriting = true; + ctx->is_writing = true; TRACE("Exiting aaruf_create() = %p", ctx); // Return context diff --git a/src/ddt/ddt_v1.c b/src/ddt/ddt_v1.c index 33bb58c..9d6de1a 100644 --- a/src/ddt/ddt_v1.c +++ b/src/ddt/ddt_v1.c @@ -82,7 +82,7 @@ * @warning The function modifies context state including sector count, shift value, and DDT version. * Ensure proper context cleanup when the function completes. */ -int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt) +int32_t process_ddt_v1(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt) { TRACE("Entering process_ddt_v1(%p, %p, %d)", ctx, entry, *found_user_data_ddt); @@ -129,13 +129,13 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us *found_user_data_ddt = true; - ctx->imageInfo.ImageSize += ddt_header.cmpLength; + ctx->image_info.ImageSize += ddt_header.cmpLength; if(entry->dataType == UserData) { - ctx->imageInfo.Sectors = ddt_header.entries; - ctx->shift = ddt_header.shift; - ctx->ddtVersion = 1; + ctx->image_info.Sectors = ddt_header.entries; + ctx->shift = ddt_header.shift; + ctx->ddt_version = 1; // Check for DDT compression switch(ddt_header.compression) @@ -157,8 +157,8 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us break; } - ctx->userDataDdt = (uint64_t *)malloc(ddt_header.length); - if(ctx->userDataDdt == NULL) + ctx->user_data_ddt = (uint64_t *)malloc(ddt_header.length); + if(ctx->user_data_ddt == NULL) { TRACE("Cannot allocate memory for DDT, continuing..."); free(cmp_data); @@ -170,8 +170,8 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us { TRACE("Could not read LZMA properties, continuing..."); free(cmp_data); - free(ctx->userDataDdt); - ctx->userDataDdt = NULL; + free(ctx->user_data_ddt); + ctx->user_data_ddt = NULL; break; } @@ -180,22 +180,22 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us { TRACE("Could not read compressed block, continuing..."); free(cmp_data); - free(ctx->userDataDdt); - ctx->userDataDdt = NULL; + free(ctx->user_data_ddt); + ctx->user_data_ddt = NULL; break; } read_bytes = ddt_header.length; TRACE("Decompressing block of size %zu bytes", ddt_header.length); - error_no = aaruf_lzma_decode_buffer((uint8_t *)ctx->userDataDdt, &read_bytes, cmp_data, &lzma_size, + error_no = aaruf_lzma_decode_buffer((uint8_t *)ctx->user_data_ddt, &read_bytes, cmp_data, &lzma_size, lzma_properties, LZMA_PROPERTIES_LENGTH); if(error_no != 0) { FATAL("Got error %d from LZMA, stopping...", error_no); free(cmp_data); - free(ctx->userDataDdt); - ctx->userDataDdt = NULL; + free(ctx->user_data_ddt); + ctx->user_data_ddt = NULL; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; } @@ -203,15 +203,15 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us { FATAL("Error decompressing block, should be {0} bytes but got {1} bytes., stopping..."); free(cmp_data); - free(ctx->userDataDdt); - ctx->userDataDdt = NULL; + free(ctx->user_data_ddt); + ctx->user_data_ddt = NULL; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; } free(cmp_data); cmp_data = NULL; - ctx->inMemoryDdt = true; + ctx->in_memory_ddt = true; *found_user_data_ddt = true; break; @@ -219,18 +219,18 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us case None: #ifdef __linux__ TRACE("Memory mapping deduplication table at position %" PRIu64, entry->offset + sizeof(ddt_header)); - ctx->mappedMemoryDdtSize = sizeof(uint64_t) * ddt_header.entries; - ctx->userDataDdt = mmap(NULL, ctx->mappedMemoryDdtSize, PROT_READ, MAP_SHARED, fileno(ctx->imageStream), - entry->offset + sizeof(ddt_header)); + ctx->mapped_memory_ddt_size = sizeof(uint64_t) * ddt_header.entries; + ctx->user_data_ddt = mmap(NULL, ctx->mapped_memory_ddt_size, PROT_READ, MAP_SHARED, + fileno(ctx->imageStream), entry->offset + sizeof(ddt_header)); - if(ctx->userDataDdt == MAP_FAILED) + if(ctx->user_data_ddt == MAP_FAILED) { *found_user_data_ddt = false; FATAL("Could not read map deduplication table."); break; } - ctx->inMemoryDdt = false; + ctx->in_memory_ddt = false; break; #else // TODO: Implement TRACE("Uncompressed DDT not yet implemented..."); @@ -315,9 +315,9 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us cmp_data = NULL; if(entry->dataType == CdSectorPrefixCorrected) - ctx->sectorPrefixDdt = cd_ddt; + ctx->sector_prefix_ddt = cd_ddt; else if(entry->dataType == CdSectorSuffixCorrected) - ctx->sectorSuffixDdt = cd_ddt; + ctx->sector_suffix_ddt = cd_ddt; else free(cd_ddt); @@ -343,9 +343,9 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us } if(entry->dataType == CdSectorPrefixCorrected) - ctx->sectorPrefixDdt = cd_ddt; + ctx->sector_prefix_ddt = cd_ddt; else if(entry->dataType == CdSectorSuffixCorrected) - ctx->sectorSuffixDdt = cd_ddt; + ctx->sector_suffix_ddt = cd_ddt; else free(cd_ddt); @@ -402,7 +402,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *found_us * @warning No bounds checking is performed on sector_address. Accessing beyond the DDT table * boundaries will result in undefined behavior. */ -int32_t decode_ddt_entry_v1(aaruformatContext *ctx, const uint64_t sector_address, uint64_t *offset, +int32_t decode_ddt_entry_v1(aaruformat_context *ctx, const uint64_t sector_address, uint64_t *offset, uint64_t *block_offset, uint8_t *sector_status) { TRACE("Entering decode_ddt_entry_v1(%p, %" PRIu64 ", %p, %p, %p)", ctx, sector_address, offset, block_offset, @@ -416,7 +416,7 @@ int32_t decode_ddt_entry_v1(aaruformatContext *ctx, const uint64_t sector_addres return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->userDataDdt == NULL) + if(ctx->user_data_ddt == NULL) { FATAL("User data DDT not loaded."); TRACE("Exiting decode_ddt_entry_v1() = AARUF_ERROR_NOT_AARUFORMAT"); @@ -430,7 +430,7 @@ int32_t decode_ddt_entry_v1(aaruformatContext *ctx, const uint64_t sector_addres return AARUF_ERROR_INCORRECT_DATA_SIZE; } - const uint64_t ddt_entry = ctx->userDataDdt[sector_address]; + const uint64_t ddt_entry = ctx->user_data_ddt[sector_address]; const uint64_t offset_mask64 = (UINT64_C(1) << ctx->shift) - UINT64_C(1); *offset = ddt_entry & offset_mask64; *block_offset = ddt_entry >> ctx->shift; diff --git a/src/ddt/ddt_v2.c b/src/ddt/ddt_v2.c index a1d0500..8f5a7db 100644 --- a/src/ddt/ddt_v2.c +++ b/src/ddt/ddt_v2.c @@ -94,7 +94,7 @@ * @warning Memory allocated for DDT data becomes part of the context and should not be freed separately. * The context cleanup functions will handle DDT memory deallocation. */ -int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_user_data_ddt) +int32_t process_ddt_v2(aaruformat_context *ctx, IndexEntry *entry, bool *found_user_data_ddt) { TRACE("Entering process_ddt_v2(%p, %p, %d)", ctx, entry, *found_user_data_ddt); @@ -142,17 +142,17 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us *found_user_data_ddt = false; - ctx->imageInfo.ImageSize += ddt_header.cmpLength; + ctx->image_info.ImageSize += ddt_header.cmpLength; if(entry->dataType == UserData) { // User area sectors is blocks stored in DDT minus the negative and overflow displacement blocks - ctx->imageInfo.Sectors = ddt_header.blocks - ddt_header.negative - ddt_header.overflow; + ctx->image_info.Sectors = ddt_header.blocks - ddt_header.negative - ddt_header.overflow; // We need the header later for the shift calculations - ctx->userDataDdtHeader = ddt_header; - ctx->ddtVersion = 2; + ctx->user_data_ddt_header = ddt_header; + ctx->ddt_version = 2; // Store the primary DDT table's file offset for secondary table references - ctx->primaryDdtOffset = entry->offset; + ctx->primary_ddt_offset = entry->offset; // Check for DDT compression switch(ddt_header.compression) @@ -247,9 +247,9 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us return AARUF_ERROR_INVALID_BLOCK_CRC; } - ctx->userDataDdtBig = (uint32_t *)buffer; + ctx->user_data_ddt2 = (uint32_t *)buffer; - ctx->inMemoryDdt = true; + ctx->in_memory_ddt = true; *found_user_data_ddt = true; break; @@ -293,9 +293,9 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us return AARUF_ERROR_INVALID_BLOCK_CRC; } - ctx->userDataDdtBig = (uint32_t *)buffer; + ctx->user_data_ddt2 = (uint32_t *)buffer; - ctx->inMemoryDdt = true; + ctx->in_memory_ddt = true; *found_user_data_ddt = true; break; @@ -399,8 +399,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us return AARUF_ERROR_INVALID_BLOCK_CRC; } - if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixDdt = (uint32_t *)buffer; } - else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sectorSuffixDdt = (uint32_t *)buffer; } + if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_ddt = (uint32_t *)buffer; } + else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sector_suffix_ddt = (uint32_t *)buffer; } else free(buffer); @@ -445,8 +445,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us return AARUF_ERROR_INVALID_BLOCK_CRC; } - if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixDdt = (uint32_t *)buffer; } - else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sectorSuffixDdt = (uint32_t *)buffer; } + if(entry->dataType == CdSectorPrefixCorrected) { ctx->sector_prefix_ddt = (uint32_t *)buffer; } + else if(entry->dataType == CdSectorSuffixCorrected) { ctx->sector_suffix_ddt = (uint32_t *)buffer; } else free(buffer); @@ -505,7 +505,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *found_us * @warning All output parameters must be valid pointers. No bounds checking is performed * on the sector_address parameter at this level. */ -int32_t decode_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, bool negative, uint64_t *offset, +int32_t decode_ddt_entry_v2(aaruformat_context *ctx, const uint64_t sector_address, bool negative, uint64_t *offset, uint64_t *block_offset, uint8_t *sector_status) { TRACE("Entering decode_ddt_entry_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative, *offset, @@ -519,7 +519,7 @@ int32_t decode_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_addres return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->userDataDdtHeader.tableShift > 0) + if(ctx->user_data_ddt_header.tableShift > 0) return decode_ddt_multi_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status); return decode_ddt_single_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status); @@ -585,7 +585,7 @@ int32_t decode_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_addres * @warning This function should only be called when tableShift is 0. Calling it with * tableShift > 0 will result in AARUF_ERROR_CANNOT_READ_BLOCK. */ -int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset, +int32_t decode_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset, uint64_t *block_offset, uint8_t *sector_status) { TRACE("Entering decode_ddt_single_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative, @@ -603,7 +603,7 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre } // Should not really be here - if(ctx->userDataDdtHeader.tableShift != 0) + if(ctx->user_data_ddt_header.tableShift != 0) { FATAL("DDT table shift is not zero, but we are in single-level DDT decoding."); TRACE("Exiting decode_ddt_single_level_v2() = AARUF_ERROR_CANNOT_READ_BLOCK"); @@ -612,12 +612,12 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre // Calculate positive or negative sector if(negative) - sector_address -= ctx->userDataDdtHeader.negative; + sector_address -= ctx->user_data_ddt_header.negative; else - sector_address += ctx->userDataDdtHeader.negative; + sector_address += ctx->user_data_ddt_header.negative; - if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) - ddt_entry = ctx->userDataDdtBig[sector_address]; + if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType) + ddt_entry = ctx->user_data_ddt2[sector_address]; else { FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType); @@ -638,9 +638,10 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre *sector_status = ddt_entry >> 28; ddt_entry &= 0x0fffffff; - const uint64_t offset_mask = (uint64_t)((1 << ctx->userDataDdtHeader.dataShift) - 1); + const uint64_t offset_mask = (uint64_t)((1 << ctx->user_data_ddt_header.dataShift) - 1); *offset = ddt_entry & offset_mask; - *block_offset = (ddt_entry >> ctx->userDataDdtHeader.dataShift) * (1 << ctx->userDataDdtHeader.blockAlignmentShift); + *block_offset = + (ddt_entry >> ctx->user_data_ddt_header.dataShift) * (1 << ctx->user_data_ddt_header.blockAlignmentShift); TRACE("Exiting decode_ddt_single_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d) = AARUF_STATUS_OK", ctx, sector_address, negative, *offset, *block_offset, *sector_status); @@ -735,7 +736,7 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_addre * @warning No bounds checking is performed on sector_address or calculated DDT positions. * Accessing beyond table boundaries will result in undefined behavior. */ -int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t *offset, +int32_t decode_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t *offset, uint64_t *block_offset, uint8_t *sector_status) { TRACE("Entering decode_ddt_multi_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative, @@ -762,7 +763,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres } // Should not really be here - if(ctx->userDataDdtHeader.tableShift == 0) + if(ctx->user_data_ddt_header.tableShift == 0) { FATAL("DDT table shift is zero, but we are in multi-level DDT decoding."); TRACE("Exiting decode_ddt_multi_level_v2() = AARUF_ERROR_CANNOT_READ_BLOCK"); @@ -771,15 +772,15 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres // Calculate positive or negative sector if(negative) - sector_address -= ctx->userDataDdtHeader.negative; + sector_address -= ctx->user_data_ddt_header.negative; else - sector_address += ctx->userDataDdtHeader.negative; + sector_address += ctx->user_data_ddt_header.negative; - items_per_ddt_entry = 1 << ctx->userDataDdtHeader.tableShift; + items_per_ddt_entry = 1 << ctx->user_data_ddt_header.tableShift; ddt_position = sector_address / items_per_ddt_entry; - if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) - secondary_ddt_offset = ctx->userDataDdtBig[ddt_position]; + if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType) + secondary_ddt_offset = ctx->user_data_ddt2[ddt_position]; else { FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType); @@ -788,10 +789,10 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres } // Position in file of the child DDT table - secondary_ddt_offset *= 1 << ctx->userDataDdtHeader.blockAlignmentShift; + secondary_ddt_offset *= 1 << ctx->user_data_ddt_header.blockAlignmentShift; // Is the one we have cached the same as the one we need to read? - if(ctx->cachedDdtOffset != secondary_ddt_offset) + if(ctx->cached_ddt_offset != secondary_ddt_offset) { int32_t error_no = 0; fseek(ctx->imageStream, secondary_ddt_offset, SEEK_SET); @@ -907,9 +908,9 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres return AARUF_ERROR_INVALID_BLOCK_CRC; } - ctx->cachedSecondaryDdtBig = (uint32_t *)buffer; + ctx->cached_secondary_ddt2 = (uint32_t *)buffer; - ctx->cachedDdtOffset = secondary_ddt_offset; + ctx->cached_ddt_offset = secondary_ddt_offset; break; case None: @@ -953,9 +954,9 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres return AARUF_ERROR_INVALID_BLOCK_CRC; } - ctx->cachedSecondaryDdtBig = (uint32_t *)buffer; + ctx->cached_secondary_ddt2 = (uint32_t *)buffer; - ctx->cachedDdtOffset = secondary_ddt_offset; + ctx->cached_ddt_offset = secondary_ddt_offset; break; default: @@ -965,7 +966,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres } } - ddt_entry = ctx->cachedSecondaryDdtBig[sector_address % items_per_ddt_entry]; + ddt_entry = ctx->cached_secondary_ddt2[sector_address % items_per_ddt_entry]; if(ddt_entry == 0) { @@ -981,9 +982,10 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres *sector_status = ddt_entry >> 28; ddt_entry &= 0x0fffffff; - const uint64_t offset_mask = (uint64_t)((1 << ctx->userDataDdtHeader.dataShift) - 1); + const uint64_t offset_mask = (uint64_t)((1 << ctx->user_data_ddt_header.dataShift) - 1); *offset = ddt_entry & offset_mask; - *block_offset = (ddt_entry >> ctx->userDataDdtHeader.dataShift) * (1 << ctx->userDataDdtHeader.blockAlignmentShift); + *block_offset = + (ddt_entry >> ctx->user_data_ddt_header.dataShift) * (1 << ctx->user_data_ddt_header.blockAlignmentShift); TRACE("Exiting decode_ddt_multi_level_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d) = AARUF_STATUS_OK", ctx, sector_address, negative, *offset, *block_offset, *sector_status); @@ -1006,7 +1008,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_addres * @return Returns one of the following status codes: * @retval true if the entry was set successfully, false otherwise. */ -bool set_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, bool negative, const uint64_t offset, +bool set_ddt_entry_v2(aaruformat_context *ctx, const uint64_t sector_address, bool negative, const uint64_t offset, const uint64_t block_offset, const uint8_t sector_status, uint64_t *ddt_entry) { TRACE("Entering set_ddt_entry_v2(%p, %" PRIu64 ", %d, %llu, %llu, %d)", ctx, sector_address, negative, offset, @@ -1019,7 +1021,7 @@ bool set_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, boo return false; } - if(ctx->userDataDdtHeader.tableShift > 0) + if(ctx->user_data_ddt_header.tableShift > 0) return set_ddt_multi_level_v2(ctx, sector_address, false, offset, block_offset, sector_status, ddt_entry); return set_ddt_single_level_v2(ctx, sector_address, false, offset, block_offset, sector_status, ddt_entry); @@ -1041,7 +1043,7 @@ bool set_ddt_entry_v2(aaruformatContext *ctx, const uint64_t sector_address, boo * @return Returns one of the following status codes: * @retval true if the entry was set successfully, false otherwise. */ -bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, const bool negative, +bool set_ddt_single_level_v2(aaruformat_context *ctx, uint64_t sector_address, const bool negative, const uint64_t offset, const uint64_t block_offset, const uint8_t sector_status, uint64_t *ddt_entry) { @@ -1057,7 +1059,7 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co } // Should not really be here - if(ctx->userDataDdtHeader.tableShift != 0) + if(ctx->user_data_ddt_header.tableShift != 0) { FATAL("DDT table shift is not zero, but we are in single-level DDT setting."); TRACE("Exiting set_ddt_single_level_v2() = false"); @@ -1066,15 +1068,15 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co // Calculate positive or negative sector if(negative) - sector_address -= ctx->userDataDdtHeader.negative; + sector_address -= ctx->user_data_ddt_header.negative; else - sector_address += ctx->userDataDdtHeader.negative; + sector_address += ctx->user_data_ddt_header.negative; if(*ddt_entry == 0) { - const uint64_t block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; - *ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index - << ctx->userDataDdtHeader.dataShift; + const uint64_t block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift; + *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 | + block_index << ctx->user_data_ddt_header.dataShift; // Overflow detection for DDT entry if(*ddt_entry > 0xFFFFFFF) @@ -1088,7 +1090,7 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co } TRACE("Setting big single-level DDT entry %d to %u", sector_address, (uint32_t)*ddt_entry); - ctx->userDataDdtBig[sector_address] = (uint32_t)*ddt_entry; + ctx->user_data_ddt2[sector_address] = (uint32_t)*ddt_entry; TRACE("Exiting set_ddt_single_level_v2() = true"); return true; @@ -1110,7 +1112,7 @@ bool set_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sector_address, co * @return Returns one of the following status codes: * @retval true if the entry was set successfully, false otherwise. */ -bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, bool negative, uint64_t offset, +bool set_ddt_multi_level_v2(aaruformat_context *ctx, uint64_t sector_address, bool negative, uint64_t offset, uint64_t block_offset, uint8_t sector_status, uint64_t *ddt_entry) { TRACE("Entering set_ddt_multi_level_v2(%p, %" PRIu64 ", %d, %" PRIu64 ", %" PRIu64 ", %d)", ctx, sector_address, @@ -1137,7 +1139,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } // Should not really be here - if(ctx->userDataDdtHeader.tableShift == 0) + if(ctx->user_data_ddt_header.tableShift == 0) { FATAL("DDT table shift is zero, but we are in multi-level DDT setting."); TRACE("Exiting set_ddt_multi_level_v2() = false"); @@ -1146,16 +1148,16 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo // Calculate positive or negative sector if(negative) - sector_address -= ctx->userDataDdtHeader.negative; + sector_address -= ctx->user_data_ddt_header.negative; else - sector_address += ctx->userDataDdtHeader.negative; + sector_address += ctx->user_data_ddt_header.negative; // Step 1: Calculate the corresponding secondary level table - items_per_ddt_entry = 1 << ctx->userDataDdtHeader.tableShift; + items_per_ddt_entry = 1 << ctx->user_data_ddt_header.tableShift; ddt_position = sector_address / items_per_ddt_entry; - if(ctx->userDataDdtHeader.sizeType == BigDdtSizeType) - secondary_ddt_offset = ctx->userDataDdtBig[ddt_position]; + if(ctx->user_data_ddt_header.sizeType == BigDdtSizeType) + secondary_ddt_offset = ctx->user_data_ddt2[ddt_position]; else { FATAL("Unknown DDT size type %d.", ctx->userDataDdtHeader.sizeType); @@ -1164,17 +1166,17 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } // Position in file of the child DDT table - secondary_ddt_offset *= 1 << ctx->userDataDdtHeader.blockAlignmentShift; + secondary_ddt_offset *= 1 << ctx->user_data_ddt_header.blockAlignmentShift; // Step 2: Check if it corresponds to the currently in-memory cached secondary level table - if(ctx->cachedDdtOffset == secondary_ddt_offset && secondary_ddt_offset != 0) + if(ctx->cached_ddt_offset == secondary_ddt_offset && secondary_ddt_offset != 0) { // Update the corresponding DDT entry directly in the cached table if(*ddt_entry == 0) { - block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; - *ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | - block_index << ctx->userDataDdtHeader.dataShift; + block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift; + *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 | + block_index << ctx->user_data_ddt_header.dataShift; // Overflow detection for DDT entry if(*ddt_entry > 0xFFFFFFF) @@ -1188,7 +1190,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } TRACE("Setting small secondary DDT entry %d to %u", sector_address % items_per_ddt_entry, (uint16_t)*ddt_entry); - ctx->cachedSecondaryDdtBig[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry; + ctx->cached_secondary_ddt2[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry; TRACE("Updated cached secondary DDT entry at position %" PRIu64, sector_address % items_per_ddt_entry); TRACE("Exiting set_ddt_multi_level_v2() = true"); @@ -1197,26 +1199,26 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo // Step 2.5: Handle case where we have a cached secondary DDT that has never been written to disk // but does not contain the requested block - if(ctx->cachedDdtOffset == 0 && (ctx->cachedSecondaryDdtBig != NULL)) + if(ctx->cached_ddt_offset == 0 && (ctx->cached_secondary_ddt2 != NULL)) { // Only write the cached table to disk if the requested block belongs to a different DDT position - if(ddt_position != ctx->cachedDdtPosition) + if(ddt_position != ctx->cached_ddt_position) { TRACE("Current secondary DDT in memory belongs to position %" PRIu64 " but requested block needs position %" PRIu64, - ctx->cachedDdtPosition, ddt_position); + ctx->cached_ddt_position, ddt_position); // Write the cached DDT to disk before proceeding with the new one // Close the current data block first - if(ctx->writingBuffer != NULL) aaruf_close_current_block(ctx); + if(ctx->writing_buffer != NULL) aaruf_close_current_block(ctx); // Get current position and seek to end of file fseek(ctx->imageStream, 0, SEEK_END); end_of_file = ftell(ctx->imageStream); // Align to block boundary - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; end_of_file = end_of_file + alignment_mask & ~alignment_mask; fseek(ctx->imageStream, end_of_file, SEEK_SET); @@ -1225,17 +1227,17 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo ddt_header.identifier = DeDuplicationTable2; ddt_header.type = UserData; ddt_header.compression = ctx->compression_enabled ? Lzma : None; // Use no compression for simplicity - ddt_header.levels = ctx->userDataDdtHeader.levels; - ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1; - ddt_header.previousLevelOffset = ctx->primaryDdtOffset; - ddt_header.negative = ctx->userDataDdtHeader.negative; + ddt_header.levels = ctx->user_data_ddt_header.levels; + ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1; + ddt_header.previousLevelOffset = ctx->primary_ddt_offset; + ddt_header.negative = ctx->user_data_ddt_header.negative; ddt_header.blocks = items_per_ddt_entry; - ddt_header.overflow = ctx->userDataDdtHeader.overflow; - ddt_header.start = ctx->cachedDdtPosition * items_per_ddt_entry; // Use cached position with table shift - ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; - ddt_header.dataShift = ctx->userDataDdtHeader.dataShift; + ddt_header.overflow = ctx->user_data_ddt_header.overflow; + ddt_header.start = ctx->cached_ddt_position * items_per_ddt_entry; // Use cached position with table shift + ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift; + ddt_header.dataShift = ctx->user_data_ddt_header.dataShift; ddt_header.tableShift = 0; // Secondary tables are single level - ddt_header.sizeType = ctx->userDataDdtHeader.sizeType; + ddt_header.sizeType = ctx->user_data_ddt_header.sizeType; ddt_header.entries = items_per_ddt_entry; // Calculate data size @@ -1251,7 +1253,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo return false; } - aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cachedSecondaryDdtBig, (uint32_t)ddt_header.length); + aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cached_secondary_ddt2, (uint32_t)ddt_header.length); aaruf_crc64_final(crc64_context, &crc64); ddt_header.crc64 = crc64; @@ -1262,7 +1264,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo if(ddt_header.compression == None) { - cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig; + cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2; ddt_header.cmpCrc64 = ddt_header.crc64; } else @@ -1276,7 +1278,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo size_t dst_size = (size_t)ddt_header.length * 2 * 2; size_t props_size = LZMA_PROPERTIES_LENGTH; - aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cachedSecondaryDdtBig, + aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cached_secondary_ddt2, ddt_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); @@ -1287,7 +1289,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo ddt_header.compression = None; free(cmp_buffer); - cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig; + cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2; } } @@ -1328,21 +1330,21 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo new_ddt_entry.dataType = UserData; new_ddt_entry.offset = end_of_file; - utarray_push_back(ctx->indexEntries, &new_ddt_entry); + utarray_push_back(ctx->index_entries, &new_ddt_entry); TRACE("Added new DDT index entry for never-written table at offset %" PRIu64, end_of_file); // Update the primary level table entry to point to the new location of the secondary table - uint64_t new_secondary_table_block_offset = end_of_file >> ctx->userDataDdtHeader.blockAlignmentShift; + uint64_t new_secondary_table_block_offset = end_of_file >> ctx->user_data_ddt_header.blockAlignmentShift; - ctx->userDataDdtBig[ctx->cachedDdtPosition] = (uint32_t)new_secondary_table_block_offset; + ctx->user_data_ddt2[ctx->cached_ddt_position] = (uint32_t)new_secondary_table_block_offset; // Write the updated primary table back to its original position in the file long saved_pos = ftell(ctx->imageStream); - fseek(ctx->imageStream, ctx->primaryDdtOffset + sizeof(DdtHeader2), SEEK_SET); + fseek(ctx->imageStream, ctx->primary_ddt_offset + sizeof(DdtHeader2), SEEK_SET); - size_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t); + size_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t); - written_bytes = fwrite(ctx->userDataDdtBig, primary_table_size, 1, ctx->imageStream); + written_bytes = fwrite(ctx->user_data_ddt2, primary_table_size, 1, ctx->imageStream); if(written_bytes != 1) { @@ -1352,20 +1354,20 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } // Update nextBlockPosition to ensure future blocks don't overwrite the DDT - uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length; - ctx->nextBlockPosition = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask; - block_offset = ctx->nextBlockPosition; - offset = 0; - TRACE("Updated nextBlockPosition after never-written DDT write to %" PRIu64, ctx->nextBlockPosition); + uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length; + ctx->next_block_position = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask; + block_offset = ctx->next_block_position; + offset = 0; + TRACE("Updated nextBlockPosition after never-written DDT write to %" PRIu64, ctx->next_block_position); // Free the cached table - free(ctx->cachedSecondaryDdtBig); - ctx->cachedSecondaryDdtBig = NULL; + free(ctx->cached_secondary_ddt2); + ctx->cached_secondary_ddt2 = NULL; // Reset cached values since we've written and freed the table - ctx->cachedDdtOffset = 0; - ctx->cachedDdtPosition = 0; + ctx->cached_ddt_offset = 0; + ctx->cached_ddt_position = 0; // Restore file position fseek(ctx->imageStream, saved_pos, SEEK_SET); @@ -1381,11 +1383,11 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } // Step 3: Write the currently in-memory cached secondary level table to the end of the file - if(ctx->cachedDdtOffset != 0) + if(ctx->cached_ddt_offset != 0) { long current_pos = 0; // Close the current data block first - if(ctx->writingBuffer != NULL) aaruf_close_current_block(ctx); + if(ctx->writing_buffer != NULL) aaruf_close_current_block(ctx); // Get current position and seek to end of file current_pos = ftell(ctx->imageStream); @@ -1393,7 +1395,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo end_of_file = ftell(ctx->imageStream); // Align to block boundary - uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; + uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; end_of_file = end_of_file + alignment_mask & ~alignment_mask; fseek(ctx->imageStream, end_of_file, SEEK_SET); @@ -1402,17 +1404,17 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo ddt_header.identifier = DeDuplicationTable2; ddt_header.type = UserData; ddt_header.compression = ctx->compression_enabled ? Lzma : None; - ddt_header.levels = ctx->userDataDdtHeader.levels; - ddt_header.tableLevel = ctx->userDataDdtHeader.tableLevel + 1; - ddt_header.previousLevelOffset = ctx->primaryDdtOffset; // Set to primary DDT table location - ddt_header.negative = ctx->userDataDdtHeader.negative; + ddt_header.levels = ctx->user_data_ddt_header.levels; + ddt_header.tableLevel = ctx->user_data_ddt_header.tableLevel + 1; + ddt_header.previousLevelOffset = ctx->primary_ddt_offset; // Set to primary DDT table location + ddt_header.negative = ctx->user_data_ddt_header.negative; ddt_header.blocks = items_per_ddt_entry; - ddt_header.overflow = ctx->userDataDdtHeader.overflow; + ddt_header.overflow = ctx->user_data_ddt_header.overflow; ddt_header.start = ddt_position * items_per_ddt_entry; // First block this DDT table references - ddt_header.blockAlignmentShift = ctx->userDataDdtHeader.blockAlignmentShift; - ddt_header.dataShift = ctx->userDataDdtHeader.dataShift; + ddt_header.blockAlignmentShift = ctx->user_data_ddt_header.blockAlignmentShift; + ddt_header.dataShift = ctx->user_data_ddt_header.dataShift; ddt_header.tableShift = 0; // Secondary tables are single level - ddt_header.sizeType = ctx->userDataDdtHeader.sizeType; + ddt_header.sizeType = ctx->user_data_ddt_header.sizeType; ddt_header.entries = items_per_ddt_entry; // Calculate data size @@ -1428,7 +1430,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo return false; } - aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cachedSecondaryDdtBig, ddt_header.length); + aaruf_crc64_update(crc64_context, (uint8_t *)ctx->cached_secondary_ddt2, ddt_header.length); aaruf_crc64_final(crc64_context, &crc64); ddt_header.crc64 = crc64; @@ -1439,7 +1441,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo if(ddt_header.compression == None) { - cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig; + cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2; ddt_header.cmpCrc64 = ddt_header.crc64; } else @@ -1453,7 +1455,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo size_t dst_size = (size_t)ddt_header.length * 2 * 2; size_t props_size = LZMA_PROPERTIES_LENGTH; - aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cachedSecondaryDdtBig, ddt_header.length, + aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, (uint8_t *)ctx->cached_secondary_ddt2, ddt_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); ddt_header.cmpLength = (uint32_t)dst_size; @@ -1463,7 +1465,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo ddt_header.compression = None; free(cmp_buffer); - cmp_buffer = (uint8_t *)ctx->cachedSecondaryDdtBig; + cmp_buffer = (uint8_t *)ctx->cached_secondary_ddt2; } } @@ -1504,19 +1506,19 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo TRACE("Updating index for evicted secondary DDT"); // Remove old index entry for the cached DDT - if(ctx->cachedDdtOffset != 0) + if(ctx->cached_ddt_offset != 0) { - TRACE("Removing old index entry for DDT at offset %" PRIu64, ctx->cachedDdtOffset); + TRACE("Removing old index entry for DDT at offset %" PRIu64, ctx->cached_ddt_offset); IndexEntry *entry = NULL; // Find and remove the old index entry - for(unsigned int i = 0; i < utarray_len(ctx->indexEntries); i++) + for(unsigned int i = 0; i < utarray_len(ctx->index_entries); i++) { - entry = (IndexEntry *)utarray_eltptr(ctx->indexEntries, i); - if(entry && entry->offset == ctx->cachedDdtOffset && entry->blockType == DeDuplicationTable2) + entry = (IndexEntry *)utarray_eltptr(ctx->index_entries, i); + if(entry && entry->offset == ctx->cached_ddt_offset && entry->blockType == DeDuplicationTable2) { TRACE("Found old DDT index entry at position %u, removing", i); - utarray_erase(ctx->indexEntries, i, 1); + utarray_erase(ctx->index_entries, i, 1); break; } } @@ -1528,24 +1530,24 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo new_ddt_entry.dataType = UserData; new_ddt_entry.offset = end_of_file; - utarray_push_back(ctx->indexEntries, &new_ddt_entry); + utarray_push_back(ctx->index_entries, &new_ddt_entry); TRACE("Added new DDT index entry at offset %" PRIu64, end_of_file); // Step 4: Update the primary level table entry and flush it back to file - uint64_t new_secondary_table_block_offset = end_of_file >> ctx->userDataDdtHeader.blockAlignmentShift; + uint64_t new_secondary_table_block_offset = end_of_file >> ctx->user_data_ddt_header.blockAlignmentShift; // Update the primary table entry to point to the new location of the secondary table // Use ddtPosition which was calculated from sectorAddress, not cachedDdtOffset - ctx->userDataDdtBig[ddt_position] = (uint32_t)new_secondary_table_block_offset; + ctx->user_data_ddt2[ddt_position] = (uint32_t)new_secondary_table_block_offset; // Write the updated primary table back to its original position in the file long saved_pos = ftell(ctx->imageStream); - fseek(ctx->imageStream, ctx->primaryDdtOffset + sizeof(DdtHeader2), SEEK_SET); + fseek(ctx->imageStream, ctx->primary_ddt_offset + sizeof(DdtHeader2), SEEK_SET); - size_t primary_table_size = ctx->userDataDdtHeader.entries * sizeof(uint32_t); + size_t primary_table_size = ctx->user_data_ddt_header.entries * sizeof(uint32_t); - written_bytes = fwrite(ctx->userDataDdtBig, primary_table_size, 1, ctx->imageStream); + written_bytes = fwrite(ctx->user_data_ddt2, primary_table_size, 1, ctx->imageStream); if(written_bytes != 1) { @@ -1555,25 +1557,25 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } // Update nextBlockPosition to ensure future blocks don't overwrite the DDT - uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length; - ctx->nextBlockPosition = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask; - block_offset = ctx->nextBlockPosition; - offset = 0; - TRACE("Updated nextBlockPosition after DDT write to %" PRIu64, ctx->nextBlockPosition); + uint64_t ddt_total_size = sizeof(DdtHeader2) + ddt_header.length; + ctx->next_block_position = end_of_file + ddt_total_size + alignment_mask & ~alignment_mask; + block_offset = ctx->next_block_position; + offset = 0; + TRACE("Updated nextBlockPosition after DDT write to %" PRIu64, ctx->next_block_position); fseek(ctx->imageStream, saved_pos, SEEK_SET); // Free the cached table - free(ctx->cachedSecondaryDdtBig); - ctx->cachedSecondaryDdtBig = NULL; + free(ctx->cached_secondary_ddt2); + ctx->cached_secondary_ddt2 = NULL; // Restore file position fseek(ctx->imageStream, current_pos, SEEK_SET); } // Step 5: Check if the specified block already has an existing secondary level table - create_new_table = ctx->cachedSecondaryDdtBig == NULL; + create_new_table = ctx->cached_secondary_ddt2 == NULL; if(!create_new_table && secondary_ddt_offset != 0) { @@ -1630,9 +1632,9 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo // Cache the loaded table - ctx->cachedSecondaryDdtBig = (uint32_t *)buffer; + ctx->cached_secondary_ddt2 = (uint32_t *)buffer; - ctx->cachedDdtOffset = secondary_ddt_offset; + ctx->cached_ddt_offset = secondary_ddt_offset; } if(create_new_table) @@ -1648,19 +1650,19 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo return false; } - ctx->cachedSecondaryDdtBig = (uint32_t *)buffer; + ctx->cached_secondary_ddt2 = (uint32_t *)buffer; - ctx->cachedDdtOffset = 0; // Will be set when written to file - ctx->cachedDdtPosition = ddt_position; // Track which primary DDT position this new table belongs to + ctx->cached_ddt_offset = 0; // Will be set when written to file + ctx->cached_ddt_position = ddt_position; // Track which primary DDT position this new table belongs to TRACE("Created new secondary DDT for position %" PRIu64, ddt_position); } // Step 6: Update the corresponding DDT entry if(*ddt_entry == 0) { - block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; - *ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index - << ctx->userDataDdtHeader.dataShift; + block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift; + *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 | + block_index << ctx->user_data_ddt_header.dataShift; // Overflow detection for DDT entry if(*ddt_entry > 0xFFFFFFF) @@ -1674,7 +1676,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo } TRACE("Setting big secondary DDT entry %d to %u", sector_address % items_per_ddt_entry, (uint32_t)*ddt_entry); - ctx->cachedSecondaryDdtBig[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry; + ctx->cached_secondary_ddt2[sector_address % items_per_ddt_entry] = (uint32_t)*ddt_entry; TRACE("Updated secondary DDT entry at position %" PRIu64, sector_address % items_per_ddt_entry); TRACE("Exiting set_ddt_multi_level_v2() = true"); @@ -1797,7 +1799,7 @@ bool set_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sector_address, boo * @see set_ddt_entry_v2() for the main DDT entry point that dispatches to this function * @see get_ddt_tape() for retrieving tape DDT entries from the hash table */ -bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, const uint64_t offset, const uint64_t block_offset, +bool set_ddt_tape(aaruformat_context *ctx, uint64_t sector_address, const uint64_t offset, const uint64_t block_offset, const uint8_t sector_status, uint64_t *ddt_entry) { TRACE("Entering set_ddt_tape(%p, %" PRIu64 ", %llu, %llu, %d)", ctx, sector_address, offset, block_offset, @@ -1821,9 +1823,9 @@ bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, const uint64_ if(*ddt_entry == 0) { - const uint64_t block_index = block_offset >> ctx->userDataDdtHeader.blockAlignmentShift; - *ddt_entry = offset & (1ULL << ctx->userDataDdtHeader.dataShift) - 1 | block_index - << ctx->userDataDdtHeader.dataShift; + const uint64_t block_index = block_offset >> ctx->user_data_ddt_header.blockAlignmentShift; + *ddt_entry = offset & (1ULL << ctx->user_data_ddt_header.dataShift) - 1 | + block_index << ctx->user_data_ddt_header.dataShift; // Overflow detection for DDT entry if(*ddt_entry > 0xFFFFFFF) { @@ -1851,7 +1853,7 @@ bool set_ddt_tape(aaruformatContext *ctx, uint64_t sector_address, const uint64_ new_entry->value = *ddt_entry; // Insert entry into tape DDT - HASH_REPLACE(hh, ctx->tapeDdt, key, sizeof(uint64_t), new_entry, old_entry); + HASH_REPLACE(hh, ctx->tape_ddt, key, sizeof(uint64_t), new_entry, old_entry); if(old_entry) free(old_entry); TRACE("Exiting set_ddt_tape() = true"); diff --git a/src/dump.c b/src/dump.c index 9d91d6e..5724d1e 100644 --- a/src/dump.c +++ b/src/dump.c @@ -190,7 +190,7 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length) TRACE("Entering aaruf_get_dumphw(%p, %p, %zu)", context, buffer, length_value); - aaruformatContext *ctx = NULL; + aaruformat_context *ctx = NULL; if(context == NULL) { @@ -219,8 +219,8 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->dumpHardwareEntriesWithData == NULL || ctx->dumpHardwareHeader.entries == 0 || - ctx->dumpHardwareHeader.identifier != DumpHardwareBlock) + if(ctx->dump_hardware_entries_with_data == NULL || ctx->dump_hardware_header.entries == 0 || + ctx->dump_hardware_header.identifier != DumpHardwareBlock) { FATAL("No dump hardware information present"); @@ -228,7 +228,7 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_CANNOT_READ_BLOCK; } - size_t required_length = sizeof(DumpHardwareHeader) + (size_t)ctx->dumpHardwareHeader.length; + size_t required_length = sizeof(DumpHardwareHeader) + (size_t)ctx->dump_hardware_header.length; if(required_length < sizeof(DumpHardwareHeader)) { FATAL("Dump hardware payload length overflow"); @@ -250,11 +250,11 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length) // Start to iterate and copy the data size_t offset = 0; - for(uint32_t i = 0; i < ctx->dumpHardwareHeader.entries; i++) + for(uint32_t i = 0; i < ctx->dump_hardware_header.entries; i++) { size_t entry_size = sizeof(DumpHardwareEntry); - const DumpHardwareEntry *entry = &ctx->dumpHardwareEntriesWithData[i].entry; + const DumpHardwareEntry *entry = &ctx->dump_hardware_entries_with_data[i].entry; const size_t extent_bytes = (size_t)entry->extents * sizeof(DumpExtent); if(entry->extents != 0 && extent_bytes / sizeof(DumpExtent) != entry->extents) @@ -292,77 +292,77 @@ int32_t aaruf_get_dumphw(void *context, uint8_t *buffer, size_t *length) return AARUF_ERROR_BUFFER_TOO_SMALL; } - memcpy(buffer + offset, &ctx->dumpHardwareEntriesWithData[i].entry, sizeof(DumpHardwareEntry)); + memcpy(buffer + offset, &ctx->dump_hardware_entries_with_data[i].entry, sizeof(DumpHardwareEntry)); offset += sizeof(DumpHardwareEntry); - if(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength > 0 && - ctx->dumpHardwareEntriesWithData[i].manufacturer != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength > 0 && + ctx->dump_hardware_entries_with_data[i].manufacturer != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].manufacturer, - ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].manufacturer, + ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.modelLength > 0 && - ctx->dumpHardwareEntriesWithData[i].model != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.modelLength > 0 && + ctx->dump_hardware_entries_with_data[i].model != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].model, - ctx->dumpHardwareEntriesWithData[i].entry.modelLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.modelLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].model, + ctx->dump_hardware_entries_with_data[i].entry.modelLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.modelLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength > 0 && - ctx->dumpHardwareEntriesWithData[i].revision != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.revisionLength > 0 && + ctx->dump_hardware_entries_with_data[i].revision != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].revision, - ctx->dumpHardwareEntriesWithData[i].entry.revisionLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.revisionLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].revision, + ctx->dump_hardware_entries_with_data[i].entry.revisionLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.revisionLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength > 0 && - ctx->dumpHardwareEntriesWithData[i].firmware != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength > 0 && + ctx->dump_hardware_entries_with_data[i].firmware != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].firmware, - ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].firmware, + ctx->dump_hardware_entries_with_data[i].entry.firmwareLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.firmwareLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.serialLength > 0 && - ctx->dumpHardwareEntriesWithData[i].serial != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.serialLength > 0 && + ctx->dump_hardware_entries_with_data[i].serial != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].serial, - ctx->dumpHardwareEntriesWithData[i].entry.serialLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.serialLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].serial, + ctx->dump_hardware_entries_with_data[i].entry.serialLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.serialLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength > 0 && - ctx->dumpHardwareEntriesWithData[i].softwareName != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength > 0 && + ctx->dump_hardware_entries_with_data[i].softwareName != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareName, - ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareName, + ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength > 0 && - ctx->dumpHardwareEntriesWithData[i].softwareVersion != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength > 0 && + ctx->dump_hardware_entries_with_data[i].softwareVersion != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareVersion, - ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareVersion, + ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength; } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength > 0 && - ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem != NULL) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength > 0 && + ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem, - ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength); - offset += ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength; + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem, + ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength); + offset += ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength; } - if(entry->extents > 0 && ctx->dumpHardwareEntriesWithData[i].extents != NULL) + if(entry->extents > 0 && ctx->dump_hardware_entries_with_data[i].extents != NULL) { - memcpy(buffer + offset, ctx->dumpHardwareEntriesWithData[i].extents, extent_bytes); + memcpy(buffer + offset, ctx->dump_hardware_entries_with_data[i].extents, extent_bytes); offset += extent_bytes; } } // Calculate CRC64 - ctx->dumpHardwareHeader.crc64 = - aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dumpHardwareHeader.length); + ctx->dump_hardware_header.crc64 = + aaruf_crc64_data(buffer + sizeof(DumpHardwareHeader), ctx->dump_hardware_header.length); // Copy header - memcpy(buffer, &ctx->dumpHardwareHeader, sizeof(DumpHardwareHeader)); + memcpy(buffer, &ctx->dump_hardware_header, sizeof(DumpHardwareHeader)); TRACE("Exiting aaruf_get_dumphw() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; @@ -541,7 +541,7 @@ int32_t aaruf_set_dumphw(void *context, uint8_t *data, size_t length) return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -553,7 +553,7 @@ int32_t aaruf_set_dumphw(void *context, uint8_t *data, size_t length) } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -674,9 +674,9 @@ int32_t aaruf_set_dumphw(void *context, uint8_t *data, size_t length) goto invalid_data; } - free_dump_hardware_entries(ctx->dumpHardwareEntriesWithData, ctx->dumpHardwareHeader.entries); - ctx->dumpHardwareEntriesWithData = copy; - ctx->dumpHardwareHeader = header; + free_dump_hardware_entries(ctx->dump_hardware_entries_with_data, ctx->dump_hardware_header.entries); + ctx->dump_hardware_entries_with_data = copy; + ctx->dump_hardware_header = header; TRACE("Exiting aaruf_set_dumphw() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; diff --git a/src/index/index_v1.c b/src/index/index_v1.c index 15a4531..fc5fc29 100644 --- a/src/index/index_v1.c +++ b/src/index/index_v1.c @@ -76,7 +76,7 @@ * @warning The function assumes ctx->header.indexOffset points to a valid index block. * Invalid offsets may cause file access errors or reading incorrect data. */ -UT_array *process_index_v1(aaruformatContext *ctx) +UT_array *process_index_v1(aaruformat_context *ctx) { TRACE("Entering process_index_v1(%p)", ctx); @@ -222,7 +222,7 @@ UT_array *process_index_v1(aaruformatContext *ctx) * @warning CRC validation failure indicates potential data corruption and may suggest * the image file is damaged or has been modified outside of library control. */ -int32_t verify_index_v1(aaruformatContext *ctx) +int32_t verify_index_v1(aaruformat_context *ctx) { TRACE("Entering verify_index_v1(%p)", ctx); diff --git a/src/index/index_v2.c b/src/index/index_v2.c index fa59304..f97f9e0 100644 --- a/src/index/index_v2.c +++ b/src/index/index_v2.c @@ -78,7 +78,7 @@ * @warning The function assumes ctx->header.indexOffset points to a valid index block. * Invalid offsets may cause file access errors or reading incorrect data. */ -UT_array *process_index_v2(aaruformatContext *ctx) +UT_array *process_index_v2(aaruformat_context *ctx) { TRACE("Entering process_index_v2(%p)", ctx); @@ -224,7 +224,7 @@ UT_array *process_index_v2(aaruformatContext *ctx) * @warning CRC validation failure indicates potential data corruption and may suggest * the image file is damaged or has been modified outside of library control. */ -int32_t verify_index_v2(aaruformatContext *ctx) +int32_t verify_index_v2(aaruformat_context *ctx) { TRACE("Entering verify_index_v2(%p)", ctx); diff --git a/src/index/index_v3.c b/src/index/index_v3.c index 2176127..96bfe7d 100644 --- a/src/index/index_v3.c +++ b/src/index/index_v3.c @@ -27,7 +27,7 @@ #include "log.h" #include "utarray.h" -static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries, const IndexEntry *subindex_entry); +static bool add_subindex_entries(aaruformat_context *ctx, UT_array *index_entries, const IndexEntry *subindex_entry); /** * @brief Processes an index block (version 3) from the image stream. @@ -95,7 +95,7 @@ static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries * @warning The function assumes ctx->header.indexOffset points to a valid index block. * Invalid offsets may cause file access errors or reading incorrect data. */ -UT_array *process_index_v3(aaruformatContext *ctx) +UT_array *process_index_v3(aaruformat_context *ctx) { TRACE("Entering process_index_v3(%p)", ctx); @@ -244,7 +244,7 @@ UT_array *process_index_v3(aaruformatContext *ctx) * @warning No validation is performed on individual IndexEntry contents - only * structural validation of subindex headers is done. */ -static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries, const IndexEntry *subindex_entry) +static bool add_subindex_entries(aaruformat_context *ctx, UT_array *index_entries, const IndexEntry *subindex_entry) { TRACE("Entering add_subindex_entries(%p, %p, %p)", ctx, index_entries, subindex_entry); @@ -405,7 +405,7 @@ static bool add_subindex_entries(aaruformatContext *ctx, UT_array *index_entries * @warning For complete integrity verification of hierarchical indexes, additional validation * of subindex blocks may be required beyond this function's scope. */ -int32_t verify_index_v3(aaruformatContext *ctx) +int32_t verify_index_v3(aaruformat_context *ctx) { TRACE("Entering verify_index_v3(%p)", ctx); diff --git a/src/metadata.c b/src/metadata.c index ab7aba9..6450ac3 100644 --- a/src/metadata.c +++ b/src/metadata.c @@ -95,7 +95,7 @@ int32_t aaruf_get_geometry(const void *context, uint32_t *cylinders, uint32_t *h { TRACE("Entering aaruf_get_geometry(%p, %p, %p, %p)", context, cylinders, heads, sectors_per_track); - const aaruformatContext *ctx = NULL; + const aaruformat_context *ctx = NULL; if(context == NULL) { @@ -116,7 +116,7 @@ int32_t aaruf_get_geometry(const void *context, uint32_t *cylinders, uint32_t *h return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->geometryBlock.identifier != GeometryBlock) + if(ctx->geometry_block.identifier != GeometryBlock) { FATAL("No geometry block present"); @@ -124,9 +124,9 @@ int32_t aaruf_get_geometry(const void *context, uint32_t *cylinders, uint32_t *h return AARUF_ERROR_CANNOT_READ_BLOCK; } - *cylinders = ctx->geometryBlock.cylinders; - *heads = ctx->geometryBlock.heads; - *sectors_per_track = ctx->geometryBlock.sectorsPerTrack; + *cylinders = ctx->geometry_block.cylinders; + *heads = ctx->geometry_block.heads; + *sectors_per_track = ctx->geometry_block.sectorsPerTrack; TRACE("Exiting aaruf_get_geometry(%p, %u, %u, %u) = AARUF_STATUS_OK", context, *cylinders, *heads, *sectors_per_track); @@ -231,7 +231,7 @@ int32_t aaruf_set_geometry(void *context, const uint32_t cylinders, const uint32 { TRACE("Entering aaruf_set_geometry(%p, %u, %u, %u)", context, cylinders, heads, sectors_per_track); - aaruformatContext *ctx = NULL; + aaruformat_context *ctx = NULL; if(context == NULL) { @@ -253,7 +253,7 @@ int32_t aaruf_set_geometry(void *context, const uint32_t cylinders, const uint32 } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -261,13 +261,13 @@ int32_t aaruf_set_geometry(void *context, const uint32_t cylinders, const uint32 return AARUF_READ_ONLY; } - ctx->geometryBlock.identifier = GeometryBlock; - ctx->geometryBlock.cylinders = cylinders; - ctx->geometryBlock.heads = heads; - ctx->geometryBlock.sectorsPerTrack = sectors_per_track; - ctx->Cylinders = cylinders; - ctx->Heads = heads; - ctx->SectorsPerTrack = sectors_per_track; + ctx->geometry_block.identifier = GeometryBlock; + ctx->geometry_block.cylinders = cylinders; + ctx->geometry_block.heads = heads; + ctx->geometry_block.sectorsPerTrack = sectors_per_track; + ctx->cylinders = cylinders; + ctx->heads = heads; + ctx->sectors_per_track = sectors_per_track; TRACE("Exiting aaruf_set_geometry(%p, %u, %u, %u) = AARUF_STATUS_OK", context, cylinders, heads, sectors_per_track); return AARUF_STATUS_OK; @@ -373,7 +373,7 @@ int32_t aaruf_set_media_sequence(void *context, const int32_t sequence, const in return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -385,7 +385,7 @@ int32_t aaruf_set_media_sequence(void *context, const int32_t sequence, const in } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -394,10 +394,10 @@ int32_t aaruf_set_media_sequence(void *context, const int32_t sequence, const in } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; - ctx->metadataBlockHeader.mediaSequence = sequence; - ctx->metadataBlockHeader.lastMediaSequence = last_sequence; + ctx->metadata_block_header.mediaSequence = sequence; + ctx->metadata_block_header.lastMediaSequence = last_sequence; TRACE("Exiting aaruf_set_media_sequence(%p, %d, %d) = AARUF_STATUS_OK", context, sequence, last_sequence); return AARUF_STATUS_OK; @@ -503,7 +503,7 @@ int32_t aaruf_set_creator(void *context, const uint8_t *data, const int32_t leng return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -515,7 +515,7 @@ int32_t aaruf_set_creator(void *context, const uint8_t *data, const int32_t leng } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -524,7 +524,7 @@ int32_t aaruf_set_creator(void *context, const uint8_t *data, const int32_t leng } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -536,9 +536,9 @@ int32_t aaruf_set_creator(void *context, const uint8_t *data, const int32_t leng // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->Creator != NULL) free(ctx->Creator); - ctx->Creator = copy; - ctx->metadataBlockHeader.creatorLength = length; + if(ctx->creator != NULL) free(ctx->creator); + ctx->creator = copy; + ctx->metadata_block_header.creatorLength = length; TRACE("Exiting aaruf_set_creator(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -617,7 +617,7 @@ int32_t aaruf_set_comments(void *context, const uint8_t *data, const int32_t len return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -629,7 +629,7 @@ int32_t aaruf_set_comments(void *context, const uint8_t *data, const int32_t len } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -638,7 +638,7 @@ int32_t aaruf_set_comments(void *context, const uint8_t *data, const int32_t len } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -650,9 +650,9 @@ int32_t aaruf_set_comments(void *context, const uint8_t *data, const int32_t len // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->Comments != NULL) free(ctx->Comments); - ctx->Comments = copy; - ctx->metadataBlockHeader.commentsLength = length; + if(ctx->comments != NULL) free(ctx->comments); + ctx->comments = copy; + ctx->metadata_block_header.commentsLength = length; TRACE("Exiting aaruf_set_comments(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -730,7 +730,7 @@ int32_t aaruf_set_media_title(void *context, const uint8_t *data, const int32_t return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -742,7 +742,7 @@ int32_t aaruf_set_media_title(void *context, const uint8_t *data, const int32_t } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -751,7 +751,7 @@ int32_t aaruf_set_media_title(void *context, const uint8_t *data, const int32_t } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -763,9 +763,9 @@ int32_t aaruf_set_media_title(void *context, const uint8_t *data, const int32_t // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->MediaTitle != NULL) free(ctx->MediaTitle); - ctx->MediaTitle = copy; - ctx->metadataBlockHeader.mediaTitleLength = length; + if(ctx->media_title != NULL) free(ctx->media_title); + ctx->media_title = copy; + ctx->metadata_block_header.mediaTitleLength = length; TRACE("Exiting aaruf_set_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -842,7 +842,7 @@ int32_t aaruf_set_media_manufacturer(void *context, const uint8_t *data, const i return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -854,7 +854,7 @@ int32_t aaruf_set_media_manufacturer(void *context, const uint8_t *data, const i } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -863,7 +863,7 @@ int32_t aaruf_set_media_manufacturer(void *context, const uint8_t *data, const i } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -875,9 +875,9 @@ int32_t aaruf_set_media_manufacturer(void *context, const uint8_t *data, const i // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->MediaManufacturer != NULL) free(ctx->MediaManufacturer); - ctx->MediaManufacturer = copy; - ctx->metadataBlockHeader.mediaManufacturerLength = length; + if(ctx->media_manufacturer != NULL) free(ctx->media_manufacturer); + ctx->media_manufacturer = copy; + ctx->metadata_block_header.mediaManufacturerLength = length; TRACE("Exiting aaruf_set_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -949,7 +949,7 @@ int32_t aaruf_set_media_model(void *context, const uint8_t *data, const int32_t return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -961,7 +961,7 @@ int32_t aaruf_set_media_model(void *context, const uint8_t *data, const int32_t } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -970,7 +970,7 @@ int32_t aaruf_set_media_model(void *context, const uint8_t *data, const int32_t } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -982,9 +982,9 @@ int32_t aaruf_set_media_model(void *context, const uint8_t *data, const int32_t // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->MediaModel != NULL) free(ctx->MediaModel); - ctx->MediaModel = copy; - ctx->metadataBlockHeader.mediaModelLength = length; + if(ctx->media_model != NULL) free(ctx->media_model); + ctx->media_model = copy; + ctx->metadata_block_header.mediaModelLength = length; TRACE("Exiting aaruf_set_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1064,7 +1064,7 @@ int32_t aaruf_set_media_serial_number(void *context, const uint8_t *data, const return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1076,7 +1076,7 @@ int32_t aaruf_set_media_serial_number(void *context, const uint8_t *data, const } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1085,7 +1085,7 @@ int32_t aaruf_set_media_serial_number(void *context, const uint8_t *data, const } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1097,9 +1097,9 @@ int32_t aaruf_set_media_serial_number(void *context, const uint8_t *data, const // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->MediaSerialNumber != NULL) free(ctx->MediaSerialNumber); - ctx->MediaSerialNumber = copy; - ctx->metadataBlockHeader.mediaSerialNumberLength = length; + if(ctx->media_serial_number != NULL) free(ctx->media_serial_number); + ctx->media_serial_number = copy; + ctx->metadata_block_header.mediaSerialNumberLength = length; TRACE("Exiting aaruf_set_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1186,7 +1186,7 @@ int32_t aaruf_set_media_barcode(void *context, const uint8_t *data, const int32_ return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1198,7 +1198,7 @@ int32_t aaruf_set_media_barcode(void *context, const uint8_t *data, const int32_ } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1207,7 +1207,7 @@ int32_t aaruf_set_media_barcode(void *context, const uint8_t *data, const int32_ } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1219,9 +1219,9 @@ int32_t aaruf_set_media_barcode(void *context, const uint8_t *data, const int32_ // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->MediaBarcode != NULL) free(ctx->MediaBarcode); - ctx->MediaBarcode = copy; - ctx->metadataBlockHeader.mediaBarcodeLength = length; + if(ctx->media_barcode != NULL) free(ctx->media_barcode); + ctx->media_barcode = copy; + ctx->metadata_block_header.mediaBarcodeLength = length; TRACE("Exiting aaruf_set_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1307,7 +1307,7 @@ int32_t aaruf_set_media_part_number(void *context, const uint8_t *data, const in return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1319,7 +1319,7 @@ int32_t aaruf_set_media_part_number(void *context, const uint8_t *data, const in } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1328,7 +1328,7 @@ int32_t aaruf_set_media_part_number(void *context, const uint8_t *data, const in } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1340,9 +1340,9 @@ int32_t aaruf_set_media_part_number(void *context, const uint8_t *data, const in // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->MediaPartNumber != NULL) free(ctx->MediaPartNumber); - ctx->MediaPartNumber = copy; - ctx->metadataBlockHeader.mediaPartNumberLength = length; + if(ctx->media_part_number != NULL) free(ctx->media_part_number); + ctx->media_part_number = copy; + ctx->metadata_block_header.mediaPartNumberLength = length; TRACE("Exiting aaruf_set_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1422,7 +1422,7 @@ int32_t aaruf_set_drive_manufacturer(void *context, const uint8_t *data, const i return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1434,7 +1434,7 @@ int32_t aaruf_set_drive_manufacturer(void *context, const uint8_t *data, const i } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1443,7 +1443,7 @@ int32_t aaruf_set_drive_manufacturer(void *context, const uint8_t *data, const i } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1455,9 +1455,9 @@ int32_t aaruf_set_drive_manufacturer(void *context, const uint8_t *data, const i // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->DriveManufacturer != NULL) free(ctx->DriveManufacturer); - ctx->DriveManufacturer = copy; - ctx->metadataBlockHeader.driveManufacturerLength = length; + if(ctx->drive_manufacturer != NULL) free(ctx->drive_manufacturer); + ctx->drive_manufacturer = copy; + ctx->metadata_block_header.driveManufacturerLength = length; TRACE("Exiting aaruf_set_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1544,7 +1544,7 @@ int32_t aaruf_set_drive_model(void *context, const uint8_t *data, const int32_t return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1556,7 +1556,7 @@ int32_t aaruf_set_drive_model(void *context, const uint8_t *data, const int32_t } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1565,7 +1565,7 @@ int32_t aaruf_set_drive_model(void *context, const uint8_t *data, const int32_t } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1577,9 +1577,9 @@ int32_t aaruf_set_drive_model(void *context, const uint8_t *data, const int32_t // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->DriveModel != NULL) free(ctx->DriveModel); - ctx->DriveModel = copy; - ctx->metadataBlockHeader.driveModelLength = length; + if(ctx->drive_model != NULL) free(ctx->drive_model); + ctx->drive_model = copy; + ctx->metadata_block_header.driveModelLength = length; TRACE("Exiting aaruf_set_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1668,7 +1668,7 @@ int32_t aaruf_set_drive_serial_number(void *context, const uint8_t *data, const return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1680,7 +1680,7 @@ int32_t aaruf_set_drive_serial_number(void *context, const uint8_t *data, const } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1689,7 +1689,7 @@ int32_t aaruf_set_drive_serial_number(void *context, const uint8_t *data, const } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1701,9 +1701,9 @@ int32_t aaruf_set_drive_serial_number(void *context, const uint8_t *data, const // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->DriveSerialNumber != NULL) free(ctx->DriveSerialNumber); - ctx->DriveSerialNumber = copy; - ctx->metadataBlockHeader.driveSerialNumberLength = length; + if(ctx->drive_serial_number != NULL) free(ctx->drive_serial_number); + ctx->drive_serial_number = copy; + ctx->metadata_block_header.driveSerialNumberLength = length; TRACE("Exiting aaruf_set_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1803,7 +1803,7 @@ int32_t aaruf_set_drive_firmware_revision(void *context, const uint8_t *data, co return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1815,7 +1815,7 @@ int32_t aaruf_set_drive_firmware_revision(void *context, const uint8_t *data, co } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -1824,7 +1824,7 @@ int32_t aaruf_set_drive_firmware_revision(void *context, const uint8_t *data, co } // Initialize - if(ctx->metadataBlockHeader.identifier != MetadataBlock) ctx->metadataBlockHeader.identifier = MetadataBlock; + if(ctx->metadata_block_header.identifier != MetadataBlock) ctx->metadata_block_header.identifier = MetadataBlock; // Reserve memory uint8_t *copy = malloc(length); @@ -1836,9 +1836,9 @@ int32_t aaruf_set_drive_firmware_revision(void *context, const uint8_t *data, co // Copy opaque UTF-16LE string memcpy(copy, data, length); - if(ctx->DriveFirmwareRevision != NULL) free(ctx->DriveFirmwareRevision); - ctx->DriveFirmwareRevision = copy; - ctx->metadataBlockHeader.driveFirmwareRevisionLength = length; + if(ctx->drive_firmware_revision != NULL) free(ctx->drive_firmware_revision); + ctx->drive_firmware_revision = copy; + ctx->metadata_block_header.driveFirmwareRevisionLength = length; TRACE("Exiting aaruf_set_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -1954,7 +1954,7 @@ int32_t aaruf_get_cicm_metadata(const void *context, uint8_t *buffer, size_t *le return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1965,7 +1965,7 @@ int32_t aaruf_get_cicm_metadata(const void *context, uint8_t *buffer, size_t *le return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->cicmBlock == NULL || ctx->cicmBlockHeader.length == 0 || ctx->cicmBlockHeader.identifier != CicmBlock) + if(ctx->cicm_block == NULL || ctx->cicm_block_header.length == 0 || ctx->cicm_block_header.identifier != CicmBlock) { TRACE("No CICM XML metadata present"); *length = 0; @@ -1974,17 +1974,17 @@ int32_t aaruf_get_cicm_metadata(const void *context, uint8_t *buffer, size_t *le return AARUF_ERROR_CANNOT_READ_BLOCK; } - if(*length < ctx->cicmBlockHeader.length) + if(*length < ctx->cicm_block_header.length) { - TRACE("Buffer too small for CICM XML metadata, required %u bytes", ctx->cicmBlockHeader.length); - *length = ctx->cicmBlockHeader.length; + TRACE("Buffer too small for CICM XML metadata, required %u bytes", ctx->cicm_block_header.length); + *length = ctx->cicm_block_header.length; TRACE("Exiting aaruf_get_cicm_metadata() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } - *length = ctx->cicmBlockHeader.length; - memcpy(buffer, ctx->cicmBlock, ctx->cicmBlockHeader.length); + *length = ctx->cicm_block_header.length; + memcpy(buffer, ctx->cicm_block, ctx->cicm_block_header.length); TRACE("CICM XML metadata read successfully, length %u", *length); TRACE("Exiting aaruf_get_cicm_metadata(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); @@ -2109,7 +2109,7 @@ int32_t aaruf_get_aaru_json_metadata(const void *context, uint8_t *buffer, size_ return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2120,8 +2120,8 @@ int32_t aaruf_get_aaru_json_metadata(const void *context, uint8_t *buffer, size_ return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->jsonBlock == NULL || ctx->jsonBlockHeader.length == 0 || - ctx->jsonBlockHeader.identifier != AaruMetadataJsonBlock) + if(ctx->json_block == NULL || ctx->json_block_header.length == 0 || + ctx->json_block_header.identifier != AaruMetadataJsonBlock) { TRACE("No Aaru metadata JSON present"); *length = 0; @@ -2130,17 +2130,17 @@ int32_t aaruf_get_aaru_json_metadata(const void *context, uint8_t *buffer, size_ return AARUF_ERROR_CANNOT_READ_BLOCK; } - if(*length < ctx->jsonBlockHeader.length) + if(*length < ctx->json_block_header.length) { - TRACE("Buffer too small for Aaru metadata JSON, required %u bytes", ctx->jsonBlockHeader.length); - *length = ctx->jsonBlockHeader.length; + TRACE("Buffer too small for Aaru metadata JSON, required %u bytes", ctx->json_block_header.length); + *length = ctx->json_block_header.length; TRACE("Exiting aaruf_get_aaru_json_metadata() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } - *length = ctx->jsonBlockHeader.length; - memcpy(buffer, ctx->jsonBlock, ctx->jsonBlockHeader.length); + *length = ctx->json_block_header.length; + memcpy(buffer, ctx->json_block, ctx->json_block_header.length); TRACE("Aaru metadata JSON read successfully, length %u", *length); TRACE("Exiting aaruf_get_aaru_json_metadata(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); @@ -2268,7 +2268,7 @@ int32_t aaruf_set_aaru_json_metadata(void *context, uint8_t *data, size_t length return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2280,7 +2280,7 @@ int32_t aaruf_set_aaru_json_metadata(void *context, uint8_t *data, size_t length } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -2298,10 +2298,10 @@ int32_t aaruf_set_aaru_json_metadata(void *context, uint8_t *data, size_t length // Copy opaque UTF-8 string memcpy(copy, data, length); - if(ctx->jsonBlock != NULL) free(ctx->jsonBlock); - ctx->jsonBlock = copy; - ctx->jsonBlockHeader.identifier = AaruMetadataJsonBlock; - ctx->jsonBlockHeader.length = (uint32_t)length; + if(ctx->json_block != NULL) free(ctx->json_block); + ctx->json_block = copy; + ctx->json_block_header.identifier = AaruMetadataJsonBlock; + ctx->json_block_header.length = (uint32_t)length; TRACE("Exiting aaruf_set_aaru_json_metadata(%p, %p, %d) = AARUF_STATUS_OK", context, data, length); return AARUF_STATUS_OK; @@ -2347,7 +2347,7 @@ int32_t aaruf_get_media_sequence(const void *context, int32_t *sequence, int32_t return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2358,7 +2358,7 @@ int32_t aaruf_get_media_sequence(const void *context, int32_t *sequence, int32_t return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock) + if(ctx->metadata_block_header.identifier != MetadataBlock) { FATAL("No metadata block present"); @@ -2366,8 +2366,8 @@ int32_t aaruf_get_media_sequence(const void *context, int32_t *sequence, int32_t return AARUF_ERROR_METADATA_NOT_PRESENT; } - *sequence = ctx->metadataBlockHeader.mediaSequence; - *last_sequence = ctx->metadataBlockHeader.lastMediaSequence; + *sequence = ctx->metadata_block_header.mediaSequence; + *last_sequence = ctx->metadata_block_header.lastMediaSequence; TRACE("Exiting aaruf_set_media_sequence(%p, %d, %d) = AARUF_STATUS_OK", context, *sequence, *last_sequence); return AARUF_STATUS_OK; @@ -2414,7 +2414,7 @@ int32_t aaruf_get_creator(const void *context, uint8_t *buffer, int32_t *length) return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2425,8 +2425,8 @@ int32_t aaruf_get_creator(const void *context, uint8_t *buffer, int32_t *length) return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->Creator == NULL || - ctx->metadataBlockHeader.creatorLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->creator == NULL || + ctx->metadata_block_header.creatorLength == 0) { FATAL("No metadata block present"); @@ -2434,17 +2434,17 @@ int32_t aaruf_get_creator(const void *context, uint8_t *buffer, int32_t *length) return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.creatorLength) + if(buffer == NULL || *length < ctx->metadata_block_header.creatorLength) { - *length = ctx->metadataBlockHeader.creatorLength; + *length = ctx->metadata_block_header.creatorLength; TRACE("Exiting aaruf_get_creator() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->Creator, ctx->metadataBlockHeader.creatorLength); - *length = ctx->metadataBlockHeader.creatorLength; + memcpy(buffer, ctx->creator, ctx->metadata_block_header.creatorLength); + *length = ctx->metadata_block_header.creatorLength; TRACE("Exiting aaruf_get_creator(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2486,7 +2486,7 @@ int32_t aaruf_get_comments(const void *context, uint8_t *buffer, int32_t *length return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2497,8 +2497,8 @@ int32_t aaruf_get_comments(const void *context, uint8_t *buffer, int32_t *length return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->Comments == NULL || - ctx->metadataBlockHeader.commentsLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->comments == NULL || + ctx->metadata_block_header.commentsLength == 0) { FATAL("No metadata block present"); @@ -2506,17 +2506,17 @@ int32_t aaruf_get_comments(const void *context, uint8_t *buffer, int32_t *length return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.commentsLength) + if(buffer == NULL || *length < ctx->metadata_block_header.commentsLength) { - *length = ctx->metadataBlockHeader.commentsLength; + *length = ctx->metadata_block_header.commentsLength; TRACE("Exiting aaruf_get_comments() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->Comments, ctx->metadataBlockHeader.commentsLength); - *length = ctx->metadataBlockHeader.commentsLength; + memcpy(buffer, ctx->comments, ctx->metadata_block_header.commentsLength); + *length = ctx->metadata_block_header.commentsLength; TRACE("Exiting aaruf_get_comments(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2556,7 +2556,7 @@ int32_t aaruf_get_media_title(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2567,8 +2567,8 @@ int32_t aaruf_get_media_title(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaTitle == NULL || - ctx->metadataBlockHeader.mediaTitleLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_title == NULL || + ctx->metadata_block_header.mediaTitleLength == 0) { FATAL("No metadata block present"); @@ -2576,17 +2576,17 @@ int32_t aaruf_get_media_title(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.mediaTitleLength) + if(buffer == NULL || *length < ctx->metadata_block_header.mediaTitleLength) { - *length = ctx->metadataBlockHeader.mediaTitleLength; + *length = ctx->metadata_block_header.mediaTitleLength; TRACE("Exiting aaruf_get_media_title() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->MediaTitle, ctx->metadataBlockHeader.mediaTitleLength); - *length = ctx->metadataBlockHeader.mediaTitleLength; + memcpy(buffer, ctx->media_title, ctx->metadata_block_header.mediaTitleLength); + *length = ctx->metadata_block_header.mediaTitleLength; TRACE("Exiting aaruf_get_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2626,7 +2626,7 @@ int32_t aaruf_get_media_manufacturer(const void *context, uint8_t *buffer, int32 return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2637,8 +2637,8 @@ int32_t aaruf_get_media_manufacturer(const void *context, uint8_t *buffer, int32 return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaManufacturer == NULL || - ctx->metadataBlockHeader.mediaManufacturerLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_manufacturer == NULL || + ctx->metadata_block_header.mediaManufacturerLength == 0) { FATAL("No metadata block present"); @@ -2646,17 +2646,17 @@ int32_t aaruf_get_media_manufacturer(const void *context, uint8_t *buffer, int32 return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.mediaManufacturerLength) + if(buffer == NULL || *length < ctx->metadata_block_header.mediaManufacturerLength) { - *length = ctx->metadataBlockHeader.mediaManufacturerLength; + *length = ctx->metadata_block_header.mediaManufacturerLength; TRACE("Exiting aaruf_get_media_manufacturer() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength); - *length = ctx->metadataBlockHeader.mediaManufacturerLength; + memcpy(buffer, ctx->media_manufacturer, ctx->metadata_block_header.mediaManufacturerLength); + *length = ctx->metadata_block_header.mediaManufacturerLength; TRACE("Exiting aaruf_get_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2696,7 +2696,7 @@ int32_t aaruf_get_media_model(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2707,8 +2707,8 @@ int32_t aaruf_get_media_model(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaModel == NULL || - ctx->metadataBlockHeader.mediaModelLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_model == NULL || + ctx->metadata_block_header.mediaModelLength == 0) { FATAL("No metadata block present"); @@ -2716,17 +2716,17 @@ int32_t aaruf_get_media_model(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.mediaModelLength) + if(buffer == NULL || *length < ctx->metadata_block_header.mediaModelLength) { - *length = ctx->metadataBlockHeader.mediaModelLength; + *length = ctx->metadata_block_header.mediaModelLength; TRACE("Exiting aaruf_get_media_model() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->MediaModel, ctx->metadataBlockHeader.mediaModelLength); - *length = ctx->metadataBlockHeader.mediaModelLength; + memcpy(buffer, ctx->media_model, ctx->metadata_block_header.mediaModelLength); + *length = ctx->metadata_block_header.mediaModelLength; TRACE("Exiting aaruf_get_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2766,7 +2766,7 @@ int32_t aaruf_get_media_serial_number(const void *context, uint8_t *buffer, int3 return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2777,8 +2777,8 @@ int32_t aaruf_get_media_serial_number(const void *context, uint8_t *buffer, int3 return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaSerialNumber == NULL || - ctx->metadataBlockHeader.mediaSerialNumberLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_serial_number == NULL || + ctx->metadata_block_header.mediaSerialNumberLength == 0) { FATAL("No metadata block present"); @@ -2786,17 +2786,17 @@ int32_t aaruf_get_media_serial_number(const void *context, uint8_t *buffer, int3 return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.mediaSerialNumberLength) + if(buffer == NULL || *length < ctx->metadata_block_header.mediaSerialNumberLength) { - *length = ctx->metadataBlockHeader.mediaSerialNumberLength; + *length = ctx->metadata_block_header.mediaSerialNumberLength; TRACE("Exiting aaruf_get_media_serial_number() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength); - *length = ctx->metadataBlockHeader.mediaSerialNumberLength; + memcpy(buffer, ctx->media_serial_number, ctx->metadata_block_header.mediaSerialNumberLength); + *length = ctx->metadata_block_header.mediaSerialNumberLength; TRACE("Exiting aaruf_get_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2835,7 +2835,7 @@ int32_t aaruf_get_media_barcode(const void *context, uint8_t *buffer, int32_t *l return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2846,8 +2846,8 @@ int32_t aaruf_get_media_barcode(const void *context, uint8_t *buffer, int32_t *l return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaBarcode == NULL || - ctx->metadataBlockHeader.mediaBarcodeLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_barcode == NULL || + ctx->metadata_block_header.mediaBarcodeLength == 0) { FATAL("No metadata block present"); @@ -2855,17 +2855,17 @@ int32_t aaruf_get_media_barcode(const void *context, uint8_t *buffer, int32_t *l return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.mediaBarcodeLength) + if(buffer == NULL || *length < ctx->metadata_block_header.mediaBarcodeLength) { - *length = ctx->metadataBlockHeader.mediaBarcodeLength; + *length = ctx->metadata_block_header.mediaBarcodeLength; TRACE("Exiting aaruf_get_media_barcode() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength); - *length = ctx->metadataBlockHeader.mediaBarcodeLength; + memcpy(buffer, ctx->media_barcode, ctx->metadata_block_header.mediaBarcodeLength); + *length = ctx->metadata_block_header.mediaBarcodeLength; TRACE("Exiting aaruf_get_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2906,7 +2906,7 @@ int32_t aaruf_get_media_part_number(const void *context, uint8_t *buffer, int32_ return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2917,8 +2917,8 @@ int32_t aaruf_get_media_part_number(const void *context, uint8_t *buffer, int32_ return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaPartNumber == NULL || - ctx->metadataBlockHeader.mediaPartNumberLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->media_part_number == NULL || + ctx->metadata_block_header.mediaPartNumberLength == 0) { FATAL("No metadata block present"); @@ -2926,17 +2926,17 @@ int32_t aaruf_get_media_part_number(const void *context, uint8_t *buffer, int32_ return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.mediaPartNumberLength) + if(buffer == NULL || *length < ctx->metadata_block_header.mediaPartNumberLength) { - *length = ctx->metadataBlockHeader.mediaPartNumberLength; + *length = ctx->metadata_block_header.mediaPartNumberLength; TRACE("Exiting aaruf_get_media_part_number() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength); - *length = ctx->metadataBlockHeader.mediaPartNumberLength; + memcpy(buffer, ctx->media_part_number, ctx->metadata_block_header.mediaPartNumberLength); + *length = ctx->metadata_block_header.mediaPartNumberLength; TRACE("Exiting aaruf_get_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -2978,7 +2978,7 @@ int32_t aaruf_get_drive_manufacturer(const void *context, uint8_t *buffer, int32 return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2989,8 +2989,8 @@ int32_t aaruf_get_drive_manufacturer(const void *context, uint8_t *buffer, int32 return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveManufacturer == NULL || - ctx->metadataBlockHeader.driveManufacturerLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_manufacturer == NULL || + ctx->metadata_block_header.driveManufacturerLength == 0) { FATAL("No metadata block present"); @@ -2998,17 +2998,17 @@ int32_t aaruf_get_drive_manufacturer(const void *context, uint8_t *buffer, int32 return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.driveManufacturerLength) + if(buffer == NULL || *length < ctx->metadata_block_header.driveManufacturerLength) { - *length = ctx->metadataBlockHeader.driveManufacturerLength; + *length = ctx->metadata_block_header.driveManufacturerLength; TRACE("Exiting aaruf_get_drive_manufacturer() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength); - *length = ctx->metadataBlockHeader.driveManufacturerLength; + memcpy(buffer, ctx->drive_manufacturer, ctx->metadata_block_header.driveManufacturerLength); + *length = ctx->metadata_block_header.driveManufacturerLength; TRACE("Exiting aaruf_get_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -3048,7 +3048,7 @@ int32_t aaruf_get_drive_model(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -3059,8 +3059,8 @@ int32_t aaruf_get_drive_model(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveModel == NULL || - ctx->metadataBlockHeader.driveModelLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_model == NULL || + ctx->metadata_block_header.driveModelLength == 0) { FATAL("No metadata block present"); @@ -3068,17 +3068,17 @@ int32_t aaruf_get_drive_model(const void *context, uint8_t *buffer, int32_t *len return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.driveModelLength) + if(buffer == NULL || *length < ctx->metadata_block_header.driveModelLength) { - *length = ctx->metadataBlockHeader.driveModelLength; + *length = ctx->metadata_block_header.driveModelLength; TRACE("Exiting aaruf_get_drive_model() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->DriveModel, ctx->metadataBlockHeader.driveModelLength); - *length = ctx->metadataBlockHeader.driveModelLength; + memcpy(buffer, ctx->drive_model, ctx->metadata_block_header.driveModelLength); + *length = ctx->metadata_block_header.driveModelLength; TRACE("Exiting aaruf_get_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -3118,7 +3118,7 @@ int32_t aaruf_get_drive_serial_number(const void *context, uint8_t *buffer, int3 return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -3129,8 +3129,8 @@ int32_t aaruf_get_drive_serial_number(const void *context, uint8_t *buffer, int3 return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveSerialNumber == NULL || - ctx->metadataBlockHeader.driveSerialNumberLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_serial_number == NULL || + ctx->metadata_block_header.driveSerialNumberLength == 0) { FATAL("No metadata block present"); @@ -3138,17 +3138,17 @@ int32_t aaruf_get_drive_serial_number(const void *context, uint8_t *buffer, int3 return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.driveSerialNumberLength) + if(buffer == NULL || *length < ctx->metadata_block_header.driveSerialNumberLength) { - *length = ctx->metadataBlockHeader.driveSerialNumberLength; + *length = ctx->metadata_block_header.driveSerialNumberLength; TRACE("Exiting aaruf_get_drive_serial_number() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength); - *length = ctx->metadataBlockHeader.driveSerialNumberLength; + memcpy(buffer, ctx->drive_serial_number, ctx->metadata_block_header.driveSerialNumberLength); + *length = ctx->metadata_block_header.driveSerialNumberLength; TRACE("Exiting aaruf_get_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; @@ -3188,7 +3188,7 @@ int32_t aaruf_get_drive_firmware_revision(const void *context, uint8_t *buffer, return AARUF_ERROR_NOT_AARUFORMAT; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -3199,8 +3199,8 @@ int32_t aaruf_get_drive_firmware_revision(const void *context, uint8_t *buffer, return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveFirmwareRevision == NULL || - ctx->metadataBlockHeader.driveFirmwareRevisionLength == 0) + if(ctx->metadata_block_header.identifier != MetadataBlock || ctx->drive_firmware_revision == NULL || + ctx->metadata_block_header.driveFirmwareRevisionLength == 0) { FATAL("No metadata block present"); @@ -3208,17 +3208,17 @@ int32_t aaruf_get_drive_firmware_revision(const void *context, uint8_t *buffer, return AARUF_ERROR_METADATA_NOT_PRESENT; } - if(buffer == NULL || *length < ctx->metadataBlockHeader.driveFirmwareRevisionLength) + if(buffer == NULL || *length < ctx->metadata_block_header.driveFirmwareRevisionLength) { - *length = ctx->metadataBlockHeader.driveFirmwareRevisionLength; + *length = ctx->metadata_block_header.driveFirmwareRevisionLength; TRACE("Exiting aaruf_get_drive_firmware_revision() = AARUF_ERROR_BUFFER_TOO_SMALL"); return AARUF_ERROR_BUFFER_TOO_SMALL; } // Copy opaque UTF-16LE string - memcpy(buffer, ctx->DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength); - *length = ctx->metadataBlockHeader.driveFirmwareRevisionLength; + memcpy(buffer, ctx->drive_firmware_revision, ctx->metadata_block_header.driveFirmwareRevisionLength); + *length = ctx->metadata_block_header.driveFirmwareRevisionLength; TRACE("Exiting aaruf_get_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); return AARUF_STATUS_OK; diff --git a/src/open.c b/src/open.c index ba5f722..1b8a83b 100644 --- a/src/open.c +++ b/src/open.c @@ -31,7 +31,7 @@ #include "log.h" #include "utarray.h" -static void cleanup_open_failure(aaruformatContext *ctx) +static void cleanup_open_failure(aaruformat_context *ctx) { if(ctx == NULL) return; @@ -127,13 +127,13 @@ static void cleanup_open_failure(aaruformatContext *ctx) */ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) { - aaruformatContext *ctx = NULL; - int error_no = 0; - size_t read_bytes = 0; - long pos = 0; - int i = 0; - uint32_t signature = 0; - UT_array *index_entries = NULL; + aaruformat_context *ctx = NULL; + int error_no = 0; + size_t read_bytes = 0; + long pos = 0; + int i = 0; + uint32_t signature = 0; + UT_array *index_entries = NULL; #ifdef USE_SLOG #include "slog.h" @@ -146,7 +146,7 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) TRACE("Entering aaruf_open(%s)", filepath); TRACE("Allocating memory for context"); - ctx = (aaruformatContext *)malloc(sizeof(aaruformatContext)); + ctx = (aaruformat_context *)malloc(sizeof(aaruformat_context)); if(ctx == NULL) { @@ -157,7 +157,7 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) return NULL; } - memset(ctx, 0, sizeof(aaruformatContext)); + memset(ctx, 0, sizeof(aaruformat_context)); TRACE("Opening file %s", filepath); ctx->imageStream = fopen(filepath, "rb"); @@ -267,29 +267,29 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) // Ensure it fits in the Application buffer (64 bytes including null terminator) if(app_name_utf8_len < 64) { - u_strToUTF8(ctx->imageInfo.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status); + u_strToUTF8(ctx->image_info.Application, 64, NULL, app_name_utf16, app_name_utf16_len, &status); if(U_FAILURE(status)) { TRACE("Error converting application name to UTF-8: %d, using raw bytes", status); // Fallback: just copy what we can - memset(ctx->imageInfo.Application, 0, 64); - strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63); + memset(ctx->image_info.Application, 0, 64); + strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63); } } else { TRACE("Application name too long for buffer, truncating"); - u_strToUTF8(ctx->imageInfo.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status); - ctx->imageInfo.Application[63] = '\0'; + u_strToUTF8(ctx->image_info.Application, 63, NULL, app_name_utf16, app_name_utf16_len, &status); + ctx->image_info.Application[63] = '\0'; } } else { TRACE("Error getting UTF-8 length: %d, using raw bytes", status); // Fallback: just copy what we can - memset(ctx->imageInfo.Application, 0, 64); - strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63); + memset(ctx->image_info.Application, 0, 64); + strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63); } free(app_name_utf16); @@ -298,20 +298,20 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) { TRACE("Could not allocate memory for UTF-16 conversion, using raw bytes"); // Fallback: just copy what we can - memset(ctx->imageInfo.Application, 0, 64); - strncpy(ctx->imageInfo.Application, (const char *)ctx->header.application, 63); + memset(ctx->image_info.Application, 0, 64); + strncpy(ctx->image_info.Application, (const char *)ctx->header.application, 63); } // Set application version string directly in the fixed-size array - memset(ctx->imageInfo.ApplicationVersion, 0, 32); - sprintf(ctx->imageInfo.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion, + memset(ctx->image_info.ApplicationVersion, 0, 32); + sprintf(ctx->image_info.ApplicationVersion, "%d.%d", ctx->header.applicationMajorVersion, ctx->header.applicationMinorVersion); // Set image version string directly in the fixed-size array - memset(ctx->imageInfo.Version, 0, 32); - sprintf(ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion); + memset(ctx->image_info.Version, 0, 32); + sprintf(ctx->image_info.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion); - ctx->imageInfo.MediaType = ctx->header.mediaType; + ctx->image_info.MediaType = ctx->header.mediaType; // Read the index header TRACE("Reading index header at position %" PRIu64, ctx->header.indexOffset); @@ -373,8 +373,8 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) entry->dataType, entry->offset); } - bool found_user_data_ddt = false; - ctx->imageInfo.ImageSize = 0; + bool found_user_data_ddt = false; + ctx->image_info.ImageSize = 0; for(i = 0; i < utarray_len(index_entries); i++) { IndexEntry *entry = utarray_eltptr(index_entries, i); @@ -486,43 +486,43 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size) return NULL; } - ctx->imageInfo.CreationTime = ctx->header.creationTime; - ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime; - ctx->imageInfo.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType); + ctx->image_info.CreationTime = ctx->header.creationTime; + ctx->image_info.LastModificationTime = ctx->header.lastWrittenTime; + ctx->image_info.MetadataMediaType = aaruf_get_xml_mediatype(ctx->header.mediaType); - if(ctx->geometryBlock.identifier != GeometryBlock && ctx->imageInfo.MetadataMediaType == BlockMedia) + if(ctx->geometry_block.identifier != GeometryBlock && ctx->image_info.MetadataMediaType == BlockMedia) { - ctx->Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63); - ctx->Heads = 16; - ctx->SectorsPerTrack = 63; + ctx->cylinders = (uint32_t)(ctx->image_info.Sectors / 16 / 63); + ctx->heads = 16; + ctx->sectors_per_track = 63; } // Initialize caches TRACE("Initializing caches"); - ctx->blockHeaderCache.cache = NULL; - ctx->blockCache.cache = NULL; + ctx->block_header_cache.cache = NULL; + ctx->block_cache.cache = NULL; - const uint64_t cache_divisor = (uint64_t)ctx->imageInfo.SectorSize * (1ULL << ctx->shift); + const uint64_t cache_divisor = (uint64_t)ctx->image_info.SectorSize * (1ULL << ctx->shift); if(cache_divisor == 0) { - ctx->blockHeaderCache.max_items = 0; - ctx->blockCache.max_items = 0; + ctx->block_header_cache.max_items = 0; + ctx->block_cache.max_items = 0; } else { - ctx->blockHeaderCache.max_items = MAX_CACHE_SIZE / cache_divisor; - ctx->blockCache.max_items = ctx->blockHeaderCache.max_items; + ctx->block_header_cache.max_items = MAX_CACHE_SIZE / cache_divisor; + ctx->block_cache.max_items = ctx->block_header_cache.max_items; } // TODO: Cache tracks and sessions? // Initialize ECC for Compact Disc TRACE("Initializing ECC for Compact Disc"); - ctx->eccCdContext = (CdEccContext *)aaruf_ecc_cd_init(); + ctx->ecc_cd_context = (CdEccContext *)aaruf_ecc_cd_init(); - ctx->magic = AARU_MAGIC; - ctx->libraryMajorVersion = LIBAARUFORMAT_MAJOR_VERSION; - ctx->libraryMinorVersion = LIBAARUFORMAT_MINOR_VERSION; + ctx->magic = AARU_MAGIC; + ctx->library_major_version = LIBAARUFORMAT_MAJOR_VERSION; + ctx->library_minor_version = LIBAARUFORMAT_MINOR_VERSION; TRACE("Exiting aaruf_open() = %p", ctx); return ctx; diff --git a/src/read.c b/src/read.c index 991460d..575704e 100644 --- a/src/read.c +++ b/src/read.c @@ -104,7 +104,7 @@ int32_t aaruf_read_media_tag(void *context, uint8_t *data, const int32_t tag, ui return AARUF_ERROR_INCORRECT_DATA_SIZE; } - const aaruformatContext *ctx = context; + const aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -254,17 +254,17 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg TRACE("Entering aaruf_read_sector(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, negative, data, initial_length); - aaruformatContext *ctx = NULL; - uint64_t offset = 0; - uint64_t block_offset = 0; - BlockHeader *block_header = NULL; - uint8_t *block = NULL; - size_t read_bytes = 0; - uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH]; - size_t lzma_size = 0; - uint8_t *cmp_data = NULL; - int error_no = 0; - uint8_t sector_status = 0; + aaruformat_context *ctx = NULL; + uint64_t offset = 0; + uint64_t block_offset = 0; + BlockHeader *block_header = NULL; + uint8_t *block = NULL; + size_t read_bytes = 0; + uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH]; + size_t lzma_size = 0; + uint8_t *cmp_data = NULL; + int error_no = 0; + uint8_t sector_status = 0; if(context == NULL) { @@ -293,7 +293,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg return AARUF_ERROR_NOT_AARUFORMAT; } - if(negative && sector_address > ctx->userDataDdtHeader.negative - 1) + if(negative && sector_address > ctx->user_data_ddt_header.negative - 1) { FATAL("Sector address out of bounds"); @@ -301,7 +301,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS; } - if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1) + if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1) { FATAL("Sector address out of bounds"); @@ -309,7 +309,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS; } - if(ctx->ddtVersion == 1) + if(ctx->ddt_version == 1) { if(negative) { @@ -319,7 +319,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg error_no = decode_ddt_entry_v1(ctx, sector_address, &offset, &block_offset, §or_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, §or_status); if(error_no != AARUF_STATUS_OK) @@ -333,7 +333,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg // Partially written image... as we can't know the real sector size just assume it's common :/ if(sector_status == SectorStatusNotDumped) { - *length = ctx->imageInfo.SectorSize; + *length = ctx->image_info.SectorSize; TRACE("Exiting aaruf_read_sector() = AARUF_STATUS_SECTOR_NOT_DUMPED"); return AARUF_STATUS_SECTOR_NOT_DUMPED; @@ -341,7 +341,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg // Check if block header is cached TRACE("Checking if block header is cached"); - block_header = find_in_cache_uint64(&ctx->blockHeaderCache, block_offset); + block_header = find_in_cache_uint64(&ctx->block_header_cache, block_offset); // Read block header if(block_header == NULL) @@ -378,7 +378,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg } TRACE("Adding block header to cache"); - add_to_cache_uint64(&ctx->blockHeaderCache, block_offset, block_header); + add_to_cache_uint64(&ctx->block_header_cache, block_offset, block_header); } else if(fseek(ctx->imageStream, block_offset + sizeof(BlockHeader), SEEK_SET) != 0) { @@ -399,7 +399,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg // Check if block is cached TRACE("Checking if block is cached"); - block = find_in_cache_uint64(&ctx->blockCache, block_offset); + block = find_in_cache_uint64(&ctx->block_cache, block_offset); if(block != NULL) { @@ -582,7 +582,7 @@ int32_t aaruf_read_sector(void *context, const uint64_t sector_address, bool neg // Add block to cache TRACE("Adding block to cache"); - add_to_cache_uint64(&ctx->blockCache, block_offset, block); + add_to_cache_uint64(&ctx->block_cache, block_offset, block); memcpy(data, block + offset * block_header->sectorSize, block_header->sectorSize); *length = block_header->sectorSize; @@ -676,7 +676,7 @@ int32_t aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sec return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; if(length == NULL) { @@ -695,7 +695,7 @@ int32_t aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sec return AARUF_ERROR_NOT_AARUFORMAT; } - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Incorrect media type %d, expected OpticalDisc", ctx->imageInfo.XmlMediaType); @@ -703,9 +703,9 @@ int32_t aaruf_read_track_sector(void *context, uint8_t *data, const uint64_t sec return AARUF_ERROR_INCORRECT_MEDIA_TYPE; } - for(int i = 0; i < ctx->numberOfDataTracks; i++) - if(ctx->dataTracks[i].sequence == track) - return aaruf_read_sector(context, ctx->dataTracks[i].start + sector_address, false, data, length); + for(int i = 0; i < ctx->number_of_data_tracks; i++) + if(ctx->data_tracks[i].sequence == track) + return aaruf_read_sector(context, ctx->data_tracks[i].start + sector_address, false, data, length); TRACE("Track %d not found", track); TRACE("Exiting aaruf_read_track_sector() = AARUF_ERROR_TRACK_NOT_FOUND"); @@ -820,15 +820,15 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo TRACE("Entering aaruf_read_sector_long(%p, %" PRIu64 ", %d, %p, %u)", context, sector_address, data, initial_length); - const aaruformatContext *ctx = NULL; - uint32_t bare_length = 0; - uint32_t tag_length = 0; - uint8_t *bare_data = NULL; - int32_t res = 0; - int32_t query_status; - TrackEntry trk; - int i = 0; - bool trk_found = false; + const aaruformat_context *ctx = NULL; + uint32_t bare_length = 0; + uint32_t tag_length = 0; + uint8_t *bare_data = NULL; + int32_t res = 0; + int32_t query_status; + TrackEntry trk; + int i = 0; + bool trk_found = false; if(context == NULL) { @@ -857,7 +857,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo return AARUF_ERROR_NOT_AARUFORMAT; } - if(negative && sector_address > ctx->userDataDdtHeader.negative - 1) + if(negative && sector_address > ctx->user_data_ddt_header.negative - 1) { FATAL("Sector address out of bounds"); @@ -865,7 +865,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS; } - if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1) + if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1) { FATAL("Sector address out of bounds"); @@ -877,21 +877,21 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo // Calculate positive or negative sector if(negative) - corrected_sector_address -= ctx->userDataDdtHeader.negative; + corrected_sector_address -= ctx->user_data_ddt_header.negative; else - corrected_sector_address += ctx->userDataDdtHeader.negative; + corrected_sector_address += ctx->user_data_ddt_header.negative; - switch(ctx->imageInfo.MetadataMediaType) + switch(ctx->image_info.MetadataMediaType) { case OpticalDisc: - if(ctx->imageInfo.MediaType == DVDROM || ctx->imageInfo.MediaType == PS2DVD || - ctx->imageInfo.MediaType == SACD || ctx->imageInfo.MediaType == PS3DVD || - ctx->imageInfo.MediaType == DVDR || ctx->imageInfo.MediaType == DVDRW || - ctx->imageInfo.MediaType == DVDPR || ctx->imageInfo.MediaType == DVDPRW || - ctx->imageInfo.MediaType == DVDPRWDL || ctx->imageInfo.MediaType == DVDRDL || - ctx->imageInfo.MediaType == DVDPRDL || ctx->imageInfo.MediaType == DVDRAM || - ctx->imageInfo.MediaType == DVDRWDL || ctx->imageInfo.MediaType == DVDDownload || - ctx->imageInfo.MediaType == Nuon) + if(ctx->image_info.MediaType == DVDROM || ctx->image_info.MediaType == PS2DVD || + ctx->image_info.MediaType == SACD || ctx->image_info.MediaType == PS3DVD || + ctx->image_info.MediaType == DVDR || ctx->image_info.MediaType == DVDRW || + ctx->image_info.MediaType == DVDPR || ctx->image_info.MediaType == DVDPRW || + ctx->image_info.MediaType == DVDPRWDL || ctx->image_info.MediaType == DVDRDL || + ctx->image_info.MediaType == DVDPRDL || ctx->image_info.MediaType == DVDRAM || + ctx->image_info.MediaType == DVDRWDL || ctx->image_info.MediaType == DVDDownload || + ctx->image_info.MediaType == Nuon) { if(ctx->sector_id == NULL || ctx->sector_ied == NULL || ctx->sector_cpr_mai == NULL || ctx->sector_edc == NULL) @@ -967,7 +967,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo } if((ctx->sector_suffix == NULL || ctx->sector_prefix == NULL) && - (ctx->sectorSuffixCorrected == NULL || ctx->sectorPrefixCorrected == NULL)) + (ctx->sector_suffix_corrected == NULL || ctx->sector_prefix_corrected == NULL)) return aaruf_read_sector(context, sector_address, negative, data, length); bare_length = 0; @@ -1010,11 +1010,11 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo trk_found = false; - for(i = 0; i < ctx->numberOfDataTracks; i++) - if(sector_address >= ctx->dataTracks[i].start && sector_address <= ctx->dataTracks[i].end) + for(i = 0; i < ctx->number_of_data_tracks; i++) + if(sector_address >= ctx->data_tracks[i].start && sector_address <= ctx->data_tracks[i].end) { trk_found = true; - trk = ctx->dataTracks[i]; + trk = ctx->data_tracks[i]; break; } @@ -1040,19 +1040,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo if(ctx->sector_prefix != NULL) memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16); - else if(ctx->sectorPrefixDdt != NULL) + else if(ctx->sector_prefix_ddt != NULL) { - if((ctx->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == Correct) + if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct) { aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address); res = AARUF_STATUS_OK; } - else if((ctx->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) + else if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) res = AARUF_STATUS_SECTOR_NOT_DUMPED; else memcpy(data, - ctx->sectorPrefixCorrected + - ((ctx->sectorPrefixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16, + ctx->sector_prefix_corrected + + ((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16, 16); } else @@ -1071,19 +1071,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo if(ctx->sector_suffix != NULL) memcpy(data + 2064, ctx->sector_suffix + corrected_sector_address * 288, 288); - else if(ctx->sectorSuffixDdt != NULL) + else if(ctx->sector_suffix_ddt != NULL) { - if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Correct) + if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct) { - aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, trk.type); + aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, trk.type); res = AARUF_STATUS_OK; } - else if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) + else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) res = AARUF_STATUS_SECTOR_NOT_DUMPED; else memcpy(data + 2064, - ctx->sectorSuffixCorrected + - ((ctx->sectorSuffixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288, + ctx->sector_suffix_corrected + + ((ctx->sector_suffix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 288, 288); } else @@ -1101,19 +1101,19 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo case CdMode2Form2: if(ctx->sector_prefix != NULL) memcpy(data, ctx->sector_prefix + corrected_sector_address * 16, 16); - else if(ctx->sectorPrefixDdt != NULL) + else if(ctx->sector_prefix_ddt != NULL) { - if((ctx->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == Correct) + if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Correct) { aaruf_ecc_cd_reconstruct_prefix(data, trk.type, sector_address); res = AARUF_STATUS_OK; } - else if((ctx->sectorPrefixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) + else if((ctx->sector_prefix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) res = AARUF_STATUS_SECTOR_NOT_DUMPED; else memcpy(data, - ctx->sectorPrefixCorrected + - ((ctx->sectorPrefixDdt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16, + ctx->sector_prefix_corrected + + ((ctx->sector_prefix_ddt[corrected_sector_address] & CD_DFIX_MASK) - 1) * 16, 16); } else @@ -1130,23 +1130,23 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo return res; } - if(ctx->mode2_subheaders != NULL && ctx->sectorSuffixDdt != NULL) + if(ctx->mode2_subheaders != NULL && ctx->sector_suffix_ddt != NULL) { memcpy(data + 16, ctx->mode2_subheaders + corrected_sector_address * 8, 8); - if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form1Ok) + if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form1Ok) { memcpy(data + 24, bare_data, 2048); - aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, CdMode2Form1); + aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form1); } - else if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok || - (ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2NoCrc) + else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok || + (ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2NoCrc) { memcpy(data + 24, bare_data, 2324); - if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok) - aaruf_ecc_cd_reconstruct(ctx->eccCdContext, data, CdMode2Form2); + if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == Mode2Form2Ok) + aaruf_ecc_cd_reconstruct(ctx->ecc_cd_context, data, CdMode2Form2); } - else if((ctx->sectorSuffixDdt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) + else if((ctx->sector_suffix_ddt[corrected_sector_address] & CD_XFIX_MASK) == NotDumped) res = AARUF_STATUS_SECTOR_NOT_DUMPED; else // Mode 2 where ECC failed @@ -1171,7 +1171,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo return AARUF_ERROR_INVALID_TRACK_FORMAT; } case BlockMedia: - switch(ctx->imageInfo.MediaType) + switch(ctx->image_info.MediaType) { case AppleFileWare: case AppleProfile: @@ -1182,7 +1182,7 @@ int32_t aaruf_read_sector_long(void *context, const uint64_t sector_address, boo if(ctx->sector_subchannel == NULL) return aaruf_read_sector(context, sector_address, negative, data, length); - switch(ctx->imageInfo.MediaType) + switch(ctx->image_info.MediaType) { case AppleFileWare: case AppleProfile: @@ -1394,7 +1394,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Entering aaruf_read_sector_tag(%p, %" PRIu64 ", %d, %p, %u, %d)", context, sector_address, negative, buffer, initial_length, tag); - const aaruformatContext *ctx = NULL; + const aaruformat_context *ctx = NULL; if(context == NULL) { @@ -1423,7 +1423,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address return AARUF_ERROR_NOT_AARUFORMAT; } - if(negative && sector_address > ctx->userDataDdtHeader.negative - 1) + if(negative && sector_address > ctx->user_data_ddt_header.negative - 1) { FATAL("Sector address out of bounds"); @@ -1431,7 +1431,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS; } - if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1) + if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1) { FATAL("Sector address out of bounds"); @@ -1443,14 +1443,14 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address // Calculate positive or negative sector if(negative) - corrected_sector_address -= ctx->userDataDdtHeader.negative; + corrected_sector_address -= ctx->user_data_ddt_header.negative; else - corrected_sector_address += ctx->userDataDdtHeader.negative; + corrected_sector_address += ctx->user_data_ddt_header.negative; switch(tag) { case CdTrackFlags: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1465,10 +1465,10 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address return AARUF_ERROR_INCORRECT_DATA_SIZE; } - for(int i = 0; i < ctx->tracksHeader.entries; i++) - if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) + for(int i = 0; i < ctx->tracks_header.entries; i++) + if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end) { - buffer[0] = ctx->trackEntries[i].flags; + buffer[0] = ctx->track_entries[i].flags; TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; } @@ -1476,7 +1476,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address FATAL("Track not found"); return AARUF_ERROR_TRACK_NOT_FOUND; case CdTrackIsrc: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1491,10 +1491,10 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address return AARUF_ERROR_INCORRECT_DATA_SIZE; } - for(int i = 0; i < ctx->tracksHeader.entries; i++) - if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) + for(int i = 0; i < ctx->tracks_header.entries; i++) + if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end) { - memcpy(buffer, ctx->trackEntries[i].isrc, 12); + memcpy(buffer, ctx->track_entries[i].isrc, 12); TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; } @@ -1502,7 +1502,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address FATAL("Track not found"); return AARUF_ERROR_TRACK_NOT_FOUND; case CdSectorSubchannel: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1528,7 +1528,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdCmi: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1554,7 +1554,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorInformation: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1580,7 +1580,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorNumber: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1606,7 +1606,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorIed: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1632,7 +1632,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorEdc: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1658,7 +1658,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdTitleKeyDecrypted: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1684,7 +1684,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case AppleSonyTag: - if(ctx->imageInfo.MetadataMediaType != BlockMedia) + if(ctx->image_info.MetadataMediaType != BlockMedia) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1710,7 +1710,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case AppleProfileTag: - if(ctx->imageInfo.MetadataMediaType != BlockMedia) + if(ctx->image_info.MetadataMediaType != BlockMedia) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -1736,7 +1736,7 @@ int32_t aaruf_read_sector_tag(const void *context, const uint64_t sector_address TRACE("Exiting aaruf_read_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case PriamDataTowerTag: - if(ctx->imageInfo.MetadataMediaType != BlockMedia) + if(ctx->image_info.MetadataMediaType != BlockMedia) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_read_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); diff --git a/src/verify.c b/src/verify.c index 5407d2e..9bb7813 100644 --- a/src/verify.c +++ b/src/verify.c @@ -131,18 +131,18 @@ int32_t aaruf_verify_image(void *context) { TRACE("Entering aaruf_verify_image(%p)", context); - aaruformatContext *ctx = NULL; - uint64_t crc64 = 0; - size_t read_bytes = 0; - void *buffer = NULL; - crc64_ctx *crc64_context = NULL; - BlockHeader block_header; - DdtHeader ddt_header; - DdtHeader2 ddt2_header; - TracksHeader tracks_header; - uint32_t signature = 0; - UT_array *index_entries = NULL; - int32_t status = AARUF_STATUS_OK; + aaruformat_context *ctx = NULL; + uint64_t crc64 = 0; + size_t read_bytes = 0; + void *buffer = NULL; + crc64_ctx *crc64_context = NULL; + BlockHeader block_header; + DdtHeader ddt_header; + DdtHeader2 ddt2_header; + TracksHeader tracks_header; + uint32_t signature = 0; + UT_array *index_entries = NULL; + int32_t status = AARUF_STATUS_OK; if(context == NULL) { diff --git a/src/write.c b/src/write.c index fb873f9..8ec38f9 100644 --- a/src/write.c +++ b/src/write.c @@ -110,7 +110,7 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -122,7 +122,7 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -130,7 +130,7 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative return AARUF_READ_ONLY; } - 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"); @@ -138,7 +138,7 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative 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"); @@ -169,26 +169,26 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative } // Calculate MD5 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_md5 && !negative && sector_address <= ctx->imageInfo.Sectors && !ctx->writingLong) + if(ctx->calculating_md5 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long) aaruf_md5_update(&ctx->md5_context, data, length); // Calculate SHA1 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_sha1 && !negative && sector_address <= ctx->imageInfo.Sectors && !ctx->writingLong) + if(ctx->calculating_sha1 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long) aaruf_sha1_update(&ctx->sha1_context, data, length); // Calculate SHA256 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_sha256 && !negative && sector_address <= ctx->imageInfo.Sectors && !ctx->writingLong) + if(ctx->calculating_sha256 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long) aaruf_sha256_update(&ctx->sha256_context, data, length); // Calculate SpamSum on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_spamsum && !negative && sector_address <= ctx->imageInfo.Sectors && !ctx->writingLong) + if(ctx->calculating_spamsum && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long) aaruf_spamsum_update(ctx->spamsum_context, data, length); // Calculate BLAKE3 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_blake3 && !negative && sector_address <= ctx->imageInfo.Sectors && !ctx->writingLong) + if(ctx->calculating_blake3 && !negative && sector_address <= ctx->image_info.Sectors && !ctx->writing_long) blake3_hasher_update(ctx->blake3_context, data, length); // Close current block first - if(ctx->writingBuffer != NULL && + if(ctx->writing_buffer != NULL && // When sector size changes or block reaches maximum size - (ctx->currentBlockHeader.sectorSize != length || - ctx->currentBlockOffset == 1 << ctx->userDataDdtHeader.dataShift)) + (ctx->current_block_header.sectorSize != length || + ctx->current_block_offset == 1 << ctx->user_data_ddt_header.dataShift)) { TRACE("Closing current block before writing new data"); int error = aaruf_close_current_block(ctx); @@ -212,10 +212,10 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative uint64_t hash = XXH3_64bits(data, length); // Check if the hash is already in the map - bool existing = lookup_map(ctx->sectorHashMap, hash, &ddt_entry); + bool existing = lookup_map(ctx->sector_hash_map, hash, &ddt_entry); TRACE("Block does %s exist in deduplication map", existing ? "already" : "not yet"); - ddt_ok = set_ddt_entry_v2(ctx, sector_address, negative, ctx->currentBlockOffset, ctx->nextBlockPosition, + ddt_ok = set_ddt_entry_v2(ctx, sector_address, negative, ctx->current_block_offset, ctx->next_block_position, sector_status, &ddt_entry); if(!ddt_ok) { @@ -231,10 +231,10 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative } TRACE("Inserting sector hash into deduplication map, proceeding to write into image as normal"); - insert_map(ctx->sectorHashMap, hash, ddt_entry); + insert_map(ctx->sector_hash_map, hash, ddt_entry); } else - ddt_ok = set_ddt_entry_v2(ctx, sector_address, negative, ctx->currentBlockOffset, ctx->nextBlockPosition, + ddt_ok = set_ddt_entry_v2(ctx, sector_address, negative, ctx->current_block_offset, ctx->next_block_position, sector_status, &ddt_entry); if(!ddt_ok) @@ -244,66 +244,66 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative } // No block set - if(ctx->writingBufferPosition == 0) + if(ctx->writing_buffer_position == 0) { TRACE("Creating new writing block"); - ctx->currentBlockHeader.identifier = DataBlock; - ctx->currentBlockHeader.type = UserData; - ctx->currentBlockHeader.sectorSize = length; + ctx->current_block_header.identifier = DataBlock; + ctx->current_block_header.type = UserData; + ctx->current_block_header.sectorSize = length; // We need to save the track type for later compression - if(ctx->imageInfo.MetadataMediaType == OpticalDisc && ctx->trackEntries != NULL) + if(ctx->image_info.MetadataMediaType == OpticalDisc && ctx->track_entries != NULL) { const TrackEntry *track = NULL; - for(int i = 0; i < ctx->tracksHeader.entries; i++) - if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) + for(int i = 0; i < ctx->tracks_header.entries; i++) + if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end) { - track = &ctx->trackEntries[i]; + track = &ctx->track_entries[i]; break; } if(track != NULL) { - ctx->currentTrackType = track->type; + ctx->current_track_type = track->type; - if(track->sequence == 0 && track->start == 0 && track->end == 0) ctx->currentTrackType = Data; + if(track->sequence == 0 && track->start == 0 && track->end == 0) ctx->current_track_type = Data; } else - ctx->currentTrackType = Data; + ctx->current_track_type = Data; - if(ctx->currentTrackType == Audio && + if(ctx->current_track_type == Audio && // JaguarCD stores data in audio tracks. FLAC is too inefficient, we need to use LZMA as data. - (ctx->imageInfo.MediaType == JaguarCD && track->session > 1 || + (ctx->image_info.MediaType == JaguarCD && track->session > 1 || // VideoNow stores video in audio tracks, and LZMA works better too. - ctx->imageInfo.MediaType == VideoNow || ctx->imageInfo.MediaType == VideoNowColor || - ctx->imageInfo.MediaType == VideoNowXp)) - ctx->currentTrackType = Data; + ctx->image_info.MediaType == VideoNow || ctx->image_info.MediaType == VideoNowColor || + ctx->image_info.MediaType == VideoNowXp)) + ctx->current_track_type = Data; if(ctx->compression_enabled) { - if(ctx->currentTrackType == Audio) - ctx->currentBlockHeader.compression = Flac; + if(ctx->current_track_type == Audio) + ctx->current_block_header.compression = Flac; else - ctx->currentBlockHeader.compression = Lzma; + ctx->current_block_header.compression = Lzma; } else - ctx->currentBlockHeader.compression = None; + ctx->current_block_header.compression = None; } else { - ctx->currentTrackType = Data; + ctx->current_track_type = Data; if(ctx->compression_enabled) - ctx->currentBlockHeader.compression = Lzma; + ctx->current_block_header.compression = Lzma; else - ctx->currentBlockHeader.compression = None; + ctx->current_block_header.compression = None; } - uint32_t max_buffer_size = (1 << ctx->userDataDdtHeader.dataShift) * ctx->currentBlockHeader.sectorSize; + uint32_t max_buffer_size = (1 << ctx->user_data_ddt_header.dataShift) * ctx->current_block_header.sectorSize; TRACE("Setting max buffer size to %u bytes", max_buffer_size); TRACE("Allocating memory for writing buffer"); - ctx->writingBuffer = (uint8_t *)calloc(1, max_buffer_size); - if(ctx->writingBuffer == NULL) + ctx->writing_buffer = (uint8_t *)calloc(1, max_buffer_size); + if(ctx->writing_buffer == NULL) { FATAL("Could not allocate memory"); @@ -312,12 +312,12 @@ int32_t aaruf_write_sector(void *context, uint64_t sector_address, bool negative } } - TRACE("Copying data to writing buffer at position %zu", ctx->writingBufferPosition); - memcpy(ctx->writingBuffer + ctx->writingBufferPosition, data, length); - TRACE("Advancing writing buffer position to %zu", ctx->writingBufferPosition + length); - ctx->writingBufferPosition += length; - TRACE("Advancing current block offset to %zu", ctx->currentBlockOffset + 1); - ctx->currentBlockOffset++; + TRACE("Copying data to writing buffer at position %zu", ctx->writing_buffer_position); + memcpy(ctx->writing_buffer + ctx->writing_buffer_position, data, length); + TRACE("Advancing writing buffer position to %zu", ctx->writing_buffer_position + length); + ctx->writing_buffer_position += length; + TRACE("Advancing current block offset to %zu", ctx->current_block_offset + 1); + ctx->current_block_offset++; TRACE("Exiting aaruf_write_sector() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; @@ -544,7 +544,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -556,7 +556,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -564,7 +564,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg return AARUF_READ_ONLY; } - 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"); @@ -572,7 +572,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS; } - if(!negative && sector_address > ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow - 1) + if(!negative && sector_address > ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow - 1) { FATAL("Sector address out of bounds"); @@ -580,15 +580,15 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg return AARUF_ERROR_SECTOR_OUT_OF_BOUNDS; } - switch(ctx->imageInfo.MetadataMediaType) + switch(ctx->image_info.MetadataMediaType) { case OpticalDisc: TrackEntry track = {0}; - for(int i = 0; i < ctx->tracksHeader.entries; i++) - if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) + for(int i = 0; i < ctx->tracks_header.entries; i++) + if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end) { - track = ctx->trackEntries[i]; + track = ctx->track_entries[i]; break; } @@ -598,22 +598,22 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg // Calculate positive or negative sector if(negative) - corrected_sector_address -= ctx->userDataDdtHeader.negative; + corrected_sector_address -= ctx->user_data_ddt_header.negative; else - corrected_sector_address += ctx->userDataDdtHeader.negative; + corrected_sector_address += ctx->user_data_ddt_header.negative; uint64_t total_sectors = - ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow; + ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow; // DVD long sector - if(length == 2064 && (ctx->imageInfo.MediaType == DVDROM || ctx->imageInfo.MediaType == PS2DVD || - ctx->imageInfo.MediaType == SACD || ctx->imageInfo.MediaType == PS3DVD || - ctx->imageInfo.MediaType == DVDR || ctx->imageInfo.MediaType == DVDRW || - ctx->imageInfo.MediaType == DVDPR || ctx->imageInfo.MediaType == DVDPRW || - ctx->imageInfo.MediaType == DVDPRWDL || ctx->imageInfo.MediaType == DVDRDL || - ctx->imageInfo.MediaType == DVDPRDL || ctx->imageInfo.MediaType == DVDRAM || - ctx->imageInfo.MediaType == DVDRWDL || ctx->imageInfo.MediaType == DVDDownload || - ctx->imageInfo.MediaType == Nuon)) + if(length == 2064 && (ctx->image_info.MediaType == DVDROM || ctx->image_info.MediaType == PS2DVD || + ctx->image_info.MediaType == SACD || ctx->image_info.MediaType == PS3DVD || + ctx->image_info.MediaType == DVDR || ctx->image_info.MediaType == DVDRW || + ctx->image_info.MediaType == DVDPR || ctx->image_info.MediaType == DVDPRW || + ctx->image_info.MediaType == DVDPRWDL || ctx->image_info.MediaType == DVDRDL || + ctx->image_info.MediaType == DVDPRDL || ctx->image_info.MediaType == DVDRAM || + ctx->image_info.MediaType == DVDRWDL || ctx->image_info.MediaType == DVDDownload || + ctx->image_info.MediaType == Nuon)) { if(ctx->sector_id == NULL) ctx->sector_id = calloc(1, 4 * total_sectors); if(ctx->sector_ied == NULL) ctx->sector_ied = calloc(1, 2 * total_sectors); @@ -635,7 +635,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg return AARUF_ERROR_INCORRECT_DATA_SIZE; } - ctx->writingLong = true; + ctx->writing_long = true; if(!ctx->rewinded) { @@ -660,19 +660,19 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg } // Calculate MD5 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_md5 && !negative && sector_address <= ctx->imageInfo.Sectors) + if(ctx->calculating_md5 && !negative && sector_address <= ctx->image_info.Sectors) aaruf_md5_update(&ctx->md5_context, data, length); // Calculate SHA1 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_sha1 && !negative && sector_address <= ctx->imageInfo.Sectors) + if(ctx->calculating_sha1 && !negative && sector_address <= ctx->image_info.Sectors) aaruf_sha1_update(&ctx->sha1_context, data, length); // Calculate SHA256 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_sha256 && !negative && sector_address <= ctx->imageInfo.Sectors) + if(ctx->calculating_sha256 && !negative && sector_address <= ctx->image_info.Sectors) aaruf_sha256_update(&ctx->sha256_context, data, length); // Calculate SpamSum on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_spamsum && !negative && sector_address <= ctx->imageInfo.Sectors) + if(ctx->calculating_spamsum && !negative && sector_address <= ctx->image_info.Sectors) aaruf_spamsum_update(ctx->spamsum_context, data, length); // Calculate BLAKE3 on-the-fly if requested and sector is within user sectors (not negative or overflow) - if(ctx->calculating_blake3 && !negative && sector_address <= ctx->imageInfo.Sectors) + if(ctx->calculating_blake3 && !negative && sector_address <= ctx->image_info.Sectors) blake3_hasher_update(ctx->blake3_context, data, length); bool prefix_correct; @@ -686,13 +686,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg case CdMode1: // If we do not have a DDT V2 for sector prefix, create one - if(ctx->sectorPrefixDdt2 == NULL) + if(ctx->sector_prefix_ddt2 == NULL) { - ctx->sectorPrefixDdt2 = - calloc(1, sizeof(uint32_t) * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow)); + ctx->sector_prefix_ddt2 = + calloc(1, sizeof(uint32_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow)); - if(ctx->sectorPrefixDdt2 == NULL) + if(ctx->sector_prefix_ddt2 == NULL) { FATAL("Could not allocate memory for CD sector prefix DDT"); @@ -702,13 +702,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg } // If we do not have a DDT V2 for sector suffix, create one - if(ctx->sectorSuffixDdt2 == NULL) + if(ctx->sector_suffix_ddt2 == NULL) { - ctx->sectorSuffixDdt2 = - calloc(1, sizeof(uint32_t) * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow)); + ctx->sector_suffix_ddt2 = + calloc(1, sizeof(uint32_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow)); - if(ctx->sectorSuffixDdt2 == NULL) + if(ctx->sector_suffix_ddt2 == NULL) { FATAL("Could not allocate memory for CD sector prefix DDT"); @@ -719,8 +719,8 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(ctx->sector_prefix == NULL) { - ctx->sector_prefix_length = 16 * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow); + ctx->sector_prefix_length = 16 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow); ctx->sector_prefix = malloc(ctx->sector_prefix_length); if(ctx->sector_prefix == NULL) @@ -734,9 +734,10 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(ctx->sector_suffix == NULL) { - ctx->sector_suffix_length = 288 * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow); - ctx->sector_suffix = malloc(ctx->sector_suffix_length); + ctx->sector_suffix_length = + 288 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow); + ctx->sector_suffix = malloc(ctx->sector_suffix_length); if(ctx->sector_suffix == NULL) { @@ -758,8 +759,8 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(empty) { - ctx->sectorPrefixDdt2[corrected_sector_address] = SectorStatusNotDumped; - ctx->sectorSuffixDdt2[corrected_sector_address] = SectorStatusNotDumped; + ctx->sector_prefix_ddt2[corrected_sector_address] = SectorStatusNotDumped; + ctx->sector_suffix_ddt2[corrected_sector_address] = SectorStatusNotDumped; return aaruf_write_sector(context, sector_address, negative, data + 16, SectorStatusNotDumped, 2048); } @@ -782,13 +783,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg } if(prefix_correct) - ctx->sectorPrefixDdt2[corrected_sector_address] = SectorStatusMode1Correct << 28; + ctx->sector_prefix_ddt2[corrected_sector_address] = SectorStatusMode1Correct << 28; else { // Copy CD prefix from data buffer to prefix buffer memcpy(ctx->sector_prefix + ctx->sector_prefix_offset, data, 16); - ctx->sectorPrefixDdt2[corrected_sector_address] = (uint32_t)(ctx->sector_prefix_offset / 16); - ctx->sectorPrefixDdt2[corrected_sector_address] |= SectorStatusErrored << 28; + ctx->sector_prefix_ddt2[corrected_sector_address] = (uint32_t)(ctx->sector_prefix_offset / 16); + ctx->sector_prefix_ddt2[corrected_sector_address] |= SectorStatusErrored << 28; ctx->sector_prefix_offset += 16; // Grow prefix buffer if needed @@ -810,13 +811,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg const bool suffix_correct = aaruf_ecc_cd_is_suffix_correct(context, data); if(suffix_correct) - ctx->sectorSuffixDdt2[corrected_sector_address] = SectorStatusMode1Correct << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] = SectorStatusMode1Correct << 28; else { // Copy CD suffix from data buffer to suffix buffer memcpy(ctx->sector_suffix + ctx->sector_suffix_offset, data + 2064, 288); - ctx->sectorSuffixDdt2[corrected_sector_address] = (uint32_t)(ctx->sector_suffix_offset / 288); - ctx->sectorSuffixDdt2[corrected_sector_address] |= SectorStatusErrored << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] = (uint32_t)(ctx->sector_suffix_offset / 288); + ctx->sector_suffix_ddt2[corrected_sector_address] |= SectorStatusErrored << 28; ctx->sector_suffix_offset += 288; // Grow suffix buffer if needed @@ -841,13 +842,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg case CdMode2Form2: case CdMode2Formless: // If we do not have a DDT V2 for sector prefix, create one - if(ctx->sectorPrefixDdt2 == NULL) + if(ctx->sector_prefix_ddt2 == NULL) { - ctx->sectorPrefixDdt2 = - calloc(1, sizeof(uint32_t) * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow)); + ctx->sector_prefix_ddt2 = + calloc(1, sizeof(uint32_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow)); - if(ctx->sectorPrefixDdt2 == NULL) + if(ctx->sector_prefix_ddt2 == NULL) { FATAL("Could not allocate memory for CD sector prefix DDT"); @@ -857,13 +858,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg } // If we do not have a DDT V2 for sector suffix, create one - if(ctx->sectorSuffixDdt2 == NULL) + if(ctx->sector_suffix_ddt2 == NULL) { - ctx->sectorSuffixDdt2 = - calloc(1, sizeof(uint32_t) * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow)); + ctx->sector_suffix_ddt2 = + calloc(1, sizeof(uint32_t) * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow)); - if(ctx->sectorSuffixDdt2 == NULL) + if(ctx->sector_suffix_ddt2 == NULL) { FATAL("Could not allocate memory for CD sector prefix DDT"); @@ -874,8 +875,8 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(ctx->sector_prefix == NULL) { - ctx->sector_prefix_length = 16 * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow); + ctx->sector_prefix_length = 16 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow); ctx->sector_prefix = malloc(ctx->sector_prefix_length); if(ctx->sector_prefix == NULL) @@ -889,9 +890,10 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(ctx->sector_suffix == NULL) { - ctx->sector_suffix_length = 288 * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow); - ctx->sector_suffix = malloc(ctx->sector_suffix_length); + ctx->sector_suffix_length = + 288 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow); + ctx->sector_suffix = malloc(ctx->sector_suffix_length); if(ctx->sector_suffix == NULL) { @@ -913,8 +915,8 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(empty) { - ctx->sectorPrefixDdt2[corrected_sector_address] = SectorStatusNotDumped; - ctx->sectorSuffixDdt2[corrected_sector_address] = SectorStatusNotDumped; + ctx->sector_prefix_ddt2[corrected_sector_address] = SectorStatusNotDumped; + ctx->sector_suffix_ddt2[corrected_sector_address] = SectorStatusNotDumped; return aaruf_write_sector(context, sector_address, negative, data + 16, SectorStatusNotDumped, 2328); } @@ -939,14 +941,14 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg } if(prefix_correct) - ctx->sectorPrefixDdt2[corrected_sector_address] = + ctx->sector_prefix_ddt2[corrected_sector_address] = (form2 ? SectorStatusMode2Form2Ok : SectorStatusMode2Form1Ok) << 28; else { // Copy CD prefix from data buffer to prefix buffer memcpy(ctx->sector_prefix + ctx->sector_prefix_offset, data, 16); - ctx->sectorPrefixDdt2[corrected_sector_address] = (uint32_t)(ctx->sector_prefix_offset / 16); - ctx->sectorPrefixDdt2[corrected_sector_address] |= SectorStatusErrored << 28; + ctx->sector_prefix_ddt2[corrected_sector_address] = (uint32_t)(ctx->sector_prefix_offset / 16); + ctx->sector_prefix_ddt2[corrected_sector_address] |= SectorStatusErrored << 28; ctx->sector_prefix_offset += 16; // Grow prefix buffer if needed @@ -968,8 +970,8 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(ctx->mode2_subheaders == NULL) { ctx->mode2_subheaders = - calloc(1, 8 * (ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + - ctx->userDataDdtHeader.overflow)); + calloc(1, 8 * (ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + + ctx->user_data_ddt_header.overflow)); if(ctx->mode2_subheaders == NULL) { @@ -988,16 +990,16 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg const bool correct_edc = computed_edc == edc; if(correct_edc) - ctx->sectorSuffixDdt2[corrected_sector_address] = SectorStatusMode2Form2Ok << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] = SectorStatusMode2Form2Ok << 28; else if(edc == 0) - ctx->sectorSuffixDdt2[corrected_sector_address] = SectorStatusMode2Form2NoCrc << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] = SectorStatusMode2Form2NoCrc << 28; else { // Copy CD suffix from data buffer to suffix buffer memcpy(ctx->sector_suffix + ctx->sector_suffix_offset, data + 2348, 4); - ctx->sectorSuffixDdt2[corrected_sector_address] = + ctx->sector_suffix_ddt2[corrected_sector_address] = (uint32_t)(ctx->sector_suffix_offset / 288); - ctx->sectorSuffixDdt2[corrected_sector_address] |= SectorStatusErrored << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] |= SectorStatusErrored << 28; ctx->sector_suffix_offset += 288; // Grow suffix buffer if needed @@ -1032,13 +1034,13 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg const bool correct_edc = computed_edc == edc; if(correct_ecc && correct_edc) - ctx->sectorSuffixDdt2[corrected_sector_address] = SectorStatusMode2Form1Ok << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] = SectorStatusMode2Form1Ok << 28; else { // Copy CD suffix from data buffer to suffix buffer memcpy(ctx->sector_suffix + ctx->sector_suffix_offset, data + 2072, 280); - ctx->sectorSuffixDdt2[corrected_sector_address] = (uint32_t)(ctx->sector_suffix_offset / 288); - ctx->sectorSuffixDdt2[corrected_sector_address] |= SectorStatusErrored << 28; + ctx->sector_suffix_ddt2[corrected_sector_address] = (uint32_t)(ctx->sector_suffix_offset / 288); + ctx->sector_suffix_ddt2[corrected_sector_address] |= SectorStatusErrored << 28; ctx->sector_suffix_offset += 288; // Grow suffix buffer if needed @@ -1066,7 +1068,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg break; case BlockMedia: - switch(ctx->imageInfo.MediaType) + switch(ctx->image_info.MediaType) { case AppleFileWare: case AppleProfile: @@ -1083,19 +1085,20 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg case 12: const sony_tag decoded_sony_tag = bytes_to_sony_tag(data + 512); - if(ctx->imageInfo.MediaType == AppleProfile || ctx->imageInfo.MediaType == AppleFileWare) + if(ctx->image_info.MediaType == AppleProfile || ctx->image_info.MediaType == AppleFileWare) { const profile_tag decoded_profile_tag = sony_tag_to_profile(decoded_sony_tag); newTag = profile_tag_to_bytes(decoded_profile_tag); newTagSize = 20; } - else if(ctx->imageInfo.MediaType == PriamDataTower) + else if(ctx->image_info.MediaType == PriamDataTower) { const priam_tag decoded_priam_tag = sony_tag_to_priam(decoded_sony_tag); newTag = priam_tag_to_bytes(decoded_priam_tag); newTagSize = 24; } - else if(ctx->imageInfo.MediaType == AppleSonyDS || ctx->imageInfo.MediaType == AppleSonySS) + else if(ctx->image_info.MediaType == AppleSonyDS || + ctx->image_info.MediaType == AppleSonySS) { newTag = malloc(12); memcpy(newTag, data + 512, 12); @@ -1106,19 +1109,20 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg case 20: const profile_tag decoded_profile_tag = bytes_to_profile_tag(data + 512); - if(ctx->imageInfo.MediaType == AppleProfile || ctx->imageInfo.MediaType == AppleFileWare) + if(ctx->image_info.MediaType == AppleProfile || ctx->image_info.MediaType == AppleFileWare) { newTag = malloc(20); memcpy(newTag, data + 512, 20); newTagSize = 20; } - else if(ctx->imageInfo.MediaType == PriamDataTower) + else if(ctx->image_info.MediaType == PriamDataTower) { const priam_tag decoded_priam_tag = profile_tag_to_priam(decoded_profile_tag); newTag = priam_tag_to_bytes(decoded_priam_tag); newTagSize = 24; } - else if(ctx->imageInfo.MediaType == AppleSonyDS || ctx->imageInfo.MediaType == AppleSonySS) + else if(ctx->image_info.MediaType == AppleSonyDS || + ctx->image_info.MediaType == AppleSonySS) { const sony_tag decoded_sony_tag = profile_tag_to_sony(decoded_profile_tag); newTag = sony_tag_to_bytes(decoded_sony_tag); @@ -1128,19 +1132,20 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg // Priam tag case 24: const priam_tag decoded_priam_tag = bytes_to_priam_tag(data + 512); - if(ctx->imageInfo.MediaType == AppleProfile || ctx->imageInfo.MediaType == AppleFileWare) + if(ctx->image_info.MediaType == AppleProfile || ctx->image_info.MediaType == AppleFileWare) { const profile_tag decoded_profile_tag = priam_tag_to_profile(decoded_priam_tag); newTag = profile_tag_to_bytes(decoded_profile_tag); newTagSize = 20; } - else if(ctx->imageInfo.MediaType == PriamDataTower) + else if(ctx->image_info.MediaType == PriamDataTower) { newTag = malloc(24); memcpy(newTag, data + 512, 24); newTagSize = 24; } - else if(ctx->imageInfo.MediaType == AppleSonyDS || ctx->imageInfo.MediaType == AppleSonySS) + else if(ctx->image_info.MediaType == AppleSonyDS || + ctx->image_info.MediaType == AppleSonySS) { const sony_tag decoded_sony_tag = priam_tag_to_sony(decoded_priam_tag); newTag = sony_tag_to_bytes(decoded_sony_tag); @@ -1162,7 +1167,7 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg if(ctx->sector_subchannel == NULL) { ctx->sector_subchannel = - calloc(1, newTagSize * (ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow)); + calloc(1, newTagSize * (ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow)); if(ctx->sector_subchannel == NULL) { @@ -1373,38 +1378,38 @@ int32_t aaruf_write_sector_long(void *context, uint64_t sector_address, bool neg * * @internal */ -int32_t aaruf_close_current_block(aaruformatContext *ctx) +int32_t aaruf_close_current_block(aaruformat_context *ctx) { // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) return AARUF_ERROR_NOT_AARUFORMAT; // Check we are writing - if(!ctx->isWriting) return AARUF_READ_ONLY; + if(!ctx->is_writing) return AARUF_READ_ONLY; - ctx->currentBlockHeader.length = ctx->currentBlockOffset * ctx->currentBlockHeader.sectorSize; + ctx->current_block_header.length = ctx->current_block_offset * ctx->current_block_header.sectorSize; TRACE("Initializing CRC64 context"); - ctx->crc64Context = aaruf_crc64_init(); + ctx->crc64_context = aaruf_crc64_init(); TRACE("Updating CRC64"); - aaruf_crc64_update(ctx->crc64Context, ctx->writingBuffer, ctx->currentBlockHeader.length); - aaruf_crc64_final(ctx->crc64Context, &ctx->currentBlockHeader.crc64); + aaruf_crc64_update(ctx->crc64_context, ctx->writing_buffer, ctx->current_block_header.length); + aaruf_crc64_final(ctx->crc64_context, &ctx->current_block_header.crc64); uint8_t lzma_properties[LZMA_PROPERTIES_LENGTH] = {0}; uint8_t *cmp_buffer = NULL; - switch(ctx->currentBlockHeader.compression) + switch(ctx->current_block_header.compression) { case None: break; case Flac: - cmp_buffer = malloc(ctx->currentBlockHeader.length * 2); + cmp_buffer = malloc(ctx->current_block_header.length * 2); if(cmp_buffer == NULL) { FATAL("Could not allocate buffer for compressed data"); return AARUF_ERROR_NOT_ENOUGH_MEMORY; } - const uint32_t current_samples = ctx->currentBlockOffset * SAMPLES_PER_SECTOR; - uint32_t flac_block_size = ctx->currentBlockOffset * SAMPLES_PER_SECTOR; + const uint32_t current_samples = ctx->current_block_offset * SAMPLES_PER_SECTOR; + uint32_t flac_block_size = ctx->current_block_offset * SAMPLES_PER_SECTOR; if(flac_block_size > MAX_FLAKE_BLOCK) flac_block_size = MAX_FLAKE_BLOCK; if(flac_block_size < MIN_FLAKE_BLOCK) flac_block_size = MIN_FLAKE_BLOCK; @@ -1413,37 +1418,37 @@ int32_t aaruf_close_current_block(aaruformatContext *ctx) // Fill FLAC block if(remaining != 0) - for(int r = 0; r < remaining * 4; r++) ctx->writingBuffer[ctx->writingBufferPosition + r] = 0; + for(int r = 0; r < remaining * 4; r++) ctx->writing_buffer[ctx->writing_buffer_position + r] = 0; - ctx->currentBlockHeader.cmpLength = aaruf_flac_encode_redbook_buffer( - cmp_buffer, ctx->currentBlockHeader.length * 2, ctx->writingBuffer, ctx->currentBlockHeader.length, + ctx->current_block_header.cmpLength = aaruf_flac_encode_redbook_buffer( + cmp_buffer, ctx->current_block_header.length * 2, ctx->writing_buffer, ctx->current_block_header.length, flac_block_size, true, false, "hamming", 12, 15, true, false, 0, 8, "Aaru", 4); - if(ctx->currentBlockHeader.cmpLength >= ctx->currentBlockHeader.length) + if(ctx->current_block_header.cmpLength >= ctx->current_block_header.length) { - ctx->currentBlockHeader.compression = None; + ctx->current_block_header.compression = None; free(cmp_buffer); } break; case Lzma: - cmp_buffer = malloc(ctx->currentBlockHeader.length * 2); + cmp_buffer = malloc(ctx->current_block_header.length * 2); if(cmp_buffer == NULL) { FATAL("Could not allocate buffer for compressed data"); return AARUF_ERROR_NOT_ENOUGH_MEMORY; } - size_t dst_size = ctx->currentBlockHeader.length * 2; + size_t dst_size = ctx->current_block_header.length * 2; size_t props_size = LZMA_PROPERTIES_LENGTH; - aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, ctx->writingBuffer, ctx->currentBlockHeader.length, + aaruf_lzma_encode_buffer(cmp_buffer, &dst_size, ctx->writing_buffer, ctx->current_block_header.length, lzma_properties, &props_size, 9, ctx->lzma_dict_size, 4, 0, 2, 273, 8); - ctx->currentBlockHeader.cmpLength = (uint32_t)dst_size; + ctx->current_block_header.cmpLength = (uint32_t)dst_size; - if(ctx->currentBlockHeader.cmpLength >= ctx->currentBlockHeader.length) + if(ctx->current_block_header.cmpLength >= ctx->current_block_header.length) { - ctx->currentBlockHeader.compression = None; + ctx->current_block_header.compression = None; free(cmp_buffer); } @@ -1453,51 +1458,51 @@ int32_t aaruf_close_current_block(aaruformatContext *ctx) return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA; } - if(ctx->currentBlockHeader.compression == None) + if(ctx->current_block_header.compression == None) { - ctx->currentBlockHeader.cmpCrc64 = ctx->currentBlockHeader.crc64; - ctx->currentBlockHeader.cmpLength = ctx->currentBlockHeader.length; + ctx->current_block_header.cmpCrc64 = ctx->current_block_header.crc64; + ctx->current_block_header.cmpLength = ctx->current_block_header.length; } else - ctx->currentBlockHeader.cmpCrc64 = aaruf_crc64_data(cmp_buffer, ctx->currentBlockHeader.cmpLength); + ctx->current_block_header.cmpCrc64 = aaruf_crc64_data(cmp_buffer, ctx->current_block_header.cmpLength); - if(ctx->currentBlockHeader.compression == Lzma) ctx->currentBlockHeader.cmpLength += LZMA_PROPERTIES_LENGTH; + if(ctx->current_block_header.compression == Lzma) ctx->current_block_header.cmpLength += LZMA_PROPERTIES_LENGTH; // Add to index TRACE("Adding block to index"); IndexEntry index_entry; index_entry.blockType = DataBlock; index_entry.dataType = UserData; - index_entry.offset = ctx->nextBlockPosition; + index_entry.offset = ctx->next_block_position; - utarray_push_back(ctx->indexEntries, &index_entry); + utarray_push_back(ctx->index_entries, &index_entry); TRACE("Block added to index at offset %" PRIu64, index_entry.offset); // Write block header to file // Move to expected block position - fseek(ctx->imageStream, ctx->nextBlockPosition, SEEK_SET); + fseek(ctx->imageStream, ctx->next_block_position, SEEK_SET); // Write block header - if(fwrite(&ctx->currentBlockHeader, sizeof(BlockHeader), 1, ctx->imageStream) != 1) + if(fwrite(&ctx->current_block_header, sizeof(BlockHeader), 1, ctx->imageStream) != 1) return AARUF_ERROR_CANNOT_WRITE_BLOCK_HEADER; // Write block data - if(ctx->currentBlockHeader.compression == Lzma && + if(ctx->current_block_header.compression == Lzma && fwrite(lzma_properties, LZMA_PROPERTIES_LENGTH, 1, ctx->imageStream) != 1) { free(cmp_buffer); return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA; } - if(ctx->currentBlockHeader.compression == None) + if(ctx->current_block_header.compression == None) { - if(fwrite(ctx->writingBuffer, ctx->currentBlockHeader.length, 1, ctx->imageStream) != 1) + if(fwrite(ctx->writing_buffer, ctx->current_block_header.length, 1, ctx->imageStream) != 1) return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA; } else { - if(fwrite(cmp_buffer, ctx->currentBlockHeader.cmpLength, 1, ctx->imageStream) != 1) + if(fwrite(cmp_buffer, ctx->current_block_header.cmpLength, 1, ctx->imageStream) != 1) { free(cmp_buffer); return AARUF_ERROR_CANNOT_WRITE_BLOCK_DATA; @@ -1507,18 +1512,18 @@ int32_t aaruf_close_current_block(aaruformatContext *ctx) } // Update nextBlockPosition to point to the next available aligned position - const uint64_t block_total_size = sizeof(BlockHeader) + ctx->currentBlockHeader.cmpLength; - const uint64_t alignment_mask = (1ULL << ctx->userDataDdtHeader.blockAlignmentShift) - 1; - ctx->nextBlockPosition = ctx->nextBlockPosition + block_total_size + alignment_mask & ~alignment_mask; - TRACE("Updated nextBlockPosition to %" PRIu64, ctx->nextBlockPosition); + const uint64_t block_total_size = sizeof(BlockHeader) + ctx->current_block_header.cmpLength; + const uint64_t alignment_mask = (1ULL << ctx->user_data_ddt_header.blockAlignmentShift) - 1; + ctx->next_block_position = ctx->next_block_position + block_total_size + alignment_mask & ~alignment_mask; + TRACE("Updated nextBlockPosition to %" PRIu64, ctx->next_block_position); // Clear values - free(ctx->writingBuffer); - ctx->writingBuffer = NULL; - ctx->currentBlockOffset = 0; - memset(&ctx->currentBlockHeader, 0, sizeof(BlockHeader)); - aaruf_crc64_free(ctx->crc64Context); - ctx->writingBufferPosition = 0; + free(ctx->writing_buffer); + ctx->writing_buffer = NULL; + ctx->current_block_offset = 0; + memset(&ctx->current_block_header, 0, sizeof(BlockHeader)); + aaruf_crc64_free(ctx->crc64_context); + ctx->writing_buffer_position = 0; return AARUF_STATUS_OK; } @@ -1783,7 +1788,7 @@ int32_t aaruf_write_media_tag(void *context, const uint8_t *data, const int32_t return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -1795,7 +1800,7 @@ int32_t aaruf_write_media_tag(void *context, const uint8_t *data, const int32_t } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -2053,7 +2058,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con return AARUF_ERROR_NOT_AARUFORMAT; } - aaruformatContext *ctx = context; + aaruformat_context *ctx = context; // Not a libaaruformat context if(ctx->magic != AARU_MAGIC) @@ -2065,7 +2070,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con } // Check we are writing - if(!ctx->isWriting) + if(!ctx->is_writing) { FATAL("Trying to write a read-only image"); @@ -2073,7 +2078,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con return AARUF_READ_ONLY; } - 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"); @@ -2081,7 +2086,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con 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"); @@ -2099,17 +2104,17 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con // Calculate positive or negative sector if(negative) - corrected_sector_address -= ctx->userDataDdtHeader.negative; + corrected_sector_address -= ctx->user_data_ddt_header.negative; else - corrected_sector_address += ctx->userDataDdtHeader.negative; + corrected_sector_address += ctx->user_data_ddt_header.negative; const uint64_t total_sectors = - ctx->userDataDdtHeader.negative + ctx->imageInfo.Sectors + ctx->userDataDdtHeader.overflow; + ctx->user_data_ddt_header.negative + ctx->image_info.Sectors + ctx->user_data_ddt_header.overflow; switch(tag) { case CdTrackFlags: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2123,10 +2128,10 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con return AARUF_ERROR_INCORRECT_DATA_SIZE; } - for(int i = 0; i < ctx->tracksHeader.entries; i++) - if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) + for(int i = 0; i < ctx->tracks_header.entries; i++) + if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end) { - ctx->trackEntries[i].flags = data[0]; + ctx->track_entries[i].flags = data[0]; TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; } @@ -2134,7 +2139,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con FATAL("Track not found"); return AARUF_ERROR_TRACK_NOT_FOUND; case CdTrackIsrc: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2148,10 +2153,10 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con return AARUF_ERROR_INCORRECT_DATA_SIZE; } - for(int i = 0; i < ctx->tracksHeader.entries; i++) - if(sector_address >= ctx->trackEntries[i].start && sector_address <= ctx->trackEntries[i].end) + for(int i = 0; i < ctx->tracks_header.entries; i++) + if(sector_address >= ctx->track_entries[i].start && sector_address <= ctx->track_entries[i].end) { - memcpy(ctx->trackEntries[i].isrc, data, 12); + memcpy(ctx->track_entries[i].isrc, data, 12); TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; } @@ -2159,7 +2164,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con FATAL("Track not found"); return AARUF_ERROR_TRACK_NOT_FOUND; case CdSectorSubchannel: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2187,7 +2192,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdCmi: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2215,7 +2220,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorInformation: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2243,7 +2248,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorNumber: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2271,7 +2276,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorIed: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2299,7 +2304,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdSectorEdc: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2327,7 +2332,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case DvdTitleKeyDecrypted: - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2355,7 +2360,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case AppleSonyTag: - if(ctx->imageInfo.MetadataMediaType != BlockMedia) + if(ctx->image_info.MetadataMediaType != BlockMedia) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2383,7 +2388,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case AppleProfileTag: - if(ctx->imageInfo.MetadataMediaType != BlockMedia) + if(ctx->image_info.MetadataMediaType != BlockMedia) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); @@ -2411,7 +2416,7 @@ int32_t aaruf_write_sector_tag(void *context, const uint64_t sector_address, con TRACE("Exiting aaruf_write_sector_tag() = AARUF_STATUS_OK"); return AARUF_STATUS_OK; case PriamDataTowerTag: - if(ctx->imageInfo.MetadataMediaType != BlockMedia) + if(ctx->image_info.MetadataMediaType != BlockMedia) { FATAL("Invalid media type for tag"); TRACE("Exiting aaruf_write_sector_tag() = AARUF_ERROR_INCORRECT_MEDIA_TYPE"); diff --git a/tool/cli_compare.c b/tool/cli_compare.c index 07b2d63..9caf343 100644 --- a/tool/cli_compare.c +++ b/tool/cli_compare.c @@ -28,18 +28,18 @@ int cli_compare(const char *path1, const char *path2) { - aaruformatContext *ctx1 = NULL; - aaruformatContext *ctx2 = NULL; - uint8_t *buffer1 = NULL; - uint8_t *buffer2 = NULL; - uint32_t buffer1_length = 0; - uint32_t buffer2_length = 0; - uint64_t total_sectors = 0; - uint64_t different_sectors = 0; - uint64_t sectors_processed = 0; - int result = 0; - int32_t read_result1 = 0; - int32_t read_result2 = 0; + aaruformat_context *ctx1 = NULL; + aaruformat_context *ctx2 = NULL; + uint8_t *buffer1 = NULL; + uint8_t *buffer2 = NULL; + uint32_t buffer1_length = 0; + uint32_t buffer2_length = 0; + uint64_t total_sectors = 0; + uint64_t different_sectors = 0; + uint64_t sectors_processed = 0; + int result = 0; + int32_t read_result1 = 0; + int32_t read_result2 = 0; printf("Opening first image: %s\n", path1); ctx1 = aaruf_open(path1); @@ -60,32 +60,32 @@ int cli_compare(const char *path1, const char *path2) // Access image information through context structure printf("\nImage Information:\n"); - printf("Image 1: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx1->imageInfo.Sectors, - ctx1->imageInfo.SectorSize); - printf("Image 2: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx2->imageInfo.Sectors, - ctx2->imageInfo.SectorSize); + printf("Image 1: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx1->image_info.Sectors, + ctx1->image_info.SectorSize); + printf("Image 2: %llu sectors, %u bytes per sector\n", (unsigned long long)ctx2->image_info.Sectors, + ctx2->image_info.SectorSize); - if(ctx1->imageInfo.Sectors != ctx2->imageInfo.Sectors) + if(ctx1->image_info.Sectors != ctx2->image_info.Sectors) { fprintf(stderr, "Warning: Images have different number of sectors\n"); total_sectors = - ctx1->imageInfo.Sectors < ctx2->imageInfo.Sectors ? ctx1->imageInfo.Sectors : ctx2->imageInfo.Sectors; + ctx1->image_info.Sectors < ctx2->image_info.Sectors ? ctx1->image_info.Sectors : ctx2->image_info.Sectors; printf("Will compare first %llu sectors\n", (unsigned long long)total_sectors); } - else { total_sectors = ctx1->imageInfo.Sectors; } + else { total_sectors = ctx1->image_info.Sectors; } - if(ctx1->imageInfo.SectorSize != ctx2->imageInfo.SectorSize) + if(ctx1->image_info.SectorSize != ctx2->image_info.SectorSize) { - fprintf(stderr, "Error: Images have different sector sizes (%u vs %u)\n", ctx1->imageInfo.SectorSize, - ctx2->imageInfo.SectorSize); + fprintf(stderr, "Error: Images have different sector sizes (%u vs %u)\n", ctx1->image_info.SectorSize, + ctx2->image_info.SectorSize); aaruf_close(ctx1); aaruf_close(ctx2); return -1; } // Allocate buffers for sector data - buffer1 = malloc(ctx1->imageInfo.SectorSize); - buffer2 = malloc(ctx2->imageInfo.SectorSize); + buffer1 = malloc(ctx1->image_info.SectorSize); + buffer2 = malloc(ctx2->image_info.SectorSize); if(buffer1 == NULL || buffer2 == NULL) { fprintf(stderr, "Error: Could not allocate memory for sector buffers\n"); @@ -103,8 +103,8 @@ int cli_compare(const char *path1, const char *path2) // Compare sectors for(uint64_t sector = 0; sector < total_sectors; sector++) { - buffer1_length = ctx1->imageInfo.SectorSize; - buffer2_length = ctx2->imageInfo.SectorSize; + buffer1_length = ctx1->image_info.SectorSize; + buffer2_length = ctx2->image_info.SectorSize; read_result1 = aaruf_read_sector(ctx1, sector, false, buffer1, &buffer1_length); read_result2 = aaruf_read_sector(ctx2, sector, false, buffer2, &buffer2_length); diff --git a/tool/compare.c b/tool/compare.c index 600666c..edd73ed 100644 --- a/tool/compare.c +++ b/tool/compare.c @@ -44,24 +44,24 @@ void draw_progress_bar(int row, int percent) int compare(const char *path1, const char *path2) { - int ret = AARUF_STATUS_OK; - aaruformatContext *ctx1 = NULL; - aaruformatContext *ctx2 = NULL; - bool imagesAreDifferent = false; - char *strBuffer = NULL; - UErrorCode u_error_code = U_ZERO_ERROR; - int lr = 0; - int rr = 0; - uintattr_t appVerColor = TB_WHITE; - uintattr_t imageVerColor = TB_WHITE; - uintattr_t mediaTypeColor = TB_WHITE; - uintattr_t creationTimeColor = TB_WHITE; - uintattr_t lastWrittenTimeColor = TB_WHITE; - uintattr_t partitionsColor = TB_WHITE; - uintattr_t sessionsColor = TB_WHITE; - uintattr_t sectorsColor = TB_WHITE; - uintattr_t sectorSizeColor = TB_WHITE; - uintattr_t versionColor = TB_WHITE; + int ret = AARUF_STATUS_OK; + aaruformat_context *ctx1 = NULL; + aaruformat_context *ctx2 = NULL; + bool imagesAreDifferent = false; + char *strBuffer = NULL; + UErrorCode u_error_code = U_ZERO_ERROR; + int lr = 0; + int rr = 0; + uintattr_t appVerColor = TB_WHITE; + uintattr_t imageVerColor = TB_WHITE; + uintattr_t mediaTypeColor = TB_WHITE; + uintattr_t creationTimeColor = TB_WHITE; + uintattr_t lastWrittenTimeColor = TB_WHITE; + uintattr_t partitionsColor = TB_WHITE; + uintattr_t sessionsColor = TB_WHITE; + uintattr_t sectorsColor = TB_WHITE; + uintattr_t sectorSizeColor = TB_WHITE; + uintattr_t versionColor = TB_WHITE; // Initialize termbox2 if(tb_init() != 0) return 1; @@ -229,8 +229,8 @@ int compare(const char *path1, const char *path2) // Compare ImageInfo u_error_code = U_ZERO_ERROR; - u_error_code = u_strCompare((const UChar *)ctx1->imageInfo.Application, -1, - (const UChar *)ctx2->imageInfo.Application, -1, false); + u_error_code = u_strCompare((const UChar *)ctx1->image_info.Application, -1, + (const UChar *)ctx2->image_info.Application, -1, false); if(u_error_code != U_ZERO_ERROR) imagesAreDifferent = true; // Current left row @@ -238,73 +238,73 @@ int compare(const char *path1, const char *path2) // Current right row rr = 9; - if(ctx1->imageInfo.HasPartitions != ctx2->imageInfo.HasPartitions) + if(ctx1->image_info.HasPartitions != ctx2->image_info.HasPartitions) { imagesAreDifferent = true; partitionsColor = TB_RED; } - if(ctx1->imageInfo.HasSessions != ctx2->imageInfo.HasSessions) + if(ctx1->image_info.HasSessions != ctx2->image_info.HasSessions) { imagesAreDifferent = true; sessionsColor = TB_RED; } - if(ctx1->imageInfo.Sectors != ctx2->imageInfo.Sectors) + if(ctx1->image_info.Sectors != ctx2->image_info.Sectors) { imagesAreDifferent = true; sectorsColor = TB_RED; } - if(ctx1->imageInfo.SectorSize != ctx2->imageInfo.SectorSize) + if(ctx1->image_info.SectorSize != ctx2->image_info.SectorSize) { imagesAreDifferent = true; sectorSizeColor = TB_RED; } - if(ctx1->imageInfo.Version != ctx2->imageInfo.Version) + if(ctx1->image_info.Version != ctx2->image_info.Version) { imagesAreDifferent = true; versionColor = TB_RED; } tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Has partitions?: "); - tb_printf(19, lr++, partitionsColor, TB_BLUE, "%s", ctx1->imageInfo.HasPartitions ? "yes" : "no"); + tb_printf(19, lr++, partitionsColor, TB_BLUE, "%s", ctx1->image_info.HasPartitions ? "yes" : "no"); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Has sessions?: "); - tb_printf(17, lr++, sessionsColor, TB_BLUE, "%s", ctx1->imageInfo.HasSessions ? "yes" : "no"); + tb_printf(17, lr++, sessionsColor, TB_BLUE, "%s", ctx1->image_info.HasSessions ? "yes" : "no"); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Image size without headers: "); - tb_printf(30, lr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx1->imageInfo.ImageSize); + tb_printf(30, lr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx1->image_info.ImageSize); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Image contains: "); - tb_printf(18, lr++, sectorsColor, TB_BLUE, "%llu sectors", ctx1->imageInfo.Sectors); + tb_printf(18, lr++, sectorsColor, TB_BLUE, "%llu sectors", ctx1->image_info.Sectors); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Biggest sector is: "); - tb_printf(21, lr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx1->imageInfo.SectorSize); + tb_printf(21, lr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx1->image_info.SectorSize); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Image version: "); - tb_printf(17, lr++, versionColor, TB_BLUE, "%s", ctx1->imageInfo.Version); + tb_printf(17, lr++, versionColor, TB_BLUE, "%s", ctx1->image_info.Version); tb_present(); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Has partitions?: "); - tb_printf(mid_x + 19, rr++, partitionsColor, TB_BLUE, "%s", ctx2->imageInfo.HasPartitions ? "yes" : "no"); + tb_printf(mid_x + 19, rr++, partitionsColor, TB_BLUE, "%s", ctx2->image_info.HasPartitions ? "yes" : "no"); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Has sessions?: "); - tb_printf(mid_x + 17, rr++, sessionsColor, TB_BLUE, "%s", ctx2->imageInfo.HasSessions ? "yes" : "no"); + tb_printf(mid_x + 17, rr++, sessionsColor, TB_BLUE, "%s", ctx2->image_info.HasSessions ? "yes" : "no"); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Image size without headers: "); - tb_printf(mid_x + 30, rr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx2->imageInfo.ImageSize); + tb_printf(mid_x + 30, rr++, TB_WHITE, TB_BLUE, "%llu bytes", ctx2->image_info.ImageSize); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Image contains: "); - tb_printf(mid_x + 18, rr++, sectorsColor, TB_BLUE, "%llu sectors", ctx2->imageInfo.Sectors); + tb_printf(mid_x + 18, rr++, sectorsColor, TB_BLUE, "%llu sectors", ctx2->image_info.Sectors); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Biggest sector is: "); - tb_printf(mid_x + 21, rr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx2->imageInfo.SectorSize); + tb_printf(mid_x + 21, rr++, sectorSizeColor, TB_BLUE, "%d bytes", ctx2->image_info.SectorSize); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Image version: "); - tb_printf(mid_x + 17, rr++, versionColor, TB_BLUE, "%s", ctx2->imageInfo.Version); + tb_printf(mid_x + 17, rr++, versionColor, TB_BLUE, "%s", ctx2->image_info.Version); tb_present(); - if(ctx1->imageInfo.Application != NULL || ctx2->imageInfo.Application != NULL) + if(ctx1->image_info.Application != NULL || ctx2->image_info.Application != NULL) { strBuffer = malloc(65); memset(strBuffer, 0, 65); u_error_code = U_ZERO_ERROR; // Reset error code before conversion - ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx1->imageInfo.Application, 64, &u_error_code); + ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx1->image_info.Application, 64, &u_error_code); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Application: "); if(u_error_code == U_ZERO_ERROR) tb_printf(15, lr, TB_WHITE, TB_BLUE, "%s", strBuffer); lr++; memset(strBuffer, 0, 65); u_error_code = U_ZERO_ERROR; // Reset error code before conversion - ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx2->imageInfo.Application, 64, &u_error_code); + ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx2->image_info.Application, 64, &u_error_code); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Application: "); if(u_error_code == U_ZERO_ERROR) tb_printf(mid_x + 15, rr, TB_WHITE, TB_BLUE, "%s", strBuffer); rr++; @@ -313,155 +313,156 @@ int compare(const char *path1, const char *path2) tb_present(); } - if(ctx1->imageInfo.ApplicationVersion != NULL || ctx2->imageInfo.ApplicationVersion != NULL) + if(ctx1->image_info.ApplicationVersion != NULL || ctx2->image_info.ApplicationVersion != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Application version: "); - tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.ApplicationVersion); + tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->image_info.ApplicationVersion); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Application version: "); - tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->imageInfo.ApplicationVersion); + tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->image_info.ApplicationVersion); } - if(ctx1->Creator != NULL || ctx2->Creator != NULL) + if(ctx1->creator != NULL || ctx2->creator != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Creator: "); - tb_printf(11, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->Creator); + tb_printf(11, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->creator); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Creator: "); - tb_printf(mid_x + 11, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->Creator); + tb_printf(mid_x + 11, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->creator); } tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Creation time: "); - tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->imageInfo.CreationTime); + tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->image_info.CreationTime); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Creation time: "); - tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->imageInfo.CreationTime); + tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->image_info.CreationTime); tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Last written time: "); - tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->imageInfo.LastModificationTime); + tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%lld", ctx1->image_info.LastModificationTime); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Last written time: "); - tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->imageInfo.LastModificationTime); + tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%lld", ctx2->image_info.LastModificationTime); - if(ctx1->Comments != NULL || ctx2->Comments != NULL) + if(ctx1->comments != NULL || ctx2->comments != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Comments: "); - tb_printf(12, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->Comments); + tb_printf(12, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->comments); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Comments: "); - tb_printf(mid_x + 12, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->Comments); + tb_printf(mid_x + 12, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->comments); } - if(ctx1->MediaTitle != NULL || ctx2->MediaTitle != NULL) + if(ctx1->media_title != NULL || ctx2->media_title != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media title: "); - tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaTitle); + tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_title); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media title: "); - tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaTitle); + tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_title); } - if(ctx1->MediaManufacturer != NULL || ctx2->MediaManufacturer != NULL) + if(ctx1->media_manufacturer != NULL || ctx2->media_manufacturer != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media manufacturer: "); - tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaManufacturer); + tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_manufacturer); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media manufacturer: "); - tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaManufacturer); + tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_manufacturer); } - if(ctx1->MediaSerialNumber != NULL || ctx2->MediaSerialNumber != NULL) + if(ctx1->media_serial_number != NULL || ctx2->media_serial_number != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media serial number: "); - tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaSerialNumber); + tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_serial_number); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media serial number: "); - tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaSerialNumber); + tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_serial_number); } - if(ctx1->MediaBarcode != NULL || ctx2->MediaBarcode != NULL) + if(ctx1->media_barcode != NULL || ctx2->media_barcode != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media barcode: "); - tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaBarcode); + tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_barcode); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media barcode: "); - tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaBarcode); + tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_barcode); } - if(ctx1->MediaPartNumber != NULL || ctx2->MediaPartNumber != NULL) + if(ctx1->media_part_number != NULL || ctx2->media_part_number != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media part number: "); - tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaPartNumber); + tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->media_part_number); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media part number: "); - tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaPartNumber); + tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->media_part_number); } tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media type: "); - tb_printf(14, lr++, TB_WHITE, TB_BLUE, "%u", ctx1->imageInfo.MediaType); + tb_printf(14, lr++, TB_WHITE, TB_BLUE, "%u", ctx1->image_info.MediaType); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Media type: "); - tb_printf(mid_x + 14, rr++, TB_WHITE, TB_BLUE, "%u", ctx2->imageInfo.MediaType); + tb_printf(mid_x + 14, rr++, TB_WHITE, TB_BLUE, "%u", ctx2->image_info.MediaType); - if(ctx1->MediaSequence > 0 || ctx1->LastMediaSequence > 0 || ctx2->MediaSequence > 0 || ctx2->LastMediaSequence > 0) + if(ctx1->media_sequence > 0 || ctx1->last_media_sequence > 0 || ctx2->media_sequence > 0 || + ctx2->last_media_sequence > 0) { - tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media", ctx1->MediaSequence, - ctx1->LastMediaSequence); + tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media", ctx1->media_sequence, + ctx1->last_media_sequence); tb_printf(mid_x + 2, rr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media", - ctx2->MediaSequence, ctx2->LastMediaSequence); + ctx2->media_sequence, ctx2->last_media_sequence); } - if(ctx1->DriveManufacturer != NULL || ctx2->DriveManufacturer != NULL) + if(ctx1->drive_manufacturer != NULL || ctx2->drive_manufacturer != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive manufacturer: "); - tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveManufacturer); + tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_manufacturer); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive manufacturer: "); - tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveManufacturer); + tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_manufacturer); } - if(ctx1->DriveModel != NULL || ctx2->DriveModel != NULL) + if(ctx1->drive_model != NULL || ctx2->drive_model != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive model: "); - tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveModel); + tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_model); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive model: "); - tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveModel); + tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_model); } - if(ctx1->DriveSerialNumber != NULL || ctx2->DriveSerialNumber != NULL) + if(ctx1->drive_serial_number != NULL || ctx2->drive_serial_number != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive serial number: "); - tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveSerialNumber); + tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_serial_number); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive serial number: "); - tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveSerialNumber); + tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_serial_number); } - if(ctx1->DriveFirmwareRevision != NULL || ctx2->DriveFirmwareRevision != NULL) + if(ctx1->drive_firmware_revision != NULL || ctx2->drive_firmware_revision != NULL) { tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive firmware revision: "); - tb_printf(27, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveFirmwareRevision); + tb_printf(27, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->drive_firmware_revision); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive firmware revision: "); - tb_printf(mid_x + 27, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveFirmwareRevision); + tb_printf(mid_x + 27, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->drive_firmware_revision); } tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "XML media type: "); - tb_printf(18, lr++, TB_WHITE, TB_BLUE, "%d", ctx1->imageInfo.MetadataMediaType); + tb_printf(18, lr++, TB_WHITE, TB_BLUE, "%d", ctx1->image_info.MetadataMediaType); tb_printf(mid_x + 2, rr, TB_WHITE | TB_BOLD, TB_BLUE, "XML media type: "); - tb_printf(mid_x + 18, rr++, TB_WHITE, TB_BLUE, "%d", ctx2->imageInfo.MetadataMediaType); + tb_printf(mid_x + 18, rr++, TB_WHITE, TB_BLUE, "%d", ctx2->image_info.MetadataMediaType); - if(ctx1->Cylinders > 0 || ctx1->Heads > 0 || ctx1->SectorsPerTrack > 0 || ctx2->Cylinders > 0 || ctx2->Heads > 0 || - ctx2->SectorsPerTrack > 0) + if(ctx1->cylinders > 0 || ctx1->heads > 0 || ctx1->sectors_per_track > 0 || ctx2->cylinders > 0 || + ctx2->heads > 0 || ctx2->sectors_per_track > 0) { tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media has %d cylinders, %d heads and %d sectors per track", - ctx1->Cylinders, ctx1->Heads, ctx1->SectorsPerTrack); + ctx1->cylinders, ctx1->heads, ctx1->sectors_per_track); tb_printf(mid_x + 2, rr++, TB_WHITE | TB_BOLD, TB_BLUE, - "Media has %d cylinders, %d heads and %d sectors per track", ctx2->Cylinders, ctx2->Heads, - ctx2->SectorsPerTrack); + "Media has %d cylinders, %d heads and %d sectors per track", ctx2->cylinders, ctx2->heads, + ctx2->sectors_per_track); } tb_present(); lr++; - uint64_t sectors = ctx1->imageInfo.Sectors; - if(ctx2->imageInfo.Sectors < sectors) sectors = ctx2->imageInfo.Sectors; + uint64_t sectors = ctx1->image_info.Sectors; + if(ctx2->image_info.Sectors < sectors) sectors = ctx2->image_info.Sectors; bool imageContentsAreDifferent = false; - uint32_t sectorSize = ctx1->imageInfo.SectorSize; - if(ctx2->imageInfo.SectorSize > sectorSize) sectorSize = ctx2->imageInfo.SectorSize; + uint32_t sectorSize = ctx1->image_info.SectorSize; + if(ctx2->image_info.SectorSize > sectorSize) sectorSize = ctx2->image_info.SectorSize; uint8_t *buffer1 = malloc(sectorSize); if(buffer1 == NULL) diff --git a/tool/convert.c b/tool/convert.c index dc887e0..c2a9991 100644 --- a/tool/convert.c +++ b/tool/convert.c @@ -30,12 +30,12 @@ int convert(const char *input_path, const char *output_path) { - aaruformatContext *input_ctx = NULL; - aaruformatContext *output_ctx = NULL; - int32_t res = 0; - uint32_t sector_size = 0; - uint64_t total_sectors = 0; - uint8_t *sector_data = NULL; + aaruformat_context *input_ctx = NULL; + aaruformat_context *output_ctx = NULL; + int32_t res = 0; + uint32_t sector_size = 0; + uint64_t total_sectors = 0; + uint8_t *sector_data = NULL; printf("Converting image from %s to %s...\n", input_path, output_path); @@ -48,8 +48,8 @@ int convert(const char *input_path, const char *output_path) } // Get image information from input - total_sectors = input_ctx->imageInfo.Sectors; - sector_size = input_ctx->imageInfo.SectorSize; + total_sectors = input_ctx->image_info.Sectors; + sector_size = input_ctx->image_info.SectorSize; printf("Input image has %llu sectors of %u bytes each.\n", total_sectors, sector_size); @@ -93,7 +93,7 @@ int convert(const char *input_path, const char *output_path) free(app_name_utf16); // Create output image - output_ctx = aaruf_create(output_path, input_ctx->imageInfo.MediaType, sector_size, total_sectors, + output_ctx = aaruf_create(output_path, input_ctx->image_info.MediaType, sector_size, total_sectors, 0, // negative sectors 0, // overflow sectors NULL, // options diff --git a/tool/info.c b/tool/info.c index 13b4897..80ee256 100644 --- a/tool/info.c +++ b/tool/info.c @@ -69,7 +69,7 @@ static const char *format_filetime(uint64_t filetime) int info(const char *path) { - aaruformatContext *ctx = NULL; + aaruformat_context *ctx = NULL; char *strBuffer = NULL; UErrorCode u_error_code = U_ZERO_ERROR; uint i = 0; @@ -86,7 +86,7 @@ int info(const char *path) printf("AaruFormat context information:\n"); printf("Magic number: %8.8s\n", (char *)&ctx->magic); - printf("Library version: %d.%d\n", ctx->libraryMajorVersion, ctx->libraryMinorVersion); + printf("Library version: %d.%d\n", ctx->library_major_version, ctx->library_minor_version); printf("AaruFormat header:\n"); printf("\tIdentifier: %8.8s\n", (char *)&ctx->header.identifier); @@ -107,11 +107,11 @@ int info(const char *path) if(ctx->sector_prefix != NULL) printf("Sector prefix array has been read.\n"); - if(ctx->sectorPrefixCorrected != NULL) printf("Sector prefix corrected array has been read.\n"); + if(ctx->sector_prefix_corrected != NULL) printf("Sector prefix corrected array has been read.\n"); if(ctx->sector_suffix != NULL) printf("Sector suffix array has been read.\n"); - if(ctx->sectorSuffixCorrected != NULL) printf("Sector suffix corrected array has been read.\n"); + if(ctx->sector_suffix_corrected != NULL) printf("Sector suffix corrected array has been read.\n"); if(ctx->sector_subchannel != NULL) printf("Sector subchannel array has been read.\n"); @@ -119,15 +119,15 @@ int info(const char *path) printf("Shift is %d (%d bytes).\n", ctx->shift, 1 << ctx->shift); - if(ctx->inMemoryDdt) printf("User-data DDT resides in memory.\n"); + if(ctx->in_memory_ddt) printf("User-data DDT resides in memory.\n"); - if(ctx->userDataDdt != NULL) printf("User-data DDT has been read to memory.\n"); + if(ctx->user_data_ddt != NULL) printf("User-data DDT has been read to memory.\n"); - if(ctx->mappedMemoryDdtSize > 0) printf("Mapped memory DDT has %zu bytes", ctx->mappedMemoryDdtSize); + if(ctx->mapped_memory_ddt_size > 0) printf("Mapped memory DDT has %zu bytes", ctx->mapped_memory_ddt_size); - if(ctx->sectorPrefixDdt != NULL) printf("Sector prefix DDT has been read to memory.\n"); + if(ctx->sector_prefix_ddt != NULL) printf("Sector prefix DDT has been read to memory.\n"); - if(ctx->sectorPrefixDdt != NULL) printf("Sector suffix DDT has been read to memory.\n"); + if(ctx->sector_prefix_ddt != NULL) printf("Sector suffix DDT has been read to memory.\n"); uint32_t cylinders = 0; uint32_t heads = 0; @@ -421,181 +421,183 @@ int info(const char *path) } // TODO: Table format? - if(ctx->tracksHeader.identifier == TracksBlock) + if(ctx->tracks_header.identifier == TracksBlock) { printf("Tracks block:\n"); - for(i = 0; i < ctx->tracksHeader.entries; i++) + for(i = 0; i < ctx->tracks_header.entries; i++) { printf("\tTrack entry %d:\n", i); - printf("\t\tSequence: %d\n", ctx->trackEntries[i].sequence); - printf("\t\tType: %d\n", ctx->trackEntries[i].type); - printf("\t\tStart: %lld\n", ctx->trackEntries[i].start); - printf("\t\tEnd: %lld\n", ctx->trackEntries[i].end); - printf("\t\tPregap: %lld\n", ctx->trackEntries[i].pregap); - printf("\t\tSession: %d\n", ctx->trackEntries[i].session); - printf("\t\tISRC: %.13s\n", ctx->trackEntries[i].isrc); - printf("\t\tFlags: %d\n", ctx->trackEntries[i].flags); + printf("\t\tSequence: %d\n", ctx->track_entries[i].sequence); + printf("\t\tType: %d\n", ctx->track_entries[i].type); + printf("\t\tStart: %lld\n", ctx->track_entries[i].start); + printf("\t\tEnd: %lld\n", ctx->track_entries[i].end); + printf("\t\tPregap: %lld\n", ctx->track_entries[i].pregap); + printf("\t\tSession: %d\n", ctx->track_entries[i].session); + printf("\t\tISRC: %.13s\n", ctx->track_entries[i].isrc); + printf("\t\tFlags: %d\n", ctx->track_entries[i].flags); } } - if(ctx->cicmBlockHeader.identifier == CicmBlock) + if(ctx->cicm_block_header.identifier == CicmBlock) { printf("CICM block:\n"); - printf("%s", ctx->cicmBlock); + printf("%s", ctx->cicm_block); } // TODO: Table format? - if(ctx->dumpHardwareHeader.identifier == DumpHardwareBlock) + if(ctx->dump_hardware_header.identifier == DumpHardwareBlock) { printf("Dump hardware block:\n"); - for(i = 0; i < ctx->dumpHardwareHeader.entries; i++) + for(i = 0; i < ctx->dump_hardware_header.entries; i++) { printf("\tDump hardware entry %d\n", i); - if(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength + 1); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength + 1); ucnv_convert(NULL, "UTF-8", strBuffer, - (int)ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength, - (char *)ctx->dumpHardwareEntriesWithData[i].manufacturer, - (int)ctx->dumpHardwareEntriesWithData[i].entry.manufacturerLength, &u_error_code); + (int)ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength, + (char *)ctx->dump_hardware_entries_with_data[i].manufacturer, + (int)ctx->dump_hardware_entries_with_data[i].entry.manufacturerLength, &u_error_code); printf("\t\tManufacturer: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.modelLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.modelLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.modelLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.modelLength + 1); - ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.modelLength, - (char *)ctx->dumpHardwareEntriesWithData[i].model, - (int)ctx->dumpHardwareEntriesWithData[i].entry.modelLength, &u_error_code); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.modelLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.modelLength + 1); + ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dump_hardware_entries_with_data[i].entry.modelLength, + (char *)ctx->dump_hardware_entries_with_data[i].model, + (int)ctx->dump_hardware_entries_with_data[i].entry.modelLength, &u_error_code); printf("\t\tModel: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.revisionLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.revisionLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.revisionLength + 1); - ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.revisionLength, - (char *)ctx->dumpHardwareEntriesWithData[i].revision, - (int)ctx->dumpHardwareEntriesWithData[i].entry.revisionLength, &u_error_code); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.revisionLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.revisionLength + 1); + ucnv_convert(NULL, "UTF-8", strBuffer, + (int)ctx->dump_hardware_entries_with_data[i].entry.revisionLength, + (char *)ctx->dump_hardware_entries_with_data[i].revision, + (int)ctx->dump_hardware_entries_with_data[i].entry.revisionLength, &u_error_code); printf("\t\tRevision: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength + 1); - ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength, - (char *)ctx->dumpHardwareEntriesWithData[i].firmware, - (int)ctx->dumpHardwareEntriesWithData[i].entry.firmwareLength, &u_error_code); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.firmwareLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.firmwareLength + 1); + ucnv_convert(NULL, "UTF-8", strBuffer, + (int)ctx->dump_hardware_entries_with_data[i].entry.firmwareLength, + (char *)ctx->dump_hardware_entries_with_data[i].firmware, + (int)ctx->dump_hardware_entries_with_data[i].entry.firmwareLength, &u_error_code); printf("\t\tFirmware version: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.serialLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.serialLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.serialLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.serialLength + 1); - ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dumpHardwareEntriesWithData[i].entry.serialLength, - (char *)ctx->dumpHardwareEntriesWithData[i].serial, - (int)ctx->dumpHardwareEntriesWithData[i].entry.serialLength, &u_error_code); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.serialLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.serialLength + 1); + ucnv_convert(NULL, "UTF-8", strBuffer, (int)ctx->dump_hardware_entries_with_data[i].entry.serialLength, + (char *)ctx->dump_hardware_entries_with_data[i].serial, + (int)ctx->dump_hardware_entries_with_data[i].entry.serialLength, &u_error_code); printf("\t\tSerial number: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength + 1); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength + 1); ucnv_convert(NULL, "UTF-8", strBuffer, - (int)ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength, - (char *)ctx->dumpHardwareEntriesWithData[i].softwareName, - (int)ctx->dumpHardwareEntriesWithData[i].entry.softwareNameLength, &u_error_code); + (int)ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength, + (char *)ctx->dump_hardware_entries_with_data[i].softwareName, + (int)ctx->dump_hardware_entries_with_data[i].entry.softwareNameLength, &u_error_code); printf("\t\tSoftware name: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength + 1); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength + 1); ucnv_convert(NULL, "UTF-8", strBuffer, - (int)ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength, - (char *)ctx->dumpHardwareEntriesWithData[i].softwareVersion, - (int)ctx->dumpHardwareEntriesWithData[i].entry.softwareVersionLength, &u_error_code); + (int)ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength, + (char *)ctx->dump_hardware_entries_with_data[i].softwareVersion, + (int)ctx->dump_hardware_entries_with_data[i].entry.softwareVersionLength, &u_error_code); printf("\t\tSoftware version: %s\n", strBuffer); free(strBuffer); } - if(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength > 0) + if(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength > 0) { - strBuffer = malloc(ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength + 1); - memset(strBuffer, 0, ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength + 1); + strBuffer = malloc(ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + 1); + memset(strBuffer, 0, ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength + 1); ucnv_convert(NULL, "UTF-8", strBuffer, - (int)ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength, - (char *)ctx->dumpHardwareEntriesWithData[i].softwareOperatingSystem, - (int)ctx->dumpHardwareEntriesWithData[i].entry.softwareOperatingSystemLength, + (int)ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength, + (char *)ctx->dump_hardware_entries_with_data[i].softwareOperatingSystem, + (int)ctx->dump_hardware_entries_with_data[i].entry.softwareOperatingSystemLength, &u_error_code); printf("\t\tSoftware operating system: %s\n", strBuffer); free(strBuffer); } - for(uint j = 0; j < ctx->dumpHardwareEntriesWithData[i].entry.extents; j++) + for(uint j = 0; j < ctx->dump_hardware_entries_with_data[i].entry.extents; j++) { printf("\t\tExtent %d:\n", j); - printf("\t\t\tStart: %llu\n", ctx->dumpHardwareEntriesWithData[i].extents[j].start); - printf("\t\t\tEnd: %llu\n", ctx->dumpHardwareEntriesWithData[i].extents[j].end); + printf("\t\t\tStart: %llu\n", ctx->dump_hardware_entries_with_data[i].extents[j].start); + printf("\t\t\tEnd: %llu\n", ctx->dump_hardware_entries_with_data[i].extents[j].end); } } } - if(ctx->eccCdContext != NULL) printf("CD ECC has been initialized.\n"); + if(ctx->ecc_cd_context != NULL) printf("CD ECC has been initialized.\n"); - printf("There are %d data tracks.\n", ctx->numberOfDataTracks); + printf("There are %d data tracks.\n", ctx->number_of_data_tracks); // TODO: ctx->readableSectorTags; - if(ctx->blockHeaderCache.max_items > 0) + if(ctx->block_header_cache.max_items > 0) { - if(ctx->blockHeaderCache.cache != NULL) printf("Block header cache has been initialized.\n"); - printf("Block header cache can contain a maximum of %llu items.\n", ctx->blockHeaderCache.max_items); + if(ctx->block_header_cache.cache != NULL) printf("Block header cache has been initialized.\n"); + printf("Block header cache can contain a maximum of %llu items.\n", ctx->block_header_cache.max_items); } - if(ctx->blockCache.max_items > 0) + if(ctx->block_cache.max_items > 0) { - if(ctx->blockCache.cache != NULL) printf("Block cache has been initialized.\n"); - printf("Block cache can contain a maximum of %llu items.\n", ctx->blockCache.max_items); + if(ctx->block_cache.cache != NULL) printf("Block cache has been initialized.\n"); + printf("Block cache can contain a maximum of %llu items.\n", ctx->block_cache.max_items); } printf("Aaru's ImageInfo:\n"); - printf("\tHas partitions?: %s\n", ctx->imageInfo.HasPartitions ? "yes" : "no"); - printf("\tHas sessions?: %s\n", ctx->imageInfo.HasSessions ? "yes" : "no"); - printf("\tImage size without headers: %llu bytes\n", ctx->imageInfo.ImageSize); - printf("\tImage contains %llu sectors\n", ctx->imageInfo.Sectors); - printf("\tBiggest sector is %d bytes\n", ctx->imageInfo.SectorSize); - printf("\tImage version: %s\n", ctx->imageInfo.Version); + printf("\tHas partitions?: %s\n", ctx->image_info.HasPartitions ? "yes" : "no"); + printf("\tHas sessions?: %s\n", ctx->image_info.HasSessions ? "yes" : "no"); + printf("\tImage size without headers: %llu bytes\n", ctx->image_info.ImageSize); + printf("\tImage contains %llu sectors\n", ctx->image_info.Sectors); + printf("\tBiggest sector is %d bytes\n", ctx->image_info.SectorSize); + printf("\tImage version: %s\n", ctx->image_info.Version); - if(ctx->imageInfo.Application != NULL) + if(ctx->image_info.Application != NULL) { strBuffer = malloc(65); memset(strBuffer, 0, 65); - ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx->imageInfo.Application, 64, &u_error_code); + ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx->image_info.Application, 64, &u_error_code); if(u_error_code == U_ZERO_ERROR) printf("\tApplication: %s\n", strBuffer); free(strBuffer); } - if(ctx->imageInfo.ApplicationVersion != NULL) - printf("\tApplication version: %s\n", ctx->imageInfo.ApplicationVersion); - printf("\tCreation time: %s\n", format_filetime(ctx->imageInfo.CreationTime)); - printf("\tLast written time: %s\n", format_filetime(ctx->imageInfo.LastModificationTime)); - printf("\tMedia type: %u (%s)\n", ctx->imageInfo.MediaType, media_type_to_string(ctx->imageInfo.MediaType)); - printf("\tXML media type: %d\n", ctx->imageInfo.MetadataMediaType); + if(ctx->image_info.ApplicationVersion != NULL) + printf("\tApplication version: %s\n", ctx->image_info.ApplicationVersion); + printf("\tCreation time: %s\n", format_filetime(ctx->image_info.CreationTime)); + printf("\tLast written time: %s\n", format_filetime(ctx->image_info.LastModificationTime)); + printf("\tMedia type: %u (%s)\n", ctx->image_info.MediaType, media_type_to_string(ctx->image_info.MediaType)); + printf("\tXML media type: %d\n", ctx->image_info.MetadataMediaType); if(ctx->checksums.hasMd5) { diff --git a/tool/read.c b/tool/read.c index 229c800..7303a5f 100644 --- a/tool/read.c +++ b/tool/read.c @@ -26,10 +26,10 @@ int read(const unsigned long long sector_no, const char *path) { - aaruformatContext *ctx = NULL; - int32_t res = 0; - uint32_t length = 0; - uint8_t *data = NULL; + aaruformat_context *ctx = NULL; + int32_t res = 0; + uint32_t length = 0; + uint8_t *data = NULL; ctx = aaruf_open(path); @@ -78,10 +78,10 @@ int read(const unsigned long long sector_no, const char *path) int read_long(const unsigned long long sector_no, const char *path) { - aaruformatContext *ctx = NULL; - int32_t res = 0; - uint32_t length = 0; - uint8_t *data = NULL; + aaruformat_context *ctx = NULL; + int32_t res = 0; + uint32_t length = 0; + uint8_t *data = NULL; ctx = aaruf_open(path); diff --git a/tool/verify.c b/tool/verify.c index 87ce740..cbf191b 100644 --- a/tool/verify.c +++ b/tool/verify.c @@ -25,8 +25,8 @@ int verify(const char *path) { - aaruformatContext *ctx = NULL; - uint32_t res = 0; + aaruformat_context *ctx = NULL; + uint32_t res = 0; ctx = aaruf_open(path); @@ -50,13 +50,13 @@ int verify(const char *path) int verify_sectors(const char *path) { - aaruformatContext *ctx = NULL; - uint8_t *buffer = NULL; - uint32_t buffer_len = 2352; - int32_t res = 0; - CdEccContext *cd_ecc_context = NULL; - ctx = aaruf_open(path); - bool verify_result = false; + aaruformat_context *ctx = NULL; + uint8_t *buffer = NULL; + uint32_t buffer_len = 2352; + int32_t res = 0; + CdEccContext *cd_ecc_context = NULL; + ctx = aaruf_open(path); + bool verify_result = false; bool has_edc = false, has_ecc_p = false, ecc_p_correct = false, has_ecc_q = false, ecc_q_correct = false; bool edc_correct = false; bool unknown = false; @@ -69,7 +69,7 @@ int verify_sectors(const char *path) return errno; } - if(ctx->imageInfo.MetadataMediaType != OpticalDisc) + if(ctx->image_info.MetadataMediaType != OpticalDisc) { printf("Image sectors do not contain checksums, cannot verify.\n"); return 0; @@ -80,7 +80,7 @@ int verify_sectors(const char *path) unknowns = 0; any_error = false; - for(uint64_t s = 0; s < ctx->imageInfo.Sectors; s++) + for(uint64_t s = 0; s < ctx->image_info.Sectors; s++) { printf("\rVerifying sector %llu...", s); res = aaruf_read_sector_long(ctx, s, buffer, false, &buffer_len); @@ -118,7 +118,7 @@ int verify_sectors(const char *path) else printf("\rAll sector checksums are correct.\n"); - printf("Total sectors........... %llu\n", ctx->imageInfo.Sectors); + printf("Total sectors........... %llu\n", ctx->image_info.Sectors); printf("Total errors............ %llu\n", errors); printf("Total unknowns.......... %llu\n", unknowns); printf("Total errors+unknowns... %llu\n", errors + unknowns);