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
Files
4ab2e1bb49b0d422074678f2e51d787ce250a2ce
libaaruformat/src/open.c

1170 lines
52 KiB
C
Raw Normal View History

Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : open.c
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : libdicformat.
//
// --[ Description ] ----------------------------------------------------------
//
// Handles opening DiscImageChef format disk images.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
#include <stdio.h>
#include <dicformat.h>
#include <malloc.h>
#include <errno.h>
Read and traverse the index.
2019-03-17 21:14:40 +00:00
#include <inttypes.h>
#include <string.h>
Read uncompressed user data deduplication table.
2019-03-17 23:19:13 +00:00
#include <sys/mman.h>
Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
Read and traverse the index.
2019-03-17 21:14:40 +00:00
// TODO: Check CRC64 on structures
Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
void *open(const char *filepath)
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
dicformatContext *ctx;
Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
int errorNo;
size_t readBytes;
Read and traverse the index.
2019-03-17 21:14:40 +00:00
long pos;
IndexHeader idxHeader;
IndexEntry *idxEntries;
Change unsigned char to uint8_t.
2019-03-20 22:34:21 +00:00
uint8_t *data;
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
uint32_t *cdDdt;
Use CRC64.
2019-03-20 23:55:32 +00:00
uint64_t crc64;
Read and traverse the index.
2019-03-17 21:14:40 +00:00
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx = (dicformatContext *)malloc(sizeof(dicformatContext));
Read and traverse the index.
2019-03-17 21:14:40 +00:00
memset(ctx, 0, sizeof(dicformatContext));
Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
if(ctx == NULL)
return NULL;
ctx->imageStream = fopen(filepath, "rb");
if(ctx->imageStream == NULL)
{
errorNo = errno;
free(ctx);
errno = errorNo;
return NULL;
}
fseek(ctx->imageStream, 0, SEEK_SET);
readBytes = fread(&ctx->header, sizeof(DicHeader), 1, ctx->imageStream);
if(readBytes != sizeof(DicHeader))
{
free(ctx);
errno = DICF_ERROR_FILE_TOO_SMALL;
return NULL;
}
if(ctx->header.identifier != DIC_MAGIC)
{
free(ctx);
errno = DICF_ERROR_NOT_DICFORMAT;
return NULL;
}
if(ctx->header.imageMajorVersion > DICF_VERSION)
{
free(ctx);
errno = DICF_ERROR_INCOMPATIBLE_VERSION;
return NULL;
}
fprintf(stderr,
Read and traverse the index.
2019-03-17 21:14:40 +00:00
"libdicformat: Opening image version %d.%d",
Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
ctx->header.imageMajorVersion,
ctx->header.imageMinorVersion);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.Application = ctx->header.application;
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.ApplicationVersion = (uint8_t *)malloc(32);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.ApplicationVersion != NULL)
{
memset(ctx->imageInfo.ApplicationVersion, 0, 32);
sprintf((char *)ctx->imageInfo.ApplicationVersion,
"%d.%d",
ctx->header.applicationMajorVersion,
ctx->header.applicationMinorVersion);
}
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.Version = (uint8_t *)malloc(32);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.Version != NULL)
{
memset(ctx->imageInfo.Version, 0, 32);
sprintf((char *)ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
}
ctx->imageInfo.MediaType = ctx->header.mediaType;
Read and traverse the index.
2019-03-17 21:14:40 +00:00
// Read the index header
pos = fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_CUR);
if(pos < 0)
{
free(ctx);
errno = DICF_ERROR_CANNOT_READ_INDEX;
return NULL;
}
pos = ftell(ctx->imageStream);
if(pos != ctx->header.indexOffset)
{
free(ctx);
errno = DICF_ERROR_CANNOT_READ_INDEX;
return NULL;
}
readBytes = fread(&idxHeader, sizeof(IndexHeader), 1, ctx->imageStream);
if(readBytes != sizeof(IndexHeader) || idxHeader.identifier != IndexBlock)
{
free(ctx);
errno = DICF_ERROR_CANNOT_READ_INDEX;
return NULL;
}
fprintf(stderr, "libdicformat: Index at %"PRIu64" contains %d entries", ctx->header.indexOffset, idxHeader.entries);
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
idxEntries = (IndexEntry *)malloc(sizeof(IndexEntry) * idxHeader.entries);
Read and traverse the index.
2019-03-17 21:14:40 +00:00
if(idxEntries == NULL)
{
errorNo = errno;
free(ctx);
errno = errorNo;
return NULL;
}
memset(idxEntries, 0, sizeof(IndexEntry) * idxHeader.entries);
readBytes = fread(idxEntries, sizeof(IndexEntry), idxHeader.entries, ctx->imageStream);
if(readBytes != sizeof(IndexEntry) * idxHeader.entries)
{
free(idxEntries);
free(ctx);
errno = DICF_ERROR_CANNOT_READ_INDEX;
return NULL;
}
for(int i = 0; i < idxHeader.entries; i++)
{
Correct formatting for data and block types in fprintf().
2019-03-18 00:10:58 +00:00
fprintf(stderr, "libdicformat: Block type %4.4s with data type %4.4s is indexed to be at %"PRIu64"",
Read and traverse the index.
2019-03-17 21:14:40 +00:00
(char *)&idxEntries[i].blockType,
(char *)&idxEntries[i].dataType,
idxEntries[i].offset);
}
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
bool foundUserDataDdt = false;
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.ImageSize = 0;
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
for(int i = 0; i < idxHeader.entries; i++)
{
pos = fseek(ctx->imageStream, idxEntries[i].offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != idxEntries[i].offset)
{
fprintf(stderr,
"libdicformat: Could not seek to %"PRIu64" as indicated by index entry %d, continuing...",
idxEntries[i].offset,
i);
continue;
}
Read uncompressed user data deduplication table.
2019-03-17 23:19:13 +00:00
BlockHeader blockHeader;
DdtHeader ddtHeader;
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
switch(idxEntries[i].blockType)
{
case DataBlock:
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
// NOP block, skip
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);
break;
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.ImageSize += blockHeader.cmpLength;
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
// Unused, skip
if(idxEntries[i].dataType == UserData)
{
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(blockHeader.sectorSize > ctx->imageInfo.SectorSize)
ctx->imageInfo.SectorSize = blockHeader.sectorSize;
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
break;
}
if(blockHeader.identifier != idxEntries[i].blockType)
{
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
idxEntries[i].offset);
break;
}
if(blockHeader.type != idxEntries[i].dataType)
{
fprintf(stderr,
Correct formatting for data and block types in fprintf().
2019-03-18 00:10:58 +00:00
"libdicformat: Expected block with data type %4.4s at position %"PRIu64" but found data type %4.4s",
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
(char *)&idxEntries[i].blockType,
idxEntries[i].offset,
(char *)&blockHeader.type);
break;
}
Correct formatting for data and block types in fprintf().
2019-03-18 00:10:58 +00:00
fprintf(stderr, "libdicformat: Found data block with type %4.4s at position %"PRIu64"",
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
(char *)&idxEntries[i].blockType,
idxEntries[i].offset);
if(blockHeader.compression == None)
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
data = (uint8_t *)malloc(blockHeader.length);
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
if(data == NULL)
{
fprintf(stderr, "Cannot allocate memory for block, continuing...");
break;
}
readBytes = fread(data, blockHeader.length, 1, ctx->imageStream);
if(readBytes != blockHeader.length)
{
free(data);
fprintf(stderr, "Could not read block, continuing...");
break;
}
}
else
{
fprintf(stderr,
"libdicformat: Found unknown compression type %d, continuing...",
blockHeader.compression);
break;
}
Use CRC64.
2019-03-20 23:55:32 +00:00
crc64 = crc64_data_ecma(data, blockHeader.length);
if(crc64 != blockHeader.crc64)
{
fprintf(stderr,
"libdicformat: Incorrect CRC found: 0x%"PRIx64" found, expected 0x%"PRIx64", continuing...",
crc64,
blockHeader.crc64);
break;
}
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
Read media tags.
2019-03-17 23:01:54 +00:00
dataLinkedList *mediaTag = NULL;
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
// Check if it's not a media tag, but a sector tag, and fill the appropriate table then
switch(idxEntries[i].dataType)
{
case CdSectorPrefix:
case CdSectorPrefixCorrected:
if(idxEntries[i].dataType == CdSectorPrefixCorrected)
{
ctx->sectorPrefixCorrected = data;
}
else
ctx->sectorPrefix = data;
// TODO: ReadableSectorTags
/*
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSync))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSync);
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorHeader))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorHeader);
*/
break;
case CdSectorSuffix:
case CdSectorSuffixCorrected:
if(idxEntries[i].dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixCorrected = data;
else
ctx->sectorSuffix = data;
// TODO: ReadableSectorTags
/*
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubHeader))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubHeader);
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEcc))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEcc);
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccP))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccP);
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEccQ))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEccQ);
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorEdc))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorEdc);
*/
break;
case CdSectorSubchannel:ctx->sectorSubchannel = data;
// TODO: ReadableSectorTags
/*
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
imageInfo.ReadableSectorTags.Add(SectorTagType.CdSectorSubchannel);
*/
break;
case AppleProfileTag:
case AppleSonyTag:
case PriamDataTowerTag:ctx->sectorSubchannel = data;
// TODO: ReadableSectorTags
/*
if(!imageInfo.ReadableSectorTags.Contains(SectorTagType.AppleSectorTag))
imageInfo.ReadableSectorTags.Add(SectorTagType.AppleSectorTag);
*/
break;
case CompactDiscMode2Subheader:ctx->mode2Subheaders = data;
break;
default:
Read media tags.
2019-03-17 23:01:54 +00:00
if(ctx->mediaTagsHead != NULL)
{
mediaTag = ctx->mediaTagsHead;
while(mediaTag != NULL)
{
if(mediaTag->type == blockHeader.type)
{
fprintf(stderr,
"libdicformat: Media tag type %d duplicated, removing previous entry...",
blockHeader.type);
free(mediaTag->data);
mediaTag->data = data;
break;
}
mediaTag = mediaTag->next;
}
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
// If we mediaTag is NULL means we have arrived the end of the list without finding a duplicate
// or the list was empty
Read media tags.
2019-03-17 23:01:54 +00:00
if(mediaTag != NULL)
break;
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
mediaTag = (dataLinkedList *)malloc(sizeof(dataLinkedList));
Read media tags.
2019-03-17 23:01:54 +00:00
if(mediaTag == NULL)
{
fprintf(stderr, "libdicformat: Cannot allocate memory for media tag list entry.");
break;
}
memset(mediaTag, 0, sizeof(dataLinkedList));
// TODO: MediaTagType
// MediaTagType mediaTagType = GetMediaTagTypeForDataType(blockHeader.type);
mediaTag->type = blockHeader.type;
mediaTag->data = data;
if(ctx->mediaTagsHead == NULL)
{
ctx->mediaTagsHead = mediaTag;
}
else
{
mediaTag->previous = ctx->mediaTagsTail;
ctx->mediaTagsTail->next = mediaTag;
}
ctx->mediaTagsTail = mediaTag;
Read data blocks, except for media tags.
2019-03-17 22:41:04 +00:00
break;
}
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
Read uncompressed user data deduplication table.
2019-03-17 23:19:13 +00:00
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);
break;
}
foundUserDataDdt = true;
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.ImageSize += ddtHeader.cmpLength;
Read uncompressed user data deduplication table.
2019-03-17 23:19:13 +00:00
if(idxEntries[i].dataType == UserData)
{
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.Sectors = ddtHeader.entries;
ctx->shift = ddtHeader.shift;
Read uncompressed user data deduplication table.
2019-03-17 23:19:13 +00:00
// 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));
if(ctx->userDataDdt == MAP_FAILED)
{
foundUserDataDdt = false;
fprintf(stderr, "libdicformat: Could not read map deduplication table.");
break;
}
ctx->inMemoryDdt = false;
break;
default:
fprintf(stderr,
"libdicformat: Found unknown compression type %d, continuing...",
blockHeader.compression);
foundUserDataDdt = false;
break;
}
Read CompactDisc deduplication tables.
2019-03-17 23:25:45 +00:00
}
else if(idxEntries[i].dataType == CdSectorPrefixCorrected ||
idxEntries[i].dataType == CdSectorSuffixCorrected)
{
switch(ddtHeader.compression)
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
case None:cdDdt = (uint32_t *)malloc(ddtHeader.entries * sizeof(uint32_t));
Read CompactDisc deduplication tables.
2019-03-17 23:25:45 +00:00
if(mediaTag == NULL)
{
fprintf(stderr, "libdicformat: Cannot allocate memory for deduplication table.");
break;
}
readBytes = fread(data, ddtHeader.entries * sizeof(uint32_t), 1, ctx->imageStream);
if(readBytes != ddtHeader.entries * sizeof(uint32_t))
{
free(data);
Read tracks block.
2019-03-18 00:10:24 +00:00
fprintf(stderr, "libdicformat: Could not read deduplication table, continuing...");
Read CompactDisc deduplication tables.
2019-03-17 23:25:45 +00:00
break;
}
if(idxEntries[i].dataType == CdSectorPrefixCorrected)
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->sectorPrefixDdt = cdDdt;
Read CompactDisc deduplication tables.
2019-03-17 23:25:45 +00:00
else if(idxEntries[i].dataType == CdSectorSuffixCorrected)
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->sectorSuffixDdt = cdDdt;
else
free(cdDdt);
Read CompactDisc deduplication tables.
2019-03-17 23:25:45 +00:00
break;
default:
fprintf(stderr,
"libdicformat: Found unknown compression type %d, continuing...",
blockHeader.compression);
break;
}
Read uncompressed user data deduplication table.
2019-03-17 23:19:13 +00:00
}
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
Read geometry block.
2019-03-17 23:29:29 +00:00
// 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);
if(readBytes != sizeof(GeometryBlockHeader))
{
Read metadata block.
2019-03-17 23:41:07 +00:00
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
Read tracks block.
2019-03-18 00:10:24 +00:00
fprintf(stderr, "libdicformat: Could not read geometry block, continuing...");
Read geometry block.
2019-03-17 23:29:29 +00:00
break;
}
if(ctx->geometryBlock.identifier == GeometryBlock)
{
fprintf(stderr,
"libdicformat: Geometry set to %d cylinders %d heads %d sectors per track",
ctx->geometryBlock.cylinders,
ctx->geometryBlock.heads,
ctx->geometryBlock.sectorsPerTrack);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.Cylinders = ctx->geometryBlock.cylinders;
ctx->imageInfo.Heads = ctx->geometryBlock.heads;
ctx->imageInfo.SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack;
Read geometry block.
2019-03-17 23:29:29 +00:00
}
else
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
Read metadata block.
2019-03-17 23:41:07 +00:00
// Metadata block
Read tracks block.
2019-03-18 00:10:24 +00:00
case MetadataBlock: readBytes =
fread(&ctx->metadataBlockHeader,
sizeof(MetadataBlockHeader),
1,
ctx->imageStream);
Read metadata block.
2019-03-17 23:41:07 +00:00
if(readBytes != sizeof(MetadataBlockHeader))
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
Read tracks block.
2019-03-18 00:10:24 +00:00
fprintf(stderr, "libdicformat: Could not read metadata block header, continuing...");
Read metadata block.
2019-03-17 23:41:07 +00:00
break;
}
if(ctx->metadataBlockHeader.identifier != idxEntries[i].blockType)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
idxEntries[i].offset);
break;
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.ImageSize += ctx->metadataBlockHeader.blockSize;
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->metadataBlock = (uint8_t *)malloc(ctx->metadataBlockHeader.blockSize);
Read metadata block.
2019-03-17 23:41:07 +00:00
if(ctx->metadataBlock == NULL)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr, "libdicformat: Could not allocate memory for metadata block, continuing...");
break;
}
readBytes = fread(ctx->metadataBlock, ctx->metadataBlockHeader.blockSize, 1, ctx->imageStream);
if(readBytes != ctx->metadataBlockHeader.blockSize)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
free(ctx->metadataBlock);
Read tracks block.
2019-03-18 00:10:24 +00:00
fprintf(stderr, "libdicformat: Could not read metadata block, continuing...");
Read metadata block.
2019-03-17 23:41:07 +00:00
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0)
{
ctx->imageInfo.MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->imageInfo.LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
fprintf(stderr,
"libdicformat: Setting media sequence as %d of %d",
ctx->imageInfo.MediaSequence,
ctx->imageInfo.LastMediaSequence);
}
if(ctx->metadataBlockHeader.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.Creator = (uint8_t *)malloc(ctx->metadataBlockHeader.creatorLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.Creator != NULL)
{
memcpy(ctx->imageInfo.Creator,
ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset,
ctx->metadataBlockHeader.creatorLength);
}
}
if(ctx->metadataBlockHeader.commentsLength > 0 &&
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.Comments = (uint8_t *)malloc(ctx->metadataBlockHeader.commentsLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.Comments != NULL)
{
memcpy(ctx->imageInfo.Comments,
ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset,
ctx->metadataBlockHeader.commentsLength);
}
}
if(ctx->metadataBlockHeader.mediaTitleLength > 0 &&
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.MediaTitle = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaTitleLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.MediaTitle != NULL)
{
memcpy(ctx->imageInfo.MediaTitle,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset,
ctx->metadataBlockHeader.mediaTitleLength);
}
}
if(ctx->metadataBlockHeader.mediaManufacturerLength > 0 &&
ctx->metadataBlockHeader.mediaManufacturerOffset +
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.mediaManufacturerLength <= ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.MediaManufacturer =
(uint8_t *)malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.MediaManufacturer != NULL)
{
memcpy(ctx->imageInfo.MediaManufacturer,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->metadataBlockHeader.mediaManufacturerLength);
}
}
if(ctx->metadataBlockHeader.mediaModelLength > 0 &&
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.MediaModel = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaModelOffset);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.MediaModel != NULL)
{
memcpy(ctx->imageInfo.MediaModel,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset,
ctx->metadataBlockHeader.mediaModelLength);
}
}
if(ctx->metadataBlockHeader.mediaSerialNumberLength > 0 &&
ctx->metadataBlockHeader.mediaSerialNumberOffset +
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.mediaSerialNumberLength <= ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.MediaSerialNumber =
(uint8_t *)malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.MediaSerialNumber != NULL)
{
memcpy(ctx->imageInfo.MediaSerialNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->metadataBlockHeader.mediaManufacturerLength);
}
}
if(ctx->metadataBlockHeader.mediaBarcodeLength > 0 &&
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.MediaBarcode = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.MediaBarcode != NULL)
{
memcpy(ctx->imageInfo.MediaBarcode,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset,
ctx->metadataBlockHeader.mediaBarcodeLength);
}
}
if(ctx->metadataBlockHeader.mediaPartNumberLength > 0 &&
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.MediaPartNumber = (uint8_t *)malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.MediaPartNumber != NULL)
{
memcpy(ctx->imageInfo.MediaPartNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset,
ctx->metadataBlockHeader.mediaPartNumberLength);
}
}
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveManufacturerOffset +
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.DriveManufacturer =
(uint8_t *)malloc(ctx->metadataBlockHeader.driveManufacturerLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.DriveManufacturer != NULL)
{
memcpy(ctx->imageInfo.DriveManufacturer,
ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->metadataBlockHeader.driveManufacturerLength);
}
}
if(ctx->metadataBlockHeader.driveModelLength > 0 &&
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <=
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.DriveModel = (uint8_t *)malloc(ctx->metadataBlockHeader.driveModelLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.DriveModel != NULL)
{
memcpy(ctx->imageInfo.DriveModel,
ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset,
ctx->metadataBlockHeader.driveModelLength);
}
}
if(ctx->metadataBlockHeader.driveSerialNumberLength > 0 &&
ctx->metadataBlockHeader.driveSerialNumberOffset +
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.driveSerialNumberLength <= ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.DriveSerialNumber =
(uint8_t *)malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.DriveSerialNumber != NULL)
{
memcpy(ctx->imageInfo.DriveSerialNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->metadataBlockHeader.driveSerialNumberLength);
}
}
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveFirmwareRevisionOffset +
Fix bound checking incorrect struct member.
2019-03-20 23:39:30 +00:00
ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlockHeader.blockSize)
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
{
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->imageInfo.DriveFirmwareRevision =
(uint8_t *)malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(ctx->imageInfo.DriveFirmwareRevision != NULL)
{
memcpy(ctx->imageInfo.DriveFirmwareRevision,
ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionLength,
ctx->metadataBlockHeader.driveFirmwareRevisionLength);
}
}
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
Read tracks block.
2019-03-18 00:10:24 +00:00
case TracksBlock: readBytes = fread(&ctx->tracksHeader, sizeof(TracksHeader), 1, ctx->imageStream);
if(readBytes != sizeof(TracksHeader))
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr, "libdicformat: Could not read tracks header, continuing...");
break;
}
if(ctx->tracksHeader.identifier != TracksBlock)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
idxEntries[i].offset);
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries;
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->trackEntries = (TrackEntry *)malloc(sizeof(TrackEntry) * ctx->tracksHeader.entries);
Read tracks block.
2019-03-18 00:10:24 +00:00
if(ctx->trackEntries == NULL)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr, "libdicformat: Could not allocate memory for metadata block, continuing...");
break;
}
readBytes = fread(ctx->trackEntries, sizeof(TrackEntry), ctx->tracksHeader.entries, ctx->imageStream);
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
if(readBytes != sizeof(TrackEntry) * ctx->tracksHeader.entries)
Read tracks block.
2019-03-18 00:10:24 +00:00
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
free(ctx->trackEntries);
fprintf(stderr, "libdicformat: Could not read metadata block, continuing...");
}
Use CRC64.
2019-03-20 23:55:32 +00:00
crc64 =
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...",
crc64,
ctx->tracksHeader.crc64);
break;
}
Read tracks block.
2019-03-18 00:10:24 +00:00
fprintf(stderr,
"libdicformat: Found %d tracks at position %"PRIu64".",
ctx->tracksHeader.entries,
idxEntries[i].offset);
// TODO: Cache flags and ISRCs
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.HasPartitions = true;
ctx->imageInfo.HasSessions = true;
Read tracks block.
2019-03-18 00:10:24 +00:00
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
Read CICM XML metadata block.
2019-03-18 22:06:10 +00:00
// CICM XML metadata block
case CicmBlock:readBytes = fread(&ctx->cicmBlockHeader, sizeof(CicmMetadataBlock), 1, ctx->imageStream);
if(readBytes != sizeof(CicmMetadataBlock))
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr, "libdicformat: Could not read CICM XML metadata header, continuing...");
break;
}
if(ctx->cicmBlockHeader.identifier != CicmBlock)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
idxEntries[i].offset);
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length;
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
ctx->cicmBlock = (uint8_t *)malloc(ctx->cicmBlockHeader.length);
Read CICM XML metadata block.
2019-03-18 22:06:10 +00:00
if(ctx->cicmBlock == NULL)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr,
"libdicformat: Could not allocate memory for CICM XML metadata block, continuing...");
break;
}
readBytes = fread(ctx->cicmBlock, ctx->cicmBlockHeader.length, 1, ctx->imageStream);
if(readBytes != ctx->metadataBlockHeader.blockSize)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
free(ctx->cicmBlock);
fprintf(stderr, "libdicformat: Could not read CICM XML metadata block, continuing...");
}
fprintf(stderr, "libdicformat: Found CICM XML metadata block %"PRIu64".", idxEntries[i].offset);
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
Read dump hardware block.
2019-03-20 00:23:30 +00:00
// Dump hardware block
case DumpHardwareBlock: readBytes =
fread(&ctx->dumpHardwareHeader,
sizeof(DumpHardwareHeader),
1,
ctx->imageStream);
if(readBytes != sizeof(DumpHardwareHeader))
{
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libdicformat: Could not read dump hardware block header, continuing...");
break;
}
if(ctx->dumpHardwareHeader.identifier != DumpHardwareBlock)
{
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr,
"libdicformat: Incorrect identifier for data block at position %"PRIu64"",
idxEntries[i].offset);
}
Use CRC64.
2019-03-20 23:55:32 +00:00
data = (uint8_t *)malloc(ctx->dumpHardwareHeader.length);
if(data != NULL)
{
readBytes = fread(data, ctx->dumpHardwareHeader.length, 1, ctx->imageStream);
if(readBytes == ctx->dumpHardwareHeader.length)
{
crc64 = crc64_data_ecma(data, ctx->dumpHardwareHeader.length);
if(crc64 != ctx->dumpHardwareHeader.crc64)
{
free(data);
fprintf(stderr,
"libdicformat: Incorrect CRC found: 0x%"PRIx64" found, expected 0x%"PRIx64", continuing...",
crc64,
ctx->dumpHardwareHeader.crc64);
break;
}
}
free(data);
fseek(ctx->imageStream, -readBytes, SEEK_CUR);
}
Read dump hardware block.
2019-03-20 00:23:30 +00:00
ctx->dumpHardwareEntriesWithData =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(DumpHardwareEntriesWithData *)malloc(sizeof(DumpHardwareEntriesWithData) *
ctx->dumpHardwareHeader.entries);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData == NULL)
{
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libdicformat: Could not allocate memory for dump hardware block, continuing...");
break;
}
memset(ctx->dumpHardwareEntriesWithData,
0,
sizeof(DumpHardwareEntriesWithData) * ctx->dumpHardwareHeader.entries);
for(uint16_t e = 0; e < ctx->dumpHardwareHeader.entries; e++)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].entry,
sizeof(DumpHardwareEntry),
1,
ctx->imageStream);
if(readBytes != sizeof(DumpHardwareEntry))
{
ctx->dumpHardwareHeader.entries = e + (uint16_t)1;
fprintf(stderr, "libdicformat: Could not read dump hardware block entry, continuing...");
break;
}
if(ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].manufacturer =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].manufacturer != NULL)
{
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...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.modelLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].model =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.modelLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].model != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].model,
ctx->dumpHardwareEntriesWithData[e].entry.modelLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.modelLength)
{
free(ctx->dumpHardwareEntriesWithData[e].model);
ctx->dumpHardwareEntriesWithData[e].entry.modelLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry model, continuing...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.revisionLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].revision =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.revisionLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].revision != NULL)
{
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...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].firmware =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].firmware != NULL)
{
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...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.serialLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].serial =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.serialLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].serial != NULL)
{
readBytes =
fread(&ctx->dumpHardwareEntriesWithData[e].serial,
ctx->dumpHardwareEntriesWithData[e].entry.serialLength,
1,
ctx->imageStream);
if(readBytes != ctx->dumpHardwareEntriesWithData[e].entry.serialLength)
{
free(ctx->dumpHardwareEntriesWithData[e].serial);
ctx->dumpHardwareEntriesWithData[e].entry.serialLength = 0;
fprintf(stderr,
"libdicformat: Could not read dump hardware block entry serial, continuing...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].softwareName =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].softwareName != NULL)
{
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...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].softwareVersion =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].softwareVersion != NULL)
{
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...");
}
}
}
if(ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength > 0)
{
ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(uint8_t *)malloc(ctx->dumpHardwareEntriesWithData[e].entry
.softwareOperatingSystemLength);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem != NULL)
{
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...");
}
}
}
ctx->dumpHardwareEntriesWithData[e].extents =
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
(DumpExtent *)malloc(sizeof(DumpExtent) * ctx->dumpHardwareEntriesWithData->entry.extents);
Read dump hardware block.
2019-03-20 00:23:30 +00:00
if(ctx->dumpHardwareEntriesWithData[e].extents == NULL)
{
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);
if(readBytes != sizeof(DumpExtent) * ctx->dumpHardwareEntriesWithData->entry.extents)
{
free(ctx->dumpHardwareEntriesWithData[e].extents);
fprintf(stderr, "libdicformat: Could not read dump hardware block extents, continuing...");
continue;
}
// TODO: qsort()
}
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
break;
default:
fprintf(stderr,
Correct formatting for data and block types in fprintf().
2019-03-18 00:10:58 +00:00
"libdicformat: Unhandled block type %4.4s with data type %4.4s is indexed to be at %"PRIu64"",
Seek to all indexed entries.
2019-03-17 21:32:02 +00:00
(char *)&idxEntries[i].blockType,
(char *)&idxEntries[i].dataType,
idxEntries[i].offset);
break;
}
}
Cast all malloc to destination type.
2019-03-20 22:45:05 +00:00
free(idxEntries);
Finish open image.
2019-03-20 00:35:11 +00:00
if(!foundUserDataDdt)
{
fprintf(stderr, "libdicformat: Could not find user data deduplication table, aborting...");
close(ctx);
return NULL;
}
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
ctx->imageInfo.CreationTime = ctx->header.creationTime;
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime;
Finish open image.
2019-03-20 00:35:11 +00:00
Implement ImageInfo.
2019-03-20 22:31:50 +00:00
// TODO: GetXmlMediaType
// imageInfo.XmlMediaType = GetXmlMediaType(header.mediaType);
if(ctx->geometryBlock.identifier != GeometryBlock/* && ctx->imageInfo.XmlMediaType == XmlMediaType.BlockMedia*/)
{
ctx->imageInfo.Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->imageInfo.Heads = 16;
ctx->imageInfo.SectorsPerTrack = 63;
}
Finish open image.
2019-03-20 00:35:11 +00:00
// TODO: Caches
/*
// Initialize caches
blockCache = new Dictionary<ulong, byte[]>();
blockHeaderCache = new Dictionary<ulong, BlockHeader>();
currentCacheSize = 0;
if(!inMemoryDdt) ddtEntryCache = new Dictionary<ulong, ulong>();
*/
// TODO: Cache tracks and sessions?
// TODO: Initialize ECC for Compact Disc
Read and traverse the index.
2019-03-17 21:14:40 +00:00
ctx->magic = DIC_MAGIC;
ctx->libraryMajorVersion = LIBDICFORMAT_MAJOR_VERSION;
ctx->libraryMinorVersion = LIBDICFORMAT_MINOR_VERSION;
free(idxEntries);
Add open() and close() skeletons that only recognize the image as a correct one.
2019-03-17 20:39:40 +00:00
return ctx;
}
Reference in New Issue Copy Permalink