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

Take into account size types when reading DDT v2.

Browse Source
This commit is contained in:
Natalia Portillo
2025-08-04 19:44:56 +01:00
parent 34e58145b2
commit 88e03824e0
3 changed files with 116 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
include/aaruformat/context.h
View File

@@ -44,8 +44,8 @@ typedef struct Crc64Context
typedef struct CdEccContext typedef struct CdEccContext
{ {
bool initedEdc; bool initedEdc;
uint8_t * eccBTable; uint8_t *eccBTable;
uint8_t * eccFTable; uint8_t *eccFTable;
uint32_t *edcTable; uint32_t *edcTable;
} CdEccContext; } CdEccContext;
@@ -63,7 +63,7 @@ typedef struct Checksums
typedef struct mediaTagEntry typedef struct mediaTagEntry
{ {
uint8_t * data; uint8_t *data;
int32_t type; int32_t type;
uint32_t length; uint32_t length;
UT_hash_handle hh; UT_hash_handle hh;
@@ -74,54 +74,58 @@ typedef struct aaruformatContext
uint64_t magic; uint64_t magic;
uint8_t libraryMajorVersion; uint8_t libraryMajorVersion;
uint8_t libraryMinorVersion; uint8_t libraryMinorVersion;
FILE * imageStream; FILE *imageStream;
AaruHeaderV2 header; AaruHeaderV2 header;
uint8_t * sectorPrefix; uint8_t *sectorPrefix;
uint8_t * sectorPrefixCorrected; uint8_t *sectorPrefixCorrected;
uint8_t * sectorSuffix; uint8_t *sectorSuffix;
uint8_t * sectorSuffixCorrected; uint8_t *sectorSuffixCorrected;
uint8_t * sectorSubchannel; uint8_t *sectorSubchannel;
uint8_t * mode2Subheaders; uint8_t *mode2Subheaders;
uint8_t shift; uint8_t shift;
bool inMemoryDdt; bool inMemoryDdt;
uint64_t * userDataDdt; uint64_t *userDataDdt;
size_t mappedMemoryDdtSize; size_t mappedMemoryDdtSize;
uint32_t * sectorPrefixDdt; uint32_t *sectorPrefixDdt;
uint32_t * sectorSuffixDdt; uint32_t *sectorSuffixDdt;
GeometryBlockHeader geometryBlock; GeometryBlockHeader geometryBlock;
MetadataBlockHeader metadataBlockHeader; MetadataBlockHeader metadataBlockHeader;
uint8_t * metadataBlock; uint8_t *metadataBlock;
TracksHeader tracksHeader; TracksHeader tracksHeader;
TrackEntry * trackEntries; TrackEntry *trackEntries;
CicmMetadataBlock cicmBlockHeader; CicmMetadataBlock cicmBlockHeader;
uint8_t * cicmBlock; uint8_t *cicmBlock;
DumpHardwareHeader dumpHardwareHeader; DumpHardwareHeader dumpHardwareHeader;
struct DumpHardwareEntriesWithData *dumpHardwareEntriesWithData; struct DumpHardwareEntriesWithData *dumpHardwareEntriesWithData;
struct ImageInfo imageInfo; struct ImageInfo imageInfo;
CdEccContext * eccCdContext; CdEccContext *eccCdContext;
uint8_t numberOfDataTracks; uint8_t numberOfDataTracks;
TrackEntry * dataTracks; TrackEntry *dataTracks;
bool * readableSectorTags; bool *readableSectorTags;
struct CacheHeader blockHeaderCache; struct CacheHeader blockHeaderCache;
struct CacheHeader blockCache; struct CacheHeader blockCache;
struct Checksums checksums; struct Checksums checksums;
struct mediaTagEntry * mediaTags; struct mediaTagEntry *mediaTags;
DdtHeader2 userDataDdtHeader; DdtHeader2 userDataDdtHeader;
int ddtVersion; int ddtVersion;
uint16_t *userDataDdtMini;
uint32_t *userDataDdtBig;
uint16_t *sectorPrefixDdtMini;
uint16_t *sectorSuffixDdtMini;
} aaruformatContext; } aaruformatContext;
typedef struct DumpHardwareEntriesWithData typedef struct DumpHardwareEntriesWithData
{ {
DumpHardwareEntry entry; DumpHardwareEntry entry;
struct DumpExtent *extents; struct DumpExtent *extents;
uint8_t * manufacturer; uint8_t *manufacturer;
uint8_t * model; uint8_t *model;
uint8_t * revision; uint8_t *revision;
uint8_t * firmware; uint8_t *firmware;
uint8_t * serial; uint8_t *serial;
uint8_t * softwareName; uint8_t *softwareName;
uint8_t * softwareVersion; uint8_t *softwareVersion;
uint8_t * softwareOperatingSystem; uint8_t *softwareOperatingSystem;
} DumpHardwareEntriesWithData; } DumpHardwareEntriesWithData;
#pragma pack(push, 1) #pragma pack(push, 1)

6
include/aaruformat/enums.h
View File

@@ -292,6 +292,12 @@ typedef enum
AudioMedia = 3 AudioMedia = 3
} XmlMediaType; } XmlMediaType;
typedef enum
{
SmallDdtSizeType = 0,
BigDdtSizeType = 1
} DdtSizeType;
#endif // LIBAARUFORMAT_ENUMS_H #endif // LIBAARUFORMAT_ENUMS_H
#ifndef _MSC_VER #ifndef _MSC_VER

141
src/ddt/ddt_v2.c
View File

@@ -21,10 +21,6 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#ifdef __linux__
#include <sys/mman.h>
#endif
#include "aaruformat.h" #include "aaruformat.h"
int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUserDataDdt) int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUserDataDdt)
@@ -32,13 +28,13 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
int pos = 0; int pos = 0;
size_t readBytes = 0; size_t readBytes = 0;
DdtHeader2 ddtHeader; DdtHeader2 ddtHeader;
uint8_t * cmpData = NULL; uint8_t *cmpData = NULL;
uint32_t * cdDdt = NULL;
uint8_t lzmaProperties[LZMA_PROPERTIES_LENGTH]; uint8_t lzmaProperties[LZMA_PROPERTIES_LENGTH];
size_t lzmaSize = 0; size_t lzmaSize = 0;
int errorNo = 0; int errorNo = 0;
crc64_ctx *crc64_context = NULL; crc64_ctx *crc64_context = NULL;
uint64_t crc64 = 0; uint64_t crc64 = 0;
uint8_t *buffer = NULL;
// Check if the context and image stream are valid // Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL) if(ctx == NULL || ctx->imageStream == NULL)
@@ -92,8 +88,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break; break;
} }
ctx->userDataDdt = (uint64_t *)malloc(ddtHeader.length); buffer = malloc(ddtHeader.length);
if(ctx->userDataDdt == NULL) if(buffer == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n");
free(cmpData); free(cmpData);
@@ -105,8 +101,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{ {
fprintf(stderr, "Could not read LZMA properties, continuing...\n"); fprintf(stderr, "Could not read LZMA properties, continuing...\n");
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
break; break;
} }
@@ -115,21 +110,19 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{ {
fprintf(stderr, "Could not read compressed block, continuing...\n"); fprintf(stderr, "Could not read compressed block, continuing...\n");
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
break; break;
} }
readBytes = ddtHeader.length; readBytes = ddtHeader.length;
errorNo = aaruf_lzma_decode_buffer((uint8_t *)ctx->userDataDdt, &readBytes, cmpData, &lzmaSize, errorNo = aaruf_lzma_decode_buffer(buffer, &readBytes, cmpData, &lzmaSize, lzmaProperties,
lzmaProperties, LZMA_PROPERTIES_LENGTH); LZMA_PROPERTIES_LENGTH);
if(errorNo != 0) if(errorNo != 0)
{ {
fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo); fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo);
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
} }
@@ -138,7 +131,6 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
fprintf(stderr, "Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n"); fprintf(stderr, "Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n");
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
} }
@@ -149,41 +141,44 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(crc64_context == NULL) if(crc64_context == NULL)
{ {
fprintf(stderr, "Could not initialize CRC64.\n"); fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
aaruf_crc64_update(crc64_context, (uint8_t *)ctx->userDataDdt, readBytes); aaruf_crc64_update(crc64_context, buffer, readBytes);
aaruf_crc64_final(crc64_context, &crc64); aaruf_crc64_final(crc64_context, &crc64);
if(crc64 != ddtHeader.crc64) if(crc64 != ddtHeader.crc64)
{ {
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64); fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_INVALID_BLOCK_CRC; return AARUF_ERROR_INVALID_BLOCK_CRC;
} }
if(ddtHeader.sizeType == SmallDdtSizeType)
ctx->userDataDdtMini = (uint16_t *)buffer;
else if(ddtHeader.sizeType == BigDdtSizeType)
ctx->userDataDdtBig = (uint32_t *)buffer;
ctx->inMemoryDdt = true; ctx->inMemoryDdt = true;
*foundUserDataDdt = true; *foundUserDataDdt = true;
break; break;
case None: case None:
ctx->userDataDdt = (uint64_t *)malloc(ddtHeader.length); buffer = malloc(ddtHeader.length);
if(ctx->userDataDdt == NULL)
if(buffer == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n");
free(cmpData); free(cmpData);
break; break;
} }
readBytes = fread(ctx->userDataDdt, 1, ddtHeader.entries * sizeof(uint32_t), ctx->imageStream); readBytes = fread(buffer, 1, ddtHeader.length, ctx->imageStream);
if(readBytes != ddtHeader.entries * sizeof(uint32_t)) if(readBytes != ddtHeader.length)
{ {
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n"); fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n");
break; break;
} }
@@ -193,22 +188,25 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(crc64_context == NULL) if(crc64_context == NULL)
{ {
fprintf(stderr, "Could not initialize CRC64.\n"); fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
aaruf_crc64_update(crc64_context, (uint8_t *)ctx->userDataDdt, readBytes); aaruf_crc64_update(crc64_context, buffer, readBytes);
aaruf_crc64_final(crc64_context, &crc64); aaruf_crc64_final(crc64_context, &crc64);
if(crc64 != ddtHeader.crc64) if(crc64 != ddtHeader.crc64)
{ {
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64); fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_INVALID_BLOCK_CRC; return AARUF_ERROR_INVALID_BLOCK_CRC;
} }
if(ddtHeader.sizeType == SmallDdtSizeType)
ctx->userDataDdtMini = (uint16_t *)buffer;
else if(ddtHeader.sizeType == BigDdtSizeType)
ctx->userDataDdtBig = (uint32_t *)buffer;
ctx->inMemoryDdt = true; ctx->inMemoryDdt = true;
*foundUserDataDdt = true; *foundUserDataDdt = true;
@@ -234,8 +232,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break; break;
} }
cdDdt = (uint32_t *)malloc(ddtHeader.length); buffer = malloc(ddtHeader.length);
if(cdDdt == NULL) if(buffer == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n");
free(cmpData); free(cmpData);
@@ -247,8 +245,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{ {
fprintf(stderr, "Could not read LZMA properties, continuing...\n"); fprintf(stderr, "Could not read LZMA properties, continuing...\n");
free(cmpData); free(cmpData);
free(cdDdt); free(buffer);
ctx->userDataDdt = NULL;
break; break;
} }
@@ -257,21 +254,18 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{ {
fprintf(stderr, "Could not read compressed block, continuing...\n"); fprintf(stderr, "Could not read compressed block, continuing...\n");
free(cmpData); free(cmpData);
free(cdDdt);
ctx->userDataDdt = NULL;
break; break;
} }
readBytes = ddtHeader.length; readBytes = ddtHeader.length;
errorNo = aaruf_lzma_decode_buffer((uint8_t *)cdDdt, &readBytes, cmpData, &lzmaSize, lzmaProperties, errorNo = aaruf_lzma_decode_buffer(buffer, &readBytes, cmpData, &lzmaSize, lzmaProperties,
LZMA_PROPERTIES_LENGTH); LZMA_PROPERTIES_LENGTH);
if(errorNo != 0) if(errorNo != 0)
{ {
fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo); fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo);
free(cmpData); free(cmpData);
free(cdDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
} }
@@ -279,8 +273,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{ {
fprintf(stderr, "Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n"); fprintf(stderr, "Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n");
free(cmpData); free(cmpData);
free(cdDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
} }
@@ -289,42 +282,53 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(crc64_context == NULL) if(crc64_context == NULL)
{ {
fprintf(stderr, "Could not initialize CRC64.\n"); fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
aaruf_crc64_update(crc64_context, (uint8_t *)cdDdt, readBytes); aaruf_crc64_update(crc64_context, buffer, readBytes);
aaruf_crc64_final(crc64_context, &crc64); aaruf_crc64_final(crc64_context, &crc64);
if(crc64 != ddtHeader.crc64) if(crc64 != ddtHeader.crc64)
{ {
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64); fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt); free(buffer);
ctx->userDataDdt = NULL;
return AARUF_ERROR_INVALID_BLOCK_CRC; return AARUF_ERROR_INVALID_BLOCK_CRC;
} }
if(entry->dataType == CdSectorPrefixCorrected) ctx->sectorPrefixDdt = cdDdt; if(entry->dataType == CdSectorPrefixCorrected)
else if(entry->dataType == CdSectorSuffixCorrected) ctx->sectorSuffixDdt = cdDdt; {
else free(cdDdt); if(ddtHeader.sizeType == SmallDdtSizeType)
ctx->sectorPrefixDdtMini = (uint16_t *)buffer;
else if(ddtHeader.sizeType == BigDdtSizeType)
ctx->sectorPrefixDdt = (uint32_t *)buffer;
}
else if(entry->dataType == CdSectorSuffixCorrected)
{
if(ddtHeader.sizeType == SmallDdtSizeType)
ctx->sectorSuffixDdtMini = (uint16_t *)buffer;
else if(ddtHeader.sizeType == BigDdtSizeType)
ctx->sectorSuffixDdt = (uint32_t *)buffer;
}
else
free(buffer);
break; break;
case None: case None:
cdDdt = (uint32_t *)malloc(ddtHeader.entries * sizeof(uint32_t)); buffer = malloc(ddtHeader.length);
if(cdDdt == NULL) if(buffer == NULL)
{ {
fprintf(stderr, "libaaruformat: Cannot allocate memory for deduplication table.\n"); fprintf(stderr, "libaaruformat: Cannot allocate memory for deduplication table.\n");
break; break;
} }
readBytes = fread(cdDdt, 1, ddtHeader.entries * sizeof(uint32_t), ctx->imageStream); readBytes = fread(buffer, 1, ddtHeader.length, ctx->imageStream);
if(readBytes != ddtHeader.entries * sizeof(uint32_t)) if(readBytes != ddtHeader.length)
{ {
free(cdDdt); free(buffer);
fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n"); fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n");
break; break;
} }
@@ -335,24 +339,35 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{ {
fprintf(stderr, "Could not initialize CRC64.\n"); fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
aaruf_crc64_update(crc64_context, (uint8_t *)cdDdt, readBytes); aaruf_crc64_update(crc64_context, buffer, readBytes);
aaruf_crc64_final(crc64_context, &crc64); aaruf_crc64_final(crc64_context, &crc64);
if(crc64 != ddtHeader.crc64) if(crc64 != ddtHeader.crc64)
{ {
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64); fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
return AARUF_ERROR_INVALID_BLOCK_CRC; return AARUF_ERROR_INVALID_BLOCK_CRC;
} }
if(entry->dataType == CdSectorPrefixCorrected) ctx->sectorPrefixDdt = cdDdt; if(entry->dataType == CdSectorPrefixCorrected)
else if(entry->dataType == CdSectorSuffixCorrected) ctx->sectorSuffixDdt = cdDdt; {
else free(cdDdt); if(ddtHeader.sizeType == SmallDdtSizeType)
ctx->sectorPrefixDdtMini = (uint16_t *)buffer;
else if(ddtHeader.sizeType == BigDdtSizeType)
ctx->sectorPrefixDdt = (uint32_t *)buffer;
}
else if(entry->dataType == CdSectorSuffixCorrected)
{
if(ddtHeader.sizeType == SmallDdtSizeType)
ctx->sectorSuffixDdtMini = (uint16_t *)buffer;
else if(ddtHeader.sizeType == BigDdtSizeType)
ctx->sectorSuffixDdt = (uint32_t *)buffer;
}
else
free(buffer);
break; break;
default: default: