Bump version to 1.0.0-alpha.13 in nuspec file

libaaruformat.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>libaaruformat</id>
-        <version>1.0.0-alpha.10</version>
+        <version>1.0.0-alpha.13</version>
         <description>Library for management of AaruFormat images.</description>
         <authors>claunia</authors>
         <projectUrl>https://github.com/aaru-dps/libaaruformat</projectUrl>

src/ddt/ddt_v1.c

@@ -217,26 +217,26 @@ int32_t process_ddt_v1(aaruformat_context *ctx, IndexEntry *entry, bool *found_u
                 break;
             // TODO: Check CRC
             case None:
-#ifdef __linux__
-                TRACE("Memory mapping deduplication table at position %" PRIu64, entry->offset + sizeof(ddt_header));
-                ctx->mapped_memory_ddt_size = sizeof(uint64_t) * ddt_header.entries;
-                ctx->user_data_ddt          = mmap(NULL, ctx->mapped_memory_ddt_size, PROT_READ, MAP_SHARED,
-                                                   fileno(ctx->imageStream), entry->offset + sizeof(ddt_header));
-
-                if(ctx->user_data_ddt == MAP_FAILED)
+                ctx->user_data_ddt = (uint64_t *)malloc(ddt_header.length);
+                if(ctx->user_data_ddt == NULL)
                 {
-                    *found_user_data_ddt = false;
-                    FATAL("Could not read map deduplication table.");
+                    TRACE("Cannot allocate memory for DDT, continuing...");
                     break;
                 }
 
-                ctx->in_memory_ddt = false;
+                read_bytes = fread(ctx->user_data_ddt, 1, ddt_header.entries * sizeof(uint64_t), ctx->imageStream);
+
+                if(read_bytes != ddt_header.entries * sizeof(uint64_t))
+                {
+                    free(ctx->user_data_ddt);
+                    TRACE("Could not read deduplication table, continuing...");
+                    break;
+                }
+
+                ctx->in_memory_ddt   = true;
+                *found_user_data_ddt = true;
+
                 break;
-#else  // TODO: Implement
-                TRACE("Uncompressed DDT not yet implemented...");
-                *found_user_data_ddt = false;
-                break;
-#endif
             default:
                 TRACE("Found unknown compression type %d, continuing...", ddt_header.compression);
                 *found_user_data_ddt = false;

src/read.c

@@ -297,7 +297,7 @@ AARU_EXPORT int32_t AARU_CALL aaruf_read_sector(void *context, const uint64_t se
         return AARUF_ERROR_NOT_AARUFORMAT;
     }
 
-    if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
+    if(negative && sector_address > ctx->user_data_ddt_header.negative)
     {
         FATAL("Sector address out of bounds");
 
@@ -868,7 +868,7 @@ AARU_EXPORT int32_t AARU_CALL aaruf_read_sector_long(void *context, const uint64
         return AARUF_ERROR_NOT_AARUFORMAT;
     }
 
-    if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
+    if(negative && sector_address > ctx->user_data_ddt_header.negative)
     {
         FATAL("Sector address out of bounds");
 
@@ -1509,7 +1509,7 @@ AARU_EXPORT int32_t AARU_CALL aaruf_read_sector_tag(const void *context, const u
         return AARUF_ERROR_NOT_AARUFORMAT;
     }
 
-    if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
+    if(negative && sector_address > ctx->user_data_ddt_header.negative)
     {
         FATAL("Sector address out of bounds");
 

src/verify.c

@@ -225,195 +225,242 @@ AARU_EXPORT int32_t AARU_CALL aaruf_verify_image(void *context)
         goto cleanup;
     }
 
+    uint64_t crc_length;
+    const unsigned int entry_count = utarray_len(index_entries);
+
+    for(unsigned int i = 0; i < entry_count; i++)
     {
-        const unsigned int entry_count = utarray_len(index_entries);
+        IndexEntry *entry = utarray_eltptr(index_entries, i);
+        TRACE("Checking block with type %4.4s at position %" PRIu64, (char *)&entry->blockType, entry->offset);
 
-        for(unsigned int i = 0; i < entry_count; i++)
+        if(fseek(ctx->imageStream, entry->offset, SEEK_SET) != 0)
         {
-            IndexEntry *entry = utarray_eltptr(index_entries, i);
-            TRACE("Checking block with type %4.4s at position %" PRIu64, (char *)&entry->blockType, entry->offset);
+            FATAL("Could not seek to block at offset %" PRIu64, entry->offset);
+            status = AARUF_ERROR_CANNOT_READ_BLOCK;
+            goto cleanup;
+        }
 
-            if(fseek(ctx->imageStream, entry->offset, SEEK_SET) != 0)
-            {
-                FATAL("Could not seek to block at offset %" PRIu64, entry->offset);
-                status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                goto cleanup;
-            }
-
-            switch(entry->blockType)
-            {
-                case DataBlock:
-                    read_bytes = fread(&block_header, 1, sizeof(BlockHeader), ctx->imageStream);
-                    if(read_bytes != sizeof(BlockHeader))
-                    {
-                        FATAL("Could not read block header");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    crc64_context = aaruf_crc64_init();
-                    if(crc64_context == NULL)
-                    {
-                        FATAL("Could not initialize CRC64 context");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    status = update_crc64_from_stream(ctx->imageStream, block_header.cmpLength, buffer, VERIFY_SIZE,
-                                                      crc64_context, "data block");
-                    if(status != AARUF_STATUS_OK) goto cleanup;
-
-                    if(aaruf_crc64_final(crc64_context, &crc64) != 0)
-                    {
-                        FATAL("Could not finalize CRC64 for data block");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
-
-                    if(crc64 != block_header.cmpCrc64)
-                    {
-                        FATAL("Expected block CRC 0x%16llX but got 0x%16llX", block_header.cmpCrc64, crc64);
-                        status = AARUF_ERROR_INVALID_BLOCK_CRC;
-                        goto cleanup;
-                    }
-
-                    aaruf_crc64_free(crc64_context);
-                    crc64_context = NULL;
-                    break;
-                case DeDuplicationTable:
-                    read_bytes = fread(&ddt_header, 1, sizeof(DdtHeader), ctx->imageStream);
-                    if(read_bytes != sizeof(DdtHeader))
-                    {
-                        FATAL("Could not read DDT header");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    crc64_context = aaruf_crc64_init();
-                    if(crc64_context == NULL)
-                    {
-                        FATAL("Could not initialize CRC64 context");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    status = update_crc64_from_stream(ctx->imageStream, ddt_header.cmpLength, buffer, VERIFY_SIZE,
-                                                      crc64_context, "DDT block");
-                    if(status != AARUF_STATUS_OK) goto cleanup;
-
-                    if(aaruf_crc64_final(crc64_context, &crc64) != 0)
-                    {
-                        FATAL("Could not finalize CRC64 for DDT block");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
-
-                    if(crc64 != ddt_header.cmpCrc64)
-                    {
-                        FATAL("Expected DDT CRC 0x%16llX but got 0x%16llX", ddt_header.cmpCrc64, crc64);
-                        status = AARUF_ERROR_INVALID_BLOCK_CRC;
-                        goto cleanup;
-                    }
-
-                    aaruf_crc64_free(crc64_context);
-                    crc64_context = NULL;
-                    break;
-                case DeDuplicationTable2:
-                    read_bytes = fread(&ddt2_header, 1, sizeof(DdtHeader2), ctx->imageStream);
-                    if(read_bytes != sizeof(DdtHeader2))
-                    {
-                        FATAL("Could not read DDT2 header");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    crc64_context = aaruf_crc64_init();
-                    if(crc64_context == NULL)
-                    {
-                        FATAL("Could not initialize CRC64 context");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    status = update_crc64_from_stream(ctx->imageStream, ddt2_header.cmpLength, buffer, VERIFY_SIZE,
-                                                      crc64_context, "DDT2 block");
-                    if(status != AARUF_STATUS_OK) goto cleanup;
-
-                    if(aaruf_crc64_final(crc64_context, &crc64) != 0)
-                    {
-                        FATAL("Could not finalize CRC64 for DDT2 block");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    if(crc64 != ddt2_header.cmpCrc64)
-                    {
-                        FATAL("Expected DDT2 CRC 0x%16llX but got 0x%16llX", ddt2_header.cmpCrc64, crc64);
-                        status = AARUF_ERROR_INVALID_BLOCK_CRC;
-                        goto cleanup;
-                    }
-
-                    aaruf_crc64_free(crc64_context);
-                    crc64_context = NULL;
-                    break;
-                case TracksBlock:
+        switch(entry->blockType)
+        {
+            case DataBlock:
+                read_bytes = fread(&block_header, 1, sizeof(BlockHeader), ctx->imageStream);
+                if(read_bytes != sizeof(BlockHeader))
                 {
-                    read_bytes = fread(&tracks_header, 1, sizeof(TracksHeader), ctx->imageStream);
-                    if(read_bytes != sizeof(TracksHeader))
-                    {
-                        FATAL("Could not read tracks header");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    const uint64_t tracks_bytes = (uint64_t)tracks_header.entries * sizeof(TrackEntry);
-                    if(tracks_header.entries != 0 && tracks_bytes / sizeof(TrackEntry) != tracks_header.entries)
-                    {
-                        FATAL("Tracks header length overflow (entries=%u)", tracks_header.entries);
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    crc64_context = aaruf_crc64_init();
-                    if(crc64_context == NULL)
-                    {
-                        FATAL("Could not initialize CRC64 context");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    status = update_crc64_from_stream(ctx->imageStream, tracks_bytes, buffer, VERIFY_SIZE,
-                                                      crc64_context, "tracks block");
-                    if(status != AARUF_STATUS_OK) goto cleanup;
-
-                    if(aaruf_crc64_final(crc64_context, &crc64) != 0)
-                    {
-                        FATAL("Could not finalize CRC64 for tracks block");
-                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
-                        goto cleanup;
-                    }
-
-                    if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
-
-                    if(crc64 != tracks_header.crc64)
-                    {
-                        FATAL("Expected tracks CRC 0x%16llX but got 0x%16llX", tracks_header.crc64, crc64);
-                        status = AARUF_ERROR_INVALID_BLOCK_CRC;
-                        goto cleanup;
-                    }
-
-                    aaruf_crc64_free(crc64_context);
-                    crc64_context = NULL;
-                    break;
+                    FATAL("Could not read block header");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
                 }
-                default:
-                    TRACE("Ignoring block type %4.4s", (char *)&entry->blockType);
-                    break;
+
+                crc64_context = aaruf_crc64_init();
+                if(crc64_context == NULL)
+                {
+                    FATAL("Could not initialize CRC64 context");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                // For LZMA compression, skip the 5-byte properties header
+                crc_length = block_header.cmpLength;
+                if(block_header.compression == Lzma || block_header.compression == LzmaClauniaSubchannelTransform)
+                {
+                    // Skip LZMA properties
+                    uint8_t props[LZMA_PROPERTIES_LENGTH];
+                    size_t  read_props = fread(props, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
+                    if(read_props != LZMA_PROPERTIES_LENGTH)
+                    {
+                        FATAL("Could not read LZMA properties");
+                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                        goto cleanup;
+                    }
+                    crc_length -= LZMA_PROPERTIES_LENGTH;
+                }
+
+                status = update_crc64_from_stream(ctx->imageStream, crc_length, buffer, VERIFY_SIZE, crc64_context,
+                                                  "data block");
+                if(status != AARUF_STATUS_OK) goto cleanup;
+
+                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
+                {
+                    FATAL("Could not finalize CRC64 for data block");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
+
+                if(crc64 != block_header.cmpCrc64)
+                {
+                    FATAL("Expected block CRC 0x%16llX but got 0x%16llX", block_header.cmpCrc64, crc64);
+                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
+                    goto cleanup;
+                }
+
+                aaruf_crc64_free(crc64_context);
+                crc64_context = NULL;
+                break;
+            case DeDuplicationTable:
+                read_bytes = fread(&ddt_header, 1, sizeof(DdtHeader), ctx->imageStream);
+                if(read_bytes != sizeof(DdtHeader))
+                {
+                    FATAL("Could not read DDT header");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                crc64_context = aaruf_crc64_init();
+                if(crc64_context == NULL)
+                {
+                    FATAL("Could not initialize CRC64 context");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                // For LZMA compression, skip the 5-byte properties header
+                crc_length = ddt_header.cmpLength;
+                if(ddt_header.compression == Lzma || ddt_header.compression == LzmaClauniaSubchannelTransform)
+                {
+                    // Skip LZMA properties
+                    uint8_t props[LZMA_PROPERTIES_LENGTH];
+                    size_t  read_props = fread(props, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
+                    if(read_props != LZMA_PROPERTIES_LENGTH)
+                    {
+                        FATAL("Could not read LZMA properties");
+                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                        goto cleanup;
+                    }
+                    crc_length -= LZMA_PROPERTIES_LENGTH;
+                }
+
+                status = update_crc64_from_stream(ctx->imageStream, crc_length, buffer, VERIFY_SIZE, crc64_context,
+                                                  "data block");
+                if(status != AARUF_STATUS_OK) goto cleanup;
+
+                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
+                {
+                    FATAL("Could not finalize CRC64 for DDT block");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
+
+                if(crc64 != ddt_header.cmpCrc64)
+                {
+                    FATAL("Expected DDT CRC 0x%16llX but got 0x%16llX", ddt_header.cmpCrc64, crc64);
+                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
+                    goto cleanup;
+                }
+
+                aaruf_crc64_free(crc64_context);
+                crc64_context = NULL;
+                break;
+            case DeDuplicationTable2:
+                read_bytes = fread(&ddt2_header, 1, sizeof(DdtHeader2), ctx->imageStream);
+                if(read_bytes != sizeof(DdtHeader2))
+                {
+                    FATAL("Could not read DDT2 header");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                crc64_context = aaruf_crc64_init();
+                if(crc64_context == NULL)
+                {
+                    FATAL("Could not initialize CRC64 context");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                // For LZMA compression, skip the 5-byte properties header
+                crc_length = ddt2_header.cmpLength;
+                if(ddt2_header.compression == Lzma || ddt2_header.compression == LzmaClauniaSubchannelTransform)
+                {
+                    // Skip LZMA properties
+                    uint8_t props[LZMA_PROPERTIES_LENGTH];
+                    size_t  read_props = fread(props, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
+                    if(read_props != LZMA_PROPERTIES_LENGTH)
+                    {
+                        FATAL("Could not read LZMA properties");
+                        status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                        goto cleanup;
+                    }
+                    crc_length -= LZMA_PROPERTIES_LENGTH;
+                }
+
+                status = update_crc64_from_stream(ctx->imageStream, crc_length, buffer, VERIFY_SIZE, crc64_context,
+                                                  "data block");
+                if(status != AARUF_STATUS_OK) goto cleanup;
+
+                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
+                {
+                    FATAL("Could not finalize CRC64 for DDT2 block");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                if(crc64 != ddt2_header.cmpCrc64)
+                {
+                    FATAL("Expected DDT2 CRC 0x%16llX but got 0x%16llX", ddt2_header.cmpCrc64, crc64);
+                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
+                    goto cleanup;
+                }
+
+                aaruf_crc64_free(crc64_context);
+                crc64_context = NULL;
+                break;
+            case TracksBlock:
+            {
+                read_bytes = fread(&tracks_header, 1, sizeof(TracksHeader), ctx->imageStream);
+                if(read_bytes != sizeof(TracksHeader))
+                {
+                    FATAL("Could not read tracks header");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                const uint64_t tracks_bytes = (uint64_t)tracks_header.entries * sizeof(TrackEntry);
+                if(tracks_header.entries != 0 && tracks_bytes / sizeof(TrackEntry) != tracks_header.entries)
+                {
+                    FATAL("Tracks header length overflow (entries=%u)", tracks_header.entries);
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                crc64_context = aaruf_crc64_init();
+                if(crc64_context == NULL)
+                {
+                    FATAL("Could not initialize CRC64 context");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                status = update_crc64_from_stream(ctx->imageStream, tracks_bytes, buffer, VERIFY_SIZE, crc64_context,
+                                                  "tracks block");
+                if(status != AARUF_STATUS_OK) goto cleanup;
+
+                if(aaruf_crc64_final(crc64_context, &crc64) != 0)
+                {
+                    FATAL("Could not finalize CRC64 for tracks block");
+                    status = AARUF_ERROR_CANNOT_READ_BLOCK;
+                    goto cleanup;
+                }
+
+                if(ctx->header.imageMajorVersion <= AARUF_VERSION_V1) crc64 = bswap_64(crc64);
+
+                if(crc64 != tracks_header.crc64)
+                {
+                    FATAL("Expected tracks CRC 0x%16llX but got 0x%16llX", tracks_header.crc64, crc64);
+                    status = AARUF_ERROR_INVALID_BLOCK_CRC;
+                    goto cleanup;
+                }
+
+                aaruf_crc64_free(crc64_context);
+                crc64_context = NULL;
+                break;
             }
+            default:
+                TRACE("Ignoring block type %4.4s", (char *)&entry->blockType);
+                break;
         }
     }
 

src/write.c

@@ -130,7 +130,7 @@ AARU_EXPORT int32_t AARU_CALL aaruf_write_sector(void *context, uint64_t sector_
         return AARUF_READ_ONLY;
     }
 
-    if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
+    if(negative && sector_address > ctx->user_data_ddt_header.negative)
     {
         FATAL("Sector address out of bounds");
 
@@ -569,7 +569,7 @@ AARU_EXPORT int32_t AARU_CALL aaruf_write_sector_long(void *context, uint64_t se
         return AARUF_READ_ONLY;
     }
 
-    if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
+    if(negative && sector_address > ctx->user_data_ddt_header.negative)
     {
         FATAL("Sector address out of bounds");
 
@@ -2101,7 +2101,7 @@ AARU_EXPORT int32_t AARU_CALL aaruf_write_sector_tag(void *context, const uint64
         return AARUF_READ_ONLY;
     }
 
-    if(negative && sector_address > ctx->user_data_ddt_header.negative - 1)
+    if(negative && sector_address > ctx->user_data_ddt_header.negative)
     {
         FATAL("Sector address out of bounds");
 

tool/info.c

@@ -576,16 +576,8 @@ int info(const char *path)
     printf("\tImage contains %llu sectors\n", ctx->image_info.Sectors);
     printf("\tBiggest sector is %d bytes\n", ctx->image_info.SectorSize);
     printf("\tImage version: %s\n", ctx->image_info.Version);
-
     if(ctx->image_info.Application != NULL)
-    {
-        strBuffer = malloc(65);
-        memset(strBuffer, 0, 65);
-        ucnv_convert(NULL, "UTF-16LE", strBuffer, 64, (const char *)ctx->image_info.Application, 64, &u_error_code);
-        if(u_error_code == U_ZERO_ERROR) printf("\tApplication: %s\n", strBuffer);
-        free(strBuffer);
-    }
-
+        printf("\tApplication: %s\n", ctx->image_info.Application);
     if(ctx->image_info.ApplicationVersion != NULL)
         printf("\tApplication version: %s\n", ctx->image_info.ApplicationVersion);
     printf("\tCreation time: %s\n", format_filetime(ctx->image_info.CreationTime));