cat_delta_signature.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2026 Denis Corbin
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// to contact the author, see the AUTHOR file
/*********************************************************************/

 
#ifndef CAT_DELTA_SIGNATURE_HPP
#define CAT_DELTA_SIGNATURE_HPP
 
#include "../my_config.h"
 
extern "C"
{
} // end extern "C"
 
#include "memory_file.hpp"
#include "crc.hpp"
#include "proto_compressor.hpp"
#include "archive_version.hpp"
 
#include <memory>
 
namespace libdar
{

 
    // Datastructure in archive (DATA+METADATA)
    //
    //    SEQUENTIAL MODE - in the core of the archive
    // +------+------+-----------+--------------+----------+--------+
    // | base | sig  | sig block |sig data      | data CRC | result |
    // | CRC  | size | len (if   |(if size > 0) |    if    |  CRC   |
    // | (*)  |      | size > 0) |              | size > 0 |        |
    // +------+------+-----------+--------------+----------+--------+
    //
    //    DIRECT MODE - in catalogue at end of archive (METADATA)
    // +------+------+---------------+--------+
    // | base | sig  | sig offset    | result |
    // | CRC  | size | (if size > 0) |  CRC   |
    // | (*)  |      |               |        |
    // +------+------+---------------+--------+
    //
    //    DIRECT MODE - in the core of the archive (DATA)
    // +-----------+---------------+----------+
    // | sig block | sig data      | data CRC |
    // | len (if   | (if size > 0) |    if    |
    // | size > 0) |               | size > 0 |
    // +-----------+---------------+----------+
    //
    // Note that the SEQUENTIAL MODE is wrapping the DIRECT MODE structure in the core
    // of the archive, the core of the archive contains either the sequential mode structure
    // or the direct mode. While in the catalogue, the "sig offset" fields points to the
    // offset of the direct mode in the core (possibly wrapped in the structure forming the
    // one of the sequential mode).
    //
    // (*) base_CRC has been moved to cat_file structure since format 11,2
    //     in order to read this field before the delta patch in sequential read mode
    //
    // this structure is used for all cat_file inode that have
    // either a delta signature or contain a delta patch (s_delta status)
    // base_crc is used to check we apply the patch on the good file before proceeding
    // result_crc is used to store the crc of the file the signature has been computed on
    // result_crc is also used once a patch has been applied to verify the correctness of the patch result
 


    class cat_delta_signature
    {
    public:

    cat_delta_signature(generic_file *f, proto_compressor* c);

    cat_delta_signature() { init(); };

    cat_delta_signature(const cat_delta_signature & ref) { init(); copy_from(ref); };

    cat_delta_signature(cat_delta_signature && ref) noexcept { init(); move_from(std::move(ref)); };

    cat_delta_signature & operator = (const cat_delta_signature & ref) { clear(); copy_from(ref); return *this; };

    cat_delta_signature & operator = (cat_delta_signature && ref) noexcept { move_from(std::move(ref)); return *this; };

    ~cat_delta_signature() { destroy(); };


    bool is_pending_read() const { return pending_read; };

    void read(bool sequential_read, const archive_version & ver);

    bool can_obtain_sig() const { return !delta_sig_size.is_zero(); };


    std::shared_ptr<memory_file> obtain_sig(const archive_version & ver) const;

    U_I obtain_sig_block_size() const { return sig_block_len; };


    void drop_sig() const { sig.reset(); };




    void will_have_signature() { delta_sig_size = 1; };


    void set_sig(const std::shared_ptr<memory_file> & ptr, U_I sig_block_size);

    void set_sig() { delta_sig_size = 0; delta_sig_offset = 0; sig_block_len = 0; sig.reset(); };


    void dump_data(generic_file & f, bool sequential_mode, const archive_version & ver) const;

    void dump_metadata(generic_file & f) const;
 


    bool has_patch_base_crc() const { return patch_base_check != nullptr; };

    bool get_patch_base_crc(const crc * & c) const;

    void set_patch_base_crc(const crc & c);

    bool has_patch_result_crc() const { return patch_result_check != nullptr; };

    bool get_patch_result_crc(const crc * & c) const;

    void set_patch_result_crc(const crc & c);

    void clear() { destroy(); init(); };
 
    private:
    crc *patch_base_check;      
    infinint delta_sig_size;    
    infinint delta_sig_offset;  
    mutable std::shared_ptr<memory_file>sig; 
    crc *patch_result_check;    
    generic_file *src;          
    proto_compressor *zip;      
    mutable U_I sig_block_len;  
    bool pending_read;          
 
    void init() noexcept;
    void copy_from(const cat_delta_signature & ref);
    void move_from(cat_delta_signature && ref) noexcept;
    void destroy() noexcept;
 
        // reads sig_block_len + sig data
    void fetch_data(const archive_version & ver) const;
    };

 
} // end of namespace
 
#endif