| Disk ARchive 2.8.1 Full featured and portable backup and archiving tool

Loading...
Searching...
No Matches
cat_inode.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2025 Denis Corbin
4//
5// This program is free software; you can redistribute it and/or
6// modify it under the terms of the GNU General Public License
7// as published by the Free Software Foundation; either version 2
8// of the License, or (at your option) any later version.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program; if not, write to the Free Software
17// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18//
19// to contact the author, see the AUTHOR file
20/*********************************************************************/
21
25
26#ifndef CAT_INODE_HPP
27#define CAT_INODE_HPP
28
29#include "../my_config.h"
30
31extern "C"
32{
33} // end extern "C"
34
35#include "infinint.hpp"
36#include "ea.hpp"
37#include "integers.hpp"
38#include "mask.hpp"
39#include "user_interaction.hpp"
40#include "filesystem_specific_attribute.hpp"
41#include "datetime.hpp"
42#include "cat_nomme.hpp"
43#include "archive_aux.hpp"
44
45namespace libdar
46{
49
51
52 class cat_inode : public cat_nomme
53 {
54 public:
55
57
58 cat_inode(const infinint & xuid,
59 const infinint & xgid,
60 U_16 xperm,
61 const datetime & last_access,
62 const datetime & last_modif,
63 const datetime & last_change,
64 const std::string & xname,
65 const infinint & device);
66 cat_inode(const std::shared_ptr<user_interaction> & dialog,
67 const smart_pointer<pile_descriptor> & pdesc,
68 const archive_version & reading_ver,
69 saved_status saved,
70 bool small);
71 cat_inode(const cat_inode & ref);
72 cat_inode(cat_inode && ref) noexcept: cat_nomme(std::move(ref)) { nullifyptr(); move_from(std::move(ref)); };
73 cat_inode & operator = (const cat_inode & ref);
74 cat_inode & operator = (cat_inode && ref) { cat_nomme::operator = (std::move(ref)); move_from(std::move(ref)); return *this; };
75 ~cat_inode() noexcept(false);
76
77 const infinint & get_uid() const { return uid; };
78 const infinint & get_gid() const { return gid; };
79 U_16 get_perm() const { return perm; };
80 datetime get_last_access() const { return last_acc; };
81 datetime get_last_modif() const { return last_mod; };
82 void set_last_access(const datetime & x_time) { last_acc = x_time; };
83 void set_last_modif(const datetime & x_time) { last_mod = x_time; };
84 infinint get_device() const { if(fs_dev == nullptr) throw SRC_BUG; return *fs_dev; };
85
86 bool same_as(const cat_inode & ref) const;
87 bool is_more_recent_than(const cat_inode & ref, const infinint & hourshift) const;
88 // used for RESTORATION
89 virtual bool has_changed_since(const cat_inode & ref, const infinint & hourshift, comparison_fields what_to_check) const;
90 // signature() left as an abstract method
91 // clone is abstract too
92 // used for INCREMENTAL BACKUP
93
94 void compare(const cat_inode &other,
95 const mask & ea_mask,
96 comparison_fields what_to_check,
97 const infinint & hourshift,
98 bool symlink_date,
99 const fsa_scope & scope,
100 bool isolated_mode,
101 bool seq_read_mode
102 ) const;
103 // throw Erange exception if a difference has been detected
104 // this is not a symetrical comparison, but all what is present
105 // in the current object is compared against the argument
106 // which may contain supplementary informations
107 // used for DIFFERENCE
108
109
110
112 // EXTENDED ATTRIBUTES Methods
113 //
114
115 // I : to know whether EA data is present or not for this object
116 void ea_set_saved_status(ea_saved_status status);
117 ea_saved_status ea_get_saved_status() const { return ea_saved; };
118
119 // II : to associate EA list to an cat_inode object (mainly for backup operation) #EA_FULL only#
120 void ea_attach(ea_attributs *ref);
121
123 const ea_attributs *get_ea() const; // #<-- EA_FULL *and* EA_REMOVED# for this call only
124 void ea_detach() const; //discards any future call to get_ea() !
125 infinint ea_get_size() const; //returns the size of EA (still valid if ea have been detached) mainly used to define CRC width
126
127 // III : to record where is dump the EA in the archive #EA_FULL only#
128 void ea_set_offset(const infinint & pos);
129 bool ea_get_offset(infinint & pos) const;
130 void ea_set_crc(const crc & val);
131 void ea_get_crc(const crc * & ptr) const;
132 bool ea_get_crc_size(infinint & val) const;
133
134 // IV : to know/record if EA and FSA have been modified # any EA status# and FSA status #
135 datetime get_last_change() const { return last_cha; };
136 void set_last_change(const datetime & x_time) { last_cha = x_time; };
137 bool has_last_change() const { return !last_cha.is_null(); };
138 // old format did provide last_change only when EA were present, since archive
139 // format 8, this field is always present even in absence of EA. Thus it is
140 // still necessary to check if the cat_inode has a last_change() before
141 // using get_last_change() (depends on the version of the archive read).
142
143
145 // FILESYSTEM SPECIFIC ATTRIBUTES Methods
146 //
147
148 // I : which FSA are present
149 void fsa_set_saved_status(fsa_saved_status status);
150 fsa_saved_status fsa_get_saved_status() const { return fsa_saved; };
152 fsa_scope fsa_get_families() const { if(fsa_families == nullptr) throw SRC_BUG; return infinint_to_fsa_scope(*fsa_families); };
153
154
155
156 // II : add or drop FSA list to the cat_inode
157 void fsa_attach(filesystem_specific_attribute_list *ref);
158 void fsa_partial_attach(const fsa_scope & val); // #<-- FSA_PARTIAL only
159 const filesystem_specific_attribute_list *get_fsa() const; // #<-- FSA_FULL only
160 void fsa_detach() const; // discard any future call to get_fsa() !
161 infinint fsa_get_size() const; // returns the size of FSA (still valid if fsal has been detached) / mainly used to define CRC size
162
163 // III : to record where FSA are dumped in the archive (only if fsa_status not empty !)
164 void fsa_set_offset(const infinint & pos);
165 bool fsa_get_offset(infinint & pos) const;
166 void fsa_set_crc(const crc & val);
167 void fsa_get_crc(const crc * & ptr) const;
168 bool fsa_get_crc_size(infinint & val) const;
169
170 protected:
171 virtual void sub_compare(const cat_inode & other,
172 bool isolated_mode,
173 bool seq_read_mode) const {};
174 bool get_small_read() const { return small_read; };
175
176 // inherited from cat_entree
177 virtual void inherited_dump(const pile_descriptor & pdesc, bool small) const override;
178
179
180 private :
181 infinint uid;
182 infinint gid;
183 U_16 perm;
184 datetime last_acc;
185 datetime last_mod;
186 datetime last_cha;
187 ea_saved_status ea_saved;
188 fsa_saved_status fsa_saved;
189
190 bool small_read;
191
192 // the following is used only if ea_saved == full
193 infinint *ea_offset;
194 ea_attributs *ea;
195 infinint *ea_size;
196 // the following is used if ea_saved == full or ea_saved == partial or
197 crc *ea_crc;
198
199 infinint *fsa_families;
200 infinint *fsa_offset;
201 filesystem_specific_attribute_list *fsal;
202 infinint *fsa_size;
203 crc *fsa_crc;
204 //
205 infinint *fs_dev;
206 archive_version edit;
207
208
209 void nullifyptr() noexcept;
210 void destroy() noexcept;
211 void copy_from(const cat_inode & ref);
212 void move_from(cat_inode && ref) noexcept;
213
214 static const ea_attributs empty_ea;
215 };
216
218
219} // end of namespace
220
221#endif
archive_aux.hpp
set of datastructures used to interact with a catalogue object
cat_nomme.hpp
base class of all objects contained in a catalogue and that can be named
libdar::archive_version
class archive_version manages the version of the archive format
Definition archive_version.hpp:47
libdar::cat_inode
the root class for all cat_inode
Definition cat_inode.hpp:53
libdar::cat_inode::ea_size
infinint * ea_size
storage size required by EA
Definition cat_inode.hpp:195
libdar::cat_inode::last_mod
datetime last_mod
last modification time (mtime)
Definition cat_inode.hpp:185
libdar::cat_inode::last_acc
datetime last_acc
last access time (atime)
Definition cat_inode.hpp:184
libdar::cat_inode::perm
U_16 perm
inode's permission
Definition cat_inode.hpp:183
libdar::cat_inode::ea_get_crc_size
bool ea_get_crc_size(infinint &val) const
returns true if crc is know and puts its width in argument
libdar::cat_inode::edit
archive_version edit
need to know EA and FSA format used in archive file
Definition cat_inode.hpp:206
libdar::cat_inode::inherited_dump
virtual void inherited_dump(const pile_descriptor &pdesc, bool small) const override
true if object has been created by sequential reading of an archive
libdar::cat_inode::ea
ea_attributs * ea
Extended Attributes read or to be written down.
Definition cat_inode.hpp:194
libdar::cat_inode::uid
infinint uid
inode owner's user ID
Definition cat_inode.hpp:181
libdar::cat_inode::fsa_size
infinint * fsa_size
storage size required for FSA
Definition cat_inode.hpp:202
libdar::cat_inode::cat_inode
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)
flag used to only consider certain fields when comparing/restoring inodes
libdar::cat_inode::fsa_families
infinint * fsa_families
list of FSA families present for that inode (set to nullptr in fsa_none mode)
Definition cat_inode.hpp:199
libdar::cat_inode::fsa_crc
crc * fsa_crc
CRC computed on FSA.
Definition cat_inode.hpp:203
libdar::cat_inode::small_read
bool small_read
whether we the object has been built with sequential-reading
Definition cat_inode.hpp:190
libdar::cat_inode::get_ea
const ea_attributs * get_ea() const
the returned value is the address of an existing file of the cat_inode object and shall not be delete...
libdar::cat_inode::ea_get_crc
void ea_get_crc(const crc *&ptr) const
the argument is set to point to an allocated crc object owned by this "cat_inode" object,...
libdar::cat_inode::fs_dev
infinint * fs_dev
filesystem ID on which resides the inode (only used when read from filesystem)
Definition cat_inode.hpp:205
libdar::cat_inode::ea_crc
crc * ea_crc
CRC computed on EA.
Definition cat_inode.hpp:197
libdar::cat_inode::ea_offset
infinint * ea_offset
offset in archive where to find EA
Definition cat_inode.hpp:193
libdar::cat_inode::ea_saved
ea_saved_status ea_saved
inode Extended Attribute status
Definition cat_inode.hpp:187
libdar::cat_inode::last_cha
datetime last_cha
last inode meta data change (ctime)
Definition cat_inode.hpp:186
libdar::cat_inode::fsa_saved
fsa_saved_status fsa_saved
inode Filesystem Specific Attribute status
Definition cat_inode.hpp:188
libdar::cat_inode::fsa_offset
infinint * fsa_offset
offset in archive where to find FSA # always allocated (to be reviewed)
Definition cat_inode.hpp:200
libdar::cat_inode::fsal
filesystem_specific_attribute_list * fsal
Filesystem Specific Attributes read or to be written down # only allocated if fsa_saved if set to FUL...
Definition cat_inode.hpp:201
libdar::cat_inode::gid
infinint gid
inode owner's group ID
Definition cat_inode.hpp:182
libdar::cat_inode::compare
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, bool seq_read_mode) const
libdar::cat_inode::fsa_get_families
fsa_scope fsa_get_families() const
gives the set of FSA family recorded for that inode
Definition cat_inode.hpp:152
libdar::cat_nomme
the base class for all entry that have a name
Definition cat_nomme.hpp:45
libdar::crc
pure virtual class defining interface of a CRC object
Definition crc.hpp:47
libdar::datetime
stores time information
Definition datetime.hpp:59
libdar::datetime::is_null
bool is_null() const
return true if the datetime is exactly January 1st, 1970, 0 h 0 mn 0 s
Definition datetime.hpp:131
libdar::ea_attributs
the class ea_attributs manages the set of EA that can be associated to an inode
Definition ea.hpp:48
libdar::filesystem_specific_attribute_list
interface to fileystem for FSA
Definition filesystem_specific_attribute.hpp:138
libdar::infinint
the arbitrary large positive integer class
Definition real_infinint.hpp:62
libdar::mask
the generic class, parent of all masks
Definition mask.hpp:62
libdar::smart_pointer
smart pointer class to be used to automagically manage multiple time pointed to address
Definition smart_pointer.hpp:79
datetime.hpp
this file contains the definition of class datetime that stores unix times in a portable way
ea.hpp
contains a set of routines to manage EA values associated to a file
filesystem_specific_attribute.hpp
filesystem specific attributes
libdar::comparison_fields
comparison_fields
how to consider file change during comparison and incremental backup
Definition archive_aux.hpp:53
libdar::infinint_to_fsa_scope
fsa_scope infinint_to_fsa_scope(const infinint &ref)
convert an infinint to fsa_scape
libdar::fsa_scope
std::set< fsa_family > fsa_scope
set of fsa families
Definition fsa_family.hpp:70
libdar::fsa_saved_status
fsa_saved_status
FSA saved status for an entry.
Definition cat_status.hpp:73
libdar::saved_status
saved_status
data saved status for an entry
Definition cat_status.hpp:44
libdar::ea_saved_status
ea_saved_status
EA saved status for an entry.
Definition cat_status.hpp:55
libdar::saved_status::saved
@ saved
inode is saved in the archive
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
integers.hpp
are defined here basic integer types that tend to be portable
mask.hpp
here lies a collection of mask classes
my_config.h
include macro defined by the configure script and some specific additional ones
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
user_interaction.hpp
defines the interaction interface between libdar and users.