diff --git a/include/internal.h b/include/internal.h
new file mode 100644
index 0000000..2258de1
--- /dev/null
+++ b/include/internal.h
@@ -0,0 +1,27 @@
+/*
+ * This file is part of the Aaru Data Preservation Suite.
+ * Copyright (c) 2019-2025 Natalia Portillo.
+ *
+ * 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 .
+ */
+
+#ifndef LIBAARUFORMAT_INTERNAL_H
+#define LIBAARUFORMAT_INTERNAL_H
+
+#include "utarray.h"
+
+UT_array *process_index_v1(aaruformatContext *ctx);
+int32_t verify_index_v1(aaruformatContext *ctx);
+
+#endif // LIBAARUFORMAT_INTERNAL_H
diff --git a/src/index_v1.c b/src/index_v1.c
new file mode 100644
index 0000000..fadd419
--- /dev/null
+++ b/src/index_v1.c
@@ -0,0 +1,120 @@
+/*
+ * This file is part of the Aaru Data Preservation Suite.
+ * Copyright (c) 2019-2025 Natalia Portillo.
+ *
+ * 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 .
+ */
+
+#include
+#include
+#include
+
+#include "aaruformat.h"
+#include "utarray.h"
+
+UT_array *process_index_v1(aaruformatContext *ctx)
+{
+ UT_array *index_entries = NULL;
+ IndexEntry entry;
+
+ if(ctx == NULL || ctx->imageStream == NULL) return NULL;
+
+ // Initialize the index entries array
+ UT_icd index_entry_icd = {sizeof(IndexEntry), NULL, NULL, NULL};
+
+ utarray_new(index_entries, &index_entry_icd);
+
+ // Read the index header
+ fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_SET);
+ IndexHeader idx_header;
+ fread(&idx_header, sizeof(IndexHeader), 1, ctx->imageStream);
+
+ // Check if the index header is valid
+ if(idx_header.identifier != IndexBlock)
+ {
+ fprintf(stderr, "Incorrect index identifier.\n");
+ utarray_free(index_entries);
+ return NULL;
+ }
+
+ for(int i = 0; i < idx_header.entries; i++)
+ {
+ fread(&entry, sizeof(IndexEntry), 1, ctx->imageStream);
+ utarray_push_back(index_entries, &entry);
+ }
+
+ return index_entries;
+}
+
+int32_t verify_index_v1(aaruformatContext *ctx)
+{
+ size_t read_bytes = 0;
+ IndexHeader index_header;
+ uint64_t crc64 = 0;
+ IndexEntry *index_entries = NULL;
+
+ if(ctx == NULL || ctx->imageStream == NULL) return AARUF_ERROR_NOT_AARUFORMAT;
+
+ // This will traverse all blocks and check their CRC64 without uncompressing them
+ fprintf(stderr, "Checking index integrity at %llu.\n", ctx->header.indexOffset);
+ fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_SET);
+
+ // Read the index header
+ read_bytes = fread(&index_header, 1, sizeof(IndexHeader), ctx->imageStream);
+
+ if(read_bytes != sizeof(IndexHeader))
+ {
+ fprintf(stderr, "Could not read index header.\n");
+ return AARUF_ERROR_CANNOT_READ_HEADER;
+ }
+
+ if(index_header.identifier != IndexBlock)
+ {
+ fprintf(stderr, "Incorrect index identifier.\n");
+ return AARUF_ERROR_CANNOT_READ_INDEX;
+ }
+
+ fprintf(stderr, "Index at %llu contains %d entries.\n", ctx->header.indexOffset, index_header.entries);
+
+ index_entries = malloc(sizeof(IndexEntry) * index_header.entries);
+
+ if(index_entries == NULL)
+ {
+ fprintf(stderr, "Cannot allocate memory for index entries.\n");
+ return AARUF_ERROR_NOT_ENOUGH_MEMORY;
+ }
+
+ read_bytes = fread(index_entries, 1, sizeof(IndexEntry) * index_header.entries, ctx->imageStream);
+
+ if(read_bytes != sizeof(IndexEntry) * index_header.entries)
+ {
+ fprintf(stderr, "Could not read index entries.\n");
+ free(index_entries);
+ return AARUF_ERROR_CANNOT_READ_INDEX;
+ }
+
+ crc64 = aaruf_crc64_data((const uint8_t *)index_entries, sizeof(IndexEntry) * index_header.entries);
+
+ // Due to how C# wrote it, it is effectively reversed
+ if(ctx->header.imageMajorVersion <= AARUF_VERSION) crc64 = bswap_64(crc64);
+
+ if(crc64 != index_header.crc64)
+ {
+ fprintf(stderr, "Expected index CRC 0x%16llX but got 0x%16llX.\n", index_header.crc64, crc64);
+ free(index_entries);
+ return AARUF_ERROR_INVALID_BLOCK_CRC;
+ }
+
+ return AARUF_STATUS_OK;
+}
\ No newline at end of file
diff --git a/src/open.c b/src/open.c
index 8b83771..32b029d 100644
--- a/src/open.c
+++ b/src/open.c
@@ -28,27 +28,30 @@
#include
+#include "internal.h"
+#include "utarray.h"
+
void *aaruf_open(const char *filepath)
{
- aaruformatContext *ctx = NULL;
- int errorNo = 0;
- size_t readBytes = 0;
- long pos = 0;
- IndexHeader idxHeader;
- IndexEntry *idxEntries = NULL;
- uint8_t *data = NULL;
- uint8_t *cmpData = NULL;
- uint8_t *cstData = NULL;
- uint32_t *cdDdt = NULL;
- uint64_t crc64 = 0;
- int i = 0, j = 0, k = 0;
- uint16_t e = 0;
- uint8_t lzmaProperties[LZMA_PROPERTIES_LENGTH];
- size_t lzmaSize = 0;
- ChecksumHeader checksum_header;
+ aaruformatContext *ctx = NULL;
+ int errorNo = 0;
+ size_t readBytes = 0;
+ long pos = 0;
+ uint8_t *data = NULL;
+ uint8_t *cmpData = NULL;
+ uint8_t *cstData = NULL;
+ uint32_t *cdDdt = NULL;
+ uint64_t crc64 = 0;
+ int i = 0, j = 0, k = 0;
+ uint16_t e = 0;
+ uint8_t lzmaProperties[LZMA_PROPERTIES_LENGTH];
+ size_t lzmaSize = 0;
+ ChecksumHeader checksum_header;
ChecksumEntry const *checksum_entry = NULL;
- mediaTagEntry *mediaTag = NULL;
- mediaTagEntry *oldMediaTag = NULL;
+ mediaTagEntry *mediaTag = NULL;
+ mediaTagEntry *oldMediaTag = NULL;
+ uint32_t signature = 0;
+ UT_array *index_entries = NULL;
ctx = (aaruformatContext *)malloc(sizeof(aaruformatContext));
memset(ctx, 0, sizeof(aaruformatContext));
@@ -147,9 +150,9 @@ void *aaruf_open(const char *filepath)
return NULL;
}
- readBytes = fread(&idxHeader, 1, sizeof(IndexHeader), ctx->imageStream);
+ readBytes = fread(&signature, 1, sizeof(uint32_t), ctx->imageStream);
- if(readBytes != sizeof(IndexHeader) || idxHeader.identifier != IndexBlock)
+ if(readBytes != sizeof(uint32_t) || signature != IndexBlock)
{
free(ctx);
errno = AARUF_ERROR_CANNOT_READ_INDEX;
@@ -157,49 +160,40 @@ void *aaruf_open(const char *filepath)
return NULL;
}
+ index_entries = process_index_v1(ctx);
+
+ if(index_entries == NULL)
+ {
+ fprintf(stderr, "Could not process index.\n");
+ utarray_free(index_entries);
+ free(ctx);
+ errno = AARUF_ERROR_CANNOT_READ_INDEX;
+
+ return NULL;
+ }
+
fprintf(stderr, "libaaruformat: Index at %" PRIu64 " contains %d entries\n", ctx->header.indexOffset,
- idxHeader.entries);
+ utarray_len(index_entries));
- idxEntries = (IndexEntry *)malloc(sizeof(IndexEntry) * idxHeader.entries);
-
- 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 != idxHeader.entries)
- {
- free(idxEntries);
- free(ctx);
- errno = AARUF_ERROR_CANNOT_READ_INDEX;
-
- return NULL;
- }
-
- for(i = 0; i < idxHeader.entries; i++)
+ for(i = 0; i < utarray_len(index_entries); i++)
{
+ IndexEntry *entry = (IndexEntry *)utarray_eltptr(index_entries, i);
fprintf(stderr, "libaaruformat: Block type %4.4s with data type %d is indexed to be at %" PRIu64 "\n",
- (char *)&idxEntries[i].blockType, idxEntries[i].dataType, idxEntries[i].offset);
+ (char *)&entry->blockType, entry->dataType, entry->offset);
}
bool foundUserDataDdt = false;
ctx->imageInfo.ImageSize = 0;
- for(i = 0; i < idxHeader.entries; i++)
+ for(i = 0; i < utarray_len(index_entries); i++)
{
- pos = fseek(ctx->imageStream, idxEntries[i].offset, SEEK_SET);
+ IndexEntry *entry = (IndexEntry *)utarray_eltptr(index_entries, i);
+ pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
- if(pos < 0 || ftell(ctx->imageStream) != idxEntries[i].offset)
+ if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{
fprintf(stderr,
"libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry %d, continuing...\n",
- idxEntries[i].offset, i);
+ entry->offset, i);
continue;
}
@@ -207,18 +201,17 @@ void *aaruf_open(const char *filepath)
BlockHeader blockHeader;
DdtHeader ddtHeader;
- switch(idxEntries[i].blockType)
+ switch(entry->blockType)
{
case DataBlock:
// NOP block, skip
- if(idxEntries[i].dataType == NoData) break;
+ if(entry->dataType == NoData) break;
readBytes = fread(&blockHeader, 1, sizeof(BlockHeader), ctx->imageStream);
if(readBytes != sizeof(BlockHeader))
{
- fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n",
- idxEntries[i].offset);
+ fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n", entry->offset);
break;
}
@@ -226,7 +219,7 @@ void *aaruf_open(const char *filepath)
ctx->imageInfo.ImageSize += blockHeader.cmpLength;
// Unused, skip
- if(idxEntries[i].dataType == UserData)
+ if(entry->dataType == UserData)
{
if(blockHeader.sectorSize > ctx->imageInfo.SectorSize)
ctx->imageInfo.SectorSize = blockHeader.sectorSize;
@@ -234,24 +227,24 @@ void *aaruf_open(const char *filepath)
break;
}
- if(blockHeader.identifier != idxEntries[i].blockType)
+ if(blockHeader.identifier != entry->blockType)
{
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n",
- idxEntries[i].offset);
+ entry->offset);
break;
}
- if(blockHeader.type != idxEntries[i].dataType)
+ if(blockHeader.type != entry->dataType)
{
fprintf(stderr,
"libaaruformat: Expected block with data type %4.4s at position %" PRIu64
" but found data type %4.4s\n",
- (char *)&idxEntries[i].blockType, idxEntries[i].offset, (char *)&blockHeader.type);
+ (char *)&entry->blockType, entry->offset, (char *)&blockHeader.type);
break;
}
fprintf(stderr, "libaaruformat: Found data block with type %4.4s at position %" PRIu64 "\n",
- (char *)&idxEntries[i].blockType, idxEntries[i].offset);
+ (char *)&entry->blockType, entry->offset);
if(blockHeader.compression == Lzma || blockHeader.compression == LzmaClauniaSubchannelTransform)
{
@@ -387,11 +380,11 @@ void *aaruf_open(const char *filepath)
}
// Check if it's not a media tag, but a sector tag, and fill the appropriate table then
- switch(idxEntries[i].dataType)
+ switch(entry->dataType)
{
case CdSectorPrefix:
case CdSectorPrefixCorrected:
- if(idxEntries[i].dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixCorrected = data; }
+ if(entry->dataType == CdSectorPrefixCorrected) { ctx->sectorPrefixCorrected = data; }
else
ctx->sectorPrefix = data;
@@ -401,7 +394,7 @@ void *aaruf_open(const char *filepath)
break;
case CdSectorSuffix:
case CdSectorSuffixCorrected:
- if(idxEntries[i].dataType == CdSectorSuffixCorrected)
+ if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixCorrected = data;
else
ctx->sectorSuffix = data;
@@ -458,8 +451,7 @@ void *aaruf_open(const char *filepath)
if(readBytes != sizeof(DdtHeader))
{
- fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n",
- idxEntries[i].offset);
+ fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n", entry->offset);
break;
}
@@ -468,7 +460,7 @@ void *aaruf_open(const char *filepath)
ctx->imageInfo.ImageSize += ddtHeader.cmpLength;
- if(idxEntries[i].dataType == UserData)
+ if(entry->dataType == UserData)
{
ctx->imageInfo.Sectors = ddtHeader.entries;
ctx->shift = ddtHeader.shift;
@@ -554,7 +546,7 @@ void *aaruf_open(const char *filepath)
#ifdef __linux__
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));
+ fileno(ctx->imageStream), entry->offset + sizeof(ddtHeader));
if(ctx->userDataDdt == MAP_FAILED)
{
@@ -577,8 +569,7 @@ void *aaruf_open(const char *filepath)
break;
}
}
- else if(idxEntries[i].dataType == CdSectorPrefixCorrected ||
- idxEntries[i].dataType == CdSectorSuffixCorrected)
+ else if(entry->dataType == CdSectorPrefixCorrected || entry->dataType == CdSectorSuffixCorrected)
{
switch(ddtHeader.compression)
{
@@ -651,9 +642,9 @@ void *aaruf_open(const char *filepath)
return NULL;
}
- if(idxEntries[i].dataType == CdSectorPrefixCorrected)
+ if(entry->dataType == CdSectorPrefixCorrected)
ctx->sectorPrefixDdt = cdDdt;
- else if(idxEntries[i].dataType == CdSectorSuffixCorrected)
+ else if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixDdt = cdDdt;
else
free(cdDdt);
@@ -679,9 +670,9 @@ void *aaruf_open(const char *filepath)
break;
}
- if(idxEntries[i].dataType == CdSectorPrefixCorrected)
+ if(entry->dataType == CdSectorPrefixCorrected)
ctx->sectorPrefixDdt = cdDdt;
- else if(idxEntries[i].dataType == CdSectorSuffixCorrected)
+ else if(entry->dataType == CdSectorSuffixCorrected)
ctx->sectorSuffixDdt = cdDdt;
else
free(cdDdt);
@@ -729,11 +720,11 @@ void *aaruf_open(const char *filepath)
break;
}
- if(ctx->metadataBlockHeader.identifier != idxEntries[i].blockType)
+ if(ctx->metadataBlockHeader.identifier != entry->blockType)
{
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n",
- idxEntries[i].offset);
+ entry->offset);
break;
}
@@ -944,7 +935,7 @@ void *aaruf_open(const char *filepath)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n",
- idxEntries[i].offset);
+ entry->offset);
}
ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries;
@@ -983,7 +974,7 @@ void *aaruf_open(const char *filepath)
}
fprintf(stderr, "libaaruformat: Found %d tracks at position %" PRIu64 ".\n", ctx->tracksHeader.entries,
- idxEntries[i].offset);
+ entry->offset);
ctx->imageInfo.HasPartitions = true;
ctx->imageInfo.HasSessions = true;
@@ -1021,7 +1012,7 @@ void *aaruf_open(const char *filepath)
{
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n",
- idxEntries[i].offset);
+ entry->offset);
}
ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length;
@@ -1045,7 +1036,7 @@ void *aaruf_open(const char *filepath)
fprintf(stderr, "libaaruformat: Could not read CICM XML metadata block, continuing...\n");
}
- fprintf(stderr, "libaaruformat: Found CICM XML metadata block %" PRIu64 ".\n", idxEntries[i].offset);
+ fprintf(stderr, "libaaruformat: Found CICM XML metadata block %" PRIu64 ".\n", entry->offset);
break;
// Dump hardware block
case DumpHardwareBlock:
@@ -1062,7 +1053,7 @@ void *aaruf_open(const char *filepath)
{
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n",
- idxEntries[i].offset);
+ entry->offset);
}
data = (uint8_t *)malloc(ctx->dumpHardwareHeader.length);
@@ -1348,7 +1339,7 @@ void *aaruf_open(const char *filepath)
{
memset(&checksum_header, 0, sizeof(ChecksumHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for checksum block at position %" PRIu64 "\n",
- idxEntries[i].offset);
+ entry->offset);
}
data = (uint8_t *)malloc(checksum_header.length);
@@ -1414,12 +1405,12 @@ void *aaruf_open(const char *filepath)
default:
fprintf(stderr,
"libaaruformat: Unhandled block type %4.4s with data type %d is indexed to be at %" PRIu64 "\n",
- (char *)&idxEntries[i].blockType, idxEntries[i].dataType, idxEntries[i].offset);
+ (char *)&entry->blockType, entry->dataType, entry->offset);
break;
}
}
- free(idxEntries);
+ utarray_free(index_entries);
if(!foundUserDataDdt)
{
diff --git a/src/verify.c b/src/verify.c
index 5c65c33..69828e2 100644
--- a/src/verify.c
+++ b/src/verify.c
@@ -16,26 +16,28 @@
* License along with this library; if not, see .
*/
+#include
#include
-#include
+#include "internal.h"
+#include "utarray.h"
#define VERIFY_SIZE 1048576
int32_t aaruf_verify_image(void *context)
{
- aaruformatContext *ctx = NULL;
- uint64_t crc64 = 0;
- int i = 0;
- IndexHeader index_header;
- IndexEntry *index_entries = NULL;
- size_t read_bytes = 0;
- void *buffer = NULL;
- crc64_ctx *crc64_context = NULL;
+ aaruformatContext *ctx = NULL;
+ uint64_t crc64 = 0;
+ size_t read_bytes = 0;
+ void *buffer = NULL;
+ crc64_ctx *crc64_context = NULL;
BlockHeader block_header;
- uint64_t verified_bytes = 0;
+ uint64_t verified_bytes = 0;
DdtHeader ddt_header;
TracksHeader tracks_header;
+ uint32_t signature = 0;
+ UT_array *index_entries = NULL;
+ int32_t err = 0;
if(context == NULL) return AARUF_ERROR_NOT_AARUFORMAT;
@@ -44,79 +46,64 @@ int32_t aaruf_verify_image(void *context)
// Not a libaaruformat context
if(ctx->magic != AARU_MAGIC) return AARUF_ERROR_NOT_AARUFORMAT;
- // This will traverse all blocks and check their CRC64 without uncompressing them
- fprintf(stderr, "Checking index integrity at %llu.\n", ctx->header.indexOffset);
fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_SET);
- read_bytes = fread(&index_header, 1, sizeof(IndexHeader), ctx->imageStream);
-
- if(read_bytes != sizeof(IndexHeader))
+ read_bytes = fread(&signature, 1, sizeof(uint32_t), ctx->imageStream);
+ if(read_bytes != sizeof(uint32_t))
{
- fprintf(stderr, "Could not read index header.\n");
+ fprintf(stderr, "Could not read index signature.\n");
return AARUF_ERROR_CANNOT_READ_HEADER;
}
- if(index_header.identifier != IndexBlock)
+ if(signature != IndexBlock)
{
- fprintf(stderr, "Incorrect index identifier.\n");
+ fprintf(stderr, "Incorrect index signature.\n");
return AARUF_ERROR_CANNOT_READ_INDEX;
}
- fprintf(stderr, "Index at %llu contains %d entries.\n", ctx->header.indexOffset, index_header.entries);
+ // Check if the index is correct
+ err = verify_index_v1(ctx);
- index_entries = malloc(sizeof(IndexEntry) * index_header.entries);
+ if(err != AARUF_STATUS_OK)
+ {
+ fprintf(stderr, "Index verification failed with error code %d.\n", err);
+ return err;
+ }
+
+ // Process the index
+ index_entries = process_index_v1(ctx);
if(index_entries == NULL)
{
- fprintf(stderr, "Cannot allocate memory for index entries.\n");
- return AARUF_ERROR_NOT_ENOUGH_MEMORY;
- }
-
- read_bytes = fread(index_entries, 1, sizeof(IndexEntry) * index_header.entries, ctx->imageStream);
-
- if(read_bytes != sizeof(IndexEntry) * index_header.entries)
- {
- fprintf(stderr, "Could not read index entries.\n");
- free(index_entries);
+ fprintf(stderr, "Could not process index.\n");
return AARUF_ERROR_CANNOT_READ_INDEX;
}
- crc64 = aaruf_crc64_data((const uint8_t *)index_entries, sizeof(IndexEntry) * index_header.entries);
-
- // Due to how C# wrote it, it is effectively reversed
- if(ctx->header.imageMajorVersion <= AARUF_VERSION) crc64 = bswap_64(crc64);
-
- if(crc64 != index_header.crc64)
- {
- fprintf(stderr, "Expected index CRC 0x%16llX but got 0x%16llX.\n", index_header.crc64, crc64);
- free(index_entries);
- return AARUF_ERROR_INVALID_BLOCK_CRC;
- }
-
buffer = malloc(VERIFY_SIZE);
if(buffer == NULL)
{
fprintf(stderr, "Cannot allocate memory for buffer.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_NOT_ENOUGH_MEMORY;
}
- for(i = 0; i < index_header.entries; i++)
+ for(int i = 0; i < utarray_len(index_entries); i++)
{
- fprintf(stderr, "Checking block with type %4.4s at position %" PRIu64 "\n", (char *)&index_entries[i].blockType,
- index_entries[i].offset);
+ IndexEntry *entry = (IndexEntry *)utarray_eltptr(index_entries, i);
+ fprintf(stderr, "Checking block with type %4.4s at position %" PRIu64 "\n", (char *)&entry->blockType,
+ entry->offset);
- fseek(ctx->imageStream, index_entries[i].offset, SEEK_SET);
+ fseek(ctx->imageStream, entry->offset, SEEK_SET);
- switch(index_entries[i].blockType)
+ switch(entry->blockType)
{
case DataBlock:
read_bytes = fread(&block_header, 1, sizeof(BlockHeader), ctx->imageStream);
if(read_bytes != sizeof(BlockHeader))
{
fprintf(stderr, "Could not read block header.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
@@ -125,7 +112,7 @@ int32_t aaruf_verify_image(void *context)
if(crc64_context == NULL)
{
fprintf(stderr, "Could not initialize CRC64.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
@@ -149,7 +136,7 @@ int32_t aaruf_verify_image(void *context)
if(crc64 != block_header.cmpCrc64)
{
fprintf(stderr, "Expected block CRC 0x%16llX but got 0x%16llX.\n", block_header.cmpCrc64, crc64);
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
@@ -159,7 +146,7 @@ int32_t aaruf_verify_image(void *context)
if(read_bytes != sizeof(DdtHeader))
{
fprintf(stderr, "Could not read DDT header.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
@@ -168,7 +155,7 @@ int32_t aaruf_verify_image(void *context)
if(crc64_context == NULL)
{
fprintf(stderr, "Could not initialize CRC64.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
@@ -192,7 +179,7 @@ int32_t aaruf_verify_image(void *context)
if(crc64 != ddt_header.cmpCrc64)
{
fprintf(stderr, "Expected DDT CRC 0x%16llX but got 0x%16llX.\n", ddt_header.cmpCrc64, crc64);
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
@@ -202,7 +189,7 @@ int32_t aaruf_verify_image(void *context)
if(read_bytes != sizeof(TracksHeader))
{
fprintf(stderr, "Could not read tracks header.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
@@ -211,7 +198,7 @@ int32_t aaruf_verify_image(void *context)
if(crc64_context == NULL)
{
fprintf(stderr, "Could not initialize CRC64.\n");
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_CANNOT_READ_BLOCK;
}
@@ -226,13 +213,13 @@ int32_t aaruf_verify_image(void *context)
if(crc64 != tracks_header.crc64)
{
fprintf(stderr, "Expected DDT CRC 0x%16llX but got 0x%16llX.\n", tracks_header.crc64, crc64);
- free(index_entries);
+ utarray_free(index_entries);
return AARUF_ERROR_INVALID_BLOCK_CRC;
}
break;
default:
- fprintf(stderr, "Ignoring block type %4.4s.\n", (char *)&index_entries[i].blockType);
+ fprintf(stderr, "Ignoring block type %4.4s.\n", (char *)&entry->blockType);
break;
}
}
diff --git a/tool/commands.c b/tool/commands.c
index 27200e8..7b0b370 100644
--- a/tool/commands.c
+++ b/tool/commands.c
@@ -17,11 +17,12 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
-#include "commands.h"
#include
#include
#include
+
#include "aaruformattool.h"
+#include "commands.h"
#include "usage.h"
int cmd_identify(int argc, char *argv[])