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

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

19
include/aaru.h
View File

@@ -815,29 +815,10 @@ typedef struct ImageInfo // NOLINT
uint8_t *Version; ///< Image version uint8_t *Version; ///< Image version
uint8_t *Application; ///< Application that created the image uint8_t *Application; ///< Application that created the image
uint8_t *ApplicationVersion; ///< Version of the 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 CreationTime; ///< Image creation time
int64_t LastModificationTime; ///< Image last modification 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 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 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)
} ImageInfo; } ImageInfo;
/** \addtogroup SectorTags Per-sector metadata tag types /** \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. struct DumpHardwareEntriesWithData *dumpHardwareEntriesWithData; ///< Array of dump hardware entries + strings.
AaruMetadataJsonBlockHeader jsonBlockHeader; ///< JSON metadata block header (if present). AaruMetadataJsonBlockHeader jsonBlockHeader; ///< JSON metadata block header (if present).
uint8_t *jsonBlock; ///< JSON metadata block payload (UTF-8). 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 */ /* Optical information */
TracksHeader tracksHeader; ///< Tracks header (optical) if present. 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) if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0)
{ {
ctx->imageInfo.MediaSequence = ctx->metadataBlockHeader.mediaSequence; ctx->MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->imageInfo.LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence; ctx->LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
TRACE("Setting media sequence as %d of %d", ctx->imageInfo.MediaSequence, ctx->imageInfo.LastMediaSequence); TRACE("Setting media sequence as %d of %d", ctx->MediaSequence, ctx->LastMediaSequence);
} }
if(ctx->metadataBlockHeader.creatorLength > 0 && if(ctx->metadataBlockHeader.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <= ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength); ctx->Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength);
if(ctx->imageInfo.Creator != NULL) if(ctx->Creator != NULL)
memcpy(ctx->imageInfo.Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset, memcpy(ctx->Creator, ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset,
ctx->metadataBlockHeader.creatorLength); ctx->metadataBlockHeader.creatorLength);
} }
@@ -124,9 +124,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <= ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength); ctx->Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength);
if(ctx->imageInfo.Comments != NULL) if(ctx->Comments != NULL)
memcpy(ctx->imageInfo.Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset, memcpy(ctx->Comments, ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset,
ctx->metadataBlockHeader.commentsLength); ctx->metadataBlockHeader.commentsLength);
} }
@@ -134,9 +134,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <= ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength); ctx->MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength);
if(ctx->imageInfo.MediaTitle != NULL) if(ctx->MediaTitle != NULL)
memcpy(ctx->imageInfo.MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset, memcpy(ctx->MediaTitle, ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset,
ctx->metadataBlockHeader.mediaTitleLength); ctx->metadataBlockHeader.mediaTitleLength);
} }
@@ -144,10 +144,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaManufacturerOffset + ctx->metadataBlockHeader.mediaManufacturerLength <= ctx->metadataBlockHeader.mediaManufacturerOffset + ctx->metadataBlockHeader.mediaManufacturerLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength); ctx->MediaManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
if(ctx->imageInfo.MediaManufacturer != NULL) if(ctx->MediaManufacturer != NULL)
memcpy(ctx->imageInfo.MediaManufacturer, memcpy(ctx->MediaManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->metadataBlockHeader.mediaManufacturerLength); ctx->metadataBlockHeader.mediaManufacturerLength);
} }
@@ -155,9 +154,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <= ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength); ctx->MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelLength);
if(ctx->imageInfo.MediaModel != NULL) if(ctx->MediaModel != NULL)
memcpy(ctx->imageInfo.MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset, memcpy(ctx->MediaModel, ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset,
ctx->metadataBlockHeader.mediaModelLength); ctx->metadataBlockHeader.mediaModelLength);
} }
@@ -165,10 +164,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaSerialNumberOffset + ctx->metadataBlockHeader.mediaSerialNumberLength <= ctx->metadataBlockHeader.mediaSerialNumberOffset + ctx->metadataBlockHeader.mediaSerialNumberLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength); ctx->MediaSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
if(ctx->imageInfo.MediaSerialNumber != NULL) if(ctx->MediaSerialNumber != NULL)
memcpy(ctx->imageInfo.MediaSerialNumber, memcpy(ctx->MediaSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->metadataBlockHeader.mediaSerialNumberLength); ctx->metadataBlockHeader.mediaSerialNumberLength);
} }
@@ -176,9 +174,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <= ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength); ctx->MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
if(ctx->imageInfo.MediaBarcode != NULL) if(ctx->MediaBarcode != NULL)
memcpy(ctx->imageInfo.MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset, memcpy(ctx->MediaBarcode, ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset,
ctx->metadataBlockHeader.mediaBarcodeLength); ctx->metadataBlockHeader.mediaBarcodeLength);
} }
@@ -186,9 +184,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <= ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength); ctx->MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
if(ctx->imageInfo.MediaPartNumber != NULL) if(ctx->MediaPartNumber != NULL)
memcpy(ctx->imageInfo.MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset, memcpy(ctx->MediaPartNumber, ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset,
ctx->metadataBlockHeader.mediaPartNumberLength); ctx->metadataBlockHeader.mediaPartNumberLength);
} }
@@ -196,10 +194,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveManufacturerOffset + ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlockHeader.driveManufacturerOffset + ctx->metadataBlockHeader.driveManufacturerLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength); ctx->DriveManufacturer = (uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
if(ctx->imageInfo.DriveManufacturer != NULL) if(ctx->DriveManufacturer != NULL)
memcpy(ctx->imageInfo.DriveManufacturer, memcpy(ctx->DriveManufacturer, ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->metadataBlockHeader.driveManufacturerLength); ctx->metadataBlockHeader.driveManufacturerLength);
} }
@@ -207,9 +204,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <= ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength); ctx->DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength);
if(ctx->imageInfo.DriveModel != NULL) if(ctx->DriveModel != NULL)
memcpy(ctx->imageInfo.DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset, memcpy(ctx->DriveModel, ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset,
ctx->metadataBlockHeader.driveModelLength); ctx->metadataBlockHeader.driveModelLength);
} }
@@ -217,10 +214,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveSerialNumberOffset + ctx->metadataBlockHeader.driveSerialNumberLength <= ctx->metadataBlockHeader.driveSerialNumberOffset + ctx->metadataBlockHeader.driveSerialNumberLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength); ctx->DriveSerialNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
if(ctx->imageInfo.DriveSerialNumber != NULL) if(ctx->DriveSerialNumber != NULL)
memcpy(ctx->imageInfo.DriveSerialNumber, memcpy(ctx->DriveSerialNumber, ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->metadataBlockHeader.driveSerialNumberLength); ctx->metadataBlockHeader.driveSerialNumberLength);
} }
@@ -228,9 +224,9 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
ctx->metadataBlockHeader.driveFirmwareRevisionOffset + ctx->metadataBlockHeader.driveFirmwareRevisionLength <= ctx->metadataBlockHeader.driveFirmwareRevisionOffset + ctx->metadataBlockHeader.driveFirmwareRevisionLength <=
ctx->metadataBlockHeader.blockSize) ctx->metadataBlockHeader.blockSize)
{ {
ctx->imageInfo.DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength); ctx->DriveFirmwareRevision = (uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
if(ctx->imageInfo.DriveFirmwareRevision != NULL) if(ctx->DriveFirmwareRevision != NULL)
memcpy(ctx->imageInfo.DriveFirmwareRevision, memcpy(ctx->DriveFirmwareRevision,
ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionOffset, ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionOffset,
ctx->metadataBlockHeader.driveFirmwareRevisionLength); 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, TRACE("Geometry set to %d cylinders %d heads %d sectors per track", ctx->geometryBlock.cylinders,
ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack); ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack);
ctx->imageInfo.Cylinders = ctx->geometryBlock.cylinders; ctx->Cylinders = ctx->geometryBlock.cylinders;
ctx->imageInfo.Heads = ctx->geometryBlock.heads; ctx->Heads = ctx->geometryBlock.heads;
ctx->imageInfo.SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack; ctx->SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack;
TRACE("Exiting process_geometry_block()"); 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) static void write_metadata_block(aaruformatContext *ctx)
{ {
if(ctx->metadataBlockHeader.identifier != MetadataBlock && ctx->metadataBlockHeader.mediaSequence == 0 && if(ctx->metadataBlockHeader.identifier != MetadataBlock && ctx->metadataBlockHeader.mediaSequence == 0 &&
ctx->metadataBlockHeader.lastMediaSequence == 0 && ctx->imageInfo.Creator == NULL && ctx->metadataBlockHeader.lastMediaSequence == 0 && ctx->Creator == NULL && ctx->Comments == NULL &&
ctx->imageInfo.Comments == NULL && ctx->imageInfo.MediaTitle == NULL && ctx->MediaTitle == NULL && ctx->MediaManufacturer == NULL && ctx->MediaModel == NULL &&
ctx->imageInfo.MediaManufacturer == NULL && ctx->imageInfo.MediaModel == NULL && ctx->MediaSerialNumber == NULL && ctx->MediaBarcode == NULL && ctx->MediaPartNumber == NULL &&
ctx->imageInfo.MediaSerialNumber == NULL && ctx->imageInfo.MediaBarcode == NULL && ctx->DriveManufacturer == NULL && ctx->DriveModel == NULL && ctx->DriveSerialNumber == NULL &&
ctx->imageInfo.MediaPartNumber == NULL && ctx->imageInfo.DriveManufacturer == NULL && ctx->DriveFirmwareRevision == NULL)
ctx->imageInfo.DriveModel == NULL && ctx->imageInfo.DriveSerialNumber == NULL &&
ctx->imageInfo.DriveFirmwareRevision == NULL)
return; return;
ctx->metadataBlockHeader.blockSize = ctx->metadataBlockHeader.blockSize =
@@ -3182,87 +3180,86 @@ static void write_metadata_block(aaruformatContext *ctx)
uint8_t *buffer = calloc(1, ctx->metadataBlockHeader.blockSize); uint8_t *buffer = calloc(1, ctx->metadataBlockHeader.blockSize);
if(buffer == NULL) return; 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; ctx->metadataBlockHeader.creatorOffset = pos;
pos += ctx->metadataBlockHeader.creatorLength; 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; ctx->metadataBlockHeader.commentsOffset = pos;
pos += ctx->metadataBlockHeader.commentsLength; 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; ctx->metadataBlockHeader.mediaTitleOffset = pos;
pos += ctx->metadataBlockHeader.mediaTitleLength; 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; ctx->metadataBlockHeader.mediaManufacturerOffset = pos;
pos += ctx->metadataBlockHeader.mediaManufacturerLength; 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; ctx->metadataBlockHeader.mediaModelOffset = pos;
pos += ctx->metadataBlockHeader.mediaModelLength; 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; ctx->metadataBlockHeader.mediaSerialNumberOffset = pos;
pos += ctx->metadataBlockHeader.mediaSerialNumberLength; 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; ctx->metadataBlockHeader.mediaBarcodeOffset = pos;
pos += ctx->metadataBlockHeader.mediaBarcodeLength; 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; ctx->metadataBlockHeader.mediaPartNumberOffset = pos;
pos += ctx->metadataBlockHeader.mediaPartNumberLength; 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; ctx->metadataBlockHeader.driveManufacturerOffset = pos;
pos += ctx->metadataBlockHeader.driveManufacturerLength; 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; ctx->metadataBlockHeader.driveModelOffset = pos;
pos += ctx->metadataBlockHeader.driveModelLength; 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; ctx->metadataBlockHeader.driveSerialNumberOffset = pos;
pos += ctx->metadataBlockHeader.driveSerialNumberLength; 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, memcpy(buffer + pos, ctx->DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength);
ctx->metadataBlockHeader.driveFirmwareRevisionLength);
ctx->metadataBlockHeader.driveFirmwareRevisionOffset = pos; 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.cylinders = cylinders;
ctx->geometryBlock.heads = heads; ctx->geometryBlock.heads = heads;
ctx->geometryBlock.sectorsPerTrack = sectors_per_track; ctx->geometryBlock.sectorsPerTrack = sectors_per_track;
ctx->imageInfo.Cylinders = cylinders; ctx->Cylinders = cylinders;
ctx->imageInfo.Heads = heads; ctx->Heads = heads;
ctx->imageInfo.SectorsPerTrack = sectors_per_track; ctx->SectorsPerTrack = sectors_per_track;
TRACE("Exiting aaruf_set_geometry(%p, %u, %u, %u) = AARUF_STATUS_OK", context, cylinders, heads, 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; 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.Creator != NULL) free(ctx->imageInfo.Creator); if(ctx->Creator != NULL) free(ctx->Creator);
ctx->imageInfo.Creator = copy; ctx->Creator = copy;
ctx->metadataBlockHeader.creatorLength = length; ctx->metadataBlockHeader.creatorLength = length;
TRACE("Exiting aaruf_set_creator(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.Comments != NULL) free(ctx->imageInfo.Comments); if(ctx->Comments != NULL) free(ctx->Comments);
ctx->imageInfo.Comments = copy; ctx->Comments = copy;
ctx->metadataBlockHeader.commentsLength = length; ctx->metadataBlockHeader.commentsLength = length;
TRACE("Exiting aaruf_set_comments(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.MediaTitle != NULL) free(ctx->imageInfo.MediaTitle); if(ctx->MediaTitle != NULL) free(ctx->MediaTitle);
ctx->imageInfo.MediaTitle = copy; ctx->MediaTitle = copy;
ctx->metadataBlockHeader.mediaTitleLength = length; ctx->metadataBlockHeader.mediaTitleLength = length;
TRACE("Exiting aaruf_set_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.MediaManufacturer != NULL) free(ctx->imageInfo.MediaManufacturer); if(ctx->MediaManufacturer != NULL) free(ctx->MediaManufacturer);
ctx->imageInfo.MediaManufacturer = copy; ctx->MediaManufacturer = copy;
ctx->metadataBlockHeader.mediaManufacturerLength = length; ctx->metadataBlockHeader.mediaManufacturerLength = length;
TRACE("Exiting aaruf_set_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.MediaModel != NULL) free(ctx->imageInfo.MediaModel); if(ctx->MediaModel != NULL) free(ctx->MediaModel);
ctx->imageInfo.MediaModel = copy; ctx->MediaModel = copy;
ctx->metadataBlockHeader.mediaModelLength = length; ctx->metadataBlockHeader.mediaModelLength = length;
TRACE("Exiting aaruf_set_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.MediaSerialNumber != NULL) free(ctx->imageInfo.MediaSerialNumber); if(ctx->MediaSerialNumber != NULL) free(ctx->MediaSerialNumber);
ctx->imageInfo.MediaSerialNumber = copy; ctx->MediaSerialNumber = copy;
ctx->metadataBlockHeader.mediaSerialNumberLength = length; ctx->metadataBlockHeader.mediaSerialNumberLength = length;
TRACE("Exiting aaruf_set_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.MediaBarcode != NULL) free(ctx->imageInfo.MediaBarcode); if(ctx->MediaBarcode != NULL) free(ctx->MediaBarcode);
ctx->imageInfo.MediaBarcode = copy; ctx->MediaBarcode = copy;
ctx->metadataBlockHeader.mediaBarcodeLength = length; ctx->metadataBlockHeader.mediaBarcodeLength = length;
TRACE("Exiting aaruf_set_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.MediaPartNumber != NULL) free(ctx->imageInfo.MediaPartNumber); if(ctx->MediaPartNumber != NULL) free(ctx->MediaPartNumber);
ctx->imageInfo.MediaPartNumber = copy; ctx->MediaPartNumber = copy;
ctx->metadataBlockHeader.mediaPartNumberLength = length; ctx->metadataBlockHeader.mediaPartNumberLength = length;
TRACE("Exiting aaruf_set_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.DriveManufacturer != NULL) free(ctx->imageInfo.DriveManufacturer); if(ctx->DriveManufacturer != NULL) free(ctx->DriveManufacturer);
ctx->imageInfo.DriveManufacturer = copy; ctx->DriveManufacturer = copy;
ctx->metadataBlockHeader.driveManufacturerLength = length; ctx->metadataBlockHeader.driveManufacturerLength = length;
TRACE("Exiting aaruf_set_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.DriveModel != NULL) free(ctx->imageInfo.DriveModel); if(ctx->DriveModel != NULL) free(ctx->DriveModel);
ctx->imageInfo.DriveModel = copy; ctx->DriveModel = copy;
ctx->metadataBlockHeader.driveModelLength = length; ctx->metadataBlockHeader.driveModelLength = length;
TRACE("Exiting aaruf_set_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.DriveSerialNumber != NULL) free(ctx->imageInfo.DriveSerialNumber); if(ctx->DriveSerialNumber != NULL) free(ctx->DriveSerialNumber);
ctx->imageInfo.DriveSerialNumber = copy; ctx->DriveSerialNumber = copy;
ctx->metadataBlockHeader.driveSerialNumberLength = length; ctx->metadataBlockHeader.driveSerialNumberLength = length;
TRACE("Exiting aaruf_set_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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 // Copy opaque UTF-16LE string
memcpy(copy, data, length); memcpy(copy, data, length);
if(ctx->imageInfo.DriveFirmwareRevision != NULL) free(ctx->imageInfo.DriveFirmwareRevision); if(ctx->DriveFirmwareRevision != NULL) free(ctx->DriveFirmwareRevision);
ctx->imageInfo.DriveFirmwareRevision = copy; ctx->DriveFirmwareRevision = copy;
ctx->metadataBlockHeader.driveFirmwareRevisionLength = length; ctx->metadataBlockHeader.driveFirmwareRevisionLength = length;
TRACE("Exiting aaruf_set_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, data, 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; 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) ctx->metadataBlockHeader.creatorLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.Creator, ctx->metadataBlockHeader.creatorLength); memcpy(buffer, ctx->Creator, ctx->metadataBlockHeader.creatorLength);
*length = ctx->metadataBlockHeader.creatorLength; *length = ctx->metadataBlockHeader.creatorLength;
TRACE("Exiting aaruf_get_creator(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.commentsLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.Comments, ctx->metadataBlockHeader.commentsLength); memcpy(buffer, ctx->Comments, ctx->metadataBlockHeader.commentsLength);
*length = ctx->metadataBlockHeader.commentsLength; *length = ctx->metadataBlockHeader.commentsLength;
TRACE("Exiting aaruf_get_comments(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.mediaTitleLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaTitle, ctx->metadataBlockHeader.mediaTitleLength); memcpy(buffer, ctx->MediaTitle, ctx->metadataBlockHeader.mediaTitleLength);
*length = ctx->metadataBlockHeader.mediaTitleLength; *length = ctx->metadataBlockHeader.mediaTitleLength;
TRACE("Exiting aaruf_get_media_title(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.mediaManufacturerLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength); memcpy(buffer, ctx->MediaManufacturer, ctx->metadataBlockHeader.mediaManufacturerLength);
*length = ctx->metadataBlockHeader.mediaManufacturerLength; *length = ctx->metadataBlockHeader.mediaManufacturerLength;
TRACE("Exiting aaruf_get_media_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.mediaModelLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaModel, ctx->metadataBlockHeader.mediaModelLength); memcpy(buffer, ctx->MediaModel, ctx->metadataBlockHeader.mediaModelLength);
*length = ctx->metadataBlockHeader.mediaModelLength; *length = ctx->metadataBlockHeader.mediaModelLength;
TRACE("Exiting aaruf_get_media_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.mediaSerialNumberLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength); memcpy(buffer, ctx->MediaSerialNumber, ctx->metadataBlockHeader.mediaSerialNumberLength);
*length = ctx->metadataBlockHeader.mediaSerialNumberLength; *length = ctx->metadataBlockHeader.mediaSerialNumberLength;
TRACE("Exiting aaruf_get_media_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.mediaBarcodeLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength); memcpy(buffer, ctx->MediaBarcode, ctx->metadataBlockHeader.mediaBarcodeLength);
*length = ctx->metadataBlockHeader.mediaBarcodeLength; *length = ctx->metadataBlockHeader.mediaBarcodeLength;
TRACE("Exiting aaruf_get_media_barcode(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.mediaPartNumberLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength); memcpy(buffer, ctx->MediaPartNumber, ctx->metadataBlockHeader.mediaPartNumberLength);
*length = ctx->metadataBlockHeader.mediaPartNumberLength; *length = ctx->metadataBlockHeader.mediaPartNumberLength;
TRACE("Exiting aaruf_get_media_part_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.driveManufacturerLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength); memcpy(buffer, ctx->DriveManufacturer, ctx->metadataBlockHeader.driveManufacturerLength);
*length = ctx->metadataBlockHeader.driveManufacturerLength; *length = ctx->metadataBlockHeader.driveManufacturerLength;
TRACE("Exiting aaruf_get_drive_manufacturer(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.driveModelLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveModel, ctx->metadataBlockHeader.driveModelLength); memcpy(buffer, ctx->DriveModel, ctx->metadataBlockHeader.driveModelLength);
*length = ctx->metadataBlockHeader.driveModelLength; *length = ctx->metadataBlockHeader.driveModelLength;
TRACE("Exiting aaruf_get_drive_model(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.driveSerialNumberLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength); memcpy(buffer, ctx->DriveSerialNumber, ctx->metadataBlockHeader.driveSerialNumberLength);
*length = ctx->metadataBlockHeader.driveSerialNumberLength; *length = ctx->metadataBlockHeader.driveSerialNumberLength;
TRACE("Exiting aaruf_get_drive_serial_number(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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; 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) ctx->metadataBlockHeader.driveFirmwareRevisionLength == 0)
{ {
FATAL("No metadata block present"); 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 // Copy opaque UTF-16LE string
memcpy(buffer, ctx->imageInfo.DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength); memcpy(buffer, ctx->DriveFirmwareRevision, ctx->metadataBlockHeader.driveFirmwareRevisionLength);
*length = ctx->metadataBlockHeader.driveFirmwareRevisionLength; *length = ctx->metadataBlockHeader.driveFirmwareRevisionLength;
TRACE("Exiting aaruf_get_drive_firmware_revision(%p, %p, %d) = AARUF_STATUS_OK", context, buffer, *length); 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) if(ctx->geometryBlock.identifier != GeometryBlock && ctx->imageInfo.XmlMediaType == BlockMedia)
{ {
ctx->imageInfo.Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63); ctx->Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->imageInfo.Heads = 16; ctx->Heads = 16;
ctx->imageInfo.SectorsPerTrack = 63; ctx->SectorsPerTrack = 63;
} }
// Initialize caches // 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 + 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->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(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 + 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: "); 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 + 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->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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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 + 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(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->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 + 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->imageInfo.MediaType);
if(ctx1->imageInfo.MediaSequence > 0 || ctx1->imageInfo.LastMediaSequence > 0 || if(ctx1->MediaSequence > 0 || ctx1->LastMediaSequence > 0 ||
ctx2->imageInfo.MediaSequence > 0 || ctx2->imageInfo.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", 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", 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(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 + 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(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 + 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(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 + 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(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 + 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(2, lr, TB_WHITE | TB_BOLD, TB_BLUE, "XML media type: ");
tb_printf(18, lr++, TB_WHITE, TB_BLUE, "%d", ctx1->imageInfo.XmlMediaType); 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 + 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); 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 || if(ctx1->Cylinders > 0 || ctx1->Heads > 0 || ctx1->SectorsPerTrack > 0 ||
ctx2->imageInfo.Cylinders > 0 || ctx2->imageInfo.Heads > 0 || ctx2->imageInfo.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", 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, 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, "Media has %d cylinders, %d heads and %d sectors per track", ctx2->Cylinders,
ctx2->imageInfo.Heads, ctx2->imageInfo.SectorsPerTrack); ctx2->Heads, ctx2->SectorsPerTrack);
} }
tb_present(); tb_present();