i_archive.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 I_ARCHIVE_HPP
#define I_ARCHIVE_HPP
 
#include "../my_config.h"
#include <vector>
#include <string>
#include <memory>
 
#include "erreurs.hpp"
#include "path.hpp"
#include "statistics.hpp"
#include "archive_options.hpp"
#include "pile.hpp"
#include "list_entry.hpp"
#include "crypto.hpp"
#include "slice_layout.hpp"
#include "mem_ui.hpp"
#include "archive_summary.hpp"
#include "archive_listing_callback.hpp"
#include "catalogue.hpp"
#include "archive.hpp"
#include "header_version.hpp"
 
namespace libdar
{
 
 
 
    class archive::i_archive: public mem_ui
    {
    public:
 
 
    i_archive(const std::shared_ptr<user_interaction> & dialog,
        const path & chem,
        const std::string & basename,
        const std::string & extension,
        const archive_options_read & options);
 
 
 
    i_archive(const std::shared_ptr<user_interaction> & dialog,
        const path & fs_root,
        const path & sauv_path,
        const std::string & filename,
        const std::string & extension,
        const archive_options_create & options,
        statistics * progressive_report);
 
 
    i_archive(const std::shared_ptr<user_interaction> & dialog,
        const path & sauv_path,
        std::shared_ptr<archive> ref_arch1,
        const std::string & filename,
        const std::string & extension,
        const archive_options_merge & options,
        statistics * progressive_report);
 
 
    i_archive(const std::shared_ptr<user_interaction> & dialog,
          const path & chem_src,
          const std::string & basename_src,
          const std::string & extension_src,
          const archive_options_read & options_read,
          const path & chem_dst,
          const std::string & basename_dst,
          const std::string & extension_dst,
          const archive_options_repair & options_repair,
          statistics * progressive_report);
 
 
    i_archive(const i_archive & ref) = delete;
    i_archive(i_archive && ref) = delete;
    i_archive & operator = (const i_archive & ref) = delete;
    i_archive & operator = (i_archive && ref) = delete;
 
 
    ~i_archive() { free_mem(); };
 
 
 
    statistics op_extract(const path &fs_root,
                  const archive_options_extract & options,
                  statistics *progressive_report);
 
 
    void summary();
 
    archive_summary summary_data();
 
 
 
    void op_listing(archive_listing_callback callback,
            void *context,
            const archive_options_listing & options) const;
 
 
    statistics op_diff(const path & fs_root,
               const archive_options_diff & options,
               statistics * progressive_report);
 
 
 
    statistics op_test(const archive_options_test & options, 
               bool reparing,  
               statistics * progressive_report 
        );
 
 
 
    void op_isolate(const path &sauv_path,
            const std::string & filename,
            const std::string & extension,
            const archive_options_isolate & options);
 
 
 
    bool get_children_of(archive_listing_callback callback,
                 void *context,
                 const std::string & dir,
                 bool fetch_ea = false);
 
 
    const std::vector<list_entry> get_children_in_table(const std::string & dir, bool fetch_ea = false) const;
 
    bool has_subdirectory(const std::string & dir) const;
 
    const entree_stats get_stats() const { if(cat == nullptr) throw SRC_BUG; return cat->get_stats(); };
 
    const std::list<signator> & get_signatories() const { return gnupg_signed; };
 
    void init_catalogue() const;
 
 
    const catalogue & get_catalogue() const;
 
 
    void drop_all_filedescriptors(bool repairing);
 
    void set_to_unsaved_data_and_FSA() { if(cat == nullptr) throw SRC_BUG; cat->set_to_unsaved_data_and_FSA(); };
 
 
    bool get_catalogue_slice_layout(slice_layout & slicing) const;
 
 
    U_64 get_first_slice_header_size() const;
 
 
    U_64 get_non_first_slice_header_size() const;
 
 
    private:
    enum operation { oper_create, oper_isolate, oper_merge, oper_repair };
 
    pile stack;              
    header_version ver;      
    catalogue *cat;          
    infinint local_cat_size; 
    bool exploitable;        
    bool lax_read_mode;      
    bool sequential_read;    
    std::list<signator> gnupg_signed; 
    slice_layout slices;     
 
    void free_mem();
    void check_gnupg_signed() const;
 
    const catalogue & get_cat() const { if(cat == nullptr) throw SRC_BUG; else return *cat; };
    const header_version & get_header() const { return ver; };
 
    bool get_sar_param(infinint & sub_file_size,
               infinint & first_file_size,
               infinint & last_file_size,
               infinint & total_file_number);
    std::shared_ptr<entrepot> get_entrepot(); 
    infinint get_level2_size();
    infinint get_cat_size() const { return local_cat_size; };
 
    statistics op_create_in(operation op,
                const path & fs_root,
                const std::shared_ptr<entrepot> & sauv_path_t,
                archive *ref_arch,
                const mask & selection,
                const mask & subtree,
                const std::string & filename,
                const std::string & extension,
                bool allow_over,
                bool warn_over,
                bool info_details,
                bool display_treated,
                bool display_treated_only_dir,
                bool display_skipped,
                bool display_finished,
                const infinint & pause,
                bool empty_dir,
                compression algo,
                U_I compression_level,
                U_I compression_block_size,
                const infinint & file_size,
                const infinint & first_file_size,
                const mask & ea_mask,
                const std::string & execute,
                crypto_algo crypto,
                const secu_string & pass,
                U_32 crypto_size,
                const std::vector<std::string> & gnupg_recipients,
                const std::vector<std::string> & gnupg_signatories,
                const mask & compr_mask,
                const infinint & min_compr_size,
                bool nodump,
                const std::string & exclude_by_ea,
                const infinint & hourshift,
                bool empty,
                bool alter_atime,
                bool furtive_read_mode,
                const filesystem_ids & same_fs,
                comparison_fields what_to_check,
                bool snapshot,
                bool cache_directory_tagging,
                const infinint & fixed_date,
                const std::string & slice_permission,
                const infinint & repeat_count,
                const infinint & repeat_byte,
                bool add_marks_for_sequential_reading,
                bool security_check,
                const infinint & sparse_file_min_size,
                const std::string & user_comment,
                hash_algo hash,
                const infinint & slice_min_digits,
                const std::string & backup_hook_file_execute,
                const mask & backup_hook_file_mask,
                bool ignore_unknown,
                const fsa_scope & scope,
                U_I multi_threaded_crypto,
                U_I multi_threaded_compress,
                bool delta_signature,
                bool build_delta_sig,
                const mask & delta_mask,
                const infinint & delta_sig_min_size,
                bool delta_diff,
                bool zeroing_neg_date,
                const std::set<std::string> & ignored_symlinks,
                modified_data_detection mod_data_detect,
                const infinint & iteration_count,
                hash_algo kdf_hash,
                const delta_sig_block_size & sig_block_len,
                bool never_resave_uncompressed,
                statistics * progressive_report);
 
    void op_create_in_sub(operation op,                     
                  const path & fs_root,             
                  const std::shared_ptr<entrepot> & sauv_path_t,     
                  catalogue * ref_cat1,             
                  const catalogue * ref_cat2,       
                  bool initial_pause,               
                  const mask & selection,           
                  const mask & subtree,             
                  const std::string & filename,     
                  const std::string & extension,    
                  bool allow_over,                  
                  const crit_action & overwrite,    
                  bool warn_over,                   
                  bool info_details,                
                  bool display_treated,             
                  bool display_treated_only_dir,    
                  bool display_skipped,             
                  bool display_finished,            
                  const infinint & pause,           
                  bool empty_dir,                   
                  compression algo,                 
                  U_I compression_level,            
                  U_I compression_block_size,       
                  const infinint & file_size,       
                  const infinint & first_file_size, 
                  const mask & ea_mask,             
                  const std::string & execute,      
                  crypto_algo crypto,               
                  const secu_string & pass,         
                  U_32 crypto_size,                 
                  const std::vector<std::string> & gnupg_recipients, 
                  const std::vector<std::string> & gnupg_signatories, 
                  const mask & compr_mask,          
                  const infinint & min_compr_size,  
                  bool nodump,                      
                  const std::string & exclude_by_ea,
                  const infinint & hourshift,       
                  bool empty,                       
                  bool alter_atime,                 
                  bool furtive_read_mode,           
                  const filesystem_ids & same_fs,   
                  comparison_fields what_to_check,  
                  bool snapshot,                    
                  bool cache_directory_tagging,     
                  bool keep_compressed,             
                  const infinint & fixed_date,      
                  const std::string & slice_permission,      
                  const infinint & repeat_count,             
                  const infinint & repeat_byte,              
                  bool decremental,                          
                  bool add_marks_for_sequential_reading,     
                  bool security_check,                       
                  const infinint & sparse_file_min_size,     
                  const std::string & user_comment,          
                  hash_algo hash,                            
                  const infinint & slice_min_digits,         
                  const std::string & backup_hook_file_execute, 
                  const mask & backup_hook_file_mask,         
                  bool ignore_unknown,                        
                  const fsa_scope & scope,                    
                  U_I multi_threaded_crypto,        
                  U_I multi_threaded_compress,      
                  bool delta_signature,             
                  bool build_delta_sig,             
                  const mask & delta_mask,          
                  const infinint & delta_sig_min_size, 
                  bool delta_diff,                     
                  bool zeroing_neg_date,            
                  const std::set<std::string> & ignored_symlinks, 
                  modified_data_detection mod_data_detect, 
                  const infinint & iteration_count, 
                  hash_algo kdf_hash,               
                  const delta_sig_block_size & sign_block_len, 
                  bool never_resave_uncompressed,   
                  statistics * st_ptr             
        );
 
    void disable_natural_destruction();
    void enable_natural_destruction();
    const label & get_layer1_data_name() const;
    const label & get_catalogue_data_name() const;
    bool only_contains_an_isolated_catalogue() const; 
    void check_against_isolation(bool lax) const; 
    const cat_directory *get_dir_object(const std::string & dir) const;
    void load_catalogue(bool repairing);
    };
 
} // end of namespace
 
#endif