context.h

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#ifndef LIBAARUFORMAT_CONTEXT_H
#define LIBAARUFORMAT_CONTEXT_H
 
#include "blake3.h"
#include "crc64.h"
#include "hash_map.h"
#include "lru.h"
#include "md5.h"
#include "sha1.h"
#include "sha256.h"
#include "spamsum.h"
#include "structs.h"
#include "utarray.h"

 
#ifndef MD5_DIGEST_LENGTH
#define MD5_DIGEST_LENGTH 16
#endif
 
#ifndef SHA1_DIGEST_LENGTH
#define SHA1_DIGEST_LENGTH 20
#endif
 
#ifndef SHA256_DIGEST_LENGTH
#define SHA256_DIGEST_LENGTH 32
#endif

typedef struct CdEccContext
{
    bool      inited_edc;   
    uint8_t  *ecc_b_table;  
    uint8_t  *ecc_f_table;  
    uint32_t *edc_table;    
} CdEccContext;

typedef struct Checksums
{
    bool     hasMd5;                        
    bool     hasSha1;                       
    bool     hasSha256;                     
    bool     hasBlake3;                     
    bool     hasSpamSum;                    
    uint8_t  md5[MD5_DIGEST_LENGTH];        
    uint8_t  sha1[SHA1_DIGEST_LENGTH];      
    uint8_t  sha256[SHA256_DIGEST_LENGTH];  
    uint8_t  blake3[BLAKE3_OUT_LEN];        
    uint8_t *spamsum;                       
} Checksums;

typedef struct mediaTagEntry
{
    uint8_t       *data;    
    int32_t        type;    
    uint32_t       length;  
    UT_hash_handle hh;      
} mediaTagEntry;
 
typedef struct TapeFileHashEntry
{
    uint64_t       key;        
    TapeFileEntry  fileEntry;  
    UT_hash_handle hh;         
} tapeFileHashEntry;
 
typedef struct TapePartitionHashEntry
{
    uint8_t            key;             
    TapePartitionEntry partitionEntry;  
    UT_hash_handle     hh;              
} TapePartitionHashEntry;
 
typedef struct TapeDdtHashEntry
{
    uint64_t       key;    
    uint64_t       value;  
    UT_hash_handle hh;     
} TapeDdtHashEntry;

typedef struct aaruformat_context
{
    /* Core & header */
    uint64_t     magic;                  
    AaruHeaderV2 header;                 
    FILE        *imageStream;            
    uint8_t      library_major_version;  
    uint8_t      library_minor_version;  
 
    /* Deduplication tables (DDT) */
    uint64_t         *user_data_ddt;           
    TapeDdtHashEntry *tape_ddt;                
    uint32_t         *sector_prefix_ddt;       
    uint32_t         *sector_suffix_ddt;       
    uint64_t         *sector_prefix_ddt2;      
    uint64_t         *sector_suffix_ddt2;      
    uint64_t         *user_data_ddt2;          
    uint64_t         *cached_secondary_ddt2;   
    DdtHeader2        user_data_ddt_header;    
    uint64_t          cached_ddt_offset;       
    uint64_t          cached_ddt_position;     
    uint64_t          primary_ddt_offset;      
    size_t            mapped_memory_ddt_size;  
    int               ddt_version;             
    uint8_t           shift;                   
    bool              in_memory_ddt;           
 
    /* Optical auxiliary buffers (NULL if not present) */
    uint8_t *sector_prefix;               
    uint8_t *sector_prefix_corrected;     
    uint8_t *sector_suffix;               
    uint8_t *sector_suffix_corrected;     
    uint8_t *sector_subchannel;           
    uint8_t *mode2_subheaders;            
    uint8_t *sector_id;                   
    uint8_t *sector_ied;                  
    uint8_t *sector_cpr_mai;              
    uint8_t *sector_edc;                  
    uint8_t *sector_decrypted_title_key;  
 
    /* Metadata & geometry */
    struct DumpHardwareEntriesWithData *dump_hardware_entries_with_data;  
    uint8_t                            *metadata_block;       
    uint8_t                            *cicm_block;           
    uint8_t                            *json_block;           
    uint8_t                            *creator;              
    uint8_t                            *media_title;          
    uint8_t                            *comments;             
    uint8_t                            *media_manufacturer;   
    uint8_t                            *media_model;          
    uint8_t                            *media_serial_number;  
    uint8_t                            *media_barcode;        
    uint8_t                            *media_part_number;    
    uint8_t *drive_manufacturer;   
    uint8_t *drive_model;          
    uint8_t *drive_serial_number;  
    uint8_t
        *drive_firmware_revision;  
    GeometryBlockHeader         geometry_block;         
    MetadataBlockHeader         metadata_block_header;  
    CicmMetadataBlock           cicm_block_header;      
    DumpHardwareHeader          dump_hardware_header;   
    AaruMetadataJsonBlockHeader json_block_header;      
    uint32_t                    cylinders;              
    uint32_t                    heads;                  
    uint32_t sectors_per_track;    
    int32_t  media_sequence;       
    int32_t  last_media_sequence;  
 
    /* Optical information */
    TrackEntry  *track_entries;          
    TrackEntry  *data_tracks;            
    TracksHeader tracks_header;          
    uint8_t      number_of_data_tracks;  
 
    /* Integrity & ECC */
    CdEccContext *ecc_cd_context;  
    crc64_ctx    *crc64_context;   
 
    /* Index & deduplication lookup */
    UT_array   *index_entries;    
    hash_map_t *sector_hash_map;  
 
    /* Caches */
    struct CacheHeader block_header_cache;  
    struct CacheHeader block_cache;         
 
    /* High-level summary */
    ImageInfo image_info;  
 
    /* Tags */
    bool          *readableSectorTags;  
    mediaTagEntry *mediaTags;           
 
    /* Checksums */
    spamsum_ctx   *spamsum_context;      
    blake3_hasher *blake3_context;       
    Checksums      checksums;            
    md5_ctx        md5_context;          
    sha1_ctx       sha1_context;         
    sha256_ctx     sha256_context;       
    bool           calculating_md5;      
    bool           calculating_sha1;     
    bool           calculating_sha256;   
    bool           calculating_spamsum;  
    bool           calculating_blake3;   
 
    /* Write path */
    uint8_t    *writing_buffer;           
    BlockHeader current_block_header;     
    uint64_t    next_block_position;      
    uint64_t    last_written_block;       
    size_t      sector_prefix_length;     
    size_t      sector_suffix_length;     
    size_t      sector_prefix_offset;     
    size_t      sector_suffix_offset;     
    int         current_block_offset;     
    int         writing_buffer_position;  
    uint8_t     current_track_type;  
    bool        is_writing;          
    bool        rewinded;            
    bool        writing_long;        
 
    /* Options */
    uint32_t lzma_dict_size;       
    bool     deduplicate;          
    bool     compression_enabled;  
 
    /* Tape-specific structures */
    tapeFileHashEntry      *tape_files;       
    TapePartitionHashEntry *tape_partitions;  
    bool                    is_tape;          
} aaruformat_context;

typedef struct DumpHardwareEntriesWithData
{
    DumpHardwareEntry  entry;                    
    struct DumpExtent *extents;                  
    uint8_t           *manufacturer;             
    uint8_t           *model;                    
    uint8_t           *revision;                 
    uint8_t           *firmware;                 
    uint8_t           *serial;                   
    uint8_t           *softwareName;             
    uint8_t           *softwareVersion;          
    uint8_t           *softwareOperatingSystem;  
} DumpHardwareEntriesWithData;
 
#pragma pack(push, 1)

typedef struct DumpExtent
{
    uint64_t start;  
    uint64_t end;    
} DumpExtent;
 
#pragma pack(pop)
 
#endif  // LIBAARUFORMAT_CONTEXT_H