cat_inode.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2024 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_INODE_HPP
#define CAT_INODE_HPP
 
#include "../my_config.h"
 
extern "C"
{
} // end extern "C"
 
#include "infinint.hpp"
#include "ea.hpp"
#include "integers.hpp"
#include "mask.hpp"
#include "user_interaction.hpp"
#include "filesystem_specific_attribute.hpp"
#include "datetime.hpp"
#include "cat_nomme.hpp"
#include "archive_aux.hpp"
 
namespace libdar
{
 
 
    class cat_inode : public cat_nomme
    {
    public:
 
 
        cat_inode(const infinint & xuid,
          const infinint & xgid,
          U_16 xperm,
          const datetime & last_access,
          const datetime & last_modif,
          const datetime & last_change,
          const std::string & xname,
          const infinint & device);
        cat_inode(const std::shared_ptr<user_interaction> & dialog,
          const smart_pointer<pile_descriptor> & pdesc,
          const archive_version & reading_ver,
          saved_status saved,
          bool small);
        cat_inode(const cat_inode & ref);
    cat_inode(cat_inode && ref) noexcept: cat_nomme(std::move(ref)) { nullifyptr(); move_from(std::move(ref)); };
    cat_inode & operator = (const cat_inode & ref);
    cat_inode & operator = (cat_inode && ref) { cat_nomme::operator = (std::move(ref)); move_from(std::move(ref)); return *this; };
        ~cat_inode() noexcept(false);
 
        const infinint & get_uid() const { return uid; };
        const infinint & get_gid() const { return gid; };
        U_16 get_perm() const { return perm; };
        datetime get_last_access() const { return last_acc; };
        datetime get_last_modif() const { return last_mod; };
        void set_last_access(const datetime & x_time) { last_acc = x_time; };
        void set_last_modif(const datetime & x_time) { last_mod = x_time; };
    infinint get_device() const { if(fs_dev == nullptr) throw SRC_BUG; return *fs_dev; };
 
        bool same_as(const cat_inode & ref) const;
        bool is_more_recent_than(const cat_inode & ref, const infinint & hourshift) const;
        // used for RESTORATION
        virtual bool has_changed_since(const cat_inode & ref, const infinint & hourshift, comparison_fields what_to_check) const;
            // signature() left as an abstract method
            // clone is abstract too
        // used for INCREMENTAL BACKUP
        void compare(const cat_inode &other,
             const mask & ea_mask,
             comparison_fields what_to_check,
             const infinint & hourshift,
             bool symlink_date,
             const fsa_scope & scope,
             bool isolated_mode) const; 
 
            // throw Erange exception if a difference has been detected
            // this is not a symetrical comparison, but all what is present
            // in the current object is compared against the argument
            // which may contain supplementary informations
        // used for DIFFERENCE
 
 
 
            // EXTENDED ATTRIBUTES Methods
            //
 
            // I : to know whether EA data is present or not for this object
        void ea_set_saved_status(ea_saved_status status);
        ea_saved_status ea_get_saved_status() const { return ea_saved; };
 
            // II : to associate EA list to an cat_inode object (mainly for backup operation) #EA_FULL only#
        void ea_attach(ea_attributs *ref);
 
        const ea_attributs *get_ea() const;              //   #<-- EA_FULL *and* EA_REMOVED# for this call only
        void ea_detach() const; //discards any future call to get_ea() !
    infinint ea_get_size() const; //returns the size of EA (still valid if ea have been detached) mainly used to define CRC width
 
            // III : to record where is dump the EA in the archive #EA_FULL only#
        void ea_set_offset(const infinint & pos);
    bool ea_get_offset(infinint & pos) const;
        void ea_set_crc(const crc & val);
    void ea_get_crc(const crc * & ptr) const; 
    bool ea_get_crc_size(infinint & val) const; 
 
            // IV : to know/record if EA and FSA have been modified # any EA status# and FSA status #
        datetime get_last_change() const { return last_cha; };
        void set_last_change(const datetime & x_time) { last_cha = x_time; };
    bool has_last_change() const { return !last_cha.is_null(); };
        // old format did provide last_change only when EA were present, since archive
        // format 8, this field is always present even in absence of EA. Thus it is
        // still necessary to check if the cat_inode has a last_change() before
        // using get_last_change() (depends on the version of the archive read).
 
 
            // FILESYSTEM SPECIFIC ATTRIBUTES Methods
            //
 
        // I : which FSA are present
    void fsa_set_saved_status(fsa_saved_status status);
    fsa_saved_status fsa_get_saved_status() const { return fsa_saved; };
    fsa_scope fsa_get_families() const { if(fsa_families == nullptr) throw SRC_BUG; return infinint_to_fsa_scope(*fsa_families); };
 
 
 
        // II : add or drop FSA list to the cat_inode
    void fsa_attach(filesystem_specific_attribute_list *ref);
    void fsa_partial_attach(const fsa_scope & val);            // #<-- FSA_PARTIAL only
    const filesystem_specific_attribute_list *get_fsa() const; // #<-- FSA_FULL only
    void fsa_detach() const; // discard any future call to get_fsa() !
    infinint fsa_get_size() const; // returns the size of FSA (still valid if fsal has been detached) / mainly used to define CRC size
 
        // III : to record where FSA are dumped in the archive (only if fsa_status not empty !)
    void fsa_set_offset(const infinint & pos);
    bool fsa_get_offset(infinint & pos) const;
    void fsa_set_crc(const crc & val);
    void fsa_get_crc(const crc * & ptr) const;
    bool fsa_get_crc_size(infinint & val) const;
 
    protected:
        virtual void sub_compare(const cat_inode & other, bool isolated_mode) const {};
    bool get_small_read() const { return small_read; }; 
 
        // inherited from cat_entree
        virtual void inherited_dump(const pile_descriptor & pdesc, bool small) const override;
 
 
    private :
        infinint uid;               
        infinint gid;               
        U_16 perm;                  
        datetime last_acc;          
    datetime last_mod;          
        datetime last_cha;          
        ea_saved_status ea_saved;   
    fsa_saved_status fsa_saved; 
 
    bool small_read;         
 
            //  the following is used only if ea_saved == full
        infinint *ea_offset;     
        ea_attributs *ea;        
    infinint *ea_size;       
            // the following is used if ea_saved == full or ea_saved == partial or
        crc *ea_crc;             
 
    infinint *fsa_families; 
    infinint *fsa_offset;    
    filesystem_specific_attribute_list *fsal; 
    infinint *fsa_size;      
    crc *fsa_crc;            
        //
    infinint *fs_dev;        
    archive_version edit;    
 
 
    void nullifyptr() noexcept;
    void destroy() noexcept;
    void copy_from(const cat_inode & ref);
    void move_from(cat_inode && ref) noexcept;
 
    static const ea_attributs empty_ea;
    };
 
 
} // end of namespace
 
#endif