sar.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 SAR_HPP
#define SAR_HPP
 
#include "../my_config.h"
 
#include <string>
#include "infinint.hpp"
#include "generic_file.hpp"
#include "header.hpp"
#include "integers.hpp"
#include "entrepot.hpp"
#include "slice_layout.hpp"
#include "contextual.hpp"
#include "mem_ui.hpp"
#include "thread_cancellation.hpp"
 
namespace libdar
{
    // contextual is defined in generic_file module
 
 
 
    class sar : public generic_file, public contextual, protected mem_ui
    {
    public:
 
 
        sar(const std::shared_ptr<user_interaction> & dialog,
        const std::string & base_name,
        const std::string & extension,
        const std::shared_ptr<entrepot> & where,
        bool by_the_end,
        const infinint & x_min_digits,
        bool sequential_read,
        bool lax = false,
        const std::string & execute = "");
 
 
 
        sar(const std::shared_ptr<user_interaction> & dialog,
        gf_mode open_mode,
        const std::string & base_name,
        const std::string & extension,
        const infinint & file_size,
        const infinint & first_file_size,
        bool x_warn_overwrite,
        bool x_allow_overwrite,
        const infinint & pause,
        const std::shared_ptr<entrepot> & where,
        const label & internal_name,
        const label & data_name,
        bool force_permission,
        U_I permission,
        hash_algo x_hash,
        const infinint & x_min_digits,
        bool format_07_compatible,
        const std::string & execute = "");
 
    sar(const sar & ref) = delete;
 
    sar(sar && ref) noexcept = delete;
 
    sar & operator = (const sar & ref) = delete;
 
    sar & operator = (sar && ref) noexcept = delete;
 
        ~sar();
 
            // inherited from generic_file
    virtual bool skippable(skippability direction, const infinint & amount) override;
        virtual bool skip(const infinint &pos) override;
        virtual bool skip_to_eof() override;
        virtual bool skip_relative(S_I x) override;
    virtual bool truncatable(const infinint & pos) const override;
        virtual infinint get_position() const override;
 
            // informational routines
    const slice_layout & get_slicing() const { return slicing; };
        bool get_total_file_number(infinint &num) const { num = of_last_file_num; return of_last_file_known; };
        bool get_last_file_size(infinint &num) const { num = of_last_file_size; return of_last_file_known; };
 
        // disable execution of user command when destroying the current object
    void disable_natural_destruction() { natural_destruction = false; };
 
        // enable back execution of user command when destroying the current object
    void enable_natural_destruction() { natural_destruction = true; };
 
        // true if sar's header is from an old archive format (<= "07")
    virtual bool is_an_old_start_end_archive() const override { return slicing.older_sar_than_v8; };
 
        // return the internal_name used to link slices toghether
    const label & get_internal_name_used() const { return of_internal_name; };
 
        // return the data_name used to link slices toghether
    virtual const label & get_data_name() const override { return of_data_name; };
 
    const std::shared_ptr<entrepot> & get_entrepot() const { return entr; };
 
    const infinint & get_first_slice_header_size() const { return slicing.first_slice_header; };
 
    const infinint & get_non_first_slice_header_size() const { return slicing.other_slice_header; };
 
    protected :
    virtual void inherited_read_ahead(const infinint & amount) override;
        virtual U_I inherited_read(char *a, U_I size) override;
        virtual void inherited_write(const char *a, U_I size) override;
    virtual void inherited_truncate(const infinint & pos) override;
    virtual void inherited_sync_write() override {}; // nothing to do
    virtual void inherited_flush_read() override {}; // nothing to do
    virtual void inherited_terminate() override;
 
    private :
    std::shared_ptr<entrepot> entr; 
        std::string base;            
    std::string ext;             
        std::string hook;            
    slice_layout slicing;        
        infinint file_offset;        
    hash_algo hash;              
    infinint min_digits;         
        bool natural_destruction;    
            // these following variables are modified by open_file / open_file_init
            // else the are used only for reading
        infinint of_current;         
    infinint size_of_current;    
        infinint of_max_seen;        
        bool of_last_file_known;     
        infinint of_last_file_num;   
        infinint of_last_file_size;  
        label of_internal_name;      
    label of_data_name;          
    bool force_perm;             
    U_I perm;                    
        fichier_global *of_fd;       
        char of_flag;                
        bool initial;                
            // these are the option flags
        bool opt_warn_overwrite;     
        bool opt_allow_overwrite;    
        //
        infinint pause;              
    bool lax;                    
    infinint to_read_ahead;      
    bool seq_read;               
    thread_cancellation thr;     
 
        bool skip_forward(U_I x);                    
        bool skip_backward(U_I x);                   
        void close_file(bool terminal);              
        void open_readonly(const std::string & fic,  
               const infinint &num,      
               bool bytheend             
        );
        void open_writeonly(const std::string & fic, 
                const infinint &num,     
                bool bytheend            
        );
        void open_file_init();                       
        void open_file(infinint num, bool bytheend); 
        void set_offset(infinint offset);            
        void open_last_file(bool bytheend);          
    bool is_current_eof_a_normal_end_of_slice() const;  
    infinint bytes_still_to_read_in_slice() const;  
        header make_write_header(const infinint &num, char flag);
 
            // function to lauch the eventually existing command to execute after/before each slice
        void hook_execute(const infinint &num);
    };
 
 
} // end of namespace
 
#endif