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

4
include/aaruformat/context.h
View File

@@ -108,6 +108,10 @@ typedef struct aaruformatContext
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

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

139
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)
@@ -33,12 +29,12 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
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: