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

Add slog logging support and update error handling in various modules

Browse Source
This commit is contained in:
Natalia Portillo
2025-08-13 20:16:42 +01:00
parent 64c58c0300
commit d62e3119c2
14 changed files with 228 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@@ -7,3 +7,6 @@
[submodule "3rdparty/uthash"] [submodule "3rdparty/uthash"]
path = 3rdparty/uthash path = 3rdparty/uthash
url = https://github.com/troydhanson/uthash url = https://github.com/troydhanson/uthash
[submodule "3rdparty/slog"]
path = 3rdparty/slog
url = https://github.com/kala13x/slog

1
3rdparty/slog vendored Submodule

Submodule 3rdparty/slog added at bc857dbcd9

17
CMakeLists.txt
View File

@@ -122,7 +122,8 @@ add_library(aaruformat SHARED include/aaruformat/consts.h include/aaruformat/enu
src/options.c src/options.c
src/create.c src/create.c
src/time.c src/time.c
src/write.c) src/write.c
include/log.h)
include_directories(include include/aaruformat) include_directories(include include/aaruformat)
@@ -176,8 +177,19 @@ elseif(OpenSSL_FOUND)
TARGET_LINK_LIBRARIES_WHOLE_ARCHIVE(aaruformat ${OPENSSL_CRYPTO_LIBRARY}) TARGET_LINK_LIBRARIES_WHOLE_ARCHIVE(aaruformat ${OPENSSL_CRYPTO_LIBRARY})
endif() endif()
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
# Add slog submodule
add_subdirectory(3rdparty/slog)
include_directories(include 3rdparty/uthash/src) include_directories(include 3rdparty/uthash/src)
# Include slog headers
include_directories(aaruformat 3rdparty/slog/src)
# Enable TRACE and slog output
add_compile_definitions(aaruformat ENABLE_TRACE USE_SLOG)
include(CheckLibraryExists) include(CheckLibraryExists)
check_library_exists(m log "" HAVE_LIB_M) check_library_exists(m log "" HAVE_LIB_M)
@@ -185,5 +197,8 @@ if(HAVE_LIB_M)
TARGET_LINK_LIBRARIES_WHOLE_ARCHIVE(aaruformat m) TARGET_LINK_LIBRARIES_WHOLE_ARCHIVE(aaruformat m)
endif() endif()
# Link slog
target_link_libraries(aaruformat slog)
add_subdirectory(tests) add_subdirectory(tests)
add_subdirectory(tool) add_subdirectory(tool)

1
include/aaruformat/context.h
View File

@@ -122,6 +122,7 @@ typedef struct aaruformatContext
int currentBlockOffset; int currentBlockOffset;
crc64_ctx *crc64Context; crc64_ctx *crc64Context;
int writingBufferPosition; int writingBufferPosition;
long nextBlockPosition;
} aaruformatContext; } aaruformatContext;
typedef struct DumpHardwareEntriesWithData typedef struct DumpHardwareEntriesWithData

43
include/log.h Normal file
View File

@@ -0,0 +1,43 @@
//
// Created by claunia on 13/8/25.
//
#ifndef LIBAARUFORMAT_LOG_H
#define LIBAARUFORMAT_LOG_H
#include <stdarg.h>
#include <stdio.h>
// Uncomment to enable tracing
// #define ENABLE_TRACE
// Uncomment to use slog instead of stderr
// #define USE_SLOG
#ifdef ENABLE_TRACE
#ifdef USE_SLOG
#include "slog.h"
#define TRACE(fmt, ...) slog_trace(fmt, ##__VA_ARGS__)
#else
#define TRACE(fmt, ...) fprintf(stderr, "[TRACE] %s:%d:%s(): " fmt "\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__)
#endif
#else
#define TRACE(fmt, ...)
#endif
#include <stdarg.h>
#include <stdio.h>
#ifdef ENABLE_FATAL
#ifdef USE_SLOG
#include "slog.h"
#define FATAL(fmt, ...) slog_fatal(fmt, ##__VA_ARGS__)
#else
#define FATAL(fmt, ...) fprintf(stderr, "[FATAL] %s:%d:%s(): " fmt "\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__)
#endif
#else
#define FATAL(fmt, ...)
#endif
#endif // LIBAARUFORMAT_LOG_H

52
src/blocks/checksum.c
View File

@@ -1,20 +1,20 @@
/* /*
* This file is part of the Aaru Data Preservation Suite. * This file is part of the Aaru Data Preservation Suite.
* Copyright (c) 2019-2025 Natalia Portillo. * Copyright (c) 2019-2025 Natalia Portillo.
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as * it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of the * published by the Free Software Foundation; either version 2.1 of the
* License, or (at your option) any later version. * License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, but * This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of * WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/ */
#include <inttypes.h> #include <inttypes.h>
#include <stdint.h> #include <stdint.h>
@@ -22,15 +22,16 @@
#include <stdlib.h> #include <stdlib.h>
#include "aaruformat.h" #include "aaruformat.h"
#include "log.h"
void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry) void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
int pos = 0; int pos = 0;
size_t readBytes = 0; size_t readBytes = 0;
ChecksumHeader checksum_header; ChecksumHeader checksum_header;
ChecksumEntry const *checksum_entry = NULL; ChecksumEntry const *checksum_entry = NULL;
uint8_t *data = NULL; uint8_t *data = NULL;
int j = 0; int j = 0;
// Check if the context and image stream are valid // Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL) if(ctx == NULL || ctx->imageStream == NULL)
@@ -43,7 +44,7 @@ void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry)
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return; return;
} }
@@ -54,15 +55,14 @@ void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(ChecksumHeader)) if(readBytes != sizeof(ChecksumHeader))
{ {
memset(&checksum_header, 0, sizeof(ChecksumHeader)); memset(&checksum_header, 0, sizeof(ChecksumHeader));
fprintf(stderr, "libaaruformat: Could not read checksums block header, continuing...\n"); FATAL("Could not read checksums block header, continuing...\n");
return; return;
} }
if(checksum_header.identifier != ChecksumBlock) if(checksum_header.identifier != ChecksumBlock)
{ {
memset(&checksum_header, 0, sizeof(ChecksumHeader)); memset(&checksum_header, 0, sizeof(ChecksumHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for checksum block at position %" PRIu64 "\n", FATAL("Incorrect identifier for checksum block at position %" PRIu64 "\n", entry->offset);
entry->offset);
} }
data = (uint8_t *)malloc(checksum_header.length); data = (uint8_t *)malloc(checksum_header.length);
@@ -70,7 +70,7 @@ void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry)
if(data == NULL) if(data == NULL)
{ {
memset(&checksum_header, 0, sizeof(ChecksumHeader)); memset(&checksum_header, 0, sizeof(ChecksumHeader));
fprintf(stderr, "libaaruformat: Could not allocate memory for checksum block, continuing...\n"); FATAL("Could not allocate memory for checksum block, continuing...\n");
return; return;
} }
@@ -80,7 +80,7 @@ void process_checksum_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
memset(&checksum_header, 0, sizeof(ChecksumHeader)); memset(&checksum_header, 0, sizeof(ChecksumHeader));
free(data); free(data);
fprintf(stderr, "libaaruformat: Could not read checksums block, continuing...\n"); FATAL("Could not read checksums block, continuing...\n");
return; return;
} }

21
src/blocks/data.c
View File

@@ -22,6 +22,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "aaruformat.h" #include "aaruformat.h"
#include "log.h"
#include "uthash.h" #include "uthash.h"
// Process data blocks found while opening an AaruFormat file // Process data blocks found while opening an AaruFormat file
@@ -51,7 +52,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -65,7 +66,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
if(readBytes != sizeof(BlockHeader)) if(readBytes != sizeof(BlockHeader))
{ {
fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n", entry->offset); FATAL("Could not read block header at %" PRIu64 "\n", entry->offset);
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
} }
@@ -82,22 +83,21 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
if(blockHeader.identifier != entry->blockType) if(blockHeader.identifier != entry->blockType)
{ {
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset); TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
} }
if(blockHeader.type != entry->dataType) if(blockHeader.type != entry->dataType)
{ {
fprintf(stderr, TRACE("Expected block with data type %4.4s at position %" PRIu64
"libaaruformat: Expected block with data type %4.4s at position %" PRIu64
" but found data type %4.4s\n", " but found data type %4.4s\n",
(char *)&entry->blockType, entry->offset, (char *)&blockHeader.type); (char *)&entry->blockType, entry->offset, (char *)&blockHeader.type);
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
} }
fprintf(stderr, "libaaruformat: Found data block with type %4.4s at position %" PRIu64 "\n", TRACE("Found data block with type %4.4s at position %" PRIu64 "\n",
(char *)&entry->blockType, entry->offset); (char *)&entry->blockType, entry->offset);
if(blockHeader.compression == Lzma || blockHeader.compression == LzmaClauniaSubchannelTransform) if(blockHeader.compression == Lzma || blockHeader.compression == LzmaClauniaSubchannelTransform)
@@ -209,7 +209,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
} }
else else
{ {
fprintf(stderr, "libaaruformat: Found unknown compression type %d, continuing...\n", blockHeader.compression); TRACE("Found unknown compression type %d, continuing...\n", blockHeader.compression);
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
} }
@@ -223,8 +223,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
if(crc64 != blockHeader.crc64) if(crc64 != blockHeader.crc64)
{ {
fprintf(stderr, TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n",
"libaaruformat: Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n",
crc64, blockHeader.crc64); crc64, blockHeader.crc64);
return AARUF_STATUS_OK; return AARUF_STATUS_OK;
@@ -275,7 +274,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
if(mediaTag == NULL) if(mediaTag == NULL)
{ {
fprintf(stderr, "libaaruformat: Cannot allocate memory for media tag entry.\n"); TRACE("Cannot allocate memory for media tag entry.\n");
break; break;
} }
memset(mediaTag, 0, sizeof(mediaTagEntry)); memset(mediaTag, 0, sizeof(mediaTagEntry));
@@ -288,7 +287,7 @@ int32_t process_data_block(aaruformatContext *ctx, IndexEntry *entry)
if(oldMediaTag != NULL) if(oldMediaTag != NULL)
{ {
fprintf(stderr, "libaaruformat: Replaced media tag with type %d\n", oldMediaTag->type); TRACE("Replaced media tag with type %d\n", oldMediaTag->type);
free(oldMediaTag->data); free(oldMediaTag->data);
free(oldMediaTag); free(oldMediaTag);
oldMediaTag = NULL; oldMediaTag = NULL;

54
src/blocks/dump.c
View File

@@ -22,6 +22,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "aaruformat.h" #include "aaruformat.h"
#include "log.h"
void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry) void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
@@ -34,7 +35,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
// Check if the context and image stream are valid // Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL) if(ctx == NULL || ctx->imageStream == NULL)
{ {
fprintf(stderr, "Invalid context or image stream.\n"); FATAL("Invalid context or image stream.\n");
return; return;
} }
@@ -42,7 +43,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return; return;
} }
@@ -53,14 +54,14 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(DumpHardwareHeader)) if(readBytes != sizeof(DumpHardwareHeader))
{ {
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader)); memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libaaruformat: Could not read dump hardware block header, continuing...\n"); TRACE("Could not read dump hardware block header, continuing...\n");
return; return;
} }
if(ctx->dumpHardwareHeader.identifier != DumpHardwareBlock) if(ctx->dumpHardwareHeader.identifier != DumpHardwareBlock)
{ {
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader)); memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset); TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
} }
data = (uint8_t *)malloc(ctx->dumpHardwareHeader.length); data = (uint8_t *)malloc(ctx->dumpHardwareHeader.length);
@@ -68,7 +69,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(data == NULL) if(data == NULL)
{ {
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader)); memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libaaruformat: Could not allocate memory for dump hardware block, continuing...\n"); TRACE("Could not allocate memory for dump hardware block, continuing...\n");
return; return;
} }
@@ -84,9 +85,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(crc64 != ctx->dumpHardwareHeader.crc64) if(crc64 != ctx->dumpHardwareHeader.crc64)
{ {
free(data); free(data);
fprintf(stderr, TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", crc64,
"libaaruformat: Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", ctx->dumpHardwareHeader.crc64);
crc64, ctx->dumpHardwareHeader.crc64);
return; return;
} }
} }
@@ -100,7 +100,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(ctx->dumpHardwareEntriesWithData == NULL) if(ctx->dumpHardwareEntriesWithData == NULL)
{ {
memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader)); memset(&ctx->dumpHardwareHeader, 0, sizeof(DumpHardwareHeader));
fprintf(stderr, "libaaruformat: Could not allocate memory for dump hardware block, continuing...\n"); TRACE("Could not allocate memory for dump hardware block, continuing...\n");
return; return;
} }
@@ -113,7 +113,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(DumpHardwareEntry)) if(readBytes != sizeof(DumpHardwareEntry))
{ {
ctx->dumpHardwareHeader.entries = e; ctx->dumpHardwareHeader.entries = e;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry, continuing...\n"); TRACE("Could not read dump hardware block entry, continuing...\n");
break; break;
} }
@@ -133,8 +133,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].manufacturer); free(ctx->dumpHardwareEntriesWithData[e].manufacturer);
ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.manufacturerLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry manufacturer, " TRACE("Could not read dump hardware block entry manufacturer, "
"continuing...\n"); "continuing...\n");
} }
} }
} }
@@ -154,7 +154,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].model); free(ctx->dumpHardwareEntriesWithData[e].model);
ctx->dumpHardwareEntriesWithData[e].entry.modelLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.modelLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry model, continuing...\n"); TRACE("Could not read dump hardware block entry model, continuing...\n");
} }
} }
} }
@@ -175,8 +175,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].revision); free(ctx->dumpHardwareEntriesWithData[e].revision);
ctx->dumpHardwareEntriesWithData[e].entry.revisionLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.revisionLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry revision, " TRACE("Could not read dump hardware block entry revision, "
"continuing...\n"); "continuing...\n");
} }
} }
} }
@@ -197,8 +197,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].firmware); free(ctx->dumpHardwareEntriesWithData[e].firmware);
ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.firmwareLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry firmware, " TRACE("Could not read dump hardware block entry firmware, "
"continuing...\n"); "continuing...\n");
} }
} }
} }
@@ -218,7 +218,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].serial); free(ctx->dumpHardwareEntriesWithData[e].serial);
ctx->dumpHardwareEntriesWithData[e].entry.serialLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.serialLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry serial, continuing...\n"); TRACE("Could not read dump hardware block entry serial, continuing...\n");
} }
} }
} }
@@ -239,8 +239,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].softwareName); free(ctx->dumpHardwareEntriesWithData[e].softwareName);
ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.softwareNameLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry software name, " TRACE("Could not read dump hardware block entry software name, "
"continuing...\n"); "continuing...\n");
} }
} }
} }
@@ -261,8 +261,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].softwareVersion); free(ctx->dumpHardwareEntriesWithData[e].softwareVersion);
ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.softwareVersionLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry software version, " TRACE("Could not read dump hardware block entry software version, "
"continuing...\n"); "continuing...\n");
} }
} }
} }
@@ -285,8 +285,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
free(ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem); free(ctx->dumpHardwareEntriesWithData[e].softwareOperatingSystem);
ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength = 0; ctx->dumpHardwareEntriesWithData[e].entry.softwareOperatingSystemLength = 0;
fprintf(stderr, "libaaruformat: Could not read dump hardware block entry manufacturer, " TRACE("Could not read dump hardware block entry manufacturer, "
"continuing...\n"); "continuing...\n");
} }
} }
} }
@@ -296,8 +296,8 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(ctx->dumpHardwareEntriesWithData[e].extents == NULL) if(ctx->dumpHardwareEntriesWithData[e].extents == NULL)
{ {
fprintf(stderr, "libaaruformat: Could not allocate memory for dump hardware block extents, " TRACE("Could not allocate memory for dump hardware block extents, "
"continuing...\n"); "continuing...\n");
continue; continue;
} }
@@ -307,7 +307,7 @@ void process_dumphw_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != ctx->dumpHardwareEntriesWithData->entry.extents) if(readBytes != ctx->dumpHardwareEntriesWithData->entry.extents)
{ {
free(ctx->dumpHardwareEntriesWithData[e].extents); free(ctx->dumpHardwareEntriesWithData[e].extents);
fprintf(stderr, "libaaruformat: Could not read dump hardware block extents, continuing...\n"); TRACE("Could not read dump hardware block extents, continuing...\n");
continue; continue;
} }

41
src/blocks/metadata.c
View File

@@ -22,6 +22,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "aaruformat.h" #include "aaruformat.h"
#include "log.h"
// Process the metadata block found while opening an AaruFormat file // Process the metadata block found while opening an AaruFormat file
void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry) void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
@@ -40,7 +41,7 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return; return;
} }
@@ -52,14 +53,14 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(MetadataBlockHeader)) if(readBytes != sizeof(MetadataBlockHeader))
{ {
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr, "libaaruformat: Could not read metadata block header, continuing...\n"); FATAL("Could not read metadata block header, continuing...\n");
return; return;
} }
if(ctx->metadataBlockHeader.identifier != entry->blockType) if(ctx->metadataBlockHeader.identifier != entry->blockType)
{ {
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset); TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
return; return;
} }
@@ -70,7 +71,7 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
if(ctx->metadataBlock == NULL) if(ctx->metadataBlock == NULL)
{ {
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
fprintf(stderr, "libaaruformat: Could not allocate memory for metadata block, continuing...\n"); FATAL("Could not allocate memory for metadata block, continuing...\n");
return; return;
} }
@@ -80,15 +81,14 @@ void process_metadata_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader)); memset(&ctx->metadataBlockHeader, 0, sizeof(MetadataBlockHeader));
free(ctx->metadataBlock); free(ctx->metadataBlock);
fprintf(stderr, "libaaruformat: Could not read metadata block, continuing...\n"); FATAL("Could not read metadata block, continuing...\n");
} }
if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0) if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0)
{ {
ctx->imageInfo.MediaSequence = ctx->metadataBlockHeader.mediaSequence; ctx->imageInfo.MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->imageInfo.LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence; ctx->imageInfo.LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
fprintf(stderr, "libaaruformat: Setting media sequence as %d of %d\n", ctx->imageInfo.MediaSequence, TRACE("Setting media sequence as %d of %d\n", ctx->imageInfo.MediaSequence, ctx->imageInfo.LastMediaSequence);
ctx->imageInfo.LastMediaSequence);
} }
if(ctx->metadataBlockHeader.creatorLength > 0 && if(ctx->metadataBlockHeader.creatorLength > 0 &&
@@ -249,14 +249,14 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry)
// Check if the context and image stream are valid // Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL) if(ctx == NULL || ctx->imageStream == NULL)
{ {
fprintf(stderr, "Invalid context or image stream.\n"); FATAL("Invalid context or image stream.\n");
return; return;
} }
// Seek to block // Seek to block
if(fseek(ctx->imageStream, entry->offset, SEEK_SET) != 0) if(fseek(ctx->imageStream, entry->offset, SEEK_SET) != 0)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return; return;
} }
@@ -265,22 +265,21 @@ void process_geometry_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(GeometryBlockHeader)) if(readBytes != sizeof(GeometryBlockHeader))
{ {
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader)); memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
fprintf(stderr, "libaaruformat: Could not read geometry block header, continuing...\n"); TRACE("Could not read geometry block header, continuing...\n");
return; return;
} }
if(ctx->geometryBlock.identifier != GeometryBlock) if(ctx->geometryBlock.identifier != GeometryBlock)
{ {
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader)); memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for geometry block at position %" PRIu64 "\n", TRACE("Incorrect identifier for geometry block at position %" PRIu64 "\n", entry->offset);
entry->offset);
return; return;
} }
ctx->imageInfo.ImageSize += sizeof(GeometryBlockHeader); ctx->imageInfo.ImageSize += sizeof(GeometryBlockHeader);
fprintf(stderr, "libaaruformat: Geometry set to %d cylinders %d heads %d sectors per track\n", TRACE("Geometry set to %d cylinders %d heads %d sectors per track\n", ctx->geometryBlock.cylinders,
ctx->geometryBlock.cylinders, ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack); ctx->geometryBlock.heads, ctx->geometryBlock.sectorsPerTrack);
ctx->imageInfo.Cylinders = ctx->geometryBlock.cylinders; ctx->imageInfo.Cylinders = ctx->geometryBlock.cylinders;
ctx->imageInfo.Heads = ctx->geometryBlock.heads; ctx->imageInfo.Heads = ctx->geometryBlock.heads;
@@ -296,7 +295,7 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
// Check if the context and image stream are valid // Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL) if(ctx == NULL || ctx->imageStream == NULL)
{ {
fprintf(stderr, "Invalid context or image stream.\n"); FATAL("Invalid context or image stream.\n");
return; return;
} }
@@ -304,7 +303,7 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return; return;
} }
@@ -316,14 +315,14 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(CicmMetadataBlock)) if(readBytes != sizeof(CicmMetadataBlock))
{ {
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr, "libaaruformat: Could not read CICM XML metadata header, continuing...\n"); TRACE("Could not read CICM XML metadata header, continuing...\n");
return; return;
} }
if(ctx->cicmBlockHeader.identifier != CicmBlock) if(ctx->cicmBlockHeader.identifier != CicmBlock)
{ {
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset); TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
} }
ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length; ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length;
@@ -333,7 +332,7 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
if(ctx->cicmBlock == NULL) if(ctx->cicmBlock == NULL)
{ {
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
fprintf(stderr, "libaaruformat: Could not allocate memory for CICM XML metadata block, continuing...\n"); TRACE("Could not allocate memory for CICM XML metadata block, continuing...\n");
return; return;
} }
@@ -343,8 +342,8 @@ void process_cicm_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock)); memset(&ctx->cicmBlockHeader, 0, sizeof(CicmMetadataBlock));
free(ctx->cicmBlock); free(ctx->cicmBlock);
fprintf(stderr, "libaaruformat: Could not read CICM XML metadata block, continuing...\n"); TRACE("Could not read CICM XML metadata block, continuing...\n");
} }
fprintf(stderr, "libaaruformat: Found CICM XML metadata block %" PRIu64 ".\n", entry->offset); TRACE("Found CICM XML metadata block %" PRIu64 ".\n", entry->offset);
} }

21
src/blocks/optical.c
View File

@@ -22,6 +22,7 @@
#include <stdlib.h> #include <stdlib.h>
#include "aaruformat.h" #include "aaruformat.h"
#include "log.h"
void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry) void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
@@ -33,7 +34,7 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
// Check if the context and image stream are valid // Check if the context and image stream are valid
if(ctx == NULL || ctx->imageStream == NULL) if(ctx == NULL || ctx->imageStream == NULL)
{ {
fprintf(stderr, "Invalid context or image stream.\n"); FATAL("Invalid context or image stream.\n");
return; return;
} }
@@ -41,7 +42,7 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return; return;
} }
@@ -52,14 +53,14 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
if(readBytes != sizeof(TracksHeader)) if(readBytes != sizeof(TracksHeader))
{ {
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr, "libaaruformat: Could not read tracks header, continuing...\n"); TRACE("Could not read tracks header, continuing...\n");
return; return;
} }
if(ctx->tracksHeader.identifier != TracksBlock) if(ctx->tracksHeader.identifier != TracksBlock)
{ {
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr, "libaaruformat: Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset); TRACE("Incorrect identifier for data block at position %" PRIu64 "\n", entry->offset);
} }
ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries; ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries;
@@ -69,7 +70,7 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
if(ctx->trackEntries == NULL) if(ctx->trackEntries == NULL)
{ {
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
fprintf(stderr, "libaaruformat: Could not allocate memory for metadata block, continuing...\n"); FATAL("Could not allocate memory for metadata block, continuing...\n");
return; return;
} }
@@ -79,7 +80,7 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
{ {
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader)); memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
free(ctx->trackEntries); free(ctx->trackEntries);
fprintf(stderr, "libaaruformat: Could not read metadata block, continuing...\n"); FATAL("Could not read metadata block, continuing...\n");
return; return;
} }
@@ -91,14 +92,12 @@ void process_tracks_block(aaruformatContext *ctx, const IndexEntry *entry)
if(crc64 != ctx->tracksHeader.crc64) if(crc64 != ctx->tracksHeader.crc64)
{ {
fprintf(stderr, TRACE("Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", crc64,
"libaaruformat: Incorrect CRC found: 0x%" PRIx64 " found, expected 0x%" PRIx64 ", continuing...\n", ctx->tracksHeader.crc64);
crc64, ctx->tracksHeader.crc64);
return; return;
} }
fprintf(stderr, "libaaruformat: Found %d tracks at position %" PRIu64 ".\n", ctx->tracksHeader.entries, TRACE("Found %d tracks at position %" PRIu64 ".\n", ctx->tracksHeader.entries, entry->offset);
entry->offset);
ctx->imageInfo.HasPartitions = true; ctx->imageInfo.HasPartitions = true;
ctx->imageInfo.HasSessions = true; ctx->imageInfo.HasSessions = true;

43
src/ddt/ddt_v1.c
View File

@@ -26,6 +26,7 @@
#endif #endif
#include "aaruformat.h" #include "aaruformat.h"
#include "log.h"
int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUserDataDdt) int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUserDataDdt)
{ {
@@ -49,7 +50,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -60,7 +61,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != sizeof(DdtHeader)) if(readBytes != sizeof(DdtHeader))
{ {
fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n", entry->offset); FATAL("Could not read block header at %" PRIu64 "\n", entry->offset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -85,14 +86,14 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
cmpData = (uint8_t *)malloc(lzmaSize); cmpData = (uint8_t *)malloc(lzmaSize);
if(cmpData == NULL) if(cmpData == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); TRACE("Cannot allocate memory for DDT, continuing...\n");
break; break;
} }
ctx->userDataDdt = (uint64_t *)malloc(ddtHeader.length); ctx->userDataDdt = (uint64_t *)malloc(ddtHeader.length);
if(ctx->userDataDdt == NULL) if(ctx->userDataDdt == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); TRACE("Cannot allocate memory for DDT, continuing...\n");
free(cmpData); free(cmpData);
break; break;
} }
@@ -100,7 +101,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
readBytes = fread(lzmaProperties, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream); readBytes = fread(lzmaProperties, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
if(readBytes != LZMA_PROPERTIES_LENGTH) if(readBytes != LZMA_PROPERTIES_LENGTH)
{ {
fprintf(stderr, "Could not read LZMA properties, continuing...\n"); TRACE("Could not read LZMA properties, continuing...\n");
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL; ctx->userDataDdt = NULL;
@@ -110,7 +111,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
readBytes = fread(cmpData, 1, lzmaSize, ctx->imageStream); readBytes = fread(cmpData, 1, lzmaSize, ctx->imageStream);
if(readBytes != lzmaSize) if(readBytes != lzmaSize)
{ {
fprintf(stderr, "Could not read compressed block, continuing...\n"); TRACE("Could not read compressed block, continuing...\n");
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL; ctx->userDataDdt = NULL;
@@ -123,7 +124,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(errorNo != 0) if(errorNo != 0)
{ {
fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo); FATAL("Got error %d from LZMA, stopping...\n", errorNo);
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL; ctx->userDataDdt = NULL;
@@ -132,7 +133,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != ddtHeader.length) if(readBytes != ddtHeader.length)
{ {
fprintf(stderr, "Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n"); FATAL("Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n");
free(cmpData); free(cmpData);
free(ctx->userDataDdt); free(ctx->userDataDdt);
ctx->userDataDdt = NULL; ctx->userDataDdt = NULL;
@@ -153,20 +154,19 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(ctx->userDataDdt == MAP_FAILED) if(ctx->userDataDdt == MAP_FAILED)
{ {
*foundUserDataDdt = false; *foundUserDataDdt = false;
fprintf(stderr, "libaaruformat: Could not read map deduplication table.\n"); FATAL("Could not read map deduplication table.\n");
break; break;
} }
ctx->inMemoryDdt = false; ctx->inMemoryDdt = false;
break; break;
#else // TODO: Implement #else // TODO: Implement
fprintf(stderr, "libaaruformat: Uncompressed DDT not yet implemented...\n"); TRACE("Uncompressed DDT not yet implemented...\n");
*foundUserDataDdt = false; *foundUserDataDdt = false;
break; break;
#endif #endif
default: default:
fprintf(stderr, "libaaruformat: Found unknown compression type %d, continuing...\n", TRACE("Found unknown compression type %d, continuing...\n", ddtHeader.compression);
ddtHeader.compression);
*foundUserDataDdt = false; *foundUserDataDdt = false;
break; break;
} }
@@ -182,14 +182,14 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
cmpData = (uint8_t *)malloc(lzmaSize); cmpData = (uint8_t *)malloc(lzmaSize);
if(cmpData == NULL) if(cmpData == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); TRACE("Cannot allocate memory for DDT, continuing...\n");
break; break;
} }
cdDdt = (uint32_t *)malloc(ddtHeader.length); cdDdt = (uint32_t *)malloc(ddtHeader.length);
if(cdDdt == NULL) if(cdDdt == NULL)
{ {
fprintf(stderr, "Cannot allocate memory for DDT, continuing...\n"); TRACE("Cannot allocate memory for DDT, continuing...\n");
free(cmpData); free(cmpData);
break; break;
} }
@@ -197,7 +197,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
readBytes = fread(lzmaProperties, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream); readBytes = fread(lzmaProperties, 1, LZMA_PROPERTIES_LENGTH, ctx->imageStream);
if(readBytes != LZMA_PROPERTIES_LENGTH) if(readBytes != LZMA_PROPERTIES_LENGTH)
{ {
fprintf(stderr, "Could not read LZMA properties, continuing...\n"); TRACE("Could not read LZMA properties, continuing...\n");
free(cmpData); free(cmpData);
free(cdDdt); free(cdDdt);
break; break;
@@ -206,7 +206,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
readBytes = fread(cmpData, 1, lzmaSize, ctx->imageStream); readBytes = fread(cmpData, 1, lzmaSize, ctx->imageStream);
if(readBytes != lzmaSize) if(readBytes != lzmaSize)
{ {
fprintf(stderr, "Could not read compressed block, continuing...\n"); TRACE("Could not read compressed block, continuing...\n");
free(cmpData); free(cmpData);
free(cdDdt); free(cdDdt);
break; break;
@@ -218,7 +218,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(errorNo != 0) if(errorNo != 0)
{ {
fprintf(stderr, "Got error %d from LZMA, stopping...\n", errorNo); FATAL("Got error %d from LZMA, stopping...\n", errorNo);
free(cmpData); free(cmpData);
free(cdDdt); free(cdDdt);
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
@@ -226,7 +226,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != ddtHeader.length) if(readBytes != ddtHeader.length)
{ {
fprintf(stderr, "Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n"); FATAL("Error decompressing block, should be {0} bytes but got {1} bytes., stopping...\n");
free(cmpData); free(cmpData);
free(cdDdt); free(cdDdt);
return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK; return AARUF_ERROR_CANNOT_DECOMPRESS_BLOCK;
@@ -247,7 +247,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(cdDdt == NULL) if(cdDdt == NULL)
{ {
fprintf(stderr, "libaaruformat: Cannot allocate memory for deduplication table.\n"); TRACE("Cannot allocate memory for deduplication table.\n");
break; break;
} }
@@ -256,7 +256,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != ddtHeader.entries * sizeof(uint32_t)) if(readBytes != ddtHeader.entries * sizeof(uint32_t))
{ {
free(cdDdt); free(cdDdt);
fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n"); TRACE("Could not read deduplication table, continuing...\n");
break; break;
} }
@@ -269,8 +269,7 @@ int32_t process_ddt_v1(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break; break;
default: default:
fprintf(stderr, "libaaruformat: Found unknown compression type %d, continuing...\n", TRACE("Found unknown compression type %d, continuing...\n", ddtHeader.compression);
ddtHeader.compression);
break; break;
} }
} }

30
src/ddt/ddt_v2.c
View File

@@ -23,6 +23,7 @@
#include "aaruformat.h" #include "aaruformat.h"
#include "internal.h" #include "internal.h"
#include "log.h"
int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUserDataDdt) int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUserDataDdt)
{ {
@@ -48,7 +49,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
pos = fseek(ctx->imageStream, entry->offset, SEEK_SET); pos = fseek(ctx->imageStream, entry->offset, SEEK_SET);
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf(stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset); FATAL("Could not seek to %" PRIu64 " as indicated by index entry...\n", entry->offset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -59,7 +60,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != sizeof(DdtHeader2)) if(readBytes != sizeof(DdtHeader2))
{ {
fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n", entry->offset); FATAL("Could not read block header at %" PRIu64 "\n", entry->offset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -179,7 +180,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != ddtHeader.length) if(readBytes != ddtHeader.length)
{ {
free(buffer); free(buffer);
fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n"); FATAL("Could not read deduplication table, continuing...\n");
break; break;
} }
@@ -212,8 +213,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break; break;
default: default:
fprintf(stderr, "libaaruformat: Found unknown compression type %d, continuing...\n", TRACE("Found unknown compression type %d, continuing...\n", ddtHeader.compression);
ddtHeader.compression);
*foundUserDataDdt = false; *foundUserDataDdt = false;
break; break;
} }
@@ -321,7 +321,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(buffer == NULL) if(buffer == NULL)
{ {
fprintf(stderr, "libaaruformat: Cannot allocate memory for deduplication table.\n"); TRACE("Cannot allocate memory for deduplication table.\n");
break; break;
} }
@@ -330,7 +330,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
if(readBytes != ddtHeader.length) if(readBytes != ddtHeader.length)
{ {
free(buffer); free(buffer);
fprintf(stderr, "libaaruformat: Could not read deduplication table, continuing...\n"); FATAL("Could not read deduplication table, continuing...\n");
break; break;
} }
@@ -372,8 +372,7 @@ int32_t process_ddt_v2(aaruformatContext *ctx, IndexEntry *entry, bool *foundUse
break; break;
default: default:
fprintf(stderr, "libaaruformat: Found unknown compression type %d, continuing...\n", TRACE("Found unknown compression type %d, continuing...\n", ddtHeader.compression);
ddtHeader.compression);
break; break;
} }
} }
@@ -421,7 +420,7 @@ int32_t decode_ddt_single_level_v2(aaruformatContext *ctx, uint64_t sectorAddres
ddtEntry = ctx->userDataDdtBig[sectorAddress]; ddtEntry = ctx->userDataDdtBig[sectorAddress];
else else
{ {
fprintf(stderr, "libaaruformat: Unknown DDT size type %d.\n", ctx->userDataDdtHeader.sizeType); TRACE("Unknown DDT size type %d.\n", ctx->userDataDdtHeader.sizeType);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -488,7 +487,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sectorAddress
secondaryDdtOffset = ctx->userDataDdtBig[ddtPosition]; secondaryDdtOffset = ctx->userDataDdtBig[ddtPosition];
else else
{ {
fprintf(stderr, "libaaruformat: Unknown DDT size type %d.\n", ctx->userDataDdtHeader.sizeType); TRACE("Unknown DDT size type %d.\n", ctx->userDataDdtHeader.sizeType);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -504,14 +503,14 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sectorAddress
if(readBytes != sizeof(DdtHeader2)) if(readBytes != sizeof(DdtHeader2))
{ {
fprintf(stderr, "libaaruformat: Could not read block header at %" PRIu64 "\n", secondaryDdtOffset); FATAL("Could not read block header at %" PRIu64 "\n", secondaryDdtOffset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
if(ddtHeader.identifier != DeDuplicationTable2 || ddtHeader.type != UserData) if(ddtHeader.identifier != DeDuplicationTable2 || ddtHeader.type != UserData)
{ {
fprintf(stderr, "libaaruformat: Invalid block header at %" PRIu64 "\n", secondaryDdtOffset); TRACE("Invalid block header at %" PRIu64 "\n", secondaryDdtOffset);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -618,7 +617,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sectorAddress
if(readBytes != ddtHeader.length) if(readBytes != ddtHeader.length)
{ {
free(buffer); free(buffer);
fprintf(stderr, "libaaruformat: Could not read deduplication table, stopping...\n"); FATAL("Could not read deduplication table, stopping...\n");
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
@@ -650,8 +649,7 @@ int32_t decode_ddt_multi_level_v2(aaruformatContext *ctx, uint64_t sectorAddress
break; break;
default: default:
fprintf(stderr, "libaaruformat: Found unknown compression type %d, stopping...\n", TRACE("Found unknown compression type %d, stopping...\n", ddtHeader.compression);
ddtHeader.compression);
return AARUF_ERROR_CANNOT_READ_BLOCK; return AARUF_ERROR_CANNOT_READ_BLOCK;
} }
} }

47
src/open.c
View File

@@ -25,6 +25,7 @@
#include <aaruformat.h> #include <aaruformat.h>
#include "internal.h" #include "internal.h"
#include "log.h"
#include "utarray.h" #include "utarray.h"
void *aaruf_open(const char *filepath) void *aaruf_open(const char *filepath)
@@ -35,7 +36,13 @@ void *aaruf_open(const char *filepath)
long pos = 0; long pos = 0;
int i = 0; int i = 0;
uint32_t signature = 0; uint32_t signature = 0;
UT_array * index_entries = NULL; UT_array *index_entries = NULL;
#ifdef USE_SLOG
#include "slog.h"
slog_init("aaruformat.log", SLOG_FLAGS_ALL, 0);
#endif
ctx = (aaruformatContext *)malloc(sizeof(aaruformatContext)); ctx = (aaruformatContext *)malloc(sizeof(aaruformatContext));
memset(ctx, 0, sizeof(aaruformatContext)); memset(ctx, 0, sizeof(aaruformatContext));
@@ -99,8 +106,7 @@ void *aaruf_open(const char *filepath)
return NULL; return NULL;
} }
fprintf(stderr, "libaaruformat: Opening image version %d.%d\n", ctx->header.imageMajorVersion, TRACE("Opening image version %d.%d\n", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
ctx->header.imageMinorVersion);
ctx->readableSectorTags = (bool *)malloc(sizeof(bool) * MaxSectorTag); ctx->readableSectorTags = (bool *)malloc(sizeof(bool) * MaxSectorTag);
@@ -151,8 +157,8 @@ void *aaruf_open(const char *filepath)
readBytes = fread(&signature, 1, sizeof(uint32_t), ctx->imageStream); readBytes = fread(&signature, 1, sizeof(uint32_t), ctx->imageStream);
if(readBytes != sizeof(uint32_t) || (signature != IndexBlock && signature != IndexBlock2 && signature != if(readBytes != sizeof(uint32_t) ||
IndexBlock3)) (signature != IndexBlock && signature != IndexBlock2 && signature != IndexBlock3))
{ {
free(ctx); free(ctx);
errno = AARUF_ERROR_CANNOT_READ_INDEX; errno = AARUF_ERROR_CANNOT_READ_INDEX;
@@ -160,9 +166,12 @@ void *aaruf_open(const char *filepath)
return NULL; return NULL;
} }
if(signature == IndexBlock) index_entries = process_index_v1(ctx); if(signature == IndexBlock)
else if(signature == IndexBlock2) index_entries = process_index_v2(ctx); index_entries = process_index_v1(ctx);
else if(signature == IndexBlock3) index_entries = process_index_v3(ctx); else if(signature == IndexBlock2)
index_entries = process_index_v2(ctx);
else if(signature == IndexBlock3)
index_entries = process_index_v3(ctx);
if(index_entries == NULL) if(index_entries == NULL)
{ {
@@ -174,14 +183,13 @@ void *aaruf_open(const char *filepath)
return NULL; return NULL;
} }
fprintf(stderr, "libaaruformat: Index at %" PRIu64 " contains %d entries\n", ctx->header.indexOffset, TRACE("Index at %" PRIu64 " contains %d entries\n", ctx->header.indexOffset, utarray_len(index_entries));
utarray_len(index_entries));
for(i = 0; i < utarray_len(index_entries); i++) for(i = 0; i < utarray_len(index_entries); i++)
{ {
IndexEntry *entry = (IndexEntry *)utarray_eltptr(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", TRACE("Block type %4.4s with data type %d is indexed to be at %" PRIu64 "\n", (char *)&entry->blockType,
(char *)&entry->blockType, entry->dataType, entry->offset); entry->dataType, entry->offset);
} }
bool foundUserDataDdt = false; bool foundUserDataDdt = false;
@@ -193,9 +201,9 @@ void *aaruf_open(const char *filepath)
if(pos < 0 || ftell(ctx->imageStream) != entry->offset) if(pos < 0 || ftell(ctx->imageStream) != entry->offset)
{ {
fprintf( fprintf(stderr,
stderr, "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry %d, continuing...\n", "libaaruformat: Could not seek to %" PRIu64 " as indicated by index entry %d, continuing...\n",
entry->offset, i); entry->offset, i);
continue; continue;
} }
@@ -268,10 +276,9 @@ void *aaruf_open(const char *filepath)
break; break;
default: default:
fprintf( fprintf(stderr,
stderr, "libaaruformat: Unhandled block type %4.4s with data type %d is indexed to be at %" PRIu64 "\n",
"libaaruformat: Unhandled block type %4.4s with data type %d is indexed to be at %" PRIu64 "\n", (char *)&entry->blockType, entry->dataType, entry->offset);
(char *)&entry->blockType, entry->dataType, entry->offset);
break; break;
} }
} }
@@ -280,7 +287,7 @@ void *aaruf_open(const char *filepath)
if(!foundUserDataDdt) if(!foundUserDataDdt)
{ {
fprintf(stderr, "libaaruformat: Could not find user data deduplication table, aborting...\n"); FATAL("Could not find user data deduplication table, aborting...\n");
aaruf_close(ctx); aaruf_close(ctx);
return NULL; return NULL;
} }

16
src/write.c
View File

@@ -71,6 +71,13 @@ int32_t aaruf_write_sector(void *context, uint64_t sectorAddress, uint8_t *data,
if(ctx->writingBuffer == NULL) return AARUF_ERROR_NOT_ENOUGH_MEMORY; if(ctx->writingBuffer == NULL) return AARUF_ERROR_NOT_ENOUGH_MEMORY;
ctx->crc64Context = aaruf_crc64_init(); ctx->crc64Context = aaruf_crc64_init();
// Get current file position
long pos = ftell(ctx->imageStream);
// Calculate and save next block aligned position
ctx->nextBlockPosition =
pos / (1 << ctx->userDataDdtHeader.blockAlignmentShift) * (1 << ctx->userDataDdtHeader.blockAlignmentShift);
} }
// TODO: DDT entry // TODO: DDT entry
@@ -105,13 +112,8 @@ int32_t aaruf_close_current_block(aaruformatContext *ctx)
// Write block header to file // Write block header to file
// Get file position // Move to expected block position
long pos = ftell(ctx->imageStream); fseek(ctx->imageStream, ctx->nextBlockPosition, SEEK_SET);
// Fill file with zeroes until next aligned position according to DDT's block alignment shift
long next_alignment =
pos / (1 << ctx->userDataDdtHeader.blockAlignmentShift) * (1 << ctx->userDataDdtHeader.blockAlignmentShift);
fwrite("\0", 1, next_alignment - pos, ctx->imageStream);
// Write block header // Write block header
if(fwrite(&ctx->currentBlockHeader, sizeof(BlockHeader), 1, ctx->imageStream) != 1) if(fwrite(&ctx->currentBlockHeader, sizeof(BlockHeader), 1, ctx->imageStream) != 1)