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

Reformat

Browse Source
This commit is contained in:
Natalia Portillo
2019-03-31 20:52:06 +01:00
parent b255303607
commit 701bc2cedc
16 changed files with 1276 additions and 1349 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/close.c
View File

@@ -30,10 +30,10 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
#include <stdio.h>
#include <dicformat.h>
#include <malloc.h>
#include <errno.h>
#include <malloc.h>
#include <stdio.h>
#include <sys/mman.h>
int close(void *context)
@@ -54,8 +54,7 @@ int close(void *context)
}
// This may do nothing if imageStream is NULL, but as the behaviour is undefined, better sure than sorry
if(ctx->imageStream != NULL)
fclose(ctx->imageStream);
if(ctx->imageStream != NULL) fclose(ctx->imageStream);
free(ctx->sectorPrefix);
free(ctx->sectorPrefixCorrected);
@@ -82,10 +81,7 @@ int close(void *context)
free(ctx->mediaTagsHead);
}
if(!ctx->inMemoryDdt)
{
munmap(ctx->userDataDdt, ctx->mappedMemoryDdtSize);
}
if(!ctx->inMemoryDdt) { munmap(ctx->userDataDdt, ctx->mappedMemoryDdtSize); }
free(ctx->sectorPrefixDdt);
free(ctx->sectorSuffixDdt);

26
src/crc64.c
View File

@@ -30,10 +30,10 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
#include <stdint.h>
#include <malloc.h>
#include <string.h>
#include <dicformat.h>
#include <malloc.h>
#include <stdint.h>
#include <string.h>
void *crc64_init(uint64_t polynomial, uint64_t seed)
{
@@ -41,8 +41,7 @@ void *crc64_init(uint64_t polynomial, uint64_t seed)
ctx = malloc(sizeof(Crc64Context));
if(ctx == NULL)
return NULL;
if(ctx == NULL) return NULL;
memset(ctx, 1, sizeof(Crc64Context));
@@ -52,7 +51,7 @@ void *crc64_init(uint64_t polynomial, uint64_t seed)
for(int i = 0; i < 256; i++)
{
uint64_t entry = (uint64_t)i;
for(int j = 0; j < 8; j++)
for(int j = 0; j < 8; j++)
if((entry & 1) == 1)
entry = (entry >> 1) ^ polynomial;
else
@@ -64,18 +63,13 @@ void *crc64_init(uint64_t polynomial, uint64_t seed)
return ctx;
}
void *crc64_init_ecma(void)
{
return crc64_init(CRC64_ECMA_POLY, CRC64_ECMA_SEED);
}
void *crc64_init_ecma(void) { return crc64_init(CRC64_ECMA_POLY, CRC64_ECMA_SEED); }
void crc64_update(void *context, const uint8_t *data, size_t len)
{
Crc64Context *ctx = context;
for(size_t i = 0; i < len; i++)
ctx->hashInt = (ctx->hashInt >> 8) ^ ctx->table[data[i] ^ (ctx->hashInt & 0xFF)];
for(size_t i = 0; i < len; i++) ctx->hashInt = (ctx->hashInt >> 8) ^ ctx->table[data[i] ^ (ctx->hashInt & 0xFF)];
}
uint64_t crc64_final(void *context)
@@ -93,7 +87,7 @@ uint64_t crc64_data(const uint8_t *data, size_t len, uint64_t polynomial, uint64
for(int i = 0; i < 256; i++)
{
uint64_t entry = (uint64_t)i;
for(int j = 0; j < 8; j++)
for(int j = 0; j < 8; j++)
if((entry & 1) == 1)
entry = (entry >> 1) ^ polynomial;
else
@@ -102,8 +96,7 @@ uint64_t crc64_data(const uint8_t *data, size_t len, uint64_t polynomial, uint64
table[i] = entry;
}
for(size_t i = 0; i < len; i++)
hashInt = (hashInt >> 8) ^ table[data[i] ^ (hashInt & 0xFF)];
for(size_t i = 0; i < len; i++) hashInt = (hashInt >> 8) ^ table[data[i] ^ (hashInt & 0xFF)];
return hashInt ^ seed;
}
@@ -112,4 +105,3 @@ uint64_t crc64_data_ecma(const uint8_t *data, size_t len)
{
return crc64_data(data, len, CRC64_ECMA_POLY, CRC64_ECMA_SEED);
}

38
src/cst.c
View File

@@ -30,24 +30,23 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
#include <stdint.h>
#include <malloc.h>
#include <dicformat.h>
#include <malloc.h>
#include <stdint.h>
#include <string.h>
int32_t cst_transform(const uint8_t *interleaved, uint8_t *sequential, size_t length)
{
uint8_t *p, *q, *r, *s, *t, *u, *v, *w;
size_t qStart;
size_t rStart;
size_t sStart;
size_t tStart;
size_t uStart;
size_t vStart;
size_t wStart;
size_t qStart;
size_t rStart;
size_t sStart;
size_t tStart;
size_t uStart;
size_t vStart;
size_t wStart;
if(interleaved == NULL || sequential == NULL)
return DICF_ERROR_BUFFER_TOO_SMALL;
if(interleaved == NULL || sequential == NULL) return DICF_ERROR_BUFFER_TOO_SMALL;
p = malloc(length / 8);
q = malloc(length / 8);
@@ -172,16 +171,15 @@ int32_t cst_transform(const uint8_t *interleaved, uint8_t *sequential, size_t le
int32_t cst_untransform(const uint8_t *sequential, uint8_t *interleaved, size_t length)
{
uint8_t *p, *q, *r, *s, *t, *u, *v, *w;
size_t qStart;
size_t rStart;
size_t sStart;
size_t tStart;
size_t uStart;
size_t vStart;
size_t wStart;
size_t qStart;
size_t rStart;
size_t sStart;
size_t tStart;
size_t uStart;
size_t vStart;
size_t wStart;
if(interleaved == NULL || sequential == NULL)
return DICF_ERROR_BUFFER_TOO_SMALL;
if(interleaved == NULL || sequential == NULL) return DICF_ERROR_BUFFER_TOO_SMALL;
p = malloc(length / 8);
q = malloc(length / 8);

217
src/ecc_cd.c
View File

@@ -31,21 +31,20 @@
// ECC algorithm from ECM(c) 2002-2011 Neill Corlett
// ****************************************************************************/
#include <stdint.h>
#include <malloc.h>
#include <string.h>
#include <stdbool.h>
#include <dicformat.h>
#include <malloc.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
void *ecc_cd_init()
{
CdEccContext *context;
uint32_t edc, i, j;
uint32_t edc, i, j;
context = (CdEccContext *)malloc(sizeof(CdEccContext));
if(context == NULL)
return NULL;
if(context == NULL) return NULL;
context->eccFTable = (uint8_t *)malloc(sizeof(uint8_t) * 256);
@@ -75,12 +74,11 @@ void *ecc_cd_init()
for(i = 0; i < 256; i++)
{
edc = i;
j = (uint32_t)((i << 1) ^ ((i & 0x80) == 0x80 ? 0x11D : 0));
edc = i;
j = (uint32_t)((i << 1) ^ ((i & 0x80) == 0x80 ? 0x11D : 0));
context->eccFTable[i] = (uint8_t)j;
context->eccBTable[i ^ j] = (uint8_t)i;
for(j = 0; j < 8; j++)
edc = (edc >> 1) ^ ((edc & 1) > 0 ? 0xD8018001 : 0);
for(j = 0; j < 8; j++) edc = (edc >> 1) ^ ((edc & 1) > 0 ? 0xD8018001 : 0);
context->edcTable[i] = edc;
}
@@ -92,42 +90,32 @@ void *ecc_cd_init()
bool ecc_cd_is_suffix_correct(void *context, const uint8_t *sector)
{
CdEccContext *ctx;
uint32_t storedEdc, edc, calculatedEdc;
int size, pos;
uint32_t storedEdc, edc, calculatedEdc;
int size, pos;
if(context == NULL || sector == NULL)
return false;
if(context == NULL || sector == NULL) return false;
ctx = (CdEccContext *)context;
if(!ctx->initedEdc)
return false;
if(!ctx->initedEdc) return false;
if(sector[0x814] != 0x00 ||
// reserved (8 bytes)
sector[0x815] != 0x00 ||
sector[0x816] != 0x00 ||
sector[0x817] != 0x00 ||
sector[0x818] != 0x00 ||
sector[0x819] != 0x00 ||
sector[0x81A] != 0x00 ||
sector[0x81B] != 0x00)
sector[0x815] != 0x00 || sector[0x816] != 0x00 || sector[0x817] != 0x00 || sector[0x818] != 0x00 ||
sector[0x819] != 0x00 || sector[0x81A] != 0x00 || sector[0x81B] != 0x00)
return false;
bool correctEccP = ecc_cd_check(context, sector, sector, 86, 24, 2, 86, sector, 0xC, 0x10, 0x81C);
if(!correctEccP)
return false;
if(!correctEccP) return false;
bool correctEccQ = ecc_cd_check(context, sector, sector, 52, 43, 86, 88, sector, 0xC, 0x10, 0x81C + 0xAC);
if(!correctEccQ)
return false;
bool correctEccQ = ecc_cd_check(context, sector, sector, 52, 43, 86, 88, sector, 0xC, 0x10, 0x81C + 0xAC);
if(!correctEccQ) return false;
storedEdc = sector[0x810]; // TODO: Check casting
edc = 0;
size = 0x810;
pos = 0;
for(; size > 0; size--)
edc = (edc >> 8) ^ ctx->edcTable[(edc ^ sector[pos++]) & 0xFF];
storedEdc = sector[0x810]; // TODO: Check casting
edc = 0;
size = 0x810;
pos = 0;
for(; size > 0; size--) edc = (edc >> 8) ^ ctx->edcTable[(edc ^ sector[pos++]) & 0xFF];
calculatedEdc = edc;
return calculatedEdc == storedEdc;
@@ -136,115 +124,102 @@ bool ecc_cd_is_suffix_correct(void *context, const uint8_t *sector)
bool ecc_cd_is_suffix_correct_mode2(void *context, const uint8_t *sector)
{
CdEccContext *ctx;
uint32_t storedEdc, edc, calculatedEdc;
int size, pos;
uint8_t zeroaddress[4];
uint32_t storedEdc, edc, calculatedEdc;
int size, pos;
uint8_t zeroaddress[4];
if(context == NULL || sector == NULL)
return false;
if(context == NULL || sector == NULL) return false;
ctx = (CdEccContext *)context;
if(!ctx->initedEdc)
return false;
if(!ctx->initedEdc) return false;
memset(&zeroaddress, 4, sizeof(uint8_t));
bool correctEccP = ecc_cd_check(context, zeroaddress, sector, 86, 24, 2, 86, sector, 0, 0x10, 0x81C);
if(!correctEccP)
return false;
if(!correctEccP) return false;
bool
correctEccQ =
ecc_cd_check(context, zeroaddress, sector, 52, 43, 86, 88, sector, 0, 0x10, 0x81C + 0xAC);
if(!correctEccQ)
return false;
bool correctEccQ = ecc_cd_check(context, zeroaddress, sector, 52, 43, 86, 88, sector, 0, 0x10, 0x81C + 0xAC);
if(!correctEccQ) return false;
storedEdc = sector[0x818]; // TODO: Check cast
edc = 0;
size = 0x808;
pos = 0x10;
for(; size > 0; size--)
edc = (edc >> 8) ^ ctx->edcTable[(edc ^ sector[pos++]) & 0xFF];
storedEdc = sector[0x818]; // TODO: Check cast
edc = 0;
size = 0x808;
pos = 0x10;
for(; size > 0; size--) edc = (edc >> 8) ^ ctx->edcTable[(edc ^ sector[pos++]) & 0xFF];
calculatedEdc = edc;
return calculatedEdc == storedEdc;
}
bool ecc_cd_check(void *context,
bool ecc_cd_check(void * context,
const uint8_t *address,
const uint8_t *data,
uint32_t majorCount,
uint32_t minorCount,
uint32_t majorMult,
uint32_t minorInc,
uint32_t majorCount,
uint32_t minorCount,
uint32_t majorMult,
uint32_t minorInc,
const uint8_t *ecc,
int32_t addressOffset,
int32_t dataOffset,
int32_t eccOffset)
int32_t addressOffset,
int32_t dataOffset,
int32_t eccOffset)
{
CdEccContext *ctx;
uint32_t size, major, idx, minor;
uint8_t eccA, eccB, temp;
uint32_t size, major, idx, minor;
uint8_t eccA, eccB, temp;
if(context == NULL || address == NULL || data == NULL || ecc == NULL)
return false;
if(context == NULL || address == NULL || data == NULL || ecc == NULL) return false;
ctx = (CdEccContext *)context;
if(!ctx->initedEdc)
return false;
if(!ctx->initedEdc) return false;
size = majorCount * minorCount;
size = majorCount * minorCount;
for(major = 0; major < majorCount; major++)
{
idx = (major >> 1) * majorMult + (major & 1);
eccA = 0;
eccB = 0;
idx = (major >> 1) * majorMult + (major & 1);
eccA = 0;
eccB = 0;
for(minor = 0; minor < minorCount; minor++)
{
temp = idx < 4 ? address[idx + addressOffset] : data[idx + dataOffset - 4];
idx += minorInc;
if(idx >= size)
idx -= size;
if(idx >= size) idx -= size;
eccA ^= temp;
eccB ^= temp;
eccA = ctx->eccFTable[eccA];
}
eccA = ctx->eccBTable[ctx->eccFTable[eccA] ^ eccB];
if(ecc[major + eccOffset] != eccA || ecc[major + majorCount + eccOffset] != (eccA ^ eccB))
return false;
if(ecc[major + eccOffset] != eccA || ecc[major + majorCount + eccOffset] != (eccA ^ eccB)) return false;
}
return true;
}
void ecc_cd_write(void *context,
void ecc_cd_write(void * context,
const uint8_t *address,
const uint8_t *data,
uint32_t majorCount,
uint32_t minorCount,
uint32_t majorMult,
uint32_t minorInc,
uint8_t *ecc,
int32_t addressOffset,
int32_t dataOffset,
int32_t eccOffset)
uint32_t majorCount,
uint32_t minorCount,
uint32_t majorMult,
uint32_t minorInc,
uint8_t * ecc,
int32_t addressOffset,
int32_t dataOffset,
int32_t eccOffset)
{
CdEccContext *ctx;
uint32_t size, major, idx, minor;
uint8_t eccA, eccB, temp;
uint32_t size, major, idx, minor;
uint8_t eccA, eccB, temp;
if(context == NULL || address == NULL || data == NULL || ecc == NULL)
return;
if(context == NULL || address == NULL || data == NULL || ecc == NULL) return;
ctx = (CdEccContext *)context;
if(!ctx->initedEdc)
return;
if(!ctx->initedEdc) return;
size = majorCount * minorCount;
size = majorCount * minorCount;
for(major = 0; major < majorCount; major++)
{
idx = (major >> 1) * majorMult + (major & 1);
@@ -255,28 +230,27 @@ void ecc_cd_write(void *context,
{
temp = idx < 4 ? address[idx + addressOffset] : data[idx + dataOffset - 4];
idx += minorInc;
if(idx >= size)
idx -= size;
if(idx >= size) idx -= size;
eccA ^= temp;
eccB ^= temp;
eccA = ctx->eccFTable[eccA];
}
eccA = ctx->eccBTable[ctx->eccFTable[eccA] ^ eccB];
eccA = ctx->eccBTable[ctx->eccFTable[eccA] ^ eccB];
ecc[major + eccOffset] = eccA;
ecc[major + majorCount + eccOffset] = (eccA ^ eccB);
}
}
void ecc_cd_write_sector(void *context,
void ecc_cd_write_sector(void * context,
const uint8_t *address,
const uint8_t *data,
uint8_t *ecc,
int32_t addressOffset,
int32_t dataOffset,
int32_t eccOffset)
uint8_t * ecc,
int32_t addressOffset,
int32_t dataOffset,
int32_t eccOffset)
{
ecc_cd_write(context, address, data, 86, 24, 2, 86, ecc, addressOffset, dataOffset, eccOffset); // P
ecc_cd_write(context, address, data, 86, 24, 2, 86, ecc, addressOffset, dataOffset, eccOffset); // P
ecc_cd_write(context, address, data, 52, 43, 86, 88, ecc, addressOffset, dataOffset, eccOffset + 0xAC); // Q
}
@@ -287,14 +261,13 @@ void cd_lba_to_msf(int64_t pos, uint8_t *minute, uint8_t *second, uint8_t *frame
*frame = (uint8_t)((pos + 150) % 75);
}
void ecc_cd_reconstruct_prefix(uint8_t *sector, // must point to a full 2352-byte sector
uint8_t type, int64_t lba)
uint8_t type,
int64_t lba)
{
uint8_t minute, second, frame;
if(sector == NULL)
return;
if(sector == NULL) return;
//
// Sync
@@ -345,34 +318,36 @@ void ecc_cd_reconstruct_prefix(uint8_t *sector, // must point to a full 2352-byt
}
}
void ecc_cd_reconstruct(void *context, uint8_t *sector, // must point to a full 2352-byte sector
uint8_t type)
void ecc_cd_reconstruct(void * context,
uint8_t *sector, // must point to a full 2352-byte sector
uint8_t type)
{
uint32_t computedEdc;
uint8_t zeroaddress[4];
CdEccContext *ctx;
if(context == NULL || sector == NULL)
return;
if(context == NULL || sector == NULL) return;
ctx = (CdEccContext *)context;
if(!ctx->initedEdc)
return;
if(!ctx->initedEdc) return;
switch(type)
{
//
// Compute EDC
//
case CdMode1:computedEdc = edc_cd_compute(context, 0, sector, 0x810, 0);
case CdMode1:
computedEdc = edc_cd_compute(context, 0, sector, 0x810, 0);
memcpy(sector + 0x810, &computedEdc, 4);
break;
case CdMode2Form1:computedEdc = edc_cd_compute(context, 0, sector, 0x808, 0x10);
case CdMode2Form1:
computedEdc = edc_cd_compute(context, 0, sector, 0x808, 0x10);
memcpy(sector + 0x818, &computedEdc, 4);
break;
case CdMode2Form2:computedEdc = edc_cd_compute(context, 0, sector, 0x91C, 0x10);
case CdMode2Form2:
computedEdc = edc_cd_compute(context, 0, sector, 0x91C, 0x10);
memcpy(sector + 0x92C, &computedEdc, 4);
break;
default: return;
@@ -399,8 +374,7 @@ void ecc_cd_reconstruct(void *context, uint8_t *sector, // must point to a full
sector[0x81B] = 0x00;
ecc_cd_write_sector(context, sector, sector, sector, 0xC, 0x10, 0x81C);
break;
case CdMode2Form1:ecc_cd_write_sector(context, zeroaddress, sector, sector, 0, 0x10, 0x81C);
break;
case CdMode2Form1: ecc_cd_write_sector(context, zeroaddress, sector, sector, 0, 0x10, 0x81C); break;
default: return;
}
@@ -413,16 +387,13 @@ uint32_t edc_cd_compute(void *context, uint32_t edc, const uint8_t *src, int siz
{
CdEccContext *ctx;
if(context == NULL || src == NULL)
return 0;
if(context == NULL || src == NULL) return 0;
ctx = (CdEccContext *)context;
if(!ctx->initedEdc)
return 0;
if(!ctx->initedEdc) return 0;
for(; size > 0; size--)
edc = (edc >> 8) ^ ctx->edcTable[(edc ^ src[pos++]) & 0xFF];
for(; size > 0; size--) edc = (edc >> 8) ^ ctx->edcTable[(edc ^ src[pos++]) & 0xFF];
return edc;
}

11
src/identify.c
View File

@@ -30,9 +30,9 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
#include <dicformat.h>
#include <errno.h>
#include <stdio.h>
#include <dicformat.h>
//! Identifies a file as dicformat, using path
/*!
@@ -47,8 +47,7 @@ int identify(const char *filename)
stream = fopen(filename, "rb");
if(stream == NULL)
return errno;
if(stream == NULL) return errno;
int ret = identifyStream(stream);
@@ -72,11 +71,9 @@ int identifyStream(FILE *imageStream)
size_t ret = fread(&header, sizeof(DicHeader), 1, imageStream);
if(ret < sizeof(DicHeader))
return 0;
if(ret < sizeof(DicHeader)) return 0;
if(header.identifier == DIC_MAGIC && header.imageMajorVersion <= DICF_VERSION)
return 100;
if(header.identifier == DIC_MAGIC && header.imageMajorVersion <= DICF_VERSION) return 100;
return 0;
}

335
src/open.c
View File

@@ -30,32 +30,31 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
#include <stdio.h>
#include <dicformat.h>
#include <malloc.h>
#include <errno.h>
#include <inttypes.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
void *open(const char *filepath)
{
dicformatContext *ctx;
int errorNo;
size_t readBytes;
long pos;
IndexHeader idxHeader;
IndexEntry *idxEntries;
uint8_t *data;
uint32_t *cdDdt;
uint64_t crc64;
uint8_t temp8u;
int errorNo;
size_t readBytes;
long pos;
IndexHeader idxHeader;
IndexEntry * idxEntries;
uint8_t * data;
uint32_t * cdDdt;
uint64_t crc64;
uint8_t temp8u;
ctx = (dicformatContext *)malloc(sizeof(dicformatContext));
memset(ctx, 0, sizeof(dicformatContext));
if(ctx == NULL)
return NULL;
if(ctx == NULL) return NULL;
ctx->imageStream = fopen(filepath, "rb");
@@ -159,7 +158,8 @@ void *open(const char *filepath)
return NULL;
}
fprintf(stderr, "libdicformat: Index at %"PRIu64" contains %d entries", ctx->header.indexOffset, idxHeader.entries);
fprintf(
stderr, "libdicformat: Index at %" PRIu64 " contains %d entries", ctx->header.indexOffset, idxHeader.entries);
idxEntries = (IndexEntry *)malloc(sizeof(IndexEntry) * idxHeader.entries);
@@ -186,13 +186,14 @@ void *open(const char *filepath)
for(int i = 0; i < idxHeader.entries; i++)
{
fprintf(stderr, "libdicformat: Block type %4.4s with data type %4.4s is indexed to be at %"PRIu64"",
fprintf(stderr,
"libdicformat: Block type %4.4s with data type %4.4s is indexed to be at %" PRIu64 "",
(char *)&idxEntries[i].blockType,
(char *)&idxEntries[i].dataType,
idxEntries[i].offset);
}
bool foundUserDataDdt = false;
bool foundUserDataDdt = false;
ctx->imageInfo.ImageSize = 0;
for(int i = 0; i < idxHeader.entries; i++)
{
@@ -201,7 +202,7 @@ void *open(const char *filepath)
if(pos < 0 || ftell(ctx->imageStream) != idxEntries[i].offset)
{
fprintf(stderr,
"libdicformat: Could not seek to %"PRIu64" as indicated by index entry %d, continuing...",
"libdicformat: Could not seek to %" PRIu64 " as indicated by index entry %d, continuing...",
idxEntries[i].offset,
i);
@@ -215,14 +216,13 @@ void *open(const char *filepath)
{
case DataBlock:
// NOP block, skip
if(idxEntries[i].dataType == NoData)
break;
if(idxEntries[i].dataType == NoData) break;
readBytes = fread(&blockHeader, sizeof(BlockHeader), 1, ctx->imageStream);
if(readBytes != sizeof(BlockHeader))
{
fprintf(stderr, "libdicformat: Could not read block header at %"PRIu64"", idxEntries[i].offset);
fprintf(stderr, "libdicformat: Could not read block header at %" PRIu64 "", idxEntries[i].offset);
break;
}
@@ -241,7 +241,7 @@ void *open(const char *filepath)
if(blockHeader.identifier != idxEntries[i].blockType)
{
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
"libdicformat: Incorrect identifier for data block at position %" PRIu64 "",
idxEntries[i].offset);
break;
}
@@ -249,14 +249,16 @@ void *open(const char *filepath)
if(blockHeader.type != idxEntries[i].dataType)
{
fprintf(stderr,
"libdicformat: Expected block with data type %4.4s at position %"PRIu64" but found data type %4.4s",
"libdicformat: Expected block with data type %4.4s at position %" PRIu64
" but found data type %4.4s",
(char *)&idxEntries[i].blockType,
idxEntries[i].offset,
(char *)&blockHeader.type);
break;
}
fprintf(stderr, "libdicformat: Found data block with type %4.4s at position %"PRIu64"",
fprintf(stderr,
"libdicformat: Found data block with type %4.4s at position %" PRIu64 "",
(char *)&idxEntries[i].blockType,
idxEntries[i].offset);
@@ -290,7 +292,8 @@ void *open(const char *filepath)
if(crc64 != blockHeader.crc64)
{
fprintf(stderr,
"libdicformat: Incorrect CRC found: 0x%"PRIx64" found, expected 0x%"PRIx64", continuing...",
"libdicformat: Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64
", continuing...",
crc64,
blockHeader.crc64);
break;
@@ -303,10 +306,7 @@ void *open(const char *filepath)
{
case CdSectorPrefix:
case CdSectorPrefixCorrected:
if(idxEntries[i].dataType == CdSectorPrefixCorrected)
{
ctx->sectorPrefixCorrected = data;
}
if(idxEntries[i].dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixCorrected = data; }
else
ctx->sectorPrefix = data;
@@ -327,16 +327,17 @@ void *open(const char *filepath)
ctx->readableSectorTags[CdSectorEccQ] = true;
ctx->readableSectorTags[CdSectorEdc] = true;
break;
case CdSectorSubchannel:ctx->sectorSubchannel = data;
case CdSectorSubchannel:
ctx->sectorSubchannel = data;
ctx->readableSectorTags[CdSectorSubchannel] = true;
break;
case AppleProfileTag:
case AppleSonyTag:
case PriamDataTowerTag:ctx->sectorSubchannel = data;
case PriamDataTowerTag:
ctx->sectorSubchannel = data;
ctx->readableSectorTags[AppleSectorTag] = true;
break;
case CompactDiscMode2Subheader:ctx->mode2Subheaders = data;
break;
case CompactDiscMode2Subheader: ctx->mode2Subheaders = data; break;
default:
if(ctx->mediaTagsHead != NULL)
{
@@ -359,8 +360,7 @@ void *open(const char *filepath)
// If we mediaTag is NULL means we have arrived the end of the list without finding a duplicate
// or the list was empty
if(mediaTag != NULL)
break;
if(mediaTag != NULL) break;
mediaTag = (dataLinkedList *)malloc(sizeof(dataLinkedList));
@@ -375,10 +375,7 @@ void *open(const char *filepath)
mediaTag->data = data;
mediaTag->length = blockHeader.length;
if(ctx->mediaTagsHead == NULL)
{
ctx->mediaTagsHead = mediaTag;
}
if(ctx->mediaTagsHead == NULL) { ctx->mediaTagsHead = mediaTag; }
else
{
mediaTag->previous = ctx->mediaTagsTail;
@@ -391,11 +388,12 @@ void *open(const char *filepath)
}
break;
case DeDuplicationTable:readBytes = fread(&ddtHeader, sizeof(DdtHeader), 1, ctx->imageStream);
case DeDuplicationTable:
readBytes = fread(&ddtHeader, sizeof(DdtHeader), 1, ctx->imageStream);
if(readBytes != sizeof(DdtHeader))
{
fprintf(stderr, "libdicformat: Could not read block header at %"PRIu64"", idxEntries[i].offset);
fprintf(stderr, "libdicformat: Could not read block header at %" PRIu64 "", idxEntries[i].offset);
break;
}
@@ -412,14 +410,14 @@ void *open(const char *filepath)
// Check for DDT compression
switch(ddtHeader.compression)
{
case None:ctx->mappedMemoryDdtSize = sizeof(uint64_t) * ddtHeader.entries;
ctx->userDataDdt =
mmap(NULL,
ctx->mappedMemoryDdtSize,
PROT_READ,
MAP_SHARED,
fileno(ctx->imageStream),
idxEntries[i].offset + sizeof(ddtHeader));
case None:
ctx->mappedMemoryDdtSize = sizeof(uint64_t) * ddtHeader.entries;
ctx->userDataDdt = mmap(NULL,
ctx->mappedMemoryDdtSize,
PROT_READ,
MAP_SHARED,
fileno(ctx->imageStream),
idxEntries[i].offset + sizeof(ddtHeader));
if(ctx->userDataDdt == MAP_FAILED)
{
@@ -436,7 +434,6 @@ void *open(const char *filepath)
blockHeader.compression);
foundUserDataDdt = false;
break;
}
}
else if(idxEntries[i].dataType == CdSectorPrefixCorrected ||
@@ -444,7 +441,8 @@ void *open(const char *filepath)
{
switch(ddtHeader.compression)
{
case None:cdDdt = (uint32_t *)malloc(ddtHeader.entries * sizeof(uint32_t));
case None:
cdDdt = (uint32_t *)malloc(ddtHeader.entries * sizeof(uint32_t));
if(mediaTag == NULL)
{
@@ -478,7 +476,8 @@ void *open(const char *filepath)
}
break;
// Logical geometry block. It doesn't have a CRC coz, well, it's not so important
case GeometryBlock:readBytes = fread(&ctx->geometryBlock, sizeof(GeometryBlockHeader), 1, ctx->imageStream);
case GeometryBlock:
readBytes = fread(&ctx->geometryBlock, sizeof(GeometryBlockHeader), 1, ctx->imageStream);
if(readBytes != sizeof(GeometryBlockHeader))
{
@@ -504,11 +503,8 @@ void *open(const char *filepath)
break;
// Metadata block
case MetadataBlock: readBytes =
fread(&ctx->metadataBlockHeader,
sizeof(MetadataBlockHeader),
1,
ctx->imageStream);
case MetadataBlock:
readBytes = fread(&ctx->metadataBlockHeader, sizeof(MetadataBlockHeader), 1, ctx->imageStream);
if(readBytes != sizeof(MetadataBlockHeader))
{
@@ -521,7 +517,7 @@ void *open(const char *filepath)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
"libdicformat: Incorrect identifier for data block at position %" PRIu64 "",
idxEntries[i].offset);
break;
}
@@ -558,7 +554,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength);
if(ctx->imageInfo.Creator != NULL)
@@ -571,7 +567,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.commentsLength > 0 &&
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength);
if(ctx->imageInfo.Comments != NULL)
@@ -584,7 +580,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.mediaTitleLength > 0 &&
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength);
if(ctx->imageInfo.MediaTitle != NULL)
@@ -597,10 +593,11 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.mediaManufacturerLength > 0 &&
ctx->metadataBlockHeader.mediaManufacturerOffset +
ctx->metadataBlockHeader.mediaManufacturerLength <= ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.mediaManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaManufacturer =
(uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
(uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
if(ctx->imageInfo.MediaManufacturer != NULL)
{
memcpy(ctx->imageInfo.MediaManufacturer,
@@ -611,7 +608,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.mediaModelLength > 0 &&
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelOffset);
if(ctx->imageInfo.MediaModel != NULL)
@@ -624,10 +621,11 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.mediaSerialNumberLength > 0 &&
ctx->metadataBlockHeader.mediaSerialNumberOffset +
ctx->metadataBlockHeader.mediaSerialNumberLength <= ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.mediaSerialNumberLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaSerialNumber =
(uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
(uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
if(ctx->imageInfo.MediaSerialNumber != NULL)
{
memcpy(ctx->imageInfo.MediaSerialNumber,
@@ -638,7 +636,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.mediaBarcodeLength > 0 &&
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
if(ctx->imageInfo.MediaBarcode != NULL)
@@ -651,7 +649,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.mediaPartNumberLength > 0 &&
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
if(ctx->imageInfo.MediaPartNumber != NULL)
@@ -664,10 +662,11 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveManufacturerOffset +
ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.driveManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveManufacturer =
(uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
(uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
if(ctx->imageInfo.DriveManufacturer != NULL)
{
memcpy(ctx->imageInfo.DriveManufacturer,
@@ -678,7 +677,7 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.driveModelLength > 0 &&
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <=
ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength);
if(ctx->imageInfo.DriveModel != NULL)
@@ -691,10 +690,11 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.driveSerialNumberLength > 0 &&
ctx->metadataBlockHeader.driveSerialNumberOffset +
ctx->metadataBlockHeader.driveSerialNumberLength <= ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.driveSerialNumberLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveSerialNumber =
(uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
(uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
if(ctx->imageInfo.DriveSerialNumber != NULL)
{
memcpy(ctx->imageInfo.DriveSerialNumber,
@@ -705,10 +705,11 @@ void *open(const char *filepath)
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveFirmwareRevisionOffset +
ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlockHeader.blockSize)
ctx->metadataBlockHeader.driveManufacturerLength <=
ctx->metadataBlockHeader.blockSize)
{
ctx->imageInfo.DriveFirmwareRevision =
(uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
(uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
if(ctx->imageInfo.DriveFirmwareRevision != NULL)
{
memcpy(ctx->imageInfo.DriveFirmwareRevision,
@@ -718,7 +719,8 @@ void *open(const char *filepath)
}
break;
case TracksBlock: readBytes = fread(&ctx->tracksHeader, sizeof(TracksHeader), 1, ctx->imageStream);
case TracksBlock:
readBytes = fread(&ctx->tracksHeader, sizeof(TracksHeader), 1, ctx->imageStream);
if(readBytes != sizeof(TracksHeader))
{
@@ -731,7 +733,7 @@ void *open(const char *filepath)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
"libdicformat: Incorrect identifier for data block at position %" PRIu64 "",
idxEntries[i].offset);
}
@@ -756,19 +758,19 @@ void *open(const char *filepath)
}
crc64 =
crc64_data_ecma((const uint8_t *)ctx->trackEntries,
ctx->tracksHeader.entries * sizeof(TrackEntry));
crc64_data_ecma((const uint8_t *)ctx->trackEntries, ctx->tracksHeader.entries * sizeof(TrackEntry));
if(crc64 != ctx->tracksHeader.crc64)
{
fprintf(stderr,
"libdicformat: Incorrect CRC found: 0x%"PRIx64" found, expected 0x%"PRIx64", continuing...",
"libdicformat: Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64
", continuing...",
crc64,
ctx->tracksHeader.crc64);
break;
}
fprintf(stderr,
"libdicformat: Found %d tracks at position %"PRIu64".",
"libdicformat: Found %d tracks at position %" PRIu64 ".",
ctx->tracksHeader.entries,
idxEntries[i].offset);
@@ -788,25 +790,23 @@ void *open(const char *filepath)
{
ctx->dataTracks = (TrackEntry *)malloc(sizeof(TrackEntry) * temp8u);
if(ctx->dataTracks == NULL)
break;
if(ctx->dataTracks == NULL) break;
ctx->numberOfDataTracks = temp8u;
for(i = 0, temp8u = 0; i < ctx->tracksHeader.entries; i++)
{
if(ctx->trackEntries[i].sequence > 99)
continue;
if(ctx->trackEntries[i].sequence > 99) continue;
memcpy(&ctx->dataTracks[ctx->trackEntries[i].sequence],
&ctx->trackEntries[i],
sizeof(TrackEntry));
memcpy(
&ctx->dataTracks[ctx->trackEntries[i].sequence], &ctx->trackEntries[i], sizeof(TrackEntry));
}
}
break;
// CICM XML metadata block
case CicmBlock:readBytes = fread(&ctx->cicmBlockHeader, sizeof(CicmMetadataBlock), 1, ctx->imageStream);
case CicmBlock:
readBytes = fread(&ctx->cicmBlockHeader, sizeof(CicmMetadataBlock), 1, ctx->imageStream);
if(readBytes != sizeof(CicmMetadataBlock))
{
@@ -819,7 +819,7 @@ void *open(const char *filepath)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
"libdicformat: Incorrect identifier for data block at position %" PRIu64 "",
idxEntries[i].offset);
}
@@ -844,14 +844,11 @@ void *open(const char *filepath)
fprintf(stderr, "libdicformat: Could not read CICM XML metadata block, continuing...");
}
fprintf(stderr, "libdicformat: Found CICM XML metadata block %"PRIu64".", idxEntries[i].offset);
fprintf(stderr, "libdicformat: Found CICM XML metadata block %" PRIu64 ".", idxEntries[i].offset);
break;
// Dump hardware block
case DumpHardwareBlock: readBytes =
fread(&ctx->dumpHardwareHeader,
sizeof(DumpHardwareHeader),
1,
ctx->imageStream);
case DumpHardwareBlock:
readBytes = fread(&ctx->dumpHardwareHeader, sizeof(DumpHardwareHeader), 1, ctx->imageStream);
if(readBytes != sizeof(DumpHardwareHeader))
{
@@ -864,7 +861,7 @@ void *open(const char *filepath)
{
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
"libdicformat: Incorrect identifier for data block at position %" PRIu64 "",
idxEntries[i].offset);
}
@@ -880,7 +877,8 @@ void *open(const char *filepath)
{
free(data);
fprintf(stderr,
"libdicformat: Incorrect CRC found: 0x%"PRIx64" found, expected 0x%"PRIx64", continuing...",
"libdicformat: Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64
", continuing...",
crc64,
ctx->dumpHardwareHeader.crc64);
break;
@@ -891,9 +889,8 @@ void *open(const char *filepath)
fseek(ctx->imageStream, -readBytes, SEEK_CUR);
}
ctx->dumpHardwareEntriesWithData =
(DumpHardwareEntriesWithData *)malloc(sizeof(DumpHardwareEntriesWithData) *
ctx->dumpHardwareHeader.entries);
ctx->dumpHardwareEntriesWithData = (DumpHardwareEntriesWithData *)malloc(
sizeof(DumpHardwareEntriesWithData) * ctx->dumpHardwareHeader.entries);
if(ctx->dumpHardwareEntriesWithData == NULL)
{
@@ -908,11 +905,8 @@ void *open(const char *filepath)
for(uint16_t e = 0; e < ctx->dumpHardwareHeader.entries; e++)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].entry,
sizeof(DumpHardwareEntry),
1,
ctx->imageStream);
readBytes = fread(
&ctx->dumpHardwareEntriesWithData[e].entry, sizeof(DumpHardwareEntry), 1, ctx->imageStream);
if(readBytes != sizeof(DumpHardwareEntry))
{
@@ -924,22 +918,22 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].manufacturer =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength);
if(ctx->dumpHardwareEntriesWithData[e].manufacturer != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].manufacturer,
ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].manufacturer,
ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength)
{
free(ctx->dumpHardwareEntriesWithData[e].manufacturer);
ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry manufacturer, continuing...");
"libdicformat: Could not read dump hardware block entry manufacturer, "
"continuing...");
}
}
}
@@ -947,15 +941,14 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.modelLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].model =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.modelLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.modelLength);
if(ctx->dumpHardwareEntriesWithData[e].model != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].model,
ctx->dumpHardwareEntriesWithData[e].entry.modelLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].model,
ctx->dumpHardwareEntriesWithData[e].entry.modelLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.modelLength)
{
@@ -970,22 +963,22 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.revisionLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].revision =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.revisionLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.revisionLength);
if(ctx->dumpHardwareEntriesWithData[e].revision != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].revision,
ctx->dumpHardwareEntriesWithData[e].entry.revisionLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].revision,
ctx->dumpHardwareEntriesWithData[e].entry.revisionLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.revisionLength)
{
free(ctx->dumpHardwareEntriesWithData[e].revision);
ctx->dumpHardwareEntriesWithData[e].entry.revisionLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry revision, continuing...");
fprintf(
stderr,
"libdicformat: Could not read dump hardware block entry revision, continuing...");
}
}
}
@@ -993,22 +986,22 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].firmware =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength);
if(ctx->dumpHardwareEntriesWithData[e].firmware != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].firmware,
ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].firmware,
ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength)
{
free(ctx->dumpHardwareEntriesWithData[e].firmware);
ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry firmware, continuing...");
fprintf(
stderr,
"libdicformat: Could not read dump hardware block entry firmware, continuing...");
}
}
}
@@ -1016,15 +1009,14 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.serialLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].serial =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.serialLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.serialLength);
if(ctx->dumpHardwareEntriesWithData[e].serial != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].serial,
ctx->dumpHardwareEntriesWithData[e].entry.serialLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].serial,
ctx->dumpHardwareEntriesWithData[e].entry.serialLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.serialLength)
{
@@ -1039,22 +1031,22 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].softwareName =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength);
if(ctx->dumpHardwareEntriesWithData[e].softwareName != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].softwareName,
ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].softwareName,
ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength)
{
free(ctx->dumpHardwareEntriesWithData[e].softwareName);
ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry software name, continuing...");
"libdicformat: Could not read dump hardware block entry software name, "
"continuing...");
}
}
}
@@ -1062,22 +1054,22 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].softwareVersion =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength);
if(ctx->dumpHardwareEntriesWithData[e].softwareVersion != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].softwareVersion,
ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].softwareVersion,
ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength)
{
free(ctx->dumpHardwareEntriesWithData[e].softwareVersion);
ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry software version, continuing...");
"libdicformat: Could not read dump hardware block entry software version, "
"continuing...");
}
}
}
@@ -1085,42 +1077,41 @@ void *open(const char *filepath)
if(ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem =
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry
.softwareOperatingSystemLength);
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength);
if(ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem,
ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength,
1,
ctx->imageStream);
readBytes = fread(&ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem,
ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength)
{
free(ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem);
ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry manufacturer, continuing...");
"libdicformat: Could not read dump hardware block entry manufacturer, "
"continuing...");
}
}
}
ctx->dumpHardwareEntriesWithData[e].extents =
(DumpExtent *)malloc(sizeof(DumpExtent) * ctx->dumpHardwareEntriesWithData->entry.extents);
(DumpExtent *)malloc(sizeof(DumpExtent) * ctx->dumpHardwareEntriesWithData->entry.extents);
if(ctx->dumpHardwareEntriesWithData[e].extents == NULL)
{
fprintf(stderr,
"libdicformat: Could not allocate memory for dump hardware block extents, continuing...");
fprintf(
stderr,
"libdicformat: Could not allocate memory for dump hardware block extents, continuing...");
continue;
}
readBytes =
fread(ctx->dumpHardwareEntriesWithData[e].extents,
sizeof(DumpExtent),
ctx->dumpHardwareEntriesWithData[e].entry.extents,
ctx->imageStream);
readBytes = fread(ctx->dumpHardwareEntriesWithData[e].extents,
sizeof(DumpExtent),
ctx->dumpHardwareEntriesWithData[e].entry.extents,
ctx->imageStream);
if(readBytes != sizeof(DumpExtent) * ctx->dumpHardwareEntriesWithData->entry.extents)
{
@@ -1135,7 +1126,7 @@ void *open(const char *filepath)
break;
default:
fprintf(stderr,
"libdicformat: Unhandled block type %4.4s with data type %4.4s is indexed to be at %"PRIu64"",
"libdicformat: Unhandled block type %4.4s with data type %4.4s is indexed to be at %" PRIu64 "",
(char *)&idxEntries[i].blockType,
(char *)&idxEntries[i].dataType,
idxEntries[i].offset);
@@ -1156,7 +1147,7 @@ void *open(const char *filepath)
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime;
ctx->imageInfo.XmlMediaType = GetXmlMediaType(ctx->header.mediaType);
if(ctx->geometryBlock.identifier != GeometryBlock/* && ctx->imageInfo.XmlMediaType == XmlMediaType.BlockMedia*/)
if(ctx->geometryBlock.identifier != GeometryBlock && ctx->imageInfo.XmlMediaType == BlockMedia)
{
ctx->imageInfo.Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->imageInfo.Heads = 16;

126
src/read.c
View File

@@ -37,16 +37,14 @@
int32_t read_media_tag(void *context, uint8_t *data, int32_t tag, uint32_t *length)
{
dicformatContext *ctx;
dataLinkedList *item;
dataLinkedList * item;
if(context == NULL)
return DICF_ERROR_NOT_DICFORMAT;
if(context == NULL) return DICF_ERROR_NOT_DICFORMAT;
ctx = context;
// Not a libdicformat context
if(ctx->magic != DIC_MAGIC)
return DICF_ERROR_NOT_DICFORMAT;
if(ctx->magic != DIC_MAGIC) return DICF_ERROR_NOT_DICFORMAT;
item = ctx->mediaTagsHead;
@@ -74,25 +72,22 @@ int32_t read_media_tag(void *context, uint8_t *data, int32_t tag, uint32_t *leng
int32_t read_sector(void *context, uint64_t sectorAddress, uint8_t *data, uint32_t *length)
{
dicformatContext *ctx;
uint64_t ddtEntry;
uint32_t offsetMask;
uint64_t offset;
uint64_t blockOffset;
BlockHeader blockHeader;
uint8_t *block;
size_t readBytes;
uint64_t ddtEntry;
uint32_t offsetMask;
uint64_t offset;
uint64_t blockOffset;
BlockHeader blockHeader;
uint8_t * block;
size_t readBytes;
if(context == NULL)
return DICF_ERROR_NOT_DICFORMAT;
if(context == NULL) return DICF_ERROR_NOT_DICFORMAT;
ctx = context;
// Not a libdicformat context
if(ctx->magic != DIC_MAGIC)
return DICF_ERROR_NOT_DICFORMAT;
if(ctx->magic != DIC_MAGIC) return DICF_ERROR_NOT_DICFORMAT;
if(sectorAddress > ctx->imageInfo.Sectors - 1)
return DICF_ERROR_SECTOR_OUT_OF_BOUNDS;
if(sectorAddress > ctx->imageInfo.Sectors - 1) return DICF_ERROR_SECTOR_OUT_OF_BOUNDS;
ddtEntry = ctx->userDataDdt[sectorAddress];
offsetMask = (uint32_t)((1 << ctx->shift) - 1);
@@ -114,8 +109,7 @@ int32_t read_sector(void *context, uint64_t sectorAddress, uint8_t *data, uint32
fseek(ctx->imageStream, blockOffset, SEEK_SET);
readBytes = fread(&blockHeader, sizeof(BlockHeader), 1, ctx->imageStream);
if(readBytes != sizeof(BlockHeader))
return DICF_ERROR_CANNOT_READ_HEADER;
if(readBytes != sizeof(BlockHeader)) return DICF_ERROR_CANNOT_READ_HEADER;
if(data == NULL || *length < blockHeader.sectorSize)
{
@@ -126,9 +120,9 @@ int32_t read_sector(void *context, uint64_t sectorAddress, uint8_t *data, uint32
// Decompress block
switch(blockHeader.compression)
{
case None:block = (uint8_t *)malloc(blockHeader.length);
if(block == NULL)
return DICF_ERROR_NOT_ENOUGH_MEMORY;
case None:
block = (uint8_t *)malloc(blockHeader.length);
if(block == NULL) return DICF_ERROR_NOT_ENOUGH_MEMORY;
readBytes = fread(block, blockHeader.length, 1, ctx->imageStream);
@@ -139,7 +133,7 @@ int32_t read_sector(void *context, uint64_t sectorAddress, uint8_t *data, uint32
}
break;
default:return DICF_ERROR_UNSUPPORTED_COMPRESSION;
default: return DICF_ERROR_UNSUPPORTED_COMPRESSION;
}
// Check if cache needs to be emptied
@@ -157,26 +151,21 @@ int32_t read_sector(void *context, uint64_t sectorAddress, uint8_t *data, uint32
int32_t read_track_sector(void *context, uint8_t *data, uint64_t sectorAddress, uint32_t *length, uint8_t track)
{
dicformatContext *ctx;
int i;
int i;
if(context == NULL)
return DICF_ERROR_NOT_DICFORMAT;
if(context == NULL) return DICF_ERROR_NOT_DICFORMAT;
ctx = context;
// Not a libdicformat context
if(ctx->magic != DIC_MAGIC)
return DICF_ERROR_NOT_DICFORMAT;
if(ctx->magic != DIC_MAGIC) return DICF_ERROR_NOT_DICFORMAT;
if(ctx->imageInfo.XmlMediaType != OpticalDisc)
return DICF_ERROR_INCORRECT_MEDIA_TYPE;
if(ctx->imageInfo.XmlMediaType != OpticalDisc) return DICF_ERROR_INCORRECT_MEDIA_TYPE;
for(i = 0; i < ctx->numberOfDataTracks; i++)
{
if(ctx->dataTracks[i].sequence == track)
{
return read_sector(context, ctx->dataTracks[i].start + sectorAddress, data, length);
}
{ return read_sector(context, ctx->dataTracks[i].start + sectorAddress, data, length); }
}
return DICF_ERROR_TRACK_NOT_FOUND;
@@ -185,22 +174,20 @@ int32_t read_track_sector(void *context, uint8_t *data, uint64_t sectorAddress,
int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, uint32_t *length)
{
dicformatContext *ctx;
uint32_t bareLength;
uint32_t tagLength;
uint8_t *bareData;
int32_t res;
TrackEntry trk;
int i;
bool trkFound;
uint32_t bareLength;
uint32_t tagLength;
uint8_t * bareData;
int32_t res;
TrackEntry trk;
int i;
bool trkFound;
if(context == NULL)
return DICF_ERROR_NOT_DICFORMAT;
if(context == NULL) return DICF_ERROR_NOT_DICFORMAT;
ctx = context;
// Not a libdicformat context
if(ctx->magic != DIC_MAGIC)
return DICF_ERROR_NOT_DICFORMAT;
if(ctx->magic != DIC_MAGIC) return DICF_ERROR_NOT_DICFORMAT;
switch(ctx->imageInfo.XmlMediaType)
{
@@ -219,13 +206,11 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
bareData = (uint8_t *)malloc(bareLength);
if(bareData == NULL)
return DICF_ERROR_NOT_ENOUGH_MEMORY;
if(bareData == NULL) return DICF_ERROR_NOT_ENOUGH_MEMORY;
res = read_sector(context, sectorAddress, bareData, &bareLength);
if(res < DICF_STATUS_OK)
return res;
if(res < DICF_STATUS_OK) return res;
trkFound = false;
@@ -239,15 +224,14 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
}
}
if(!trkFound)
return DICF_ERROR_TRACK_NOT_FOUND;
if(!trkFound) return DICF_ERROR_TRACK_NOT_FOUND;
switch(trk.type)
{
case Audio:
case Data:memcpy(bareData, data, bareLength);
return res;
case CdMode1:memcpy(bareData, data + 16, 2048);
case Data: memcpy(bareData, data, bareLength); return res;
case CdMode1:
memcpy(bareData, data + 16, 2048);
if(ctx->sectorPrefix != NULL)
memcpy(data, ctx->sectorPrefix + (sectorAddress * 16), 16);
@@ -266,7 +250,7 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
{
memcpy(data,
ctx->sectorPrefixCorrected +
((ctx->sectorPrefixDdt[sectorAddress] & CD_DFIX_MASK) - 1) * 16,
((ctx->sectorPrefixDdt[sectorAddress] & CD_DFIX_MASK) - 1) * 16,
16);
}
}
@@ -279,7 +263,6 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
{
if((ctx->sectorSuffixDdt[sectorAddress] & CD_XFIX_MASK) == Correct)
{
ecc_cd_reconstruct(ctx->eccCdContext, data, trk.type);
res = DICF_STATUS_OK;
}
@@ -291,7 +274,7 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
{
memcpy(data + 2064,
ctx->sectorSuffixCorrected +
((ctx->sectorSuffixDdt[sectorAddress] & CD_DFIX_MASK) - 1) * 288,
((ctx->sectorSuffixDdt[sectorAddress] & CD_DFIX_MASK) - 1) * 288,
288);
}
}
@@ -319,7 +302,7 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
{
memcpy(data,
ctx->sectorPrefixCorrected +
((ctx->sectorPrefixDdt[sectorAddress] & CD_DFIX_MASK) - 1) * 16,
((ctx->sectorPrefixDdt[sectorAddress] & CD_DFIX_MASK) - 1) * 16,
16);
}
}
@@ -352,7 +335,7 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
memcpy(data + 16, bareData, 2336);
return res;
default:return DICF_ERROR_INVALID_TRACK_FORMAT;
default: return DICF_ERROR_INVALID_TRACK_FORMAT;
}
case BlockMedia:
switch(ctx->imageInfo.MediaType)
@@ -363,21 +346,17 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
case AppleSonyDS:
case AppleWidget:
case PriamDataTower:
if(ctx->sectorSubchannel == NULL)
return read_sector(context, sectorAddress, data, length);
if(ctx->sectorSubchannel == NULL) return read_sector(context, sectorAddress, data, length);
switch(ctx->imageInfo.MediaType)
{
case AppleFileWare:
case AppleProfile:
case AppleWidget:tagLength = 20;
break;
case AppleWidget: tagLength = 20; break;
case AppleSonySS:
case AppleSonyDS:tagLength = 12;
break;
case PriamDataTower:tagLength = 24;
break;
default:return DICF_ERROR_INCORRECT_MEDIA_TYPE;
case AppleSonyDS: tagLength = 12; break;
case PriamDataTower: tagLength = 24; break;
default: return DICF_ERROR_INCORRECT_MEDIA_TYPE;
}
bareLength = 512;
@@ -390,13 +369,11 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
bareData = malloc(bareLength);
if(bareData == NULL)
return DICF_ERROR_NOT_ENOUGH_MEMORY;
if(bareData == NULL) return DICF_ERROR_NOT_ENOUGH_MEMORY;
res = read_sector(context, sectorAddress, bareData, &bareLength);
if(bareLength != 512)
return res;
if(bareLength != 512) return res;
memcpy(data, ctx->sectorSubchannel + sectorAddress * tagLength, tagLength);
memcpy(data, bareData, 512);
@@ -404,9 +381,8 @@ int32_t read_sector_long(void *context, uint8_t *data, uint64_t sectorAddress, u
free(bareData);
return res;
default:return DICF_ERROR_INCORRECT_MEDIA_TYPE;
default: return DICF_ERROR_INCORRECT_MEDIA_TYPE;
}
default:return DICF_ERROR_INCORRECT_MEDIA_TYPE;
default: return DICF_ERROR_INCORRECT_MEDIA_TYPE;
}
}