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

6
include/aaruformat/enums.h
View File

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

141
src/ddt/ddt_v2.c
View File

@@ -21,10 +21,6 @@
#include <stdio.h>
#include <stdlib.h>
#ifdef __linux__
#include <sys/mman.h>
#endif
#include "aaruformat.h"
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;
size_t readBytes = 0;
DdtHeader2 ddtHeader;
uint8_t * cmpData = NULL;
uint32_t * cdDdt = NULL;
uint8_t *cmpData = NULL;
uint8_t lzmaProperties[LZMA_PROPERTIES_LENGTH];
size_t lzmaSize = 0;
int errorNo = 0;
crc64_ctx *crc64_context = NULL;
uint64_t crc64 = 0;
uint8_t *buffer = NULL;
// Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL)
@@ -92,8 +88,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break;
}
ctx->userDataDdt = (uint64_t *)malloc(ddtHeader.length);
if(ctx->userDataDdt == NULL)
buffer = malloc(ddtHeader.length);
if(buffer == NULL)
{
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n");
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");
free(cmpData);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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");
free(cmpData);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
break;
}
readBytes = ddtHeader.length;
errorNo = aaruf_lzma_decode_buffer((uint8_t *)ctx->userDataDdt, &readBytes, cmpData, &lzmaSize,
lzmaProperties, LZMA_PROPERTIES_LENGTH);
errorNo = aaruf_lzma_decode_buffer(buffer, &readBytes, cmpData, &lzmaSize, lzmaProperties,
LZMA_PROPERTIES_LENGTH);
if(errorNo != 0)
{
fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo);
free(cmpData);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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");
free(cmpData);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
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)
{
fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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);
if(crc64 != ddtHeader.crc64)
{
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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;
*foundUserDataDdt = true;
break;
case None:
ctx->userDataDdt = (uint64_t *)malloc(ddtHeader.length);
if(ctx->userDataDdt == NULL)
buffer = malloc(ddtHeader.length);
if(buffer == NULL)
{
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n");
free(cmpData);
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);
ctx->userDataDdt = NULL;
free(buffer);
fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n");
break;
}
@@ -193,22 +188,25 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(crc64_context == NULL)
{
fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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);
if(crc64 != ddtHeader.crc64)
{
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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;
*foundUserDataDdt = true;
@@ -234,8 +232,8 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break;
}
cdDdt = (uint32_t *)malloc(ddtHeader.length);
if(cdDdt == NULL)
buffer = malloc(ddtHeader.length);
if(buffer == NULL)
{
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n");
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");
free(cmpData);
free(cdDdt);
ctx->userDataDdt = NULL;
free(buffer);
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");
free(cmpData);
free(cdDdt);
ctx->userDataDdt = NULL;
break;
}
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);
if(errorNo != 0)
{
fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo);
free(cmpData);
free(cdDdt);
ctx->userDataDdt = NULL;
free(buffer);
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");
free(cmpData);
free(cdDdt);
ctx->userDataDdt = NULL;
free(buffer);
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)
{
fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
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);
if(crc64 != ddtHeader.crc64)
{
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
free(buffer);
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
if(entry->dataType == CdSectorPrefixCorrected) ctx->sectorPrefixDdt = cdDdt;
else if(entry->dataType == CdSectorSuffixCorrected) ctx->sectorSuffixDdt = cdDdt;
else free(cdDdt);
if(entry->dataType == CdSectorPrefixCorrected)
{
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;
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");
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");
break;
}
@@ -335,24 +339,35 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
{
fprintf(stderr, "Could not initialize CRC64.\n");
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
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);
if(crc64 != ddtHeader.crc64)
{
fprintf(stderr, "Expected DDT CRC 0x%16lX but got 0x%16lX.\n", ddtHeader.crc64, crc64);
free(ctx->userDataDdt);
ctx->userDataDdt = NULL;
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
if(entry->dataType == CdSectorPrefixCorrected) ctx->sectorPrefixDdt = cdDdt;
else if(entry->dataType == CdSectorSuffixCorrected) ctx->sectorSuffixDdt = cdDdt;
else free(cdDdt);
if(entry->dataType == CdSectorPrefixCorrected)
{
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;
default: