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

Refactor metadata handling in context structures to improve organization and clarity

Browse Source
This commit is contained in:
Natalia Portillo
2025-10-09 02:06:34 +01:00
parent b02f9d4402
commit fb4acfcbda
7 changed files with 197 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
include/aaru.h
View File

@@ -807,37 +807,18 @@ typedef enum
*/
typedef struct ImageInfo // NOLINT
{
uint8_t HasPartitions; ///< Image contains partitions (or tracks for optical media)
uint8_t HasSessions; ///< Image contains sessions (optical media only)
uint64_t ImageSize; ///< Size of the image without headers
uint64_t Sectors; ///< Sectors contained in the image
uint32_t SectorSize; ///< Size of sectors contained in the image
uint8_t *Version; ///< Image version
uint8_t *Application; ///< Application that created the image
uint8_t *ApplicationVersion; ///< Version of the application that created the image
uint8_t *Creator; ///< Who (person) created the image?
int64_t CreationTime; ///< Image creation time
int64_t LastModificationTime; ///< Image last modification time
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
uint32_t MediaType; ///< Media type 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
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
uint8_t XmlMediaType; ///< Type of the media represented by the image to use in XML sidecars
// CHS geometry...
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)
uint8_t HasPartitions; ///< Image contains partitions (or tracks for optical media)
uint8_t HasSessions; ///< Image contains sessions (optical media only)
uint64_t ImageSize; ///< Size of the image without headers
uint64_t Sectors; ///< Sectors contained in the image
uint32_t SectorSize; ///< Size of sectors contained in the image
uint8_t *Version; ///< Image version
uint8_t *Application; ///< Application that created the image
uint8_t *ApplicationVersion; ///< Version of the application that created the image
int64_t CreationTime; ///< Image creation time
int64_t LastModificationTime; ///< Image last modification time
uint32_t MediaType; ///< Media type represented by the image
uint8_t XmlMediaType; ///< Type of the media represented by the image to use in XML sidecars
} ImageInfo;
/** \addtogroup SectorTags Per-sector metadata tag types

18
include/aaruformat/context.h
View File

@@ -218,6 +218,24 @@ typedef struct aaruformatContext
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)
/* Optical information */
TracksHeader tracksHeader; ///< Tracks header (optical) if present.

88
src/blocks/metadata.c
View File

@@ -105,18 +105,18 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0)
{
ctx->imageInfo.MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->imageInfo.LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
TRACE("Setting media sequence as %d of %d", ctx->imageInfo.MediaSequence, ctx->imageInfo.LastMediaSequence);
ctx->MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
TRACE("Setting media sequence as %d of %d", ctx->MediaSequence, ctx->LastMediaSequence);
}
if(ctx->metadataBlockHeader.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength);
if(ctx->imageInfo.Creator != NULL)
memcpy(ctx->imageInfo.Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset,
ctx->Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength);
if(ctx->Creator != NULL)
memcpy(ctx->Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset,
ctx->metadataBlockHeader.creatorLength);
}
@@ -124,9 +124,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength);
if(ctx->imageInfo.Comments != NULL)
memcpy(ctx->imageInfo.Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset,
ctx->Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength);
if(ctx->Comments != NULL)
memcpy(ctx->Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset,
ctx->metadataBlockHeader.commentsLength);
}
@@ -134,9 +134,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength);
if(ctx->imageInfo.MediaTitle != NULL)
memcpy(ctx->imageInfo.MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset,
ctx->MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength);
if(ctx->MediaTitle != NULL)
memcpy(ctx->MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset,
ctx->metadataBlockHeader.mediaTitleLength);
}
@@ -144,10 +144,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaManufacturerOffset + ctx->metadataBlockHeader.mediaManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
if(ctx->imageInfo.MediaManufacturer != NULL)
memcpy(ctx->imageInfo.MediaManufacturer,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
if(ctx->MediaManufacturer != NULL)
memcpy(ctx->MediaManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->metadataBlockHeader.mediaManufacturerLength);
}
@@ -155,9 +154,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength);
if(ctx->imageInfo.MediaModel != NULL)
memcpy(ctx->imageInfo.MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset,
ctx->MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength);
if(ctx->MediaModel != NULL)
memcpy(ctx->MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset,
ctx->metadataBlockHeader.mediaModelLength);
}
@@ -165,10 +164,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaSerialNumberOffset + ctx->metadataBlockHeader.mediaSerialNumberLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
if(ctx->imageInfo.MediaSerialNumber != NULL)
memcpy(ctx->imageInfo.MediaSerialNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
if(ctx->MediaSerialNumber != NULL)
memcpy(ctx->MediaSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->metadataBlockHeader.mediaSerialNumberLength);
}
@@ -176,9 +174,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
if(ctx->imageInfo.MediaBarcode != NULL)
memcpy(ctx->imageInfo.MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset,
ctx->MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
if(ctx->MediaBarcode != NULL)
memcpy(ctx->MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset,
ctx->metadataBlockHeader.mediaBarcodeLength);
}
@@ -186,9 +184,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
if(ctx->imageInfo.MediaPartNumber != NULL)
memcpy(ctx->imageInfo.MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset,
ctx->MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
if(ctx->MediaPartNumber != NULL)
memcpy(ctx->MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset,
ctx->metadataBlockHeader.mediaPartNumberLength);
}
@@ -196,10 +194,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveManufacturerOffset + ctx->metadataBlockHeader.driveManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
if(ctx->imageInfo.DriveManufacturer != NULL)
memcpy(ctx->imageInfo.DriveManufacturer,
ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
if(ctx->DriveManufacturer != NULL)
memcpy(ctx->DriveManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->metadataBlockHeader.driveManufacturerLength);
}
@@ -207,9 +204,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength);
if(ctx->imageInfo.DriveModel != NULL)
memcpy(ctx->imageInfo.DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset,
ctx->DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength);
if(ctx->DriveModel != NULL)
memcpy(ctx->DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset,
ctx->metadataBlockHeader.driveModelLength);
}
@@ -217,10 +214,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveSerialNumberOffset + ctx->metadataBlockHeader.driveSerialNumberLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
if(ctx->imageInfo.DriveSerialNumber != NULL)
memcpy(ctx->imageInfo.DriveSerialNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
if(ctx->DriveSerialNumber != NULL)
memcpy(ctx->DriveSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->metadataBlockHeader.driveSerialNumberLength);
}
@@ -228,9 +224,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveFirmwareRevisionOffset + ctx->metadataBlockHeader.driveFirmwareRevisionLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
if(ctx->imageInfo.DriveFirmwareRevision != NULL)
memcpy(ctx->imageInfo.DriveFirmwareRevision,
ctx->DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
if(ctx->DriveFirmwareRevision != NULL)
memcpy(ctx->DriveFirmwareRevision,
ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionOffset,
ctx->metadataBlockHeader.driveFirmwareRevisionLength);
}
@@ -291,9 +287,9 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry)
TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometryBlock.cylinders,
ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack);
ctx->imageInfo.Cylinders = ctx->geometryBlock.cylinders;
ctx->imageInfo.Heads = ctx->geometryBlock.heads;
ctx->imageInfo.SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack;
ctx->Cylinders = ctx->geometryBlock.cylinders;
ctx->Heads = ctx->geometryBlock.heads;
ctx->SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack;
TRACE("Exiting process_geometry_block()");
}

61
src/close.c
View File

@@ -3158,13 +3158,11 @@ static void write_geometry_block(const aaruformatContext *ctx)
static void write_metadata_block(aaruformatContext *ctx)
{
if(ctx->metadataBlockHeader.identifier != MetadataBlock && ctx->metadataBlockHeader.mediaSequence == 0 &&
ctx->metadataBlockHeader.lastMediaSequence == 0 && ctx->imageInfo.Creator == NULL &&
ctx->imageInfo.Comments == NULL && ctx->imageInfo.MediaTitle == NULL &&
ctx->imageInfo.MediaManufacturer == NULL && ctx->imageInfo.MediaModel == NULL &&
ctx->imageInfo.MediaSerialNumber == NULL && ctx->imageInfo.MediaBarcode == NULL &&
ctx->imageInfo.MediaPartNumber == NULL && ctx->imageInfo.DriveManufacturer == NULL &&
ctx->imageInfo.DriveModel == NULL && ctx->imageInfo.DriveSerialNumber == NULL &&
ctx->imageInfo.DriveFirmwareRevision == NULL)
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)
return;
ctx->metadataBlockHeader.blockSize =
@@ -3182,87 +3180,86 @@ static void write_metadata_block(aaruformatContext *ctx)
uint8_t *buffer = calloc(1, ctx->metadataBlockHeader.blockSize);
if(buffer == NULL) return;
if(ctx->imageInfo.Creator != NULL && ctx->metadataBlockHeader.creatorLength > 0)
if(ctx->Creator != NULL && ctx->metadataBlockHeader.creatorLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.Creator, ctx->metadataBlockHeader.creatorLength);
memcpy(buffer + pos, ctx->Creator, ctx->metadataBlockHeader.creatorLength);
ctx->metadataBlockHeader.creatorOffset = pos;
pos += ctx->metadataBlockHeader.creatorLength;
}
if(ctx->imageInfo.Comments != NULL && ctx->metadataBlockHeader.commentsLength > 0)
if(ctx->Comments != NULL && ctx->metadataBlockHeader.commentsLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.Comments, ctx->metadataBlockHeader.commentsLength);
memcpy(buffer + pos, ctx->Comments, ctx->metadataBlockHeader.commentsLength);
ctx->metadataBlockHeader.commentsOffset = pos;
pos += ctx->metadataBlockHeader.commentsLength;
}
if(ctx->imageInfo.MediaTitle != NULL && ctx->metadataBlockHeader.mediaTitleLength > 0)
if(ctx->MediaTitle != NULL && ctx->metadataBlockHeader.mediaTitleLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.MediaTitle, ctx->metadataBlockHeader.mediaTitleLength);
memcpy(buffer + pos, ctx->MediaTitle, ctx->metadataBlockHeader.mediaTitleLength);
ctx->metadataBlockHeader.mediaTitleOffset = pos;
pos += ctx->metadataBlockHeader.mediaTitleLength;
}
if(ctx->imageInfo.MediaManufacturer != NULL && ctx->metadataBlockHeader.mediaManufacturerLength > 0)
if(ctx->MediaManufacturer != NULL && ctx->metadataBlockHeader.mediaManufacturerLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength);
memcpy(buffer + pos, ctx->MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength);
ctx->metadataBlockHeader.mediaManufacturerOffset = pos;
pos += ctx->metadataBlockHeader.mediaManufacturerLength;
}
if(ctx->imageInfo.MediaModel != NULL && ctx->metadataBlockHeader.mediaModelLength > 0)
if(ctx->MediaModel != NULL && ctx->metadataBlockHeader.mediaModelLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.MediaModel, ctx->metadataBlockHeader.mediaModelLength);
memcpy(buffer + pos, ctx->MediaModel, ctx->metadataBlockHeader.mediaModelLength);
ctx->metadataBlockHeader.mediaModelOffset = pos;
pos += ctx->metadataBlockHeader.mediaModelLength;
}
if(ctx->imageInfo.MediaSerialNumber != NULL && ctx->metadataBlockHeader.mediaSerialNumberLength > 0)
if(ctx->MediaSerialNumber != NULL && ctx->metadataBlockHeader.mediaSerialNumberLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength);
memcpy(buffer + pos, ctx->MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength);
ctx->metadataBlockHeader.mediaSerialNumberOffset = pos;
pos += ctx->metadataBlockHeader.mediaSerialNumberLength;
}
if(ctx->imageInfo.MediaBarcode != NULL && ctx->metadataBlockHeader.mediaBarcodeLength > 0)
if(ctx->MediaBarcode != NULL && ctx->metadataBlockHeader.mediaBarcodeLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength);
memcpy(buffer + pos, ctx->MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength);
ctx->metadataBlockHeader.mediaBarcodeOffset = pos;
pos += ctx->metadataBlockHeader.mediaBarcodeLength;
}
if(ctx->imageInfo.MediaPartNumber != NULL && ctx->metadataBlockHeader.mediaPartNumberLength > 0)
if(ctx->MediaPartNumber != NULL && ctx->metadataBlockHeader.mediaPartNumberLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength);
memcpy(buffer + pos, ctx->MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength);
ctx->metadataBlockHeader.mediaPartNumberOffset = pos;
pos += ctx->metadataBlockHeader.mediaPartNumberLength;
}
if(ctx->imageInfo.DriveManufacturer != NULL && ctx->metadataBlockHeader.driveManufacturerLength > 0)
if(ctx->DriveManufacturer != NULL && ctx->metadataBlockHeader.driveManufacturerLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength);
memcpy(buffer + pos, ctx->DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength);
ctx->metadataBlockHeader.driveManufacturerOffset = pos;
pos += ctx->metadataBlockHeader.driveManufacturerLength;
}
if(ctx->imageInfo.DriveModel != NULL && ctx->metadataBlockHeader.driveModelLength > 0)
if(ctx->DriveModel != NULL && ctx->metadataBlockHeader.driveModelLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.DriveModel, ctx->metadataBlockHeader.driveModelLength);
memcpy(buffer + pos, ctx->DriveModel, ctx->metadataBlockHeader.driveModelLength);
ctx->metadataBlockHeader.driveModelOffset = pos;
pos += ctx->metadataBlockHeader.driveModelLength;
}
if(ctx->imageInfo.DriveSerialNumber != NULL && ctx->metadataBlockHeader.driveSerialNumberLength > 0)
if(ctx->DriveSerialNumber != NULL && ctx->metadataBlockHeader.driveSerialNumberLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength);
memcpy(buffer + pos, ctx->DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength);
ctx->metadataBlockHeader.driveSerialNumberOffset = pos;
pos += ctx->metadataBlockHeader.driveSerialNumberLength;
}
if(ctx->imageInfo.DriveFirmwareRevision != NULL && ctx->metadataBlockHeader.driveFirmwareRevisionLength > 0)
if(ctx->DriveFirmwareRevision != NULL && ctx->metadataBlockHeader.driveFirmwareRevisionLength > 0)
{
memcpy(buffer + pos, ctx->imageInfo.DriveFirmwareRevision,
ctx->metadataBlockHeader.driveFirmwareRevisionLength);
memcpy(buffer + pos, ctx->DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength);
ctx->metadataBlockHeader.driveFirmwareRevisionOffset = pos;
}

102
src/metadata.c
View File

@@ -265,9 +265,9 @@ int32_t aaruf_set_geometry(void *context, const uint32_t cylinders, const uint32
ctx->geometryBlock.cylinders = cylinders;
ctx->geometryBlock.heads = heads;
ctx->geometryBlock.sectorsPerTrack = sectors_per_track;
ctx->imageInfo.Cylinders = cylinders;
ctx->imageInfo.Heads = heads;
ctx->imageInfo.SectorsPerTrack = sectors_per_track;
ctx->Cylinders = cylinders;
ctx->Heads = heads;
ctx->SectorsPerTrack = 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;
@@ -536,8 +536,8 @@ 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->imageInfo.Creator != NULL) free(ctx->imageInfo.Creator);
ctx->imageInfo.Creator = copy;
if(ctx->Creator != NULL) free(ctx->Creator);
ctx->Creator = copy;
ctx->metadataBlockHeader.creatorLength = length;
TRACE("Exiting aaruf_set_creator(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -650,8 +650,8 @@ 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->imageInfo.Comments != NULL) free(ctx->imageInfo.Comments);
ctx->imageInfo.Comments = copy;
if(ctx->Comments != NULL) free(ctx->Comments);
ctx->Comments = copy;
ctx->metadataBlockHeader.commentsLength = length;
TRACE("Exiting aaruf_set_comments(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -763,8 +763,8 @@ 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->imageInfo.MediaTitle != NULL) free(ctx->imageInfo.MediaTitle);
ctx->imageInfo.MediaTitle = copy;
if(ctx->MediaTitle != NULL) free(ctx->MediaTitle);
ctx->MediaTitle = copy;
ctx->metadataBlockHeader.mediaTitleLength = length;
TRACE("Exiting aaruf_set_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -875,8 +875,8 @@ 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->imageInfo.MediaManufacturer != NULL) free(ctx->imageInfo.MediaManufacturer);
ctx->imageInfo.MediaManufacturer = copy;
if(ctx->MediaManufacturer != NULL) free(ctx->MediaManufacturer);
ctx->MediaManufacturer = copy;
ctx->metadataBlockHeader.mediaManufacturerLength = length;
TRACE("Exiting aaruf_set_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -982,8 +982,8 @@ 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->imageInfo.MediaModel != NULL) free(ctx->imageInfo.MediaModel);
ctx->imageInfo.MediaModel = copy;
if(ctx->MediaModel != NULL) free(ctx->MediaModel);
ctx->MediaModel = copy;
ctx->metadataBlockHeader.mediaModelLength = length;
TRACE("Exiting aaruf_set_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1097,8 +1097,8 @@ 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->imageInfo.MediaSerialNumber != NULL) free(ctx->imageInfo.MediaSerialNumber);
ctx->imageInfo.MediaSerialNumber = copy;
if(ctx->MediaSerialNumber != NULL) free(ctx->MediaSerialNumber);
ctx->MediaSerialNumber = copy;
ctx->metadataBlockHeader.mediaSerialNumberLength = length;
TRACE("Exiting aaruf_set_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1219,8 +1219,8 @@ 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->imageInfo.MediaBarcode != NULL) free(ctx->imageInfo.MediaBarcode);
ctx->imageInfo.MediaBarcode = copy;
if(ctx->MediaBarcode != NULL) free(ctx->MediaBarcode);
ctx->MediaBarcode = copy;
ctx->metadataBlockHeader.mediaBarcodeLength = length;
TRACE("Exiting aaruf_set_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1340,8 +1340,8 @@ 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->imageInfo.MediaPartNumber != NULL) free(ctx->imageInfo.MediaPartNumber);
ctx->imageInfo.MediaPartNumber = copy;
if(ctx->MediaPartNumber != NULL) free(ctx->MediaPartNumber);
ctx->MediaPartNumber = copy;
ctx->metadataBlockHeader.mediaPartNumberLength = length;
TRACE("Exiting aaruf_set_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1455,8 +1455,8 @@ 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->imageInfo.DriveManufacturer != NULL) free(ctx->imageInfo.DriveManufacturer);
ctx->imageInfo.DriveManufacturer = copy;
if(ctx->DriveManufacturer != NULL) free(ctx->DriveManufacturer);
ctx->DriveManufacturer = copy;
ctx->metadataBlockHeader.driveManufacturerLength = length;
TRACE("Exiting aaruf_set_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1577,8 +1577,8 @@ 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->imageInfo.DriveModel != NULL) free(ctx->imageInfo.DriveModel);
ctx->imageInfo.DriveModel = copy;
if(ctx->DriveModel != NULL) free(ctx->DriveModel);
ctx->DriveModel = copy;
ctx->metadataBlockHeader.driveModelLength = length;
TRACE("Exiting aaruf_set_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1701,8 +1701,8 @@ 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->imageInfo.DriveSerialNumber != NULL) free(ctx->imageInfo.DriveSerialNumber);
ctx->imageInfo.DriveSerialNumber = copy;
if(ctx->DriveSerialNumber != NULL) free(ctx->DriveSerialNumber);
ctx->DriveSerialNumber = copy;
ctx->metadataBlockHeader.driveSerialNumberLength = length;
TRACE("Exiting aaruf_set_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -1836,8 +1836,8 @@ 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->imageInfo.DriveFirmwareRevision != NULL) free(ctx->imageInfo.DriveFirmwareRevision);
ctx->imageInfo.DriveFirmwareRevision = copy;
if(ctx->DriveFirmwareRevision != NULL) free(ctx->DriveFirmwareRevision);
ctx->DriveFirmwareRevision = copy;
ctx->metadataBlockHeader.driveFirmwareRevisionLength = length;
TRACE("Exiting aaruf_set_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, data, length);
@@ -2425,7 +2425,7 @@ 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->imageInfo.Creator == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->Creator == NULL ||
ctx->metadataBlockHeader.creatorLength == 0)
{
FATAL("No metadata block present");
@@ -2443,7 +2443,7 @@ int32_t aaruf_get_creator(const void *context, uint8_t *buffer, int32_t *length)
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.Creator, ctx->metadataBlockHeader.creatorLength);
memcpy(buffer, ctx->Creator, ctx->metadataBlockHeader.creatorLength);
*length = ctx->metadataBlockHeader.creatorLength;
TRACE("Exiting aaruf_get_creator(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2497,7 +2497,7 @@ 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->imageInfo.Comments == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->Comments == NULL ||
ctx->metadataBlockHeader.commentsLength == 0)
{
FATAL("No metadata block present");
@@ -2515,7 +2515,7 @@ int32_t aaruf_get_comments(const void *context, uint8_t *buffer, int32_t *length
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.Comments, ctx->metadataBlockHeader.commentsLength);
memcpy(buffer, ctx->Comments, ctx->metadataBlockHeader.commentsLength);
*length = ctx->metadataBlockHeader.commentsLength;
TRACE("Exiting aaruf_get_comments(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2567,7 +2567,7 @@ 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->imageInfo.MediaTitle == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaTitle == NULL ||
ctx->metadataBlockHeader.mediaTitleLength == 0)
{
FATAL("No metadata block present");
@@ -2585,7 +2585,7 @@ int32_t aaruf_get_media_title(const void *context, uint8_t *buffer, int32_t *len
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaTitle, ctx->metadataBlockHeader.mediaTitleLength);
memcpy(buffer, ctx->MediaTitle, ctx->metadataBlockHeader.mediaTitleLength);
*length = ctx->metadataBlockHeader.mediaTitleLength;
TRACE("Exiting aaruf_get_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2637,7 +2637,7 @@ int32_t aaruf_get_media_manufacturer(const void *context, uint8_t *buffer, int32
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->imageInfo.MediaManufacturer == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaManufacturer == NULL ||
ctx->metadataBlockHeader.mediaManufacturerLength == 0)
{
FATAL("No metadata block present");
@@ -2655,7 +2655,7 @@ int32_t aaruf_get_media_manufacturer(const void *context, uint8_t *buffer, int32
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength);
memcpy(buffer, ctx->MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength);
*length = ctx->metadataBlockHeader.mediaManufacturerLength;
TRACE("Exiting aaruf_get_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2707,7 +2707,7 @@ 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->imageInfo.MediaModel == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaModel == NULL ||
ctx->metadataBlockHeader.mediaModelLength == 0)
{
FATAL("No metadata block present");
@@ -2725,7 +2725,7 @@ int32_t aaruf_get_media_model(const void *context, uint8_t *buffer, int32_t *len
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaModel, ctx->metadataBlockHeader.mediaModelLength);
memcpy(buffer, ctx->MediaModel, ctx->metadataBlockHeader.mediaModelLength);
*length = ctx->metadataBlockHeader.mediaModelLength;
TRACE("Exiting aaruf_get_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2777,7 +2777,7 @@ 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->imageInfo.MediaSerialNumber == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaSerialNumber == NULL ||
ctx->metadataBlockHeader.mediaSerialNumberLength == 0)
{
FATAL("No metadata block present");
@@ -2795,7 +2795,7 @@ int32_t aaruf_get_media_serial_number(const void *context, uint8_t *buffer, int3
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength);
memcpy(buffer, ctx->MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength);
*length = ctx->metadataBlockHeader.mediaSerialNumberLength;
TRACE("Exiting aaruf_get_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2846,7 +2846,7 @@ 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->imageInfo.MediaBarcode == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaBarcode == NULL ||
ctx->metadataBlockHeader.mediaBarcodeLength == 0)
{
FATAL("No metadata block present");
@@ -2864,7 +2864,7 @@ int32_t aaruf_get_media_barcode(const void *context, uint8_t *buffer, int32_t *l
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength);
memcpy(buffer, ctx->MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength);
*length = ctx->metadataBlockHeader.mediaBarcodeLength;
TRACE("Exiting aaruf_get_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2917,7 +2917,7 @@ 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->imageInfo.MediaPartNumber == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->MediaPartNumber == NULL ||
ctx->metadataBlockHeader.mediaPartNumberLength == 0)
{
FATAL("No metadata block present");
@@ -2935,7 +2935,7 @@ int32_t aaruf_get_media_part_number(const void *context, uint8_t *buffer, int32_
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength);
memcpy(buffer, ctx->MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength);
*length = ctx->metadataBlockHeader.mediaPartNumberLength;
TRACE("Exiting aaruf_get_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -2989,7 +2989,7 @@ int32_t aaruf_get_drive_manufacturer(const void *context, uint8_t *buffer, int32
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->imageInfo.DriveManufacturer == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveManufacturer == NULL ||
ctx->metadataBlockHeader.driveManufacturerLength == 0)
{
FATAL("No metadata block present");
@@ -3007,7 +3007,7 @@ int32_t aaruf_get_drive_manufacturer(const void *context, uint8_t *buffer, int32
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength);
memcpy(buffer, ctx->DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength);
*length = ctx->metadataBlockHeader.driveManufacturerLength;
TRACE("Exiting aaruf_get_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -3059,7 +3059,7 @@ 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->imageInfo.DriveModel == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveModel == NULL ||
ctx->metadataBlockHeader.driveModelLength == 0)
{
FATAL("No metadata block present");
@@ -3077,7 +3077,7 @@ int32_t aaruf_get_drive_model(const void *context, uint8_t *buffer, int32_t *len
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveModel, ctx->metadataBlockHeader.driveModelLength);
memcpy(buffer, ctx->DriveModel, ctx->metadataBlockHeader.driveModelLength);
*length = ctx->metadataBlockHeader.driveModelLength;
TRACE("Exiting aaruf_get_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -3129,7 +3129,7 @@ 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->imageInfo.DriveSerialNumber == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveSerialNumber == NULL ||
ctx->metadataBlockHeader.driveSerialNumberLength == 0)
{
FATAL("No metadata block present");
@@ -3147,7 +3147,7 @@ int32_t aaruf_get_drive_serial_number(const void *context, uint8_t *buffer, int3
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength);
memcpy(buffer, ctx->DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength);
*length = ctx->metadataBlockHeader.driveSerialNumberLength;
TRACE("Exiting aaruf_get_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);
@@ -3199,7 +3199,7 @@ int32_t aaruf_get_drive_firmware_revision(const void *context, uint8_t *buffer,
return AARUF_ERROR_NOT_AARUFORMAT;
}
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->imageInfo.DriveFirmwareRevision == NULL ||
if(ctx->metadataBlockHeader.identifier != MetadataBlock || ctx->DriveFirmwareRevision == NULL ||
ctx->metadataBlockHeader.driveFirmwareRevisionLength == 0)
{
FATAL("No metadata block present");
@@ -3217,7 +3217,7 @@ int32_t aaruf_get_drive_firmware_revision(const void *context, uint8_t *buffer,
}
// Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength);
memcpy(buffer, ctx->DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength);
*length = ctx->metadataBlockHeader.driveFirmwareRevisionLength;
TRACE("Exiting aaruf_get_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length);

6
src/open.c
View File

@@ -440,9 +440,9 @@ void *aaruf_open(const char *filepath) // NOLINT(readability-function-size)
if(ctx->geometryBlock.identifier != GeometryBlock && ctx->imageInfo.XmlMediaType == BlockMedia)
{
ctx->imageInfo.Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->imageInfo.Heads = 16;
ctx->imageInfo.SectorsPerTrack = 63;
ctx->Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->Heads = 16;
ctx->SectorsPerTrack = 63;
}
// Initialize caches

84
tool/compare.c
View File

@@ -321,13 +321,13 @@ int compare(const char *path1, const char *path2)
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);
}
if(ctx1->imageInfo.Creator != NULL || ctx2->imageInfo.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->imageInfo.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->imageInfo.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: ");
@@ -342,53 +342,53 @@ int compare(const char *path1, const char *path2)
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);
if(ctx1->imageInfo.Comments != NULL || ctx2->imageInfo.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->imageInfo.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->imageInfo.Comments);
tb_printf(mid_x + 12, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->Comments);
}
if(ctx1->imageInfo.MediaTitle != NULL || ctx2->imageInfo.MediaTitle != NULL)
if(ctx1->MediaTitle != NULL || ctx2->MediaTitle != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media title: ");
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.MediaTitle);
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaTitle);
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->imageInfo.MediaTitle);
tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaTitle);
}
if(ctx1->imageInfo.MediaManufacturer != NULL || ctx2->imageInfo.MediaManufacturer != NULL)
if(ctx1->MediaManufacturer != NULL || ctx2->MediaManufacturer != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media manufacturer: ");
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.MediaManufacturer);
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaManufacturer);
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->imageInfo.MediaManufacturer);
tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaManufacturer);
}
if(ctx1->imageInfo.MediaSerialNumber != NULL || ctx2->imageInfo.MediaSerialNumber != NULL)
if(ctx1->MediaSerialNumber != NULL || ctx2->MediaSerialNumber != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media serial number: ");
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.MediaSerialNumber);
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaSerialNumber);
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->imageInfo.MediaSerialNumber);
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaSerialNumber);
}
if(ctx1->imageInfo.MediaBarcode != NULL || ctx2->imageInfo.MediaBarcode != NULL)
if(ctx1->MediaBarcode != NULL || ctx2->MediaBarcode != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media barcode: ");
tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.MediaBarcode);
tb_printf(17, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaBarcode);
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->imageInfo.MediaBarcode);
tb_printf(mid_x + 17, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaBarcode);
}
if(ctx1->imageInfo.MediaPartNumber != NULL || ctx2->imageInfo.MediaPartNumber != NULL)
if(ctx1->MediaPartNumber != NULL || ctx2->MediaPartNumber != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media part number: ");
tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.MediaPartNumber);
tb_printf(21, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->MediaPartNumber);
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->imageInfo.MediaPartNumber);
tb_printf(mid_x + 21, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->MediaPartNumber);
}
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Media type: ");
tb_printf(14, lr++, TB_WHITE, TB_BLUE, "%u", ctx1->imageInfo.MediaType);
@@ -396,47 +396,47 @@ int compare(const char *path1, const char *path2)
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);
if(ctx1->imageInfo.MediaSequence > 0 || ctx1->imageInfo.LastMediaSequence > 0 ||
ctx2->imageInfo.MediaSequence > 0 || ctx2->imageInfo.LastMediaSequence > 0)
if(ctx1->MediaSequence > 0 || ctx1->LastMediaSequence > 0 ||
ctx2->MediaSequence > 0 || ctx2->LastMediaSequence > 0)
{
tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media",
ctx1->imageInfo.MediaSequence, ctx1->imageInfo.LastMediaSequence);
ctx1->MediaSequence, ctx1->LastMediaSequence);
tb_printf(mid_x + 2, rr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media is number %d in a set of %d media",
ctx2->imageInfo.MediaSequence, ctx2->imageInfo.LastMediaSequence);
ctx2->MediaSequence, ctx2->LastMediaSequence);
}
if(ctx1->imageInfo.DriveManufacturer != NULL || ctx2->imageInfo.DriveManufacturer != NULL)
if(ctx1->DriveManufacturer != NULL || ctx2->DriveManufacturer != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive manufacturer: ");
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.DriveManufacturer);
tb_printf(22, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveManufacturer);
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->imageInfo.DriveManufacturer);
tb_printf(mid_x + 22, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveManufacturer);
}
if(ctx1->imageInfo.DriveModel != NULL || ctx2->imageInfo.DriveModel != NULL)
if(ctx1->DriveModel != NULL || ctx2->DriveModel != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive model: ");
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.DriveModel);
tb_printf(15, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveModel);
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->imageInfo.DriveModel);
tb_printf(mid_x + 15, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveModel);
}
if(ctx1->imageInfo.DriveSerialNumber != NULL || ctx2->imageInfo.DriveSerialNumber != NULL)
if(ctx1->DriveSerialNumber != NULL || ctx2->DriveSerialNumber != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive serial number: ");
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.DriveSerialNumber);
tb_printf(23, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveSerialNumber);
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->imageInfo.DriveSerialNumber);
tb_printf(mid_x + 23, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveSerialNumber);
}
if(ctx1->imageInfo.DriveFirmwareRevision != NULL || ctx2->imageInfo.DriveFirmwareRevision != NULL)
if(ctx1->DriveFirmwareRevision != NULL || ctx2->DriveFirmwareRevision != NULL)
{
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "Drive firmware revision: ");
tb_printf(27, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->imageInfo.DriveFirmwareRevision);
tb_printf(27, lr++, TB_WHITE, TB_BLUE, "%s", ctx1->DriveFirmwareRevision);
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->imageInfo.DriveFirmwareRevision);
tb_printf(mid_x + 27, rr++, TB_WHITE, TB_BLUE, "%s", ctx2->DriveFirmwareRevision);
}
tb_printf(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "XML media type: ");
tb_printf(18, lr++, TB_WHITE, TB_BLUE, "%d", ctx1->imageInfo.XmlMediaType);
@@ -444,15 +444,15 @@ int compare(const char *path1, const char *path2)
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.XmlMediaType);
if(ctx1->imageInfo.Cylinders > 0 || ctx1->imageInfo.Heads > 0 || ctx1->imageInfo.SectorsPerTrack > 0 ||
ctx2->imageInfo.Cylinders > 0 || ctx2->imageInfo.Heads > 0 || ctx2->imageInfo.SectorsPerTrack > 0)
if(ctx1->Cylinders > 0 || ctx1->Heads > 0 || ctx1->SectorsPerTrack > 0 ||
ctx2->Cylinders > 0 || ctx2->Heads > 0 || ctx2->SectorsPerTrack > 0)
{
tb_printf(2, lr++, TB_WHITE | TB_BOLD, TB_BLUE, "Media has %d cylinders, %d heads and %d sectors per track",
ctx1->imageInfo.Cylinders, ctx1->imageInfo.Heads, ctx1->imageInfo.SectorsPerTrack);
ctx1->Cylinders, ctx1->Heads, ctx1->SectorsPerTrack);
tb_printf(mid_x + 2, rr++, TB_WHITE | TB_BOLD, TB_BLUE,
"Media has %d cylinders, %d heads and %d sectors per track", ctx2->imageInfo.Cylinders,
ctx2->imageInfo.Heads, ctx2->imageInfo.SectorsPerTrack);
"Media has %d cylinders, %d heads and %d sectors per track", ctx2->Cylinders,
ctx2->Heads, ctx2->SectorsPerTrack);
}
tb_present();