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

cat_file.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2023 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_FILE_HPP
27#define CAT_FILE_HPP
28
29#include "../my_config.h"
30
31 extern "C"
32{
33} // end extern "C"
34
35#include "cat_inode.hpp"
36#include "memory_file.hpp"
37#include "cat_delta_signature.hpp"
38
39 namespace libdar
40{
41
44
45
47
48 class cat_file : public cat_inode
49 {
50 public :
51
53 enum get_data_mode
54 {
55 keep_compressed,
56 keep_hole,
57 normal,
58 plain
59 };
60
61 static constexpr U_8 FILE_DATA_WITH_HOLE = 0x01;
62 static constexpr U_8 FILE_DATA_IS_DIRTY = 0x02;
63 static constexpr U_8 FILE_DATA_HAS_DELTA_SIG = 0x04;
64
65 cat_file(const infinint & xuid,
66 const infinint & xgid,
67 U_16 xperm,
68 const datetime & last_access,
69 const datetime & last_modif,
70 const datetime & last_change,
71 const std::string & src,
72 const path & che,
73 const infinint & taille,
74 const infinint & fs_device,
75 bool x_furtive_read_mode);
76 cat_file(const std::shared_ptr<user_interaction> & dialog,
77 const smart_pointer<pile_descriptor> & pdesc,
78 const archive_version & reading_ver,
79 saved_status saved,
80 compression default_algo,
81 bool small);
82 cat_file(const cat_file & ref);
83 cat_file(cat_file && ref) = delete;
84 cat_file & operator = (const cat_file & ref) = delete;
85 cat_file & operator = (cat_file && ref) = delete;
86 ~cat_file() { detruit(); };
87
88 virtual bool has_changed_since(const cat_inode & ref,
89 const infinint & hourshift,
90 comparison_fields what_to_check) const override;
91 infinint get_size() const { return *size; };
92 void change_size(const infinint & s) const { *size = s; };
93 infinint get_storage_size() const { return *storage_size; };
94 void set_storage_size(const infinint & s) { *storage_size = s; };
95
97 bool can_get_data() const { return get_saved_status() == saved_status::saved || get_saved_status() == saved_status::delta || status == from_path; };
98
100
113 virtual generic_file *get_data(get_data_mode mode,
114 std::shared_ptr<memory_file> delta_sig_mem,
115 U_I signature_block_size,
116 std::shared_ptr<memory_file> delta_ref,
117 const crc **checksum = nullptr) const;
118 void clean_data(); // partially free memory (but get_data() becomes disabled)
119 void set_offset(const infinint & r);
120 const infinint & get_offset() const;
121 virtual unsigned char signature() const override { return 'f'; };
122 virtual std::string get_description() const override { return "file"; };
123
124 void set_crc(const crc &c);
125 bool get_crc(const crc * & c) const;
126 bool has_crc() const { return check != nullptr; };
127 bool get_crc_size(infinint & val) const;
128 void drop_crc() { if(check != nullptr) { delete check; check = nullptr; } };
129
130 // whether the plain file has to detect sparse file
131 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; };
132
133 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; };
134
135 // whether the plain file is stored with a sparse_file datastructure in the archive
136 bool get_sparse_file_detection_read() const { return (file_data_status_read & FILE_DATA_WITH_HOLE) != 0; };
137 bool get_sparse_file_detection_write() const { return (file_data_status_write & FILE_DATA_WITH_HOLE) != 0; };
138
139 virtual cat_entree *clone() const override { return new (std::nothrow) cat_file(*this); };
140
141 compression get_compression_algo_read() const { return algo_read; };
142
143 compression get_compression_algo_write() const { return algo_write; };
144
145 // object migration methods (merging)
146 void change_compression_algo_write(compression x) { algo_write = x; };
147
148 // dirtiness
149
150 bool is_dirty() const { return dirty; };
151 void set_dirty(bool value) { dirty = value; };
152
153
155 bool has_delta_signature_structure() const { return delta_sig != nullptr; };
156
158
162 bool has_delta_signature_available() const { return delta_sig != nullptr && delta_sig->can_obtain_sig(); };
163
164
166 bool has_patch_base_crc() const;
167
169 bool get_patch_base_crc(const crc * & c) const;
170
172 void set_patch_base_crc(const crc & c);
173
174
175
177 bool has_patch_result_crc() const;
178
180 bool get_patch_result_crc(const crc * & c) const;
181
183 void set_patch_result_crc(const crc & c);
184
186 void will_have_delta_signature_structure();
187
189
193 void will_have_delta_signature_available();
194
196
201 void dump_delta_signature(std::shared_ptr<memory_file> & sig, U_I sign_block_size, generic_file & where, bool small) const;
202
204 void dump_delta_signature(generic_file & where, bool small) const;
205
206
208
210 void read_delta_signature_metadata() const;
211
213
218 void read_delta_signature(std::shared_ptr<memory_file> & delta_sig,
219 U_I & block_len) const;
220
222 void drop_delta_signature_data() const;
223
225 bool has_same_delta_signature(const cat_file & ref) const;
226
228 void clear_delta_signature_only();
229
231 void clear_delta_signature_structure();
232
234 virtual bool operator == (const cat_entree & ref) const override { return true; };
235
237 bool same_data_as(const cat_file & other, bool check_data, const infinint & hourshift);
238
240 const archive_version & get_archive_version() const { return read_ver; };
241
242 protected:
243 virtual void sub_compare(const cat_inode & other, bool isolated_mode) const override;
244 virtual void inherited_dump(const pile_descriptor & pdesc, bool small) const override;
245 virtual void post_constructor(const pile_descriptor & pdesc) override;
246
247 enum { empty, from_path, from_cat } status;
248
249 private:
250 std::string chemin;
251 infinint *offset;
252 infinint *size;
253 infinint *storage_size;
254 crc *check;
255 bool dirty;
256 compression algo_read;
257 compression algo_write;
258 bool furtive_read_mode;
259 char file_data_status_read;
260 char file_data_status_write;
261 crc *patch_base_check;
262 cat_delta_signature *delta_sig;
263 mutable bool delta_sig_read;
264 archive_version read_ver;
265
266 void sub_compare_internal(const cat_inode & other,
267 bool can_read_my_data,
268 bool can_read_other_data,
269 const infinint & hourshift) const;
270
271 void clean_patch_base_crc();
272
273 void detruit();
274
275 };
276
278
279} // end of namespace
280
281#endif
cat_delta_signature.hpp
class used to manage binary delta signature in catalogue and archive
cat_inode.hpp
base object for all inode types, managed EA and FSA, dates, permissions, ownership,...
libdar::archive_version
class archive_version manages the version of the archive format
Definition: archive_version.hpp:47
libdar::cat_delta_signature
the cat_delta_signature file class
Definition: cat_delta_signature.hpp:94
libdar::cat_delta_signature::can_obtain_sig
bool can_obtain_sig() const
the cat_delta_signature structure can only hold CRC without delta_signature, this call gives the situ...
Definition: cat_delta_signature.hpp:134
libdar::cat_entree
the root class from all other inherite for any entry in the catalogue
Definition: cat_entree.hpp:60
libdar::cat_entree::get_saved_status
saved_status get_saved_status() const
obtain the saved status of the object
Definition: cat_entree.hpp:164
libdar::cat_file
the plain file class
Definition: cat_file.hpp:49
libdar::cat_file::size
infinint * size
size of the data (uncompressed)
Definition: cat_file.hpp:252
libdar::cat_file::get_crc
bool get_crc(const crc *&c) const
the argument is set the an allocated crc object the owned by the "cat_file" object,...
libdar::cat_file::has_same_delta_signature
bool has_same_delta_signature(const cat_file &ref) const
return true if ref and "this" have both equal delta signatures
libdar::cat_file::set_patch_base_crc
void set_patch_base_crc(const crc &c)
set the reference CRC of the file to base the patch on, for s_detla objects
libdar::cat_file::get_patch_base_crc
bool get_patch_base_crc(const crc *&c) const
returns the CRC of the file to base the patch on, for s_delta objects
libdar::cat_file::dump_delta_signature
void dump_delta_signature(std::shared_ptr< memory_file > &sig, U_I sign_block_size, generic_file &where, bool small) const
write down to archive the given delta signature
libdar::cat_file::get_archive_version
const archive_version & get_archive_version() const
expose the archive format the object of the backup this object comes from
Definition: cat_file.hpp:240
libdar::cat_file::FILE_DATA_HAS_DELTA_SIG
static constexpr U_8 FILE_DATA_HAS_DELTA_SIG
delta signature is present
Definition: cat_file.hpp:63
libdar::cat_file::read_delta_signature
void read_delta_signature(std::shared_ptr< memory_file > &delta_sig, U_I &block_len) const
fetch the delta signature from the archive
libdar::cat_file::drop_delta_signature_data
void drop_delta_signature_data() const
drop the delta signature from memory (will not more be posible to be read, using read_delta_signature...
libdar::cat_file::post_constructor
virtual void post_constructor(const pile_descriptor &pdesc) override
let inherited classes build object's data after CRC has been read from file in small read mode
libdar::cat_file::dirty
bool dirty
true when a file has been modified at the time it was saved
Definition: cat_file.hpp:255
libdar::cat_file::get_patch_result_crc
bool get_patch_result_crc(const crc *&c) const
returns the CRC the file will have once restored or patched (for s_saved, s_delta,...
libdar::cat_file::algo_write
compression algo_write
which compression algorithm to use to write down (merging) the file's data
Definition: cat_file.hpp:257
libdar::cat_file::same_data_as
bool same_data_as(const cat_file &other, bool check_data, const infinint &hourshift)
compare just data not inode information EA nor FSA
libdar::cat_file::delta_sig_read
bool delta_sig_read
whether delta sig has been read/initialized from filesystem
Definition: cat_file.hpp:263
libdar::cat_file::FILE_DATA_IS_DIRTY
static constexpr U_8 FILE_DATA_IS_DIRTY
data modified while being saved
Definition: cat_file.hpp:62
libdar::cat_file::get_data_mode
get_data_mode
how to get data from archive
Definition: cat_file.hpp:54
libdar::cat_file::keep_compressed
@ keep_compressed
provide access to compressed data
Definition: cat_file.hpp:55
libdar::cat_file::normal
@ normal
provide access to full data (uncompressed, uses skip() to restore holes)
Definition: cat_file.hpp:57
libdar::cat_file::keep_hole
@ keep_hole
provide access to uncompressed data but sparse_file datastructure
Definition: cat_file.hpp:56
libdar::cat_file::plain
@ plain
provide access to plain data, no skip to restore holes, provide instead zeroed bytes
Definition: cat_file.hpp:58
libdar::cat_file::delta_sig
cat_delta_signature * delta_sig
delta signature and associated CRC
Definition: cat_file.hpp:262
libdar::cat_file::patch_base_check
crc * patch_base_check
when data contains a delta patch, moved from delta_sig since format 10.2
Definition: cat_file.hpp:261
libdar::cat_file::will_have_delta_signature_available
void will_have_delta_signature_available()
prepare the object to receive a delta signature structure including delta signature
libdar::cat_file::clear_delta_signature_structure
void clear_delta_signature_structure()
remove any information about delta signature
libdar::cat_file::get_crc_size
bool get_crc_size(infinint &val) const
returns true if crc is know and puts its width in argument
libdar::cat_file::clear_delta_signature_only
void clear_delta_signature_only()
remove information about delta signature also associated CRCs if status is not s_delta
libdar::cat_file::has_delta_signature_structure
bool has_delta_signature_structure() const
return whether the object has an associated delta signature structure
Definition: cat_file.hpp:155
libdar::cat_file::file_data_status_read
char file_data_status_read
defines the datastructure to use when reading the data
Definition: cat_file.hpp:259
libdar::cat_file::storage_size
infinint * storage_size
how much data used in archive (after compression)
Definition: cat_file.hpp:253
libdar::cat_file::has_patch_result_crc
bool has_patch_result_crc() const
returns whether the object has a CRC corresponding to data (for s_saved, s_delta, and when delta sign...
libdar::cat_file::check
crc * check
crc computed on the data
Definition: cat_file.hpp:254
libdar::cat_file::FILE_DATA_WITH_HOLE
static constexpr U_8 FILE_DATA_WITH_HOLE
file's data contains hole datastructure
Definition: cat_file.hpp:61
libdar::cat_file::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_file::operator==
virtual bool operator==(const cat_entree &ref) const override
not used
Definition: cat_file.hpp:234
libdar::cat_file::has_delta_signature_available
bool has_delta_signature_available() const
return whether the object has an associated delta signature structure including a delta signature dat...
Definition: cat_file.hpp:162
libdar::cat_file::clone
virtual cat_entree * clone() const override
a way to copy the exact type of an object even if pointed to by a parent class pointer
Definition: cat_file.hpp:139
libdar::cat_file::furtive_read_mode
bool furtive_read_mode
used only when status equals "from_path"
Definition: cat_file.hpp:258
libdar::cat_file::file_data_status_write
char file_data_status_write
defines the datastructure to apply when writing down the data
Definition: cat_file.hpp:260
libdar::cat_file::will_have_delta_signature_structure
void will_have_delta_signature_structure()
prepare the object to receive a delta signature structure
libdar::cat_file::read_ver
archive_version read_ver
archive format used/to use
Definition: cat_file.hpp:264
libdar::cat_file::read_delta_signature_metadata
void read_delta_signature_metadata() const
load metadata (and delta signature when in sequential mode) into memory
libdar::cat_file::get_description
virtual std::string get_description() const override
inherited class designation
Definition: cat_file.hpp:122
libdar::cat_file::set_patch_result_crc
void set_patch_result_crc(const crc &c)
set the CRC the file will have once restored or patched (for s_saved, s_delta, and when delta signatu...
libdar::cat_file::can_get_data
bool can_get_data() const
check whether the object will be able to provide a object using get_data() method
Definition: cat_file.hpp:97
libdar::cat_file::dump_delta_signature
void dump_delta_signature(generic_file &where, bool small) const
variant of dump_delta_signature when just CRC have to be dumped
libdar::cat_file::has_patch_base_crc
bool has_patch_base_crc() const
returns whether the object has a base patch CRC (s_delta status objects)
libdar::cat_file::chemin
std::string chemin
path to the data (when read from filesystem)
Definition: cat_file.hpp:250
libdar::cat_file::signature
virtual unsigned char signature() const override
inherited class signature
Definition: cat_file.hpp:121
libdar::cat_file::offset
infinint * offset
start location of the data in 'loc'
Definition: cat_file.hpp:251
libdar::cat_file::get_data
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
returns a newly allocated object in read_only mode
libdar::cat_file::algo_read
compression algo_read
which compression algorithm to use to read the file's data
Definition: cat_file.hpp:256
libdar::cat_inode
the root class for all cat_inode
Definition: cat_inode.hpp:53
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::generic_file
this is the interface class from which all other data transfer classes inherit
Definition: generic_file.hpp:77
libdar::infinint
the arbitrary large positive integer class
Definition: real_infinint.hpp:62
libdar::path
the class path is here to manipulate paths in the Unix notation: using'/'
Definition: path.hpp:51
libdar::smart_pointer< pile_descriptor >
libdar::comparison_fields
comparison_fields
how to consider file change during comparison and incremental backup
Definition: archive_aux.hpp:53
libdar::compression
compression
the different compression algorithm available
Definition: compression.hpp:46
libdar::saved_status
saved_status
data saved status for an entry
Definition: cat_status.hpp:45
libdar::saved_status::saved
@ saved
inode is saved in the archive
libdar::saved_status::delta
@ delta
inode is saved but as delta binary from the content (delta signature) of what was found in the archiv...
memory_file.hpp
Memory_file is a generic_file class that only uses virtual memory.
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47