Disk ARchive 2.7.15
Full featured and portable backup and archiving tool
Loading...
Searching...
No Matches
i_archive.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2024 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
27#ifndef I_ARCHIVE_HPP
28#define I_ARCHIVE_HPP
29
30#include "../my_config.h"
31#include <vector>
32#include <string>
33#include <memory>
34
35#include "erreurs.hpp"
36#include "path.hpp"
37#include "statistics.hpp"
38#include "archive_options.hpp"
39#include "pile.hpp"
40#include "list_entry.hpp"
41#include "crypto.hpp"
42#include "slice_layout.hpp"
43#include "mem_ui.hpp"
44#include "archive_summary.hpp"
46#include "catalogue.hpp"
47#include "archive.hpp"
48#include "header_version.hpp"
49
50namespace libdar
51{
52
55
57
59 {
60 public:
61
63
64 i_archive(const std::shared_ptr<user_interaction> & dialog,
65 const path & chem,
66 const std::string & basename,
67 const std::string & extension,
68 const archive_options_read & options);
69
70
72
73 i_archive(const std::shared_ptr<user_interaction> & dialog,
74 const path & fs_root,
75 const path & sauv_path,
76 const std::string & filename,
77 const std::string & extension,
78 const archive_options_create & options,
79 statistics * progressive_report);
80
82
83 i_archive(const std::shared_ptr<user_interaction> & dialog,
84 const path & sauv_path,
85 std::shared_ptr<archive> ref_arch1,
86 const std::string & filename,
87 const std::string & extension,
88 const archive_options_merge & options,
89 statistics * progressive_report);
90
92
93 i_archive(const std::shared_ptr<user_interaction> & dialog,
94 const path & chem_src,
95 const std::string & basename_src,
96 const std::string & extension_src,
97 const archive_options_read & options_read,
98 const path & chem_dst,
99 const std::string & basename_dst,
100 const std::string & extension_dst,
101 const archive_options_repair & options_repair);
102
104
105 i_archive(const i_archive & ref) = delete;
106 i_archive(i_archive && ref) = delete;
107 i_archive & operator = (const i_archive & ref) = delete;
108 i_archive & operator = (i_archive && ref) = delete;
109
111
112 ~i_archive() { free_mem(); };
113
114
116
117 statistics op_extract(const path &fs_root,
118 const archive_options_extract & options,
119 statistics *progressive_report);
120
122
123 void summary();
124
127
128
130
132 void *context,
133 const archive_options_listing & options) const;
134
136
137 statistics op_diff(const path & fs_root,
138 const archive_options_diff & options,
139 statistics * progressive_report);
140
141
143
145 statistics * progressive_report);
146
147
149
150 void op_isolate(const path &sauv_path,
151 const std::string & filename,
152 const std::string & extension,
153 const archive_options_isolate & options);
154
155
157
159 void *context,
160 const std::string & dir,
161 bool fetch_ea = false);
162
164
165 const std::vector<list_entry> get_children_in_table(const std::string & dir, bool fetch_ea = false) const;
166
168 bool has_subdirectory(const std::string & dir) const;
169
171 const entree_stats get_stats() const { if(cat == nullptr) throw SRC_BUG; return cat->get_stats(); };
172
174 const std::list<signator> & get_signatories() const { return gnupg_signed; };
175
178 void init_catalogue() const;
179
181
182 const catalogue & get_catalogue() const;
183
185
187
189 void set_to_unsaved_data_and_FSA() { if(cat == nullptr) throw SRC_BUG; cat->set_to_unsaved_data_and_FSA(); };
190
192
193 bool get_catalogue_slice_layout(slice_layout & slicing) const;
194
196
198
200
202
203
204 private:
205 enum operation { oper_create, oper_isolate, oper_merge, oper_repair };
206
214 std::list<signator> gnupg_signed;
215 slice_layout slices;
216
217 void free_mem();
218 void check_gnupg_signed() const;
219
220 const catalogue & get_cat() const { if(cat == nullptr) throw SRC_BUG; else return *cat; };
221 const header_version & get_header() const { return ver; };
222
223 bool get_sar_param(infinint & sub_file_size, infinint & first_file_size, infinint & last_file_size,
224 infinint & total_file_number);
225 std::shared_ptr<entrepot> get_entrepot();
226 infinint get_level2_size();
227 infinint get_cat_size() const { return local_cat_size; };
228
229 statistics op_create_in(operation op,
230 const path & fs_root,
231 const std::shared_ptr<entrepot> & sauv_path_t,
232 archive *ref_arch,
233 const mask & selection,
234 const mask & subtree,
235 const std::string & filename,
236 const std::string & extension,
237 bool allow_over,
238 bool warn_over,
239 bool info_details,
240 bool display_treated,
241 bool display_treated_only_dir,
242 bool display_skipped,
243 bool display_finished,
244 const infinint & pause,
245 bool empty_dir,
246 compression algo,
247 U_I compression_level,
248 U_I compression_block_size,
249 const infinint & file_size,
250 const infinint & first_file_size,
251 const mask & ea_mask,
252 const std::string & execute,
253 crypto_algo crypto,
254 const secu_string & pass,
255 U_32 crypto_size,
256 const std::vector<std::string> & gnupg_recipients,
257 const std::vector<std::string> & gnupg_signatories,
258 const mask & compr_mask,
259 const infinint & min_compr_size,
260 bool nodump,
261 const std::string & exclude_by_ea,
262 const infinint & hourshift,
263 bool empty,
264 bool alter_atime,
265 bool furtive_read_mode,
266 const filesystem_ids & same_fs,
267 comparison_fields what_to_check,
268 bool snapshot,
269 bool cache_directory_tagging,
270 const infinint & fixed_date,
271 const std::string & slice_permission,
272 const infinint & repeat_count,
273 const infinint & repeat_byte,
274 bool add_marks_for_sequential_reading,
275 bool security_check,
276 const infinint & sparse_file_min_size,
277 const std::string & user_comment,
278 hash_algo hash,
279 const infinint & slice_min_digits,
280 const std::string & backup_hook_file_execute,
281 const mask & backup_hook_file_mask,
282 bool ignore_unknown,
283 const fsa_scope & scope,
284 U_I multi_threaded_crypto,
285 U_I multi_threaded_compress,
286 bool delta_signature,
287 bool build_delta_sig,
288 const mask & delta_mask,
289 const infinint & delta_sig_min_size,
290 bool delta_diff,
291 bool zeroing_neg_date,
292 const std::set<std::string> & ignored_symlinks,
293 modified_data_detection mod_data_detect,
294 const infinint & iteration_count,
295 hash_algo kdf_hash,
296 const delta_sig_block_size & sig_block_len,
297 statistics * progressive_report);
298
299 void op_create_in_sub(operation op,
300 const path & fs_root,
301 const std::shared_ptr<entrepot> & sauv_path_t,
302 catalogue * ref_cat1,
303 const catalogue * ref_cat2,
304 bool initial_pause,
305 const mask & selection,
306 const mask & subtree,
307 const std::string & filename,
308 const std::string & extension,
309 bool allow_over,
310 const crit_action & overwrite,
311 bool warn_over,
312 bool info_details,
313 bool display_treated,
314 bool display_treated_only_dir,
315 bool display_skipped,
316 bool display_finished,
317 const infinint & pause,
318 bool empty_dir,
319 compression algo,
320 U_I compression_level,
321 U_I compression_block_size,
322 const infinint & file_size,
323 const infinint & first_file_size,
324 const mask & ea_mask,
325 const std::string & execute,
326 crypto_algo crypto,
327 const secu_string & pass,
328 U_32 crypto_size,
329 const std::vector<std::string> & gnupg_recipients,
330 const std::vector<std::string> & gnupg_signatories,
331 const mask & compr_mask,
332 const infinint & min_compr_size,
333 bool nodump,
334 const std::string & exclude_by_ea,
335 const infinint & hourshift,
336 bool empty,
337 bool alter_atime,
338 bool furtive_read_mode,
339 const filesystem_ids & same_fs,
340 comparison_fields what_to_check,
341 bool snapshot,
342 bool cache_directory_tagging,
343 bool keep_compressed,
344 const infinint & fixed_date,
345 const std::string & slice_permission,
346 const infinint & repeat_count,
347 const infinint & repeat_byte,
348 bool decremental,
349 bool add_marks_for_sequential_reading,
350 bool security_check,
351 const infinint & sparse_file_min_size,
352 const std::string & user_comment,
353 hash_algo hash,
354 const infinint & slice_min_digits,
355 const std::string & backup_hook_file_execute,
356 const mask & backup_hook_file_mask,
357 bool ignore_unknown,
358 const fsa_scope & scope,
359 U_I multi_threaded_crypto,
360 U_I multi_threaded_compress,
361 bool delta_signature,
362 bool build_delta_sig,
363 const mask & delta_mask,
364 const infinint & delta_sig_min_size,
365 bool delta_diff,
366 bool zeroing_neg_date,
367 const std::set<std::string> & ignored_symlinks,
368 modified_data_detection mod_data_detect,
369 const infinint & iteration_count,
370 hash_algo kdf_hash,
371 const delta_sig_block_size & sign_block_len,
372 statistics * st_ptr
373 );
374
375 void disable_natural_destruction();
376 void enable_natural_destruction();
377 const label & get_layer1_data_name() const;
378 const label & get_catalogue_data_name() const;
380 void check_against_isolation(bool lax) const;
381 const cat_directory *get_dir_object(const std::string & dir) const;
382 void load_catalogue();
383 };
384
385} // end of namespace
386
387#endif
the archive class is defined in this module
definition of the user defined callback function used for archive listing
this file contains a set of classes used to transmit options to archive operation
datastructure returned by archive::summary_data
here is defined the classe used to manage catalogue of archives
the archive::i_archive class implements the most general operations on archives
Definition i_archive.hpp:59
class holding optional parameters used to create an archive
class holding optional parameters used to extract files from an existing archive
class holding optional parameters used to isolate an existing archive
class holding optional parameters used to list the contents of an existing archive
class holding optional parameters used to proceed to the merge operation
class holding optional parameters used to read an existing archive
class holding optional parameters used to create an archive
class holding optional parameters used to test the structure coherence of an existing archive
the archive_summary class provides information about a given archive
the archive class realizes the most general operations on archives
Definition archive.hpp:65
the cat_directory inode class
the catalogue class which gather all objects contained in a give archive
Definition catalogue.hpp:60
the global action for overwriting
manages the archive header and trailer
the arbitrary large positive integer class
manage label data structure used in archive slice headers
Definition label.hpp:43
the generic class, parent of all masks
Definition mask.hpp:62
class mem_ui to keep a copy of a user_interaction object
Definition mem_ui.hpp:55
the class path is here to manipulate paths in the Unix notation: using'/'
Definition path.hpp:51
stores a stack of generic_files writing/reading on each others
Definition pile.hpp:44
class secu_string
class used by libdar::archive class to give a summary of treated file during and after an operation
the crypto algoritm definition
contains all the excetion class thrown by libdar
modified_data_detection
how to detect data has changed when some fields
comparison_fields
how to consider file change during comparison and incremental backup
const catalogue & get_catalogue() const
gives access to internal catalogue (not to be used from the API)
catalogue * cat
archive contents
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)
this constructor builds an archive from two given archive [this is the "merge" constructor]
bool only_contains_an_isolated_catalogue() const
true if the current archive only contains an isolated catalogue
header_version ver
information for the archive header
pile stack
the different layer through which the archive contents is read or wrote
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, statistics *st_ptr)
void(*)(const std::string &the_path, const list_entry &entry, void *context) archive_listing_callback
callback function type expected for archive::op_listing and archive::get_children_of()
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)
this constuctor create an archive (full or differential) [this is the "create" constructor]
bool exploitable
is false if only the catalogue is available (for reference backup or isolation).
statistics op_diff(const path &fs_root, const archive_options_diff &options, statistics *progressive_report)
archive comparison with filesystem
std::set< fsa_family > fsa_scope
set of fsa families
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)
this constructor create a new archive from a damaged one [this is the "repair" constructor]
U_64 get_first_slice_header_size() const
get the first slice header
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)
this constructor opens an already existing archive (for reading) [this is the "read" constructor]
void set_to_unsaved_data_and_FSA()
change all inode as unsaved (equal to differential backup with no change met)
bool sequential_read
whether the archive is read in sequential mode
statistics op_test(const archive_options_test &options, statistics *progressive_report)
test the archive integrity
void op_isolate(const path &sauv_path, const std::string &filename, const std::string &extension, const archive_options_isolate &options)
this methodes isolates the catalogue of a the current archive into a separated archive
const std::list< signator > & get_signatories() const
retrieving signature information about the archive
void op_listing(archive_listing_callback callback, void *context, const archive_options_listing &options) const
listing of the archive contents
void summary()
display a summary of the archive
hash_algo
hashing algorithm available
void drop_all_filedescriptors()
closes all filedescriptors and associated even when in sequential read mode
bool get_catalogue_slice_layout(slice_layout &slicing) const
returns the slice layout of the archive, or of the archive of reference in case of isolated catalogue
const entree_stats get_stats() const
retrieving statistics about archive contents
bool lax_read_mode
whether the archive has been openned in lax mode (unused for creation/merging/isolation)
i_archive(const i_archive &ref)=delete
copy constructor (not implemented, throw an exception if called explicitely or implicitely)
U_64 get_non_first_slice_header_size() const
get the non first slice header
void check_against_isolation(bool lax) const
throw Erange exception if the archive only contains an isolated catalogue
archive_summary summary_data()
same information as summary() but as broken out data
compression
the different compression algorithm available
const std::vector< list_entry > get_children_in_table(const std::string &dir, bool fetch_ea=false) const
getting information about the given directory (alternative to get_children_of)
statistics op_extract(const path &fs_root, const archive_options_extract &options, statistics *progressive_report)
extraction of data from an archive
~i_archive()
the destructor
crypto_algo
the different cypher available for encryption (strong or weak)
Definition crypto.hpp:50
slice_layout slices
slice layout, archive is not sliced <=> first_size or other_size fields are set to zero (in practice ...
std::list< signator > gnupg_signed
list of signature found in the archive (reading an existing archive)
infinint local_cat_size
size of the catalogue on disk
std::shared_ptr< entrepot > get_entrepot()
this method may return nullptr if no entrepot is used (pipes used for archive building,...
bool get_children_of(archive_listing_callback callback, void *context, const std::string &dir, bool fetch_ea=false)
getting information about a given directory
bool has_subdirectory(const std::string &dir) const
returns true if the pointed directory has one or more subdirectories
archive global header/trailer structure is defined here
class of objects describing an entry in the archive, used by archive::get_children_in_table
class mem_ui definition. This class is to be used as parent class to handle user_interaction object m...
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
here is the definition of the path class
class pile definition. Used to manage a stack of generic_file objects
object describing the slicing of an archive
class handling access to the data summary of treated files after and during each operation
defines how to calculate delta signature block size based of file size to delta sign
holds the statistics contents of a catalogue