Implement support for index v2.

CMakeLists.txt

@@ -21,6 +21,10 @@ IF (APPLE)
     SET(CMAKE_OSX_ARCHITECTURES "arm64;x86_64" CACHE STRING "Build architectures for Mac OS X" FORCE)
   ENDIF ()
 ENDIF (APPLE)
+IF(APPLE)
+  IF("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "")
+  ENDIF()
+ENDIF(APPLE)
 
 project(libaaruformat C)
 
@@ -106,7 +110,10 @@ add_library(aaruformat SHARED include/aaruformat/consts.h include/aaruformat/enu
             include/aaruformat/structs/metadata.h
             include/aaruformat/structs/dump.h
             include/aaruformat/structs/checksum.h
-        include/aaruformat/structs/optical.h)
+            include/aaruformat/structs/optical.h
+            src/index/index_v1.c
+            include/internal.h
+            src/index/index_v2.c)
 
 include_directories(include include/aaruformat)
 

include/aaruformat/enums.h

@@ -205,9 +205,11 @@ typedef enum
     /** Block containing data */
     DataBlock                    = 0x4B4C4244,
     /** Block containing a deduplication table */
-    DeDuplicationTable           = 0X2A544444,
+    DeDuplicationTable           = 0x2A544444,
     /** Block containing the index */
-    IndexBlock                   = 0X58444E49,
+    IndexBlock                   = 0x58444E49,
+    /** Block containing the index v2 */
+    IndexBlock2                  = 0x32584449,
     /** Block containing logical geometry */
     GeometryBlock                = 0x4D4F4547,
     /** Block containing metadata */

include/aaruformat/structs/index.h

@@ -22,7 +22,8 @@
 #pragma pack(push, 1)
 
 /**Header for the index, followed by entries */
-typedef struct IndexHeader {
+typedef struct IndexHeader
+{
     /**Identifier, <see cref="BlockType.Index" /> */
     uint32_t identifier;
     /**How many entries follow this header */
@@ -31,8 +32,20 @@ typedef struct IndexHeader {
     uint64_t crc64;
 } IndexHeader;
 
+/**Header for the index, followed by entries */
+typedef struct IndexHeader2
+{
+    /**Identifier, <see cref="BlockType.Index" /> */
+    uint32_t identifier;
+    /**How many entries follow this header */
+    uint64_t entries;
+    /**CRC64-ECMA of the index */
+    uint64_t crc64;
+} IndexHeader2;
+
 /**Index entry */
-typedef struct IndexEntry {
+typedef struct IndexEntry
+{
     /**Type of item pointed by this entry */
     uint32_t blockType;
     /**Type of data contained by the block pointed by this entry */

include/internal.h

@@ -23,5 +23,7 @@
 
 UT_array *process_index_v1(aaruformatContext *ctx);
 int32_t   verify_index_v1(aaruformatContext *ctx);
+UT_array *process_index_v2(aaruformatContext *ctx);
+int32_t   verify_index_v2(aaruformatContext *ctx);
 
 #endif  // LIBAARUFORMAT_INTERNAL_H

src/index/index_v2.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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "aaruformat.h"
+#include "utarray.h"
+
+UT_array *process_index_v2(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);
+    IndexHeader2 idx_header;
+    fread(&idx_header, sizeof(IndexHeader2), 1, ctx->imageStream);
+
+    // Check if the index header is valid
+    if(idx_header.identifier != IndexBlock2)
+    {
+        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_v2(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(IndexHeader2), ctx->imageStream);
+
+    if(read_bytes != sizeof(IndexHeader2))
+    {
+        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;
+}

src/open.c

@@ -152,7 +152,7 @@ void *aaruf_open(const char *filepath)
 
     readBytes = fread(&signature, 1, sizeof(uint32_t), ctx->imageStream);
 
-    if(readBytes != sizeof(uint32_t) || signature != IndexBlock)
+    if(readBytes != sizeof(uint32_t) || (signature != IndexBlock && signature != IndexBlock2))
     {
         free(ctx);
         errno = AARUF_ERROR_CANNOT_READ_INDEX;
@@ -160,7 +160,10 @@ void *aaruf_open(const char *filepath)
         return NULL;
     }
 
+    if(signature == IndexBlock)
         index_entries = process_index_v1(ctx);
+    else if(signature == IndexBlock2)
+        index_entries = process_index_v2(ctx);
 
     if(index_entries == NULL)
     {

src/verify.c

@@ -55,14 +55,17 @@ int32_t aaruf_verify_image(void *context)
         return AARUF_ERROR_CANNOT_READ_HEADER;
     }
 
-    if(signature != IndexBlock)
+    if(signature != IndexBlock && signature != IndexBlock2)
     {
         fprintf(stderr, "Incorrect index signature.\n");
         return AARUF_ERROR_CANNOT_READ_INDEX;
     }
 
     // Check if the index is correct
+    if(signature == IndexBlock)
         err = verify_index_v1(ctx);
+    else if(signature == IndexBlock2)
+        err = verify_index_v2(ctx);
 
     if(err != AARUF_STATUS_OK)
     {
@@ -71,7 +74,10 @@ int32_t aaruf_verify_image(void *context)
     }
 
     // Process the index
+    if(signature == IndexBlock)
         index_entries = process_index_v1(ctx);
+    else if(signature == IndexBlock2)
+        index_entries = process_index_v2(ctx);
 
     if(index_entries == NULL)
     {