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

Loading...
Searching...
No Matches
archive_options.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 ARCHIVE_OPTIONS_HPP
27#define ARCHIVE_OPTIONS_HPP
28
29#include "../my_config.h"
30#include "crypto.hpp"
31#include "integers.hpp"
32#include "mask.hpp"
33#include "mask_list.hpp"
34#include "crit_action.hpp"
35#include "secu_string.hpp"
36#include "entrepot.hpp"
37#include "fsa_family.hpp"
38#include "compile_time_features.hpp"
39#include "archive_aux.hpp"
40#include "compression.hpp"
41#include "delta_sig_block_size.hpp"
42#include "filesystem_ids.hpp"
43
44#include <string>
45#include <vector>
46#include <set>
47#include <memory>
48
49 namespace libdar
50{
51 class archive; // needed to be able to use pointer on archive object.
52
53
57
60
61
63
64 class archive_options_read
65 {
66 public:
68 archive_options_read();
69
71 archive_options_read(const archive_options_read & ref) : x_ref_chem(ref.x_ref_chem) { copy_from(ref); };
72 archive_options_read(archive_options_read && ref) noexcept;
73 archive_options_read & operator = (const archive_options_read & ref) { copy_from(ref); return *this; };
74 archive_options_read & operator = (archive_options_read && ref) noexcept { move_from(std::move(ref)); return *this; };
75 ~archive_options_read() = default;
76
77
79 // set back to default (this is the state just after the object is constructed
80 // this method is to be used to reuse a given object
81
83 void clear();
84
85
87 // setting methods
88
89
91
97 void set_crypto_algo(crypto_algo val) { x_crypto = val; };
98
100 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
101
103 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
104
106 void set_default_crypto_size();
107
109
112 void set_input_pipe(const std::string & input_pipe) { x_input_pipe = input_pipe; };
113
115
118 void set_output_pipe(const std::string & output_pipe) { x_output_pipe = output_pipe; };
119
121
131 void set_execute(const std::string & execute) { x_execute = execute; };
132
134 void set_info_details(bool info_details) { x_info_details = info_details; };
135
137
141 void set_lax(bool val) { x_lax = val; };
142
144
146
147 void set_sequential_read(bool val) { x_sequential_read = val; };
148
150
151 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
152
153
155 void set_entrepot(const std::shared_ptr<entrepot> & entr) { if(!entr) throw Erange("archive_options_read::set_entrepot", "null entrepot pointer given in argument"); x_entrepot = entr; };
156
158 void set_ignore_signature_check_failure(bool val) { x_ignore_signature_check_failure = val; };
159
161
164 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
165
167 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
168
170 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
171
172
174
176 void set_external_catalogue(const path & ref_chem, const std::string & ref_basename) { x_ref_chem = ref_chem, x_ref_basename = ref_basename; external_cat = true; };
178 void unset_external_catalogue();
179
181 void set_ref_crypto_algo(crypto_algo ref_crypto) { x_ref_crypto = ref_crypto; };
182
184 void set_ref_crypto_pass(const secu_string & ref_pass) { x_ref_pass = ref_pass; };
185
187 void set_ref_crypto_size(U_32 ref_crypto_size) { x_ref_crypto_size = ref_crypto_size; };
188
190
200 void set_ref_execute(const std::string & ref_execute) { x_ref_execute = ref_execute; };
201
202
204
205 void set_ref_slice_min_digits(infinint val) { x_ref_slice_min_digits = val; };
206
208 void set_ref_entrepot(const std::shared_ptr<entrepot> & entr) { if(!entr) throw Erange("archive_options_read::set_ref_entrepot", "null entrepot pointer given in argument"); x_ref_entrepot = entr; };
209
211 void set_header_only(bool val) { x_header_only = val; };
212
213
214
216 // getting methods (mainly used inside libdar, but kept public and part of the API in the case it is needed)
217
218
219 crypto_algo get_crypto_algo() const { return x_crypto; };
220 const secu_string & get_crypto_pass() const { return x_pass; };
221 U_32 get_crypto_size() const { return x_crypto_size; };
222 const std::string & get_input_pipe() const { return x_input_pipe; };
223 const std::string & get_output_pipe() const { return x_output_pipe; };
224 const std::string & get_execute() const { return x_execute; };
225 bool get_info_details() const { return x_info_details; };
226 bool get_lax() const { return x_lax; };
227 bool get_sequential_read() const { return x_sequential_read; };
228 infinint get_slice_min_digits() const { return x_slice_min_digits; };
229 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
230 bool get_ignore_signature_check_failure() const { return x_ignore_signature_check_failure; };
231 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
232 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
233
234 // All methods that follow concern the archive where to fetch the (isolated) catalogue from
235 bool is_external_catalogue_set() const { return external_cat; };
236 const path & get_ref_path() const;
237 const std::string & get_ref_basename() const;
238 crypto_algo get_ref_crypto_algo() const { return x_ref_crypto; };
239 const secu_string & get_ref_crypto_pass() const { return x_ref_pass; };
240 U_32 get_ref_crypto_size() const { return x_ref_crypto_size; };
241 const std::string & get_ref_execute() const { return x_ref_execute; };
242 infinint get_ref_slice_min_digits() const { return x_ref_slice_min_digits; };
243 const std::shared_ptr<entrepot> & get_ref_entrepot() const { return x_ref_entrepot; };
244 bool get_header_only() const { return x_header_only; };
245
246
247 private:
248 crypto_algo x_crypto;
249 secu_string x_pass;
250 U_32 x_crypto_size;
251 std::string x_input_pipe;
252 std::string x_output_pipe;
253 std::string x_execute;
254 bool x_info_details;
255 bool x_lax;
256 bool x_sequential_read;
257 infinint x_slice_min_digits;
258 std::shared_ptr<entrepot> x_entrepot;
259 bool x_ignore_signature_check_failure;
260 U_I x_multi_threaded_crypto;
261 U_I x_multi_threaded_compress;
262
263
264 // external catalogue relative fields
265 bool external_cat;
266 path x_ref_chem;
267 std::string x_ref_basename;
268 crypto_algo x_ref_crypto;
269 secu_string x_ref_pass;
270 U_32 x_ref_crypto_size;
271 std::string x_ref_execute;
272 infinint x_ref_slice_min_digits;
273 std::shared_ptr<entrepot> x_ref_entrepot;
274 bool x_header_only;
275
276 void copy_from(const archive_options_read & ref);
277 void move_from(archive_options_read && ref) noexcept;
278 };
279
280
284
286
287 class archive_options_create
288 {
289 public:
290 // default constructors and destructor.
291
292 archive_options_create();
293 archive_options_create(const archive_options_create & ref);
294 archive_options_create(archive_options_create && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
295 archive_options_create & operator = (const archive_options_create & ref) { destroy(); copy_from(ref); return *this; };
296 archive_options_create & operator = (archive_options_create && ref) noexcept { move_from(std::move(ref)); return *this; };
297 ~archive_options_create() { destroy(); };
298
300 // set back to default (this is the state just after the object is constructed
301 // this method is to be used to reuse a given object
302
304 void clear();
305
306
308 // setting methods
309
311 void set_reference(std::shared_ptr<archive> ref_arch) { x_ref_arch = ref_arch; };
312
314 void set_selection(const mask & selection);
315
317
325 void set_subtree(const mask & subtree);
326
328 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
329
331 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
332
334
339 void set_info_details(bool info_details) { x_info_details = info_details; };
340
342
345 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
346
348 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
349
351 void set_display_finished(bool display_finished) { x_display_finished = display_finished; };
352
354 void set_pause(const infinint & pause) { x_pause = pause; };
355
357 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
358
360 void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
361
363 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
364
366
375 void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };
376
378
382 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
383 {
384 x_file_size = file_size;
385 if(first_file_size.is_zero())
386 x_first_file_size = file_size;
387 else
388 x_first_file_size = first_file_size;
389 };
390
391
393 void set_ea_mask(const mask & ea_mask);
394
396
406 void set_execute(const std::string & execute) { x_execute = execute; };
407
409 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
410
413 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
414
416 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
417
419
427 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
428
429
433 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
434
436 void set_compr_mask(const mask & compr_mask);
437
439 void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
440
442 void set_nodump(bool nodump) { x_nodump = nodump; };
443
446 void set_exclude_by_ea(const std::string & ea_name)
447 { exclude_by_ea = (ea_name == "" ? "user.libdar_no_backup" : ea_name); };
448
450 void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };
451
453 void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
454
456 void set_empty(bool empty) { x_empty = empty; };
457
459
462 void set_alter_atime(bool alter_atime)
463 {
464 if(x_furtive_read)
465 x_old_alter_atime = alter_atime;
466 else
467 x_alter_atime = alter_atime;
468 };
469
471 void set_furtive_read_mode(bool furtive_read);
472
474
477 void set_same_fs(bool same_fs) { x_same_fs = same_fs; x_same_fs_include.clear(); x_same_fs_exclude.clear(); };
478
480
482 void set_same_fs_include(const std::string & included_path_to_fs) { x_same_fs_include.push_back(included_path_to_fs); };
483
485
487 void set_same_fs_exclude(const std::string & excluded_path_to_fs) { x_same_fs_exclude.push_back(excluded_path_to_fs); };
488
490 void set_snapshot(bool snapshot) { x_snapshot = snapshot; };
491
493 void set_cache_directory_tagging(bool cache_directory_tagging) { x_cache_directory_tagging = cache_directory_tagging; };
494
496 void set_fixed_date(const infinint & fixed_date) { x_fixed_date = fixed_date; };
497
499 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
500
502 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
503
505 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
506
508 void set_retry_on_change(const infinint & count_max_per_file, const infinint & global_max_byte_overhead = 0) { x_repeat_count = count_max_per_file; x_repeat_byte = global_max_byte_overhead; };
509
511 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
512
514 void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
515
517 void set_security_check(bool check) { x_security_check = check; };
518
520 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
521
523
526 void set_hash_algo(hash_algo hash);
527
529 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
530
532 void set_backup_hook(const std::string & execute, const mask & which_files);
533
535 void set_ignore_unknown_inode_type(bool val) { x_ignore_unknown = val; };
536
538 void set_entrepot(const std::shared_ptr<entrepot> & entr) { if(!entr) throw Erange("archive_options_create::set_entrepot", "null entrepot pointer given in argument"); x_entrepot = entr; };
539
541 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
542
544
547 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
548
550 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
551
553 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
554
556
558 void set_delta_diff(bool val) { if(val && !compile_time::librsync()) throw Ecompilation("librsync"); x_delta_diff = val; };
559
561 void set_delta_signature(bool val) { x_delta_signature = val; };
562
564 void set_delta_mask(const mask & delta_mask);
565
567
569 void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };
570
572 void set_auto_zeroing_neg_dates(bool val) { x_auto_zeroing_neg_dates = val; };
573
575
578 void set_ignored_as_symlink(const std::set<std::string> & list) { x_ignored_as_symlink = list; };
579
581
582 void set_modified_data_detection(modified_data_detection val) { x_modified_data_detection = val; };
583
585 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
586
588 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
589
591 void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };
592
593
595 // getting methods
596
597 std::shared_ptr<archive> get_reference() const { return x_ref_arch; };
598 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
599 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
600 bool get_allow_over() const { return x_allow_over; };
601 bool get_warn_over() const { return x_warn_over; };
602 bool get_info_details() const { return x_info_details; };
603 bool get_display_treated() const { return x_display_treated; };
604 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
605 bool get_display_skipped() const { return x_display_skipped; };
606 bool get_display_finished() const { return x_display_finished; };
607 const infinint & get_pause() const { return x_pause; };
608 bool get_empty_dir() const { return x_empty_dir; };
609 compression get_compression() const { return x_compr_algo; };
610 U_I get_compression_level() const { return x_compression_level; };
611 U_I get_compression_block_size() const { return x_compression_block_size; };
612 const infinint & get_slice_size() const { return x_file_size; };
613 const infinint & get_first_slice_size() const { return x_first_file_size; };
614 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
615 const std::string & get_execute() const { return x_execute; };
616 crypto_algo get_crypto_algo() const { return x_crypto; };
617 const secu_string & get_crypto_pass() const { return x_pass; };
618 U_32 get_crypto_size() const { return x_crypto_size; };
619 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
620 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
621 const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
622 const infinint & get_min_compr_size() const { return x_min_compr_size; };
623 bool get_nodump() const { return x_nodump; };
624 const std::string & get_exclude_by_ea() const { return exclude_by_ea; };
625 comparison_fields get_comparison_fields() const { return x_what_to_check; };
626 const infinint & get_hourshift() const { return x_hourshift; };
627 bool get_empty() const { return x_empty; };
628 bool get_alter_atime() const { return x_alter_atime; };
629 bool get_furtive_read_mode() const { return x_furtive_read; };
630 bool get_same_fs() const { return x_same_fs; };
631 std::deque<std::string> get_same_fs_include() const { return x_same_fs_include; };
632 std::deque<std::string> get_same_fs_exclude() const { return x_same_fs_exclude; };
633 bool get_snapshot() const { return x_snapshot; };
634 bool get_cache_directory_tagging() const { return x_cache_directory_tagging; };
635 const infinint & get_fixed_date() const { return x_fixed_date; };
636 const std::string & get_slice_permission() const { return x_slice_permission; };
637 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
638 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
639 const infinint & get_repeat_count() const { return x_repeat_count; };
640 const infinint & get_repeat_byte() const { return x_repeat_byte; };
641 bool get_sequential_marks() const { return x_sequential_marks; };
642 infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
643 bool get_security_check() const { return x_security_check; };
644 const std::string & get_user_comment() const { return x_user_comment; };
645 hash_algo get_hash_algo() const { return x_hash; };
646 infinint get_slice_min_digits() const { return x_slice_min_digits; };
647 const std::string & get_backup_hook_file_execute() const { return x_backup_hook_file_execute; };
648 const mask & get_backup_hook_file_mask() const { return *x_backup_hook_file_mask; };
649 bool get_ignore_unknown_inode_type() const { return x_ignore_unknown; };
650 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
651 const fsa_scope & get_fsa_scope() const { return x_scope; };
652 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
653 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
654 bool get_delta_diff() const { return x_delta_diff; };
655 bool get_delta_signature() const { return x_delta_signature; };
656 const mask & get_delta_mask() const { return *x_delta_mask; }
657 bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };
658 const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };
659 bool get_auto_zeroing_neg_dates() const { return x_auto_zeroing_neg_dates; };
660 const std::set<std::string> & get_ignored_as_symlink() const { return x_ignored_as_symlink; };
661 modified_data_detection get_modified_data_detection() const { return x_modified_data_detection; };
662 const infinint & get_iteration_count() const { return x_iteration_count; };
663 hash_algo get_kdf_hash() const { return x_kdf_hash; };
664 delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };
665
666 private:
667 std::shared_ptr<archive> x_ref_arch;
668 mask * x_selection;
669 mask * x_subtree;
670 bool x_allow_over;
671 bool x_warn_over;
672 bool x_info_details;
673 bool x_display_treated;
674 bool x_display_treated_only_dir;
675 bool x_display_skipped;
676 bool x_display_finished;
677 infinint x_pause;
678 bool x_empty_dir;
679 compression x_compr_algo;
680 U_I x_compression_level;
681 U_I x_compression_block_size;
682 infinint x_file_size;
683 infinint x_first_file_size;
684 mask * x_ea_mask;
685 std::string x_execute;
686 crypto_algo x_crypto;
687 secu_string x_pass;
688 U_32 x_crypto_size;
689 std::vector<std::string> x_gnupg_recipients;
690 std::vector<std::string> x_gnupg_signatories;
691 mask * x_compr_mask;
692 infinint x_min_compr_size;
693 bool x_nodump;
694 std::string exclude_by_ea;
695 comparison_fields x_what_to_check;
696 infinint x_hourshift;
697 bool x_empty;
698 bool x_alter_atime;
699 bool x_old_alter_atime;
700 bool x_furtive_read;
701 bool x_same_fs;
702 std::deque<std::string> x_same_fs_include;
703 std::deque<std::string> x_same_fs_exclude;
704 bool x_snapshot;
705 bool x_cache_directory_tagging;
706 infinint x_fixed_date;
707 std::string x_slice_permission;
708 std::string x_slice_user_ownership;
709 std::string x_slice_group_ownership;
710 infinint x_repeat_count;
711 infinint x_repeat_byte;
712 bool x_sequential_marks;
713 infinint x_sparse_file_min_size;
714 bool x_security_check;
715 std::string x_user_comment;
716 hash_algo x_hash;
717 infinint x_slice_min_digits;
718 mask * x_backup_hook_file_mask;
719 std::string x_backup_hook_file_execute;
720 bool x_ignore_unknown;
721 std::shared_ptr<entrepot> x_entrepot;
722 fsa_scope x_scope;
723 U_I x_multi_threaded_crypto;
724 U_I x_multi_threaded_compress;
725 bool x_delta_diff;
726 bool x_delta_signature;
727 mask *x_delta_mask;
728 bool has_delta_mask_been_set;
729 infinint x_delta_sig_min_size;
730 bool x_auto_zeroing_neg_dates;
731 std::set<std::string> x_ignored_as_symlink;
732 modified_data_detection x_modified_data_detection;
733 infinint x_iteration_count;
734 hash_algo x_kdf_hash;
735 delta_sig_block_size x_sig_block_len;
736
737 void nullifyptr() noexcept;
738 void destroy() noexcept;
739 void copy_from(const archive_options_create & ref);
740 void move_from(archive_options_create && ref) noexcept;
741 void destroy_mask(mask * & ptr);
742 void clean_mask(mask * & ptr);
743 void check_mask(const mask & m);
744 };
745
746
747
748
749
750
754
756
757 class archive_options_isolate
758 {
759 public:
760 archive_options_isolate();
761 archive_options_isolate(const archive_options_isolate & ref);
762 archive_options_isolate(archive_options_isolate && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
763 archive_options_isolate & operator = (const archive_options_isolate & ref) { destroy(); copy_from(ref); return *this; };
764 archive_options_isolate & operator = (archive_options_isolate && ref) noexcept { move_from(std::move(ref)); return *this; };
765 ~archive_options_isolate() { destroy(); };
766
767
768 void clear();
769
771 // setting methods
772
774 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
775
777 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
778
780 void set_info_details(bool info_details) { x_info_details = info_details; };
781
783 void set_pause(const infinint & pause) { x_pause = pause; };
784
786 void set_compression(compression algo) { x_algo = algo; };
787
789 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
790
792
793 void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };
794
796
800 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
801 {
802 x_file_size = file_size;
803 if(first_file_size.is_zero())
804 x_first_file_size = file_size;
805 else
806 x_first_file_size = first_file_size;
807 };
808
810
820 void set_execute(const std::string & execute) { x_execute = execute; };
821
823 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
824
826 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
827
829 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
830
835 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
836
840 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
841
843 void set_empty(bool empty) { x_empty = empty; };
844
846 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
847
849 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
850
852 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
853
855 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
856
858 void set_hash_algo(hash_algo hash);
859
861 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
862
864 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
865
867 void set_entrepot(const std::shared_ptr<entrepot> & entr) { if(!entr) throw Erange("archive_options_isolated::set_entrepot", "null entrepot pointer given in argument"); x_entrepot = entr; };
868
870
873 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
874
876 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
877
879 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
880
881
883 void set_delta_signature(bool val) { x_delta_signature = val; };
884
886 void set_delta_mask(const mask & delta_mask);
887
891 void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };
892
894 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
895
897 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
898
900 void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };
901
903 // getting methods
904
905 bool get_allow_over() const { return x_allow_over; };
906 bool get_warn_over() const { return x_warn_over; };
907 bool get_info_details() const { return x_info_details; };
908 const infinint & get_pause() const { return x_pause; };
909 compression get_compression() const { return x_algo; };
910 U_I get_compression_level() const { return x_compression_level; };
911 U_I get_compression_block_size() const { return x_compression_block_size; };
912 const infinint & get_slice_size() const { return x_file_size; };
913 const infinint & get_first_slice_size() const { return x_first_file_size; };
914 const std::string & get_execute() const { return x_execute; };
915 crypto_algo get_crypto_algo() const { return x_crypto; };
916 const secu_string & get_crypto_pass() const { return x_pass; };
917 U_32 get_crypto_size() const { return x_crypto_size; };
918 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
919 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
920 bool get_empty() const { return x_empty; };
921 const std::string & get_slice_permission() const { return x_slice_permission; };
922 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
923 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
924 const std::string & get_user_comment() const { return x_user_comment; };
925 hash_algo get_hash_algo() const { return x_hash; };
926 infinint get_slice_min_digits() const { return x_slice_min_digits; };
927 bool get_sequential_marks() const { return x_sequential_marks; };
928 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
929 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
930 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
931 bool get_delta_signature() const { return x_delta_signature; };
932 const mask & get_delta_mask() const { return *x_delta_mask; }
933 bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };
934 const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };
935 const infinint & get_iteration_count() const { return x_iteration_count; };
936 hash_algo get_kdf_hash() const { return x_kdf_hash; };
937 delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };
938
939
940 private:
941 bool x_allow_over;
942 bool x_warn_over;
943 bool x_info_details;
944 infinint x_pause;
945 compression x_algo;
946 U_I x_compression_level;
947 U_I x_compression_block_size;
948 infinint x_file_size;
949 infinint x_first_file_size;
950 std::string x_execute;
951 crypto_algo x_crypto;
952 secu_string x_pass;
953 U_32 x_crypto_size;
954 std::vector<std::string> x_gnupg_recipients;
955 std::vector<std::string> x_gnupg_signatories;
956 bool x_empty;
957 std::string x_slice_permission;
958 std::string x_slice_user_ownership;
959 std::string x_slice_group_ownership;
960 std::string x_user_comment;
961 hash_algo x_hash;
962 infinint x_slice_min_digits;
963 bool x_sequential_marks;
964 std::shared_ptr<entrepot> x_entrepot;
965 U_I x_multi_threaded_crypto;
966 U_I x_multi_threaded_compress;
967 bool x_delta_signature;
968 mask *x_delta_mask;
969 bool has_delta_mask_been_set;
970 infinint x_delta_sig_min_size;
971 infinint x_iteration_count;
972 hash_algo x_kdf_hash;
973 delta_sig_block_size x_sig_block_len;
974
975 void copy_from(const archive_options_isolate & ref);
976 void move_from(archive_options_isolate && ref) noexcept;
977 void destroy() noexcept;
978 void nullifyptr() noexcept;
979 };
980
981
982
986
988 class archive_options_merge
989 {
990 public:
991
992 archive_options_merge() { nullifyptr(); clear(); };
993 archive_options_merge(const archive_options_merge & ref) { copy_from(ref); };
994 archive_options_merge(archive_options_merge && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
995 archive_options_merge & operator = (const archive_options_merge & ref) { destroy(); copy_from(ref); return *this; };
996 archive_options_merge & operator = (archive_options_merge && ref) noexcept { move_from(std::move(ref)); return *this; };
997 ~archive_options_merge() { destroy(); };
998
999 void clear();
1000
1002 // setting methods
1003
1004 void set_auxiliary_ref(std::shared_ptr<archive> ref) { x_ref = ref; };
1005
1007 void set_selection(const mask & selection);
1008
1010
1020 void set_subtree(const mask & subtree);
1021
1023 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
1024
1026 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1027
1029 void set_overwriting_rules(const crit_action & overwrite);
1030
1032
1037 void set_info_details(bool info_details) { x_info_details = info_details; };
1038
1040
1043 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1044
1046 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1047
1049 void set_pause(const infinint & pause) { x_pause = pause; };
1050
1052 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
1053
1055 void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
1056
1058 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
1059
1061 void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };
1062
1064
1068 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
1069 {
1070 x_file_size = file_size;
1071 if(first_file_size.is_zero())
1072 x_first_file_size = file_size;
1073 else
1074 x_first_file_size = first_file_size;
1075 };
1076
1078 void set_ea_mask(const mask & ea_mask);
1079
1081
1091 void set_execute(const std::string & execute) { x_execute = execute; };
1092
1094 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
1095
1098 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
1099
1101 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
1102
1107 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
1108
1112 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
1113
1115 void set_compr_mask(const mask & compr_mask);
1116
1118 void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
1119
1121 void set_empty(bool empty) { x_empty = empty; };
1122
1124 void set_keep_compressed(bool keep_compressed) { x_keep_compressed = keep_compressed; };
1125
1127 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
1128
1130 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
1131
1133 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
1134
1136 void set_decremental_mode(bool mode) { x_decremental = mode; };
1137
1139 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
1140
1142 void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
1143
1145 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
1146
1148 void set_hash_algo(hash_algo hash);
1149
1151 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
1152
1154 void set_entrepot(const std::shared_ptr<entrepot> & entr) { if(!entr) throw Erange("archive_options_merge::set_entrepot", "null entrepot pointer given in argument"); x_entrepot = entr; };
1155
1157 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1158
1160
1163 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
1164
1166 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
1167
1169 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
1170
1176 void set_delta_signature(bool val) { x_delta_signature = val; };
1177
1179 void set_delta_mask(const mask & delta_mask);
1180
1182
1184 void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };
1185
1187 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
1188
1190 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
1191
1193 void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };
1194
1195
1197 // getting methods
1198
1199 std::shared_ptr<archive> get_auxiliary_ref() const { return x_ref; };
1200 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1201 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1202 bool get_allow_over() const { return x_allow_over; };
1203 bool get_warn_over() const { return x_warn_over; };
1204 const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
1205 bool get_info_details() const { return x_info_details; };
1206 bool get_display_treated() const { return x_display_treated; };
1207 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1208 bool get_display_skipped() const { return x_display_skipped; };
1209 const infinint & get_pause() const { return x_pause; };
1210 bool get_empty_dir() const { return x_empty_dir; };
1211 compression get_compression() const { return x_compr_algo; };
1212 U_I get_compression_level() const { return x_compression_level; };
1213 U_I get_compression_block_size() const { return x_compression_block_size; };
1214 const infinint & get_slice_size() const { return x_file_size; };
1215 const infinint & get_first_slice_size() const { return x_first_file_size; };
1216 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1217 const std::string & get_execute() const { return x_execute; };
1218 crypto_algo get_crypto_algo() const { return x_crypto; };
1219 const secu_string & get_crypto_pass() const { return x_pass; };
1220 U_32 get_crypto_size() const { return x_crypto_size; };
1221 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
1222 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
1223 const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
1224 const infinint & get_min_compr_size() const { return x_min_compr_size; };
1225 bool get_empty() const { return x_empty; };
1226 bool get_keep_compressed() const { return x_keep_compressed; };
1227 const std::string & get_slice_permission() const { return x_slice_permission; };
1228 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
1229 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
1230 bool get_decremental_mode() const { return x_decremental; };
1231 bool get_sequential_marks() const { return x_sequential_marks; };
1232 infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
1233 const std::string & get_user_comment() const { return x_user_comment; };
1234 hash_algo get_hash_algo() const { return x_hash; };
1235 infinint get_slice_min_digits() const { return x_slice_min_digits; };
1236 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
1237 const fsa_scope & get_fsa_scope() const { return x_scope; };
1238 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
1239 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
1240 bool get_delta_signature() const { return x_delta_signature; };
1241 const mask & get_delta_mask() const { return *x_delta_mask; }
1242 bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };
1243 const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };
1244 const infinint & get_iteration_count() const { return x_iteration_count; };
1245 hash_algo get_kdf_hash() const { return x_kdf_hash; };
1246 delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };
1247
1248
1249 private:
1250 std::shared_ptr<archive> x_ref;
1251 mask * x_selection;
1252 mask * x_subtree;
1253 bool x_allow_over;
1254 bool x_warn_over;
1255 crit_action * x_overwrite;
1256 bool x_info_details;
1257 bool x_display_treated;
1258 bool x_display_treated_only_dir;
1259 bool x_display_skipped;
1260 infinint x_pause;
1261 bool x_empty_dir;
1262 compression x_compr_algo;
1263 U_I x_compression_level;
1264 U_I x_compression_block_size;
1265 infinint x_file_size;
1266 infinint x_first_file_size;
1267 mask * x_ea_mask;
1268 std::string x_execute;
1269 crypto_algo x_crypto;
1270 secu_string x_pass;
1271 U_32 x_crypto_size;
1272 std::vector<std::string> x_gnupg_recipients;
1273 std::vector<std::string> x_gnupg_signatories;
1274 mask * x_compr_mask;
1275 infinint x_min_compr_size;
1276 bool x_empty;
1277 bool x_keep_compressed;
1278 std::string x_slice_permission;
1279 std::string x_slice_user_ownership;
1280 std::string x_slice_group_ownership;
1281 bool x_decremental;
1282 bool x_sequential_marks;
1283 infinint x_sparse_file_min_size;
1284 std::string x_user_comment;
1285 hash_algo x_hash;
1286 infinint x_slice_min_digits;
1287 std::shared_ptr<entrepot> x_entrepot;
1288 fsa_scope x_scope;
1289 U_I x_multi_threaded_crypto;
1290 U_I x_multi_threaded_compress;
1291 bool x_delta_signature;
1292 mask *x_delta_mask;
1293 bool has_delta_mask_been_set;
1294 infinint x_delta_sig_min_size;
1295 infinint x_iteration_count;
1296 hash_algo x_kdf_hash;
1297 delta_sig_block_size x_sig_block_len;
1298
1299 void destroy() noexcept;
1300 void copy_from(const archive_options_merge & ref);
1301 void move_from(archive_options_merge && ref) noexcept;
1302 void nullifyptr() noexcept;
1303 };
1304
1305
1309
1311 class archive_options_extract
1312 {
1313 public:
1314 enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };
1315
1316 archive_options_extract() { nullifyptr(); clear(); };
1317 archive_options_extract(const archive_options_extract & ref) { copy_from(ref); };
1318 archive_options_extract(archive_options_extract && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1319 archive_options_extract & operator = (const archive_options_extract & ref) { destroy(); copy_from(ref); return *this; };
1320 archive_options_extract & operator = (archive_options_extract && ref) noexcept { move_from(std::move(ref)); return *this; };
1321 ~archive_options_extract() { destroy(); };
1322
1323 void clear();
1324
1326 // setting methods
1327
1329 void set_selection(const mask & selection);
1330
1332
1342 void set_subtree(const mask & subtree);
1343
1345 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1346
1353 void set_info_details(bool info_details) { x_info_details = info_details; };
1354
1358 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1359
1361 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1362
1364 void set_ea_mask(const mask & ea_mask);
1365
1367 void set_flat(bool flat) { x_flat = flat; };
1368
1370 void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1371
1373 void set_warn_remove_no_match(bool warn_remove_no_match) { x_warn_remove_no_match = warn_remove_no_match; };
1374
1376 void set_empty(bool empty) { x_empty = empty; };
1377
1379 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
1380
1382
1385 void set_dirty_behavior(bool ignore, bool warn) { x_dirty = ignore ? dirty_ignore : (warn ? dirty_warn : dirty_ok); };
1386
1388 void set_dirty_behavior(t_dirty val) { x_dirty = val; };
1389
1391 void set_overwriting_rules(const crit_action & over);
1392
1394
1396 void set_only_deleted(bool val) { x_only_deleted = val; };
1397
1398
1400
1402 void set_ignore_deleted(bool val) { x_ignore_deleted = val; };
1403
1405 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1406
1408 void set_ignore_unix_sockets(bool val) { x_ignore_unix_sockets = val; };
1409
1411 void set_in_place(bool arg) { x_in_place = arg; };
1412
1413
1415 // getting methods
1416
1417 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1418 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1419 bool get_warn_over() const { return x_warn_over; };
1420 bool get_info_details() const { return x_info_details; };
1421 bool get_display_treated() const { return x_display_treated; };
1422 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1423 bool get_display_skipped() const { return x_display_skipped; };
1424 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1425 bool get_flat() const { return x_flat; };
1426 comparison_fields get_what_to_check() const { return x_what_to_check; };
1427 bool get_warn_remove_no_match() const { return x_warn_remove_no_match; };
1428 bool get_empty() const { return x_empty; };
1429 bool get_empty_dir() const { return x_empty_dir; };
1430 t_dirty get_dirty_behavior() const { return x_dirty; }
1431 const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
1432 bool get_only_deleted() const { return x_only_deleted; };
1433 bool get_ignore_deleted() const { return x_ignore_deleted; };
1434 const fsa_scope & get_fsa_scope() const { return x_scope; };
1435 bool get_ignore_unix_sockets() const { return x_ignore_unix_sockets; };
1436 bool get_in_place() const { return x_in_place; };
1437
1438 private:
1439 mask * x_selection;
1440 mask * x_subtree;
1441 bool x_warn_over;
1442 bool x_info_details;
1443 bool x_display_treated;
1444 bool x_display_treated_only_dir;
1445 bool x_display_skipped;
1446 mask * x_ea_mask;
1447 bool x_flat;
1448 comparison_fields x_what_to_check;
1449 bool x_warn_remove_no_match;
1450 bool x_empty;
1451 bool x_empty_dir;
1452 t_dirty x_dirty;
1453 crit_action *x_overwrite;
1454 bool x_only_deleted;
1455 bool x_ignore_deleted;
1456 fsa_scope x_scope;
1457 bool x_ignore_unix_sockets;
1458 bool x_in_place;
1459
1460 void destroy() noexcept;
1461 void nullifyptr() noexcept;
1462 void copy_from(const archive_options_extract & ref);
1463 void move_from(archive_options_extract && ref) noexcept;
1464 };
1465
1466
1467
1468
1472
1474 class archive_options_listing
1475 {
1476 public:
1477 archive_options_listing() { nullifyptr(); clear(); };
1478 archive_options_listing(const archive_options_listing & ref) { copy_from(ref); };
1479 archive_options_listing(archive_options_listing && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1480 archive_options_listing & operator = (const archive_options_listing & ref) { destroy(); copy_from(ref); return *this; };
1481 archive_options_listing & operator = (archive_options_listing && ref) noexcept { move_from(std::move(ref)); return *this; };
1482 virtual ~archive_options_listing() { destroy(); };
1483
1484 virtual void clear();
1485
1486
1488 // setting methods
1489
1491 void set_info_details(bool info_details) { x_info_details = info_details; };
1492
1494
1496 void set_selection(const mask & selection);
1497
1499
1509 void set_subtree(const mask & subtree);
1510
1512 void set_filter_unsaved(bool filter_unsaved) { x_filter_unsaved = filter_unsaved; };
1513
1515 void set_slicing_location(bool val) { x_slicing_location = val; };
1516
1518
1522 void set_user_slicing(const infinint & slicing_first, const infinint & slicing_others);
1523
1525
1527 void set_display_ea(bool display_ea) { x_display_ea = display_ea; };
1528
1529
1531 // getting methods
1532
1533 bool get_info_details() const { return x_info_details; };
1534 const mask & get_selection() const;
1535 const mask & get_subtree() const;
1536 bool get_filter_unsaved() const { return x_filter_unsaved; };
1537 bool get_user_slicing(infinint & slicing_first, infinint & slicing_others) const;
1538 bool get_slicing_location() const { return x_slicing_location; };
1539 bool get_display_ea() const { return x_display_ea; };
1540
1541 private:
1542 bool x_info_details;
1543 mask * x_selection;
1544 mask * x_subtree;
1545 bool x_filter_unsaved;
1546 infinint *x_slicing_first;
1547 infinint *x_slicing_others;
1548 bool x_slicing_location;
1549 bool x_display_ea;
1550
1551 void destroy() noexcept;
1552 void nullifyptr() noexcept;
1553 void copy_from(const archive_options_listing & ref);
1554 void move_from(archive_options_listing && ref) noexcept;
1555 };
1556
1560
1561
1562 class archive_options_diff
1563 {
1564 public:
1565 archive_options_diff() { nullifyptr(); clear(); };
1566 archive_options_diff(const archive_options_diff & ref) { copy_from(ref); };
1567 archive_options_diff(archive_options_diff && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1568 archive_options_diff & operator = (const archive_options_diff & ref) { destroy(); copy_from(ref); return *this; };
1569 archive_options_diff & operator = (archive_options_diff && ref) noexcept { move_from(std::move(ref)); return *this; };
1570 ~archive_options_diff() { destroy(); };
1571
1572 void clear();
1573
1575 // setting methods
1576
1578 void set_selection(const mask & selection);
1579
1581
1591 void set_subtree(const mask & subtree);
1592
1599 void set_info_details(bool info_details) { x_info_details = info_details; };
1600
1604 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1605
1607 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1608
1610 void set_ea_mask(const mask & ea_mask);
1611
1613 void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1614
1616
1619 void set_alter_atime(bool alter_atime)
1620 {
1621 if(x_furtive_read)
1622 x_old_alter_atime = alter_atime;
1623 else
1624 x_alter_atime = alter_atime;
1625 };
1626
1628 void set_furtive_read_mode(bool furtive_read);
1629
1631 void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
1632
1634 void set_compare_symlink_date(bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };
1635
1637 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1638
1640 void set_in_place(bool arg) { x_in_place = arg; };
1641
1642
1644 // getting methods
1645
1646 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1647 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1648 bool get_info_details() const { return x_info_details; };
1649 bool get_display_treated() const { return x_display_treated; };
1650 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1651 bool get_display_skipped() const { return x_display_skipped; };
1652 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1653 comparison_fields get_what_to_check() const { return x_what_to_check; };
1654 bool get_alter_atime() const { return x_alter_atime; };
1655 bool get_furtive_read_mode() const { return x_furtive_read; };
1656 const infinint & get_hourshift() const { return x_hourshift; };
1657 bool get_compare_symlink_date() const { return x_compare_symlink_date; };
1658 const fsa_scope & get_fsa_scope() const { return x_scope; };
1659 bool get_in_place() const { return x_in_place; };
1660
1661 private:
1662 mask * x_selection;
1663 mask * x_subtree;
1664 bool x_info_details;
1665 bool x_display_treated;
1666 bool x_display_treated_only_dir;
1667 bool x_display_skipped;
1668 mask * x_ea_mask;
1669 comparison_fields x_what_to_check;
1670 bool x_alter_atime;
1671 bool x_old_alter_atime;
1672 bool x_furtive_read;
1673 infinint x_hourshift;
1674 bool x_compare_symlink_date;
1675 fsa_scope x_scope;
1676 bool x_in_place;
1677
1678 void destroy() noexcept;
1679 void nullifyptr() noexcept;
1680 void copy_from(const archive_options_diff & ref);
1681 void move_from(archive_options_diff && ref) noexcept;
1682 };
1683
1684
1685
1686
1690
1692 class archive_options_test
1693 {
1694 public:
1695 archive_options_test() { nullifyptr(); clear(); };
1696 archive_options_test(const archive_options_test & ref) { copy_from(ref); };
1697 archive_options_test(archive_options_test && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1698 archive_options_test & operator = (const archive_options_test & ref) { destroy(); copy_from(ref); return *this; };
1699 archive_options_test & operator = (archive_options_test && ref) noexcept { move_from(std::move(ref)); return *this; };
1700 ~archive_options_test() { destroy(); };
1701
1702 void clear();
1703
1705 // setting methods
1706
1708 void set_selection(const mask & selection);
1709
1711
1721 void set_subtree(const mask & subtree);
1722
1729 void set_info_details(bool info_details) { x_info_details = info_details; };
1730
1732 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1733
1737 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1738
1740 void set_empty(bool empty) { x_empty = empty; };
1741
1742
1744 // getting methods
1745
1746 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1747 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1748 bool get_info_details() const { return x_info_details; };
1749 bool get_display_treated() const { return x_display_treated; };
1750 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1751 bool get_display_skipped() const { return x_display_skipped; };
1752 bool get_empty() const { return x_empty; };
1753
1754 private:
1755 mask * x_selection;
1756 mask * x_subtree;
1757 bool x_info_details;
1758 bool x_display_treated;
1759 bool x_display_treated_only_dir;
1760 bool x_display_skipped;
1761 bool x_empty;
1762
1763 void destroy() noexcept;
1764 void nullifyptr() noexcept;
1765 void copy_from(const archive_options_test & ref);
1766 void move_from(archive_options_test && ref) noexcept;
1767 };
1768
1769
1773
1775 class archive_options_repair
1776 {
1777 public:
1778 // default constructors and destructor.
1779
1780 archive_options_repair();
1781 archive_options_repair(const archive_options_repair & ref);
1782 archive_options_repair(archive_options_repair && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1783 archive_options_repair & operator = (const archive_options_repair & ref) { copy_from(ref); return *this; };
1784 archive_options_repair & operator = (archive_options_repair && ref) noexcept { move_from(std::move(ref)); return *this; };
1785 ~archive_options_repair() = default;
1786
1788 // set back to default (this is the state just after the object is constructed
1789 // this method is to be used to reuse a given object
1790
1792 void clear();
1793
1794
1796 // setting methods
1797
1799 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
1800
1802 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1803
1810 void set_info_details(bool info_details) { x_info_details = info_details; };
1811
1816 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1817
1819 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1820
1822 void set_display_finished(bool display_finished) { x_display_finished = display_finished; };
1823
1825 void set_pause(const infinint & pause) { x_pause = pause; };
1826
1828
1832 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
1833 {
1834 x_file_size = file_size;
1835 if(first_file_size.is_zero())
1836 x_first_file_size = file_size;
1837 else
1838 x_first_file_size = first_file_size;
1839 };
1840
1842
1852 void set_execute(const std::string & execute) { x_execute = execute; };
1853
1855 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
1856
1859 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
1860
1862 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
1863
1872 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
1873
1877 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
1878
1880 void set_empty(bool empty) { x_empty = empty; };
1881
1883 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
1884
1886 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
1887
1889 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
1890
1892 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
1893
1897 void set_hash_algo(hash_algo hash);
1898
1900 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
1901
1903 void set_entrepot(const std::shared_ptr<entrepot> & entr) { if(!entr) throw Erange("archive_options_repair::set_entrepot", "null entrepot pointer given in argument"); x_entrepot = entr; };
1904
1906
1909 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
1910
1912 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
1913
1915 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
1916
1918 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
1919
1921 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
1922
1923
1924
1926 // getting methods
1927
1928 bool get_allow_over() const { return x_allow_over; };
1929 bool get_warn_over() const { return x_warn_over; };
1930 bool get_info_details() const { return x_info_details; };
1931 bool get_display_treated() const { return x_display_treated; };
1932 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1933 bool get_display_skipped() const { return x_display_skipped; };
1934 bool get_display_finished() const { return x_display_finished; };
1935 const infinint & get_pause() const { return x_pause; };
1936 const infinint & get_slice_size() const { return x_file_size; };
1937 const infinint & get_first_slice_size() const { return x_first_file_size; };
1938 const std::string & get_execute() const { return x_execute; };
1939 crypto_algo get_crypto_algo() const { return x_crypto; };
1940 const secu_string & get_crypto_pass() const { return x_pass; };
1941 U_32 get_crypto_size() const { return x_crypto_size; };
1942 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
1943 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
1944 bool get_empty() const { return x_empty; };
1945 const std::string & get_slice_permission() const { return x_slice_permission; };
1946 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
1947 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
1948 const std::string & get_user_comment() const { return x_user_comment; };
1949 hash_algo get_hash_algo() const { return x_hash; };
1950 infinint get_slice_min_digits() const { return x_slice_min_digits; };
1951 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
1952 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
1953 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
1954 const infinint & get_iteration_count() const { return x_iteration_count; };
1955 hash_algo get_kdf_hash() const { return x_kdf_hash; };
1956
1957
1958 private:
1959 bool x_allow_over;
1960 bool x_warn_over;
1961 bool x_info_details;
1962 bool x_display_treated;
1963 bool x_display_treated_only_dir;
1964 bool x_display_skipped;
1965 bool x_display_finished;
1966 infinint x_pause;
1967 infinint x_file_size;
1968 infinint x_first_file_size;
1969 std::string x_execute;
1970 crypto_algo x_crypto;
1971 secu_string x_pass;
1972 U_32 x_crypto_size;
1973 std::vector<std::string> x_gnupg_recipients;
1974 std::vector<std::string> x_gnupg_signatories;
1975 bool x_empty;
1976 std::string x_slice_permission;
1977 std::string x_slice_user_ownership;
1978 std::string x_slice_group_ownership;
1979 std::string x_user_comment;
1980 hash_algo x_hash;
1981 infinint x_slice_min_digits;
1982 std::shared_ptr<entrepot> x_entrepot;
1983 U_I x_multi_threaded_crypto;
1984 U_I x_multi_threaded_compress;
1985 infinint x_iteration_count;
1986 hash_algo x_kdf_hash;
1987
1988 void nullifyptr() noexcept {};
1989 void copy_from(const archive_options_repair & ref);
1990 void move_from(archive_options_repair && ref) noexcept;
1991 };
1992
1994
1995} // end of namespace
1996
1997#endif
archive_aux.hpp
set of datastructures used to interact with a catalogue object
libdar::Ecompilation
exception used when a requested fearture has not beed activated at compilation time
Definition erreurs.hpp:366
libdar::Erange
exception used to signal range error
Definition erreurs.hpp:220
libdar::archive_options_create
class holding optional parameters used to create an archive
Definition archive_options.hpp:288
libdar::archive_options_create::clear
void clear()
reset all the options to their default values
libdar::archive_options_create::set_slicing
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
Definition archive_options.hpp:382
libdar::archive_options_create::set_delta_sig_min_size
void set_delta_sig_min_size(const infinint &val)
whether to never calculate delta signature for files which size is smaller or equal to the given argu...
Definition archive_options.hpp:569
libdar::archive_options_create::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
Definition archive_options.hpp:413
libdar::archive_options_create::set_compression_block_size
void set_compression_block_size(U_I compression_block_size)
set the compression block size
Definition archive_options.hpp:375
libdar::archive_options_create::set_auto_zeroing_neg_dates
void set_auto_zeroing_neg_dates(bool val)
whether to automatically zeroing negative dates read from the filesystem (just warn,...
Definition archive_options.hpp:572
libdar::archive_options_create::set_same_fs_include
void set_same_fs_include(const std::string &included_path_to_fs)
files on the filesystem pointed to by the given path will be considered for the backup operation if n...
Definition archive_options.hpp:482
libdar::archive_options_create::set_display_finished
void set_display_finished(bool display_finished)
whether to display a summary for each completed directory with total saved data and compression ratio
Definition archive_options.hpp:351
libdar::archive_options_create::set_allow_over
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
Definition archive_options.hpp:328
libdar::archive_options_create::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
Definition archive_options.hpp:409
libdar::archive_options_create::set_backup_hook
void set_backup_hook(const std::string &execute, const mask &which_files)
defines the backup hook for files
libdar::archive_options_create::set_compression_level
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)
Definition archive_options.hpp:363
libdar::archive_options_create::set_retry_on_change
void set_retry_on_change(const infinint &count_max_per_file, const infinint &global_max_byte_overhead=0)
how much time to retry saving a file if it changed while being read
Definition archive_options.hpp:508
libdar::archive_options_create::set_info_details
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
Definition archive_options.hpp:339
libdar::archive_options_create::set_warn_over
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
Definition archive_options.hpp:331
libdar::archive_options_create::set_execute
void set_execute(const std::string &execute)
set the command to execute after each slice creation
Definition archive_options.hpp:406
libdar::archive_options_create::set_security_check
void set_security_check(bool check)
whether to check for ctime changes since with the archive of reference
Definition archive_options.hpp:517
libdar::archive_options_create::set_min_compr_size
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
Definition archive_options.hpp:439
libdar::archive_options_create::set_fixed_date
void set_fixed_date(const infinint &fixed_date)
whether to ignore any archive of reference and only save file which modification is more recent that ...
Definition archive_options.hpp:496
libdar::archive_options_create::set_delta_signature
void set_delta_signature(bool val)
whether signature to base binary delta on the future has to be calculated and stored beside saved fil...
Definition archive_options.hpp:561
libdar::archive_options_create::set_slice_permission
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
Definition archive_options.hpp:499
libdar::archive_options_create::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
Definition archive_options.hpp:433
libdar::archive_options_create::set_subtree
void set_subtree(const mask &subtree)
defines the directories and files to consider
libdar::archive_options_create::set_modified_data_detection
void set_modified_data_detection(modified_data_detection val)
defines when to resave a file's data which inode metadata changed
Definition archive_options.hpp:582
libdar::archive_options_create::set_furtive_read_mode
void set_furtive_read_mode(bool furtive_read)
whether to use furtive read mode (if activated, alter_atime() has no meaning/use)
libdar::archive_options_create::set_sequential_marks
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive
Definition archive_options.hpp:511
libdar::archive_options_create::x_ref_arch
std::shared_ptr< archive > x_ref_arch
just contains the address of an existing object, no local copy of object is done here
Definition archive_options.hpp:667
libdar::archive_options_create::set_multi_threaded_compress
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
Definition archive_options.hpp:553
libdar::archive_options_create::set_cache_directory_tagging
void set_cache_directory_tagging(bool cache_directory_tagging)
whether to consider the Cache Directory Tagging Standard
Definition archive_options.hpp:493
libdar::archive_options_create::set_compr_mask
void set_compr_mask(const mask &compr_mask)
defines files to compress
libdar::archive_options_create::set_pause
void set_pause(const infinint &pause)
set a pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each sli...
Definition archive_options.hpp:354
libdar::archive_options_create::x_ea_mask
mask * x_ea_mask
points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
Definition archive_options.hpp:684
libdar::archive_options_create::set_slice_min_digits
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
Definition archive_options.hpp:529
libdar::archive_options_create::set_multi_threaded
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
Definition archive_options.hpp:547
libdar::archive_options_create::set_same_fs
void set_same_fs(bool same_fs)
whether to limit the backup to files located on the same filesystem as the directory taken as root of...
Definition archive_options.hpp:477
libdar::archive_options_create::set_iteration_count
void set_iteration_count(const infinint &val)
key derivation
Definition archive_options.hpp:585
libdar::archive_options_create::set_empty_dir
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
Definition archive_options.hpp:357
libdar::archive_options_create::set_delta_mask
void set_delta_mask(const mask &delta_mask)
whether to derogate to defaut delta file consideration while calculation delta signatures
libdar::archive_options_create::set_sparse_file_min_size
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
Definition archive_options.hpp:514
libdar::archive_options_create::x_subtree
mask * x_subtree
points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
Definition archive_options.hpp:669
libdar::archive_options_create::set_delta_diff
void set_delta_diff(bool val)
whether binary delta has to be computed for differential/incremental backup
Definition archive_options.hpp:558
libdar::archive_options_create::set_display_skipped
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
Definition archive_options.hpp:348
libdar::archive_options_create::set_hourshift
void set_hourshift(const infinint &hourshift)
ignore differences of at most this integer number of hours while looking for changes in dates
Definition archive_options.hpp:453
libdar::archive_options_create::x_selection
mask * x_selection
points to a local copy of mask (must be allocated / releases by the archive_option_create object)
Definition archive_options.hpp:668
libdar::archive_options_create::set_crypto_size
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
Definition archive_options.hpp:416
libdar::archive_options_create::set_ea_mask
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
libdar::archive_options_create::set_fsa_scope
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA activated at com...
Definition archive_options.hpp:541
libdar::archive_options_create::set_nodump
void set_nodump(bool nodump)
defines whether to ignore files with the nodump flag set
Definition archive_options.hpp:442
libdar::archive_options_create::set_same_fs_exclude
void set_same_fs_exclude(const std::string &excluded_path_to_fs)
files on the filesystem pointed to by the given path will not be considered for backup operation
Definition archive_options.hpp:487
libdar::archive_options_create::set_ignored_as_symlink
void set_ignored_as_symlink(const std::set< std::string > &list)
provide a list of full path which if are symlinks will be considered as the inode they point to
Definition archive_options.hpp:578
libdar::archive_options_create::set_exclude_by_ea
void set_exclude_by_ea(const std::string &ea_name)
Definition archive_options.hpp:446
libdar::archive_options_create::set_entrepot
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
Definition archive_options.hpp:538
libdar::archive_options_create::set_slice_user_ownership
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
Definition archive_options.hpp:502
libdar::archive_options_create::set_compression
void set_compression(compression compr_algo)
set the compression algorithm to be used
Definition archive_options.hpp:360
libdar::archive_options_create::x_compr_mask
mask * x_compr_mask
points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
Definition archive_options.hpp:691
libdar::archive_options_create::set_ignore_unknown_inode_type
void set_ignore_unknown_inode_type(bool val)
whether to ignore unknown inode types instead of issuing a warning
Definition archive_options.hpp:535
libdar::archive_options_create::set_snapshot
void set_snapshot(bool snapshot)
whether to make an emtpy archive only referencing the current state of files in the filesystem
Definition archive_options.hpp:490
libdar::archive_options_create::set_slice_group_ownership
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
Definition archive_options.hpp:505
libdar::archive_options_create::set_reference
void set_reference(std::shared_ptr< archive > ref_arch)
set the archive to take as reference (nullptr for a full backup)
Definition archive_options.hpp:311
libdar::archive_options_create::set_alter_atime
void set_alter_atime(bool alter_atime)
whether to alter atime or ctime in the filesystem when reading files to save
Definition archive_options.hpp:462
libdar::archive_options_create::x_old_alter_atime
bool x_old_alter_atime
used to backup origina alter_atime value when activating furtive read mode
Definition archive_options.hpp:699
libdar::archive_options_create::set_kdf_hash
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
Definition archive_options.hpp:588
libdar::archive_options_create::set_user_comment
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
Definition archive_options.hpp:520
libdar::archive_options_create::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
defines whether to show treated files
Definition archive_options.hpp:345
libdar::archive_options_create::set_hash_algo
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
libdar::archive_options_create::set_what_to_check
void set_what_to_check(comparison_fields what_to_check)
set the fields to consider when comparing inodes with reference archive (see comparison_fields enumer...
Definition archive_options.hpp:450
libdar::archive_options_create::set_sig_block_len
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
Definition archive_options.hpp:591
libdar::archive_options_create::set_selection
void set_selection(const mask &selection)
defines the filenames to only save (except directory) as those that match the given mask
libdar::archive_options_create::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
set the list of recipients that will be able to read the archive
Definition archive_options.hpp:427
libdar::archive_options_create::set_multi_threaded_crypto
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
Definition archive_options.hpp:550
libdar::archive_options_create::set_empty
void set_empty(bool empty)
whether to make a dry-run operation
Definition archive_options.hpp:456
libdar::archive_options_extract
class holding optional parameters used to extract files from an existing archive
Definition archive_options.hpp:1312
libdar::archive_options_extract::set_ea_mask
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to restore
libdar::archive_options_extract::set_empty_dir
void set_empty_dir(bool empty_dir)
whether to restore directories where no file has been triggered for backup (no file/inode change,...
Definition archive_options.hpp:1379
libdar::archive_options_extract::set_ignore_unix_sockets
void set_ignore_unix_sockets(bool val)
whether to ignore unix sockets while restoring
Definition archive_options.hpp:1408
libdar::archive_options_extract::set_overwriting_rules
void set_overwriting_rules(const crit_action &over)
overwriting policy
libdar::archive_options_extract::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition archive_options.hpp:1358
libdar::archive_options_extract::set_info_details
void set_info_details(bool info_details)
Definition archive_options.hpp:1353
libdar::archive_options_extract::set_flat
void set_flat(bool flat)
whether to ignore directory structure and restore all files in the same directory
Definition archive_options.hpp:1367
libdar::archive_options_extract::set_only_deleted
void set_only_deleted(bool val)
only consider deleted files (if set, no data get restored)
Definition archive_options.hpp:1396
libdar::archive_options_extract::set_dirty_behavior
void set_dirty_behavior(t_dirty val)
alternative method to modify dirty behavior
Definition archive_options.hpp:1388
libdar::archive_options_extract::set_ignore_deleted
void set_ignore_deleted(bool val)
do not consider deleted files (if set, no inode will be removed)
Definition archive_options.hpp:1402
libdar::archive_options_extract::set_subtree
void set_subtree(const mask &subtree)
defines the directories and files to consider
libdar::archive_options_extract::set_in_place
void set_in_place(bool arg)
whether to ignore fs_root and use in-place path stored in the archive
Definition archive_options.hpp:1411
libdar::archive_options_extract::set_warn_remove_no_match
void set_warn_remove_no_match(bool warn_remove_no_match)
whether a warning must be issue if a file to remove does not match the expected type of file
Definition archive_options.hpp:1373
libdar::archive_options_extract::set_display_skipped
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
Definition archive_options.hpp:1361
libdar::archive_options_extract::set_empty
void set_empty(bool empty)
defines whether we need to store ignored directories as empty
Definition archive_options.hpp:1376
libdar::archive_options_extract::set_selection
void set_selection(const mask &selection)
defines the filenames to only save (except directory) as those that match the given mask
libdar::archive_options_extract::set_warn_over
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
Definition archive_options.hpp:1345
libdar::archive_options_extract::set_dirty_behavior
void set_dirty_behavior(bool ignore, bool warn)
whether to restore dirty files (those that changed during backup), warn before restoring or ignoring ...
Definition archive_options.hpp:1385
libdar::archive_options_extract::set_fsa_scope
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA activated at com...
Definition archive_options.hpp:1405
libdar::archive_options_extract::set_what_to_check
void set_what_to_check(comparison_fields what_to_check)
fields to consider when comparing inodes with those on filesystem to determine if it is more recent (...
Definition archive_options.hpp:1370
libdar::archive_options_isolate
class holding optional parameters used to isolate an existing archive
Definition archive_options.hpp:758
libdar::archive_options_isolate::set_crypto_size
void set_crypto_size(U_32 crypto_size)
size of the encryption by block to use
Definition archive_options.hpp:829
libdar::archive_options_isolate::set_multi_threaded_crypto
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
Definition archive_options.hpp:876
libdar::archive_options_isolate::set_warn_over
void set_warn_over(bool warn_over)
whether a warning shall be issued before overwriting
Definition archive_options.hpp:777
libdar::archive_options_isolate::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
Definition archive_options.hpp:835
libdar::archive_options_isolate::set_delta_mask
void set_delta_mask(const mask &delta_mask)
whether to derogate to defaut delta file consideration while calculation delta signatures
libdar::archive_options_isolate::set_delta_signature
void set_delta_signature(bool val)
whether signature to base binary delta on the future has to be calculated and stored beside saved fil...
Definition archive_options.hpp:883
libdar::archive_options_isolate::set_slice_permission
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
Definition archive_options.hpp:846
libdar::archive_options_isolate::set_slicing
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
Definition archive_options.hpp:800
libdar::archive_options_isolate::set_pause
void set_pause(const infinint &pause)
Pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each slice,...
Definition archive_options.hpp:783
libdar::archive_options_isolate::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
cypher to use
Definition archive_options.hpp:823
libdar::archive_options_isolate::set_allow_over
void set_allow_over(bool allow_over)
whether overwritting is allowed
Definition archive_options.hpp:774
libdar::archive_options_isolate::set_sequential_marks
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive
Definition archive_options.hpp:864
libdar::archive_options_isolate::set_entrepot
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
Definition archive_options.hpp:867
libdar::archive_options_isolate::set_sig_block_len
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
Definition archive_options.hpp:900
libdar::archive_options_isolate::set_user_comment
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
Definition archive_options.hpp:855
libdar::archive_options_isolate::set_compression_level
void set_compression_level(U_I compression_level)
the compression level (from 1 to 9)
Definition archive_options.hpp:789
libdar::archive_options_isolate::set_delta_sig_min_size
void set_delta_sig_min_size(const infinint &val)
Definition archive_options.hpp:891
libdar::archive_options_isolate::set_multi_threaded
void set_multi_threaded(bool val)
whether libdar is allowed to created several thread to work possibily faster on multicore CPU (requir...
Definition archive_options.hpp:873
libdar::archive_options_isolate::set_slice_user_ownership
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
Definition archive_options.hpp:849
libdar::archive_options_isolate::set_execute
void set_execute(const std::string &execute)
command to execute after each slice creation
Definition archive_options.hpp:820
libdar::archive_options_isolate::set_hash_algo
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
libdar::archive_options_isolate::set_compression
void set_compression(compression algo)
the compression algorithm used
Definition archive_options.hpp:786
libdar::archive_options_isolate::set_compression_block_size
void set_compression_block_size(U_I compression_block_size)
set the compression block size
Definition archive_options.hpp:793
libdar::archive_options_isolate::set_slice_group_ownership
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
Definition archive_options.hpp:852
libdar::archive_options_isolate::set_multi_threaded_compress
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
Definition archive_options.hpp:879
libdar::archive_options_isolate::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
Definition archive_options.hpp:840
libdar::archive_options_isolate::set_slice_min_digits
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
Definition archive_options.hpp:861
libdar::archive_options_isolate::set_info_details
void set_info_details(bool info_details)
whether the user needs detailed output of the operation
Definition archive_options.hpp:780
libdar::archive_options_isolate::set_kdf_hash
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
Definition archive_options.hpp:897
libdar::archive_options_isolate::set_iteration_count
void set_iteration_count(const infinint &val)
key derivation
Definition archive_options.hpp:894
libdar::archive_options_isolate::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
password / passphrase to encrypt the data with (empty string for interactive question)
Definition archive_options.hpp:826
libdar::archive_options_isolate::set_empty
void set_empty(bool empty)
whether to make a dry-run operation
Definition archive_options.hpp:843
libdar::archive_options_listing
class holding optional parameters used to list the contents of an existing archive
Definition archive_options.hpp:1475
libdar::archive_options_listing::set_subtree
void set_subtree(const mask &subtree)
defines the directories and files to consider
libdar::archive_options_listing::set_display_ea
void set_display_ea(bool display_ea)
whether to fetch EA for listing
Definition archive_options.hpp:1527
libdar::archive_options_listing::set_user_slicing
void set_user_slicing(const infinint &slicing_first, const infinint &slicing_others)
when slice location is performed, user may modify the slice layout of the archive
libdar::archive_options_listing::set_filter_unsaved
void set_filter_unsaved(bool filter_unsaved)
whether to only show entries that have their data fully saved
Definition archive_options.hpp:1512
libdar::archive_options_listing::set_selection
void set_selection(const mask &selection)
mask applied to filename, only those marching it will be listed
libdar::archive_options_listing::set_info_details
void set_info_details(bool info_details)
whether output should be verbosed --> to be moved to shell output
Definition archive_options.hpp:1491
libdar::archive_options_listing::set_slicing_location
void set_slicing_location(bool val)
whether to calculate the slice location of each file
Definition archive_options.hpp:1515
libdar::archive_options_merge
class holding optional parameters used to proceed to the merge operation
Definition archive_options.hpp:989
libdar::archive_options_merge::set_delta_signature
void set_delta_signature(bool val)
Definition archive_options.hpp:1176
libdar::archive_options_merge::set_sequential_marks
void set_sequential_marks(bool sequential)
whether to activate escape sequence aka tape marks to allow sequential reading of the archive
Definition archive_options.hpp:1139
libdar::archive_options_merge::set_display_skipped
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
Definition archive_options.hpp:1046
libdar::archive_options_merge::set_compr_mask
void set_compr_mask(const mask &compr_mask)
defines files to compress
libdar::archive_options_merge::set_sig_block_len
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
Definition archive_options.hpp:1193
libdar::archive_options_merge::set_empty
void set_empty(bool empty)
defines whether we do a dry-run execution
Definition archive_options.hpp:1121
libdar::archive_options_merge::set_ea_mask
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
libdar::archive_options_merge::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
Definition archive_options.hpp:1098
libdar::archive_options_merge::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
defines whether to show treated files
Definition archive_options.hpp:1043
libdar::archive_options_merge::set_multi_threaded_compress
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
Definition archive_options.hpp:1169
libdar::archive_options_merge::set_slice_min_digits
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
Definition archive_options.hpp:1151
libdar::archive_options_merge::set_overwriting_rules
void set_overwriting_rules(const crit_action &overwrite)
policy to solve merging conflict
libdar::archive_options_merge::set_delta_mask
void set_delta_mask(const mask &delta_mask)
whether to derogate to defaut delta file consideration while calculation delta signatures
libdar::archive_options_merge::set_min_compr_size
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
Definition archive_options.hpp:1118
libdar::archive_options_merge::set_iteration_count
void set_iteration_count(const infinint &val)
key derivation
Definition archive_options.hpp:1187
libdar::archive_options_merge::set_compression
void set_compression(compression compr_algo)
set the compression algorithm to be used
Definition archive_options.hpp:1055
libdar::archive_options_merge::set_sparse_file_min_size
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
Definition archive_options.hpp:1142
libdar::archive_options_merge::set_multi_threaded
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
Definition archive_options.hpp:1163
libdar::archive_options_merge::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
Definition archive_options.hpp:1094
libdar::archive_options_merge::set_crypto_size
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
Definition archive_options.hpp:1101
libdar::archive_options_merge::set_keep_compressed
void set_keep_compressed(bool keep_compressed)
make dar ignore the 'algo' argument and do not uncompress / compress files that are selected for merg...
Definition archive_options.hpp:1124
libdar::archive_options_merge::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
Definition archive_options.hpp:1107
libdar::archive_options_merge::set_entrepot
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
Definition archive_options.hpp:1154
libdar::archive_options_merge::set_kdf_hash
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
Definition archive_options.hpp:1190
libdar::archive_options_merge::set_info_details
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
Definition archive_options.hpp:1037
libdar::archive_options_merge::set_multi_threaded_crypto
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
Definition archive_options.hpp:1166
libdar::archive_options_merge::set_decremental_mode
void set_decremental_mode(bool mode)
if set to true use a merging mode suitable to build a decremental backup from two full backups (see N...
Definition archive_options.hpp:1136
libdar::archive_options_merge::set_execute
void set_execute(const std::string &execute)
set the command to execute after each slice creation
Definition archive_options.hpp:1091
libdar::archive_options_merge::set_slicing
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
Definition archive_options.hpp:1068
libdar::archive_options_merge::set_pause
void set_pause(const infinint &pause)
set a pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each sli...
Definition archive_options.hpp:1049
libdar::archive_options_merge::set_empty_dir
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
Definition archive_options.hpp:1052
libdar::archive_options_merge::set_compression_block_size
void set_compression_block_size(U_I compression_block_size)
set the compression block size (0 for streamed compression)
Definition archive_options.hpp:1061
libdar::archive_options_merge::set_allow_over
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
Definition archive_options.hpp:1023
libdar::archive_options_merge::set_delta_sig_min_size
void set_delta_sig_min_size(const infinint &val)
whether to never calculate delta signature for files which size is smaller or equal to the given argu...
Definition archive_options.hpp:1184
libdar::archive_options_merge::set_subtree
void set_subtree(const mask &subtree)
defines the directories and files to consider
libdar::archive_options_merge::set_fsa_scope
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA are considered)
Definition archive_options.hpp:1157
libdar::archive_options_merge::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
Definition archive_options.hpp:1112
libdar::archive_options_merge::set_slice_group_ownership
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
Definition archive_options.hpp:1133
libdar::archive_options_merge::set_hash_algo
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
libdar::archive_options_merge::set_compression_level
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)
Definition archive_options.hpp:1058
libdar::archive_options_merge::set_user_comment
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
Definition archive_options.hpp:1145
libdar::archive_options_merge::set_slice_permission
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
Definition archive_options.hpp:1127
libdar::archive_options_merge::set_warn_over
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
Definition archive_options.hpp:1026
libdar::archive_options_merge::set_slice_user_ownership
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
Definition archive_options.hpp:1130
libdar::archive_options_merge::set_selection
void set_selection(const mask &selection)
defines the filenames to only save (except directory) as those that match the given mask
libdar::archive_options_read
class holding optional parameters used to read an existing archive
Definition archive_options.hpp:65
libdar::archive_options_read::set_input_pipe
void set_input_pipe(const std::string &input_pipe)
set the name of the input pipe to read data from (when basename is set to "-")
Definition archive_options.hpp:112
libdar::archive_options_read::set_entrepot
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use to retrieve slices
Definition archive_options.hpp:155
libdar::archive_options_read::set_crypto_algo
void set_crypto_algo(crypto_algo val)
defines the the crypto cypher to use to read the archive (default is crypto_none)
Definition archive_options.hpp:97
libdar::archive_options_read::set_ref_crypto_size
void set_ref_crypto_size(U_32 ref_crypto_size)
defines the crypto size for the reference catalogue
Definition archive_options.hpp:187
libdar::archive_options_read::set_multi_threaded_compress
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
Definition archive_options.hpp:170
libdar::archive_options_read::set_slice_min_digits
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
Definition archive_options.hpp:151
libdar::archive_options_read::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
defines the password or passphrase to decrypt (unused if encryption is not set)
Definition archive_options.hpp:100
libdar::archive_options_read::archive_options_read
archive_options_read()
build an object and set options to their default values
libdar::archive_options_read::set_multi_threaded
void set_multi_threaded(bool val)
whether libdar is allowed to create several thread to work possibly faster on multicore CPU (need lib...
Definition archive_options.hpp:164
libdar::archive_options_read::set_ref_crypto_pass
void set_ref_crypto_pass(const secu_string &ref_pass)
defines the pass for the reference catalogue
Definition archive_options.hpp:184
libdar::archive_options_read::set_ref_entrepot
void set_ref_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use to retrieve slices of the reference archive (where the external catalogue...
Definition archive_options.hpp:208
libdar::archive_options_read::clear
void clear()
reset all the options to their default values
libdar::archive_options_read::set_ignore_signature_check_failure
void set_ignore_signature_check_failure(bool val)
whether to warn (false) or ignore (true) signature failure (default is false, signature failure is re...
Definition archive_options.hpp:158
libdar::archive_options_read::unset_external_catalogue
void unset_external_catalogue()
clear any reference to an external catalogue
libdar::archive_options_read::set_ref_crypto_algo
void set_ref_crypto_algo(crypto_algo ref_crypto)
defines the crypto algo for the reference catalogue
Definition archive_options.hpp:181
libdar::archive_options_read::set_lax
void set_lax(bool val)
defines whether any archive coherence error, system error or media error lead to the abortion of the ...
Definition archive_options.hpp:141
libdar::archive_options_read::set_info_details
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
Definition archive_options.hpp:134
libdar::archive_options_read::set_header_only
void set_header_only(bool val)
whether we only read the archive header and exit
Definition archive_options.hpp:211
libdar::archive_options_read::set_ref_slice_min_digits
void set_ref_slice_min_digits(infinint val)
defines the minim digit for slice number of the archive of reference (where the external catalogue is...
Definition archive_options.hpp:205
libdar::archive_options_read::set_ref_execute
void set_ref_execute(const std::string &ref_execute)
set the command to execute before reading each slice of the reference catalogue
Definition archive_options.hpp:200
libdar::archive_options_read::set_output_pipe
void set_output_pipe(const std::string &output_pipe)
set the name of the output pipe to send orders to (when basenale is set to "-")
Definition archive_options.hpp:118
libdar::archive_options_read::set_execute
void set_execute(const std::string &execute)
set the command to execute before reading each slice (empty string for no script)
Definition archive_options.hpp:131
libdar::archive_options_read::set_default_crypto_size
void set_default_crypto_size()
set the encryption block size to the default value
libdar::archive_options_read::set_sequential_read
void set_sequential_read(bool val)
defines whether to try reading the archive sequentially (ala tar) or using the final catalogue
Definition archive_options.hpp:147
libdar::archive_options_read::set_crypto_size
void set_crypto_size(U_32 crypto_size)
the encryption block size to use to decrypt
Definition archive_options.hpp:103
libdar::archive_options_read::set_multi_threaded_crypto
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
Definition archive_options.hpp:167
libdar::archive_options_read::archive_options_read
archive_options_read(const archive_options_read &ref)
the copy constructor, assignment operator and destructor
Definition archive_options.hpp:71
libdar::archive_options_read::set_external_catalogue
void set_external_catalogue(const path &ref_chem, const std::string &ref_basename)
defines whether or not to use the catalogue from an extracted catalogue (instead of the one embedded ...
Definition archive_options.hpp:176
libdar::archive_options_repair
class holding optional parameters used to create an archive
Definition archive_options.hpp:1776
libdar::archive_options_repair::set_display_finished
void set_display_finished(bool display_finished)
whether to display a summary for each completed directory with total saved data and compression ratio
Definition archive_options.hpp:1822
libdar::archive_options_repair::set_allow_over
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
Definition archive_options.hpp:1799
libdar::archive_options_repair::set_multi_threaded_compress
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
Definition archive_options.hpp:1915
libdar::archive_options_repair::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
Definition archive_options.hpp:1877
libdar::archive_options_repair::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
Definition archive_options.hpp:1855
libdar::archive_options_repair::set_slice_min_digits
void set_slice_min_digits(infinint val)
defines the minimum digit a slice must have concerning its number, zeros will be prepended as much as...
Definition archive_options.hpp:1900
libdar::archive_options_repair::set_slice_user_ownership
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
Definition archive_options.hpp:1886
libdar::archive_options_repair::set_execute
void set_execute(const std::string &execute)
set the command to execute after each slice creation
Definition archive_options.hpp:1852
libdar::archive_options_repair::set_slice_permission
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
Definition archive_options.hpp:1883
libdar::archive_options_repair::set_crypto_size
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
Definition archive_options.hpp:1862
libdar::archive_options_repair::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
Definition archive_options.hpp:1872
libdar::archive_options_repair::clear
void clear()
reset all the options to their default values
libdar::archive_options_repair::set_info_details
void set_info_details(bool info_details)
Definition archive_options.hpp:1810
libdar::archive_options_repair::set_slice_group_ownership
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
Definition archive_options.hpp:1889
libdar::archive_options_repair::set_kdf_hash
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
Definition archive_options.hpp:1921
libdar::archive_options_repair::set_pause
void set_pause(const infinint &pause)
set a pause beteween slices. Set to zero does not pause at all, set to 1 makes libdar pauses each sli...
Definition archive_options.hpp:1825
libdar::archive_options_repair::set_iteration_count
void set_iteration_count(const infinint &val)
key derivation
Definition archive_options.hpp:1918
libdar::archive_options_repair::set_empty
void set_empty(bool empty)
whether to make a dry-run operation
Definition archive_options.hpp:1880
libdar::archive_options_repair::set_multi_threaded_crypto
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
Definition archive_options.hpp:1912
libdar::archive_options_repair::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition archive_options.hpp:1816
libdar::archive_options_repair::set_slicing
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
Definition archive_options.hpp:1832
libdar::archive_options_repair::set_display_skipped
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
Definition archive_options.hpp:1819
libdar::archive_options_repair::set_user_comment
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
Definition archive_options.hpp:1892
libdar::archive_options_repair::set_multi_threaded
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
Definition archive_options.hpp:1909
libdar::archive_options_repair::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
Definition archive_options.hpp:1859
libdar::archive_options_repair::set_hash_algo
void set_hash_algo(hash_algo hash)
libdar::archive_options_repair::set_warn_over
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
Definition archive_options.hpp:1802
libdar::archive_options_repair::set_entrepot
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
Definition archive_options.hpp:1903
libdar::archive_options_test
class holding optional parameters used to test the structure coherence of an existing archive
Definition archive_options.hpp:1693
libdar::archive_options_test::set_selection
void set_selection(const mask &selection)
list of filenames to consider (directory not concerned by this fiter)
libdar::archive_options_test::set_display_skipped
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
Definition archive_options.hpp:1732
libdar::archive_options_test::set_subtree
void set_subtree(const mask &subtree)
defines the directories and files to consider
libdar::archive_options_test::set_empty
void set_empty(bool empty)
dry-run exectution if set to true
Definition archive_options.hpp:1740
libdar::archive_options_test::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition archive_options.hpp:1737
libdar::archive_options_test::set_info_details
void set_info_details(bool info_details)
Definition archive_options.hpp:1729
libdar::crit_action
the global action for overwriting
Definition crit_action.hpp:81
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::path
the class path is here to manipulate paths in the Unix notation: using'/'
Definition path.hpp:51
libdar::secu_string
class secu_string
Definition secu_string.hpp:54
compile_time_features.hpp
nested namespace containing routines that give features activated at compile time
compression.hpp
compression parameters for API
crit_action.hpp
contains classes that let the user define the policy for overwriting files
crypto.hpp
the crypto algoritm definition
delta_sig_block_size.hpp
structure used to define how to select block size for delta signature
entrepot.hpp
defines the entrepot interface.
filesystem_ids.hpp
gather the ids of different filesystem to provide a filter based on filesystem
fsa_family.hpp
filesystem specific attributes available families and fsa_scope definition
libdar::modified_data_detection
modified_data_detection
how to detect data has changed when some fields
Definition archive_aux.hpp:44
libdar::comparison_fields
comparison_fields
how to consider file change during comparison and incremental backup
Definition archive_aux.hpp:53
libdar::hash_algo
hash_algo
hashing algorithm available
Definition archive_aux.hpp:63
libdar::fsa_scope
std::set< fsa_family > fsa_scope
set of fsa families
Definition fsa_family.hpp:70
libdar::compression
compression
the different compression algorithm available
Definition compression.hpp:46
libdar::crypto_algo
crypto_algo
the different cypher available for encryption (strong or weak)
Definition crypto.hpp:50
integers.hpp
are defined here basic integer types that tend to be portable
mask.hpp
here lies a collection of mask classes
mask_list.hpp
here lies a mask that selects files present in a given list
my_config.h
include macro defined by the configure script and some specific additional ones
libdar::compile_time::librsync
bool librsync() noexcept
returns whether delta compression is available and delta diff stuff with it
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
secu_string.hpp
this file contains the definition of secu_string class, a std::string like class but allocated in sec...
libdar::delta_sig_block_size
defines how to calculate delta signature block size based of file size to delta sign
Definition delta_sig_block_size.hpp:47
libdar::delta_sig_block_size::check
void check() const
check the sanity of the provided values