cat_file.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2025 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_FILE_HPP
#define CAT_FILE_HPP
 
#include "../my_config.h"
 
extern "C"
{
} // end extern "C"
 
#include "cat_inode.hpp"
#include "memory_file.hpp"
#include "cat_delta_signature.hpp"
 
namespace libdar
{
 
 
 
 
    class cat_file : public cat_inode
    {
    public :
 
    enum get_data_mode
    {
        keep_compressed, 
        keep_hole,       
        normal,          
        plain            
    };
 
    static constexpr U_8 FILE_DATA_WITH_HOLE = 0x01;     
    static constexpr U_8 FILE_DATA_IS_DIRTY = 0x02;      
    static constexpr U_8 FILE_DATA_HAS_DELTA_SIG = 0x04; 
 
        cat_file(const infinint & xuid,
         const infinint & xgid,
         U_16 xperm,
         const datetime & last_access,
         const datetime & last_modif,
         const datetime & last_change,
         const std::string & src,
         const path & che,
         const infinint & taille,
         const infinint & fs_device,
         bool x_furtive_read_mode);
        cat_file(const std::shared_ptr<user_interaction> & dialog,
         const smart_pointer<pile_descriptor> & pdesc,
         const archive_version & reading_ver,
         saved_status saved,
         compression default_algo,
         bool small);
    cat_file(const cat_file & ref);
    cat_file(cat_file && ref) = delete;
    cat_file & operator = (const cat_file & ref) = delete;
    cat_file & operator = (cat_file && ref) = delete;
        ~cat_file() { detruit(); };
 
        virtual bool has_changed_since(const cat_inode & ref,
                       const infinint & hourshift,
                       comparison_fields what_to_check) const override;
        infinint get_size() const { return status == from_patch ? (*in_place).get_size() : *size; };
    void change_size(const infinint & s) const { *size = s; };
        infinint get_storage_size() const { return *storage_size; };
        void set_storage_size(const infinint & s) { *storage_size = s; };
 
    bool can_get_data() const { return get_saved_status() == saved_status::saved || get_saved_status() == saved_status::delta || status == from_path; };
 
 
        virtual generic_file *get_data(get_data_mode mode,
                       std::shared_ptr<memory_file> delta_sig_mem,
                       U_I signature_block_size,
                       std::shared_ptr<memory_file> delta_ref,
                       const crc **checksum = nullptr) const;
 
        void clean_data() const; // partially free memory (but get_data() becomes disabled)
 
 
    bool set_data_from_binary_patch(cat_file* in_place_addr);
 
    bool applying_binary_patch() const { return status == from_patch && in_place != nullptr; };
 
        void set_offset(const infinint & r);
    const infinint & get_offset() const;
        virtual unsigned char signature() const override { return 'f'; };
    virtual std::string get_description() const override { return "file"; };
 
        void set_crc(const crc &c);
        bool get_crc(const crc * & c) const; 
    bool has_crc() const { return check != nullptr; };
    bool get_crc_size(infinint & val) const; 
    void drop_crc() { if(check != nullptr) { delete check; check = nullptr; } };
 
        // whether the plain file has to detect sparse file
    void set_sparse_file_detection_read(bool val) { if(status == from_cat) throw SRC_BUG; if(val) file_data_status_read |= FILE_DATA_WITH_HOLE; else file_data_status_read &= ~FILE_DATA_WITH_HOLE; };
 
    void set_sparse_file_detection_write(bool val) { if(val) file_data_status_write |= FILE_DATA_WITH_HOLE; else file_data_status_write &= ~FILE_DATA_WITH_HOLE; };
 
        // whether the plain file is stored with a sparse_file datastructure in the archive
    bool get_sparse_file_detection_read() const { return (file_data_status_read & FILE_DATA_WITH_HOLE) != 0; };
    bool get_sparse_file_detection_write() const { return (file_data_status_write & FILE_DATA_WITH_HOLE) != 0; };
 
        virtual cat_entree *clone() const override { return new (std::nothrow) cat_file(*this); };
 
        compression get_compression_algo_read() const { return algo_read; };
 
    compression get_compression_algo_write() const { return algo_write; };
 
        // object migration methods (merging)
    void change_compression_algo_write(compression x) { algo_write = x; };
 
        // dirtiness
 
    bool is_dirty() const { return dirty; };
    void set_dirty(bool value) { dirty = value; };
 
 
    bool has_delta_signature_structure() const { return delta_sig != nullptr; };
 
 
    bool has_delta_signature_available() const { return delta_sig != nullptr && delta_sig->can_obtain_sig(); };
 
 
    bool has_patch_base_crc() const;
 
    bool get_patch_base_crc(const crc * & c) const;
 
    void set_patch_base_crc(const crc & c);
 
 
 
    bool has_patch_result_crc() const;
 
    bool get_patch_result_crc(const crc * & c) const;
 
    void set_patch_result_crc(const crc & c);
 
    void will_have_delta_signature_structure();
 
 
    void will_have_delta_signature_available();
 
 
    void dump_delta_signature(std::shared_ptr<memory_file> & sig, U_I sign_block_size, generic_file & where, bool small) const;
 
    void dump_delta_signature(generic_file & where, bool small) const;
 
 
 
    void read_delta_signature_metadata() const;
 
 
    void read_delta_signature(std::shared_ptr<memory_file> & delta_sig,
                  U_I & block_len) const;
 
    void drop_delta_signature_data() const;
 
    bool has_same_delta_signature(const cat_file & ref) const;
 
    void clear_delta_signature_only();
 
    void clear_delta_signature_structure();
 
    virtual bool operator == (const cat_entree & ref) const override { return true; };
 
    bool same_data_as(const cat_file & other,
              bool check_data,
              const infinint & hourshift,
              bool me_or_other_read_in_seq_mode);
 
    const archive_version & get_archive_version() const { return read_ver; };
 
    protected:
        virtual void sub_compare(const cat_inode & other,
                 bool isolated_mode,
                 bool seq_read_mode) const override;
        virtual void inherited_dump(const pile_descriptor & pdesc, bool small) const override;
    virtual void post_constructor(const pile_descriptor & pdesc) override;
 
        enum { from_path, from_cat, from_patch } status;
 
    private:
    std::string chemin;     
        infinint *offset;       
        infinint *size;         
        infinint *storage_size; 
        crc *check;             
    bool dirty;             
        compression algo_read;  
    compression algo_write; 
    bool furtive_read_mode; 
    char file_data_status_read;  
    char file_data_status_write; 
    crc *patch_base_check;       
    cat_delta_signature *delta_sig; 
    mutable bool delta_sig_read; 
    archive_version read_ver; 
    std::unique_ptr<cat_file> in_place; 
 
    void sub_compare_internal(const cat_inode & other,
                  bool can_read_my_data,
                  bool can_read_other_data,
                  const infinint & hourshift,
                  bool seq_read_mode) const;
 
    void clean_patch_base_crc();
 
    void detruit();
 
    cat_file* clone_as_file() const;
 
    };
 
 
} // end of namespace
 
#endif