Disk ARchive 2.7.9
Full featured and portable backup and archiving tool
archive_options.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2023 Denis Corbin
4//
5// This program is free software; you can redistribute it and/or
6// modify it under the terms of the GNU General Public License
7// as published by the Free Software Foundation; either version 2
8// of the License, or (at your option) any later version.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program; if not, write to the Free Software
17// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18//
19// to contact the author, see the AUTHOR file
20/*********************************************************************/
21
25
26#ifndef 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"
39#include "archive_aux.hpp"
40#include "compression.hpp"
42#include "filesystem_ids.hpp"
43
44#include <string>
45#include <vector>
46#include <set>
47#include <memory>
48
49namespace libdar
50{
51 class archive; // needed to be able to use pointer on archive object.
52
53
57
60
61
63
65 {
66 public:
69
71 archive_options_read(const archive_options_read & ref) : x_ref_chem(ref.x_ref_chem) { copy_from(ref); };
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
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; };
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
288 {
289 public:
290 // default constructors and destructor.
291
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 void set_subtree(const mask & subtree);
318
320 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
321
323 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
324
326
331 void set_info_details(bool info_details) { x_info_details = info_details; };
332
334
337 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
338
340 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
341
343 void set_display_finished(bool display_finished) { x_display_finished = display_finished; };
344
346 void set_pause(const infinint & pause) { x_pause = pause; };
347
349 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
350
352 void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
353
355 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
356
358
367 void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };
368
370
374 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
375 {
376 x_file_size = file_size;
377 if(first_file_size.is_zero())
378 x_first_file_size = file_size;
379 else
380 x_first_file_size = first_file_size;
381 };
382
383
385 void set_ea_mask(const mask & ea_mask);
386
388
398 void set_execute(const std::string & execute) { x_execute = execute; };
399
401 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
402
405 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
406
408 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
409
411
419 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
420
421
425 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
426
428 void set_compr_mask(const mask & compr_mask);
429
431 void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
432
434 void set_nodump(bool nodump) { x_nodump = nodump; };
435
438 void set_exclude_by_ea(const std::string & ea_name)
439 { exclude_by_ea = (ea_name == "" ? "user.libdar_no_backup" : ea_name); };
440
442 void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };
443
445 void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
446
448 void set_empty(bool empty) { x_empty = empty; };
449
451
454 void set_alter_atime(bool alter_atime)
455 {
456 if(x_furtive_read)
457 x_old_alter_atime = alter_atime;
458 else
459 x_alter_atime = alter_atime;
460 };
461
464
466
469 void set_same_fs(bool same_fs) { x_same_fs = same_fs; x_same_fs_include.clear(); x_same_fs_exclude.clear(); };
470
472
474 void set_same_fs_include(const std::string & included_path_to_fs) { x_same_fs_include.push_back(included_path_to_fs); };
475
477
479 void set_same_fs_exclude(const std::string & excluded_path_to_fs) { x_same_fs_exclude.push_back(excluded_path_to_fs); };
480
482 void set_snapshot(bool snapshot) { x_snapshot = snapshot; };
483
485 void set_cache_directory_tagging(bool cache_directory_tagging) { x_cache_directory_tagging = cache_directory_tagging; };
486
488 void set_fixed_date(const infinint & fixed_date) { x_fixed_date = fixed_date; };
489
491 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
492
494 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
495
497 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
498
500 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; };
501
503 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
504
506 void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
507
509 void set_security_check(bool check) { x_security_check = check; };
510
512 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
513
515
519
521 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
522
524 void set_backup_hook(const std::string & execute, const mask & which_files);
525
527 void set_ignore_unknown_inode_type(bool val) { x_ignore_unknown = val; };
528
530 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; };
531
533 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
534
536
539 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
540
542 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
543
545 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
546
548
550 void set_delta_diff(bool val) { if(val && !compile_time::librsync()) throw Ecompilation("librsync"); x_delta_diff = val; };
551
553 void set_delta_signature(bool val) { x_delta_signature = val; };
554
556 void set_delta_mask(const mask & delta_mask);
557
559
561 void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };
562
564 void set_auto_zeroing_neg_dates(bool val) { x_auto_zeroing_neg_dates = val; };
565
567
570 void set_ignored_as_symlink(const std::set<std::string> & list) { x_ignored_as_symlink = list; };
571
573
574 void set_modified_data_detection(modified_data_detection val) { x_modified_data_detection = val; };
575
577 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
578
580 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
581
583 void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };
584
585
587 // getting methods
588
589 std::shared_ptr<archive> get_reference() const { return x_ref_arch; };
590 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
591 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
592 bool get_allow_over() const { return x_allow_over; };
593 bool get_warn_over() const { return x_warn_over; };
594 bool get_info_details() const { return x_info_details; };
595 bool get_display_treated() const { return x_display_treated; };
596 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
597 bool get_display_skipped() const { return x_display_skipped; };
598 bool get_display_finished() const { return x_display_finished; };
599 const infinint & get_pause() const { return x_pause; };
600 bool get_empty_dir() const { return x_empty_dir; };
601 compression get_compression() const { return x_compr_algo; };
602 U_I get_compression_level() const { return x_compression_level; };
603 U_I get_compression_block_size() const { return x_compression_block_size; };
604 const infinint & get_slice_size() const { return x_file_size; };
605 const infinint & get_first_slice_size() const { return x_first_file_size; };
606 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
607 const std::string & get_execute() const { return x_execute; };
608 crypto_algo get_crypto_algo() const { return x_crypto; };
609 const secu_string & get_crypto_pass() const { return x_pass; };
610 U_32 get_crypto_size() const { return x_crypto_size; };
611 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
612 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
613 const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
614 const infinint & get_min_compr_size() const { return x_min_compr_size; };
615 bool get_nodump() const { return x_nodump; };
616 const std::string & get_exclude_by_ea() const { return exclude_by_ea; };
617 comparison_fields get_comparison_fields() const { return x_what_to_check; };
618 const infinint & get_hourshift() const { return x_hourshift; };
619 bool get_empty() const { return x_empty; };
620 bool get_alter_atime() const { return x_alter_atime; };
621 bool get_furtive_read_mode() const { return x_furtive_read; };
622 bool get_same_fs() const { return x_same_fs; };
623 std::deque<std::string> get_same_fs_include() const { return x_same_fs_include; };
624 std::deque<std::string> get_same_fs_exclude() const { return x_same_fs_exclude; };
625 bool get_snapshot() const { return x_snapshot; };
626 bool get_cache_directory_tagging() const { return x_cache_directory_tagging; };
627 const infinint & get_fixed_date() const { return x_fixed_date; };
628 const std::string & get_slice_permission() const { return x_slice_permission; };
629 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
630 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
631 const infinint & get_repeat_count() const { return x_repeat_count; };
632 const infinint & get_repeat_byte() const { return x_repeat_byte; };
633 bool get_sequential_marks() const { return x_sequential_marks; };
634 infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
635 bool get_security_check() const { return x_security_check; };
636 const std::string & get_user_comment() const { return x_user_comment; };
637 hash_algo get_hash_algo() const { return x_hash; };
638 infinint get_slice_min_digits() const { return x_slice_min_digits; };
639 const std::string & get_backup_hook_file_execute() const { return x_backup_hook_file_execute; };
640 const mask & get_backup_hook_file_mask() const { return *x_backup_hook_file_mask; };
641 bool get_ignore_unknown_inode_type() const { return x_ignore_unknown; };
642 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
643 const fsa_scope & get_fsa_scope() const { return x_scope; };
644 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
645 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
646 bool get_delta_diff() const { return x_delta_diff; };
647 bool get_delta_signature() const { return x_delta_signature; };
648 const mask & get_delta_mask() const { return *x_delta_mask; }
649 bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };
650 const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };
651 bool get_auto_zeroing_neg_dates() const { return x_auto_zeroing_neg_dates; };
652 const std::set<std::string> & get_ignored_as_symlink() const { return x_ignored_as_symlink; };
653 modified_data_detection get_modified_data_detection() const { return x_modified_data_detection; };
654 const infinint & get_iteration_count() const { return x_iteration_count; };
655 hash_algo get_kdf_hash() const { return x_kdf_hash; };
656 delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };
657
658 private:
659 std::shared_ptr<archive> x_ref_arch;
662 bool x_allow_over;
663 bool x_warn_over;
664 bool x_info_details;
665 bool x_display_treated;
666 bool x_display_treated_only_dir;
667 bool x_display_skipped;
668 bool x_display_finished;
669 infinint x_pause;
670 bool x_empty_dir;
671 compression x_compr_algo;
672 U_I x_compression_level;
673 U_I x_compression_block_size;
674 infinint x_file_size;
675 infinint x_first_file_size;
677 std::string x_execute;
678 crypto_algo x_crypto;
679 secu_string x_pass;
680 U_32 x_crypto_size;
681 std::vector<std::string> x_gnupg_recipients;
682 std::vector<std::string> x_gnupg_signatories;
684 infinint x_min_compr_size;
685 bool x_nodump;
686 std::string exclude_by_ea;
687 comparison_fields x_what_to_check;
688 infinint x_hourshift;
689 bool x_empty;
690 bool x_alter_atime;
692 bool x_furtive_read;
693 bool x_same_fs;
694 std::deque<std::string> x_same_fs_include;
695 std::deque<std::string> x_same_fs_exclude;
696 bool x_snapshot;
697 bool x_cache_directory_tagging;
698 infinint x_fixed_date;
699 std::string x_slice_permission;
700 std::string x_slice_user_ownership;
701 std::string x_slice_group_ownership;
702 infinint x_repeat_count;
703 infinint x_repeat_byte;
704 bool x_sequential_marks;
705 infinint x_sparse_file_min_size;
706 bool x_security_check;
707 std::string x_user_comment;
708 hash_algo x_hash;
709 infinint x_slice_min_digits;
710 mask * x_backup_hook_file_mask;
711 std::string x_backup_hook_file_execute;
712 bool x_ignore_unknown;
713 std::shared_ptr<entrepot> x_entrepot;
714 fsa_scope x_scope;
715 U_I x_multi_threaded_crypto;
716 U_I x_multi_threaded_compress;
717 bool x_delta_diff;
718 bool x_delta_signature;
719 mask *x_delta_mask;
720 bool has_delta_mask_been_set;
721 infinint x_delta_sig_min_size;
722 bool x_auto_zeroing_neg_dates;
723 std::set<std::string> x_ignored_as_symlink;
724 modified_data_detection x_modified_data_detection;
725 infinint x_iteration_count;
726 hash_algo x_kdf_hash;
727 delta_sig_block_size x_sig_block_len;
728
729 void nullifyptr() noexcept;
730 void destroy() noexcept;
731 void copy_from(const archive_options_create & ref);
732 void move_from(archive_options_create && ref) noexcept;
733 void destroy_mask(mask * & ptr);
734 void clean_mask(mask * & ptr);
735 void check_mask(const mask & m);
736 };
737
738
739
740
741
742
746
748
750 {
751 public:
754 archive_options_isolate(archive_options_isolate && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
755 archive_options_isolate & operator = (const archive_options_isolate & ref) { destroy(); copy_from(ref); return *this; };
756 archive_options_isolate & operator = (archive_options_isolate && ref) noexcept { move_from(std::move(ref)); return *this; };
757 ~archive_options_isolate() { destroy(); };
758
759
760 void clear();
761
763 // setting methods
764
766 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
767
769 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
770
772 void set_info_details(bool info_details) { x_info_details = info_details; };
773
775 void set_pause(const infinint & pause) { x_pause = pause; };
776
778 void set_compression(compression algo) { x_algo = algo; };
779
781 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
782
784
785 void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };
786
788
792 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
793 {
794 x_file_size = file_size;
795 if(first_file_size.is_zero())
796 x_first_file_size = file_size;
797 else
798 x_first_file_size = first_file_size;
799 };
800
802
812 void set_execute(const std::string & execute) { x_execute = execute; };
813
815 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
816
818 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
819
821 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
822
827 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
828
832 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
833
835 void set_empty(bool empty) { x_empty = empty; };
836
838 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
839
841 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
842
844 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
845
847 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
848
851
853 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
854
856 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
857
859 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; };
860
862
865 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
866
868 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
869
871 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
872
873
875 void set_delta_signature(bool val) { x_delta_signature = val; };
876
878 void set_delta_mask(const mask & delta_mask);
879
883 void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };
884
886 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
887
889 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
890
892 void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };
893
895 // getting methods
896
897 bool get_allow_over() const { return x_allow_over; };
898 bool get_warn_over() const { return x_warn_over; };
899 bool get_info_details() const { return x_info_details; };
900 const infinint & get_pause() const { return x_pause; };
901 compression get_compression() const { return x_algo; };
902 U_I get_compression_level() const { return x_compression_level; };
903 U_I get_compression_block_size() const { return x_compression_block_size; };
904 const infinint & get_slice_size() const { return x_file_size; };
905 const infinint & get_first_slice_size() const { return x_first_file_size; };
906 const std::string & get_execute() const { return x_execute; };
907 crypto_algo get_crypto_algo() const { return x_crypto; };
908 const secu_string & get_crypto_pass() const { return x_pass; };
909 U_32 get_crypto_size() const { return x_crypto_size; };
910 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
911 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
912 bool get_empty() const { return x_empty; };
913 const std::string & get_slice_permission() const { return x_slice_permission; };
914 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
915 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
916 const std::string & get_user_comment() const { return x_user_comment; };
917 hash_algo get_hash_algo() const { return x_hash; };
918 infinint get_slice_min_digits() const { return x_slice_min_digits; };
919 bool get_sequential_marks() const { return x_sequential_marks; };
920 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
921 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
922 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
923 bool get_delta_signature() const { return x_delta_signature; };
924 const mask & get_delta_mask() const { return *x_delta_mask; }
925 bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };
926 const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };
927 const infinint & get_iteration_count() const { return x_iteration_count; };
928 hash_algo get_kdf_hash() const { return x_kdf_hash; };
929 delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };
930
931
932 private:
933 bool x_allow_over;
934 bool x_warn_over;
935 bool x_info_details;
936 infinint x_pause;
937 compression x_algo;
938 U_I x_compression_level;
939 U_I x_compression_block_size;
940 infinint x_file_size;
941 infinint x_first_file_size;
942 std::string x_execute;
943 crypto_algo x_crypto;
944 secu_string x_pass;
945 U_32 x_crypto_size;
946 std::vector<std::string> x_gnupg_recipients;
947 std::vector<std::string> x_gnupg_signatories;
948 bool x_empty;
949 std::string x_slice_permission;
950 std::string x_slice_user_ownership;
951 std::string x_slice_group_ownership;
952 std::string x_user_comment;
953 hash_algo x_hash;
954 infinint x_slice_min_digits;
955 bool x_sequential_marks;
956 std::shared_ptr<entrepot> x_entrepot;
957 U_I x_multi_threaded_crypto;
958 U_I x_multi_threaded_compress;
959 bool x_delta_signature;
960 mask *x_delta_mask;
961 bool has_delta_mask_been_set;
962 infinint x_delta_sig_min_size;
963 infinint x_iteration_count;
964 hash_algo x_kdf_hash;
965 delta_sig_block_size x_sig_block_len;
966
967 void copy_from(const archive_options_isolate & ref);
968 void move_from(archive_options_isolate && ref) noexcept;
969 void destroy() noexcept;
970 void nullifyptr() noexcept;
971 };
972
973
974
978
981 {
982 public:
983
984 archive_options_merge() { nullifyptr(); clear(); };
985 archive_options_merge(const archive_options_merge & ref) { copy_from(ref); };
986 archive_options_merge(archive_options_merge && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
987 archive_options_merge & operator = (const archive_options_merge & ref) { destroy(); copy_from(ref); return *this; };
988 archive_options_merge & operator = (archive_options_merge && ref) noexcept { move_from(std::move(ref)); return *this; };
989 ~archive_options_merge() { destroy(); };
990
991 void clear();
992
994 // setting methods
995
996 void set_auxiliary_ref(std::shared_ptr<archive> ref) { x_ref = ref; };
997
999 void set_selection(const mask & selection);
1000
1002 void set_subtree(const mask & subtree);
1003
1005 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
1006
1008 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1009
1011 void set_overwriting_rules(const crit_action & overwrite);
1012
1014
1019 void set_info_details(bool info_details) { x_info_details = info_details; };
1020
1022
1025 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1026
1028 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1029
1031 void set_pause(const infinint & pause) { x_pause = pause; };
1032
1034 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
1035
1037 void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
1038
1040 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
1041
1043 void set_compression_block_size(U_I compression_block_size) { x_compression_block_size = compression_block_size; };
1044
1046
1050 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
1051 {
1052 x_file_size = file_size;
1053 if(first_file_size.is_zero())
1054 x_first_file_size = file_size;
1055 else
1056 x_first_file_size = first_file_size;
1057 };
1058
1060 void set_ea_mask(const mask & ea_mask);
1061
1063
1073 void set_execute(const std::string & execute) { x_execute = execute; };
1074
1076 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
1077
1080 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
1081
1083 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
1084
1089 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
1090
1094 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
1095
1097 void set_compr_mask(const mask & compr_mask);
1098
1100 void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
1101
1103 void set_empty(bool empty) { x_empty = empty; };
1104
1106 void set_keep_compressed(bool keep_compressed) { x_keep_compressed = keep_compressed; };
1107
1109 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
1110
1112 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
1113
1115 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
1116
1118 void set_decremental_mode(bool mode) { x_decremental = mode; };
1119
1121 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
1122
1124 void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
1125
1127 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
1128
1131
1133 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
1134
1136 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; };
1137
1139 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1140
1142
1145 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
1146
1148 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
1149
1151 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
1152
1158 void set_delta_signature(bool val) { x_delta_signature = val; };
1159
1161 void set_delta_mask(const mask & delta_mask);
1162
1164
1166 void set_delta_sig_min_size(const infinint & val) { x_delta_sig_min_size = val; };
1167
1169 void set_iteration_count(const infinint & val) { x_iteration_count = val; };
1170
1172 void set_kdf_hash(hash_algo algo) { x_kdf_hash = algo; };
1173
1175 void set_sig_block_len(delta_sig_block_size val) { val.check(); x_sig_block_len = val; };
1176
1177
1179 // getting methods
1180
1181 std::shared_ptr<archive> get_auxiliary_ref() const { return x_ref; };
1182 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1183 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1184 bool get_allow_over() const { return x_allow_over; };
1185 bool get_warn_over() const { return x_warn_over; };
1186 const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
1187 bool get_info_details() const { return x_info_details; };
1188 bool get_display_treated() const { return x_display_treated; };
1189 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1190 bool get_display_skipped() const { return x_display_skipped; };
1191 const infinint & get_pause() const { return x_pause; };
1192 bool get_empty_dir() const { return x_empty_dir; };
1193 compression get_compression() const { return x_compr_algo; };
1194 U_I get_compression_level() const { return x_compression_level; };
1195 U_I get_compression_block_size() const { return x_compression_block_size; };
1196 const infinint & get_slice_size() const { return x_file_size; };
1197 const infinint & get_first_slice_size() const { return x_first_file_size; };
1198 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1199 const std::string & get_execute() const { return x_execute; };
1200 crypto_algo get_crypto_algo() const { return x_crypto; };
1201 const secu_string & get_crypto_pass() const { return x_pass; };
1202 U_32 get_crypto_size() const { return x_crypto_size; };
1203 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
1204 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
1205 const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
1206 const infinint & get_min_compr_size() const { return x_min_compr_size; };
1207 bool get_empty() const { return x_empty; };
1208 bool get_keep_compressed() const { return x_keep_compressed; };
1209 const std::string & get_slice_permission() const { return x_slice_permission; };
1210 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
1211 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
1212 bool get_decremental_mode() const { return x_decremental; };
1213 bool get_sequential_marks() const { return x_sequential_marks; };
1214 infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
1215 const std::string & get_user_comment() const { return x_user_comment; };
1216 hash_algo get_hash_algo() const { return x_hash; };
1217 infinint get_slice_min_digits() const { return x_slice_min_digits; };
1218 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
1219 const fsa_scope & get_fsa_scope() const { return x_scope; };
1220 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
1221 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
1222 bool get_delta_signature() const { return x_delta_signature; };
1223 const mask & get_delta_mask() const { return *x_delta_mask; }
1224 bool get_has_delta_mask_been_set() const { return has_delta_mask_been_set; };
1225 const infinint & get_delta_sig_min_size() const { return x_delta_sig_min_size; };
1226 const infinint & get_iteration_count() const { return x_iteration_count; };
1227 hash_algo get_kdf_hash() const { return x_kdf_hash; };
1228 delta_sig_block_size get_sig_block_len() const { return x_sig_block_len; };
1229
1230
1231 private:
1232 std::shared_ptr<archive> x_ref;
1233 mask * x_selection;
1234 mask * x_subtree;
1235 bool x_allow_over;
1236 bool x_warn_over;
1237 crit_action * x_overwrite;
1238 bool x_info_details;
1239 bool x_display_treated;
1240 bool x_display_treated_only_dir;
1241 bool x_display_skipped;
1242 infinint x_pause;
1243 bool x_empty_dir;
1244 compression x_compr_algo;
1245 U_I x_compression_level;
1246 U_I x_compression_block_size;
1247 infinint x_file_size;
1248 infinint x_first_file_size;
1249 mask * x_ea_mask;
1250 std::string x_execute;
1251 crypto_algo x_crypto;
1252 secu_string x_pass;
1253 U_32 x_crypto_size;
1254 std::vector<std::string> x_gnupg_recipients;
1255 std::vector<std::string> x_gnupg_signatories;
1256 mask * x_compr_mask;
1257 infinint x_min_compr_size;
1258 bool x_empty;
1259 bool x_keep_compressed;
1260 std::string x_slice_permission;
1261 std::string x_slice_user_ownership;
1262 std::string x_slice_group_ownership;
1263 bool x_decremental;
1264 bool x_sequential_marks;
1265 infinint x_sparse_file_min_size;
1266 std::string x_user_comment;
1267 hash_algo x_hash;
1268 infinint x_slice_min_digits;
1269 std::shared_ptr<entrepot> x_entrepot;
1270 fsa_scope x_scope;
1271 U_I x_multi_threaded_crypto;
1272 U_I x_multi_threaded_compress;
1273 bool x_delta_signature;
1274 mask *x_delta_mask;
1275 bool has_delta_mask_been_set;
1276 infinint x_delta_sig_min_size;
1277 infinint x_iteration_count;
1278 hash_algo x_kdf_hash;
1279 delta_sig_block_size x_sig_block_len;
1280
1281 void destroy() noexcept;
1282 void copy_from(const archive_options_merge & ref);
1283 void move_from(archive_options_merge && ref) noexcept;
1284 void nullifyptr() noexcept;
1285 };
1286
1287
1291
1294 {
1295 public:
1296 enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };
1297
1298 archive_options_extract() { nullifyptr(); clear(); };
1299 archive_options_extract(const archive_options_extract & ref) { copy_from(ref); };
1300 archive_options_extract(archive_options_extract && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1301 archive_options_extract & operator = (const archive_options_extract & ref) { destroy(); copy_from(ref); return *this; };
1302 archive_options_extract & operator = (archive_options_extract && ref) noexcept { move_from(std::move(ref)); return *this; };
1303 ~archive_options_extract() { destroy(); };
1304
1305 void clear();
1306
1308 // setting methods
1309
1311 void set_selection(const mask & selection);
1312
1314 void set_subtree(const mask & subtree);
1315
1317 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1318
1325 void set_info_details(bool info_details) { x_info_details = info_details; };
1326
1330 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1331
1333 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1334
1336 void set_ea_mask(const mask & ea_mask);
1337
1339 void set_flat(bool flat) { x_flat = flat; };
1340
1342 void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1343
1345 void set_warn_remove_no_match(bool warn_remove_no_match) { x_warn_remove_no_match = warn_remove_no_match; };
1346
1348 void set_empty(bool empty) { x_empty = empty; };
1349
1351 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
1352
1354
1357 void set_dirty_behavior(bool ignore, bool warn) { x_dirty = ignore ? dirty_ignore : (warn ? dirty_warn : dirty_ok); };
1358
1360 void set_dirty_behavior(t_dirty val) { x_dirty = val; };
1361
1364
1366
1368 void set_only_deleted(bool val) { x_only_deleted = val; };
1369
1370
1372
1374 void set_ignore_deleted(bool val) { x_ignore_deleted = val; };
1375
1377 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1378
1380 void set_ignore_unix_sockets(bool val) { x_ignore_unix_sockets = val; };
1381
1383 void set_in_place(bool arg) { x_in_place = arg; };
1384
1385
1387 // getting methods
1388
1389 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1390 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1391 bool get_warn_over() const { return x_warn_over; };
1392 bool get_info_details() const { return x_info_details; };
1393 bool get_display_treated() const { return x_display_treated; };
1394 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1395 bool get_display_skipped() const { return x_display_skipped; };
1396 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1397 bool get_flat() const { return x_flat; };
1398 comparison_fields get_what_to_check() const { return x_what_to_check; };
1399 bool get_warn_remove_no_match() const { return x_warn_remove_no_match; };
1400 bool get_empty() const { return x_empty; };
1401 bool get_empty_dir() const { return x_empty_dir; };
1402 t_dirty get_dirty_behavior() const { return x_dirty; }
1403 const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
1404 bool get_only_deleted() const { return x_only_deleted; };
1405 bool get_ignore_deleted() const { return x_ignore_deleted; };
1406 const fsa_scope & get_fsa_scope() const { return x_scope; };
1407 bool get_ignore_unix_sockets() const { return x_ignore_unix_sockets; };
1408 bool get_in_place() const { return x_in_place; };
1409
1410 private:
1411 mask * x_selection;
1412 mask * x_subtree;
1413 bool x_warn_over;
1414 bool x_info_details;
1415 bool x_display_treated;
1416 bool x_display_treated_only_dir;
1417 bool x_display_skipped;
1418 mask * x_ea_mask;
1419 bool x_flat;
1420 comparison_fields x_what_to_check;
1421 bool x_warn_remove_no_match;
1422 bool x_empty;
1423 bool x_empty_dir;
1424 t_dirty x_dirty;
1425 crit_action *x_overwrite;
1426 bool x_only_deleted;
1427 bool x_ignore_deleted;
1428 fsa_scope x_scope;
1429 bool x_ignore_unix_sockets;
1430 bool x_in_place;
1431
1432 void destroy() noexcept;
1433 void nullifyptr() noexcept;
1434 void copy_from(const archive_options_extract & ref);
1435 void move_from(archive_options_extract && ref) noexcept;
1436 };
1437
1438
1439
1440
1444
1447 {
1448 public:
1449 archive_options_listing() { nullifyptr(); clear(); };
1450 archive_options_listing(const archive_options_listing & ref) { copy_from(ref); };
1451 archive_options_listing(archive_options_listing && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1452 archive_options_listing & operator = (const archive_options_listing & ref) { destroy(); copy_from(ref); return *this; };
1453 archive_options_listing & operator = (archive_options_listing && ref) noexcept { move_from(std::move(ref)); return *this; };
1454 virtual ~archive_options_listing() { destroy(); };
1455
1456 virtual void clear();
1457
1458
1460 // setting methods
1461
1463 void set_info_details(bool info_details) { x_info_details = info_details; };
1464
1466
1468 void set_selection(const mask & selection);
1469
1471
1473 void set_subtree(const mask & subtree);
1474
1476 void set_filter_unsaved(bool filter_unsaved) { x_filter_unsaved = filter_unsaved; };
1477
1479 void set_slicing_location(bool val) { x_slicing_location = val; };
1480
1482
1486 void set_user_slicing(const infinint & slicing_first, const infinint & slicing_others);
1487
1489
1491 void set_display_ea(bool display_ea) { x_display_ea = display_ea; };
1492
1493
1495 // getting methods
1496
1497 bool get_info_details() const { return x_info_details; };
1498 const mask & get_selection() const;
1499 const mask & get_subtree() const;
1500 bool get_filter_unsaved() const { return x_filter_unsaved; };
1501 bool get_user_slicing(infinint & slicing_first, infinint & slicing_others) const;
1502 bool get_slicing_location() const { return x_slicing_location; };
1503 bool get_display_ea() const { return x_display_ea; };
1504
1505 private:
1506 bool x_info_details;
1507 mask * x_selection;
1508 mask * x_subtree;
1509 bool x_filter_unsaved;
1510 infinint *x_slicing_first;
1511 infinint *x_slicing_others;
1512 bool x_slicing_location;
1513 bool x_display_ea;
1514
1515 void destroy() noexcept;
1516 void nullifyptr() noexcept;
1517 void copy_from(const archive_options_listing & ref);
1518 void move_from(archive_options_listing && ref) noexcept;
1519 };
1520
1524
1525
1526 class archive_options_diff
1527 {
1528 public:
1529 archive_options_diff() { nullifyptr(); clear(); };
1530 archive_options_diff(const archive_options_diff & ref) { copy_from(ref); };
1531 archive_options_diff(archive_options_diff && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1532 archive_options_diff & operator = (const archive_options_diff & ref) { destroy(); copy_from(ref); return *this; };
1533 archive_options_diff & operator = (archive_options_diff && ref) noexcept { move_from(std::move(ref)); return *this; };
1534 ~archive_options_diff() { destroy(); };
1535
1536 void clear();
1537
1539 // setting methods
1540
1542 void set_selection(const mask & selection);
1543
1545 void set_subtree(const mask & subtree);
1546
1553 void set_info_details(bool info_details) { x_info_details = info_details; };
1554
1558 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1559
1561 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1562
1564 void set_ea_mask(const mask & ea_mask);
1565
1567 void set_what_to_check(comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1568
1570
1573 void set_alter_atime(bool alter_atime)
1574 {
1575 if(x_furtive_read)
1576 x_old_alter_atime = alter_atime;
1577 else
1578 x_alter_atime = alter_atime;
1579 };
1580
1583
1585 void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
1586
1588 void set_compare_symlink_date(bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };
1589
1591 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1592
1594 void set_in_place(bool arg) { x_in_place = arg; };
1595
1596
1598 // getting methods
1599
1600 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1601 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1602 bool get_info_details() const { return x_info_details; };
1603 bool get_display_treated() const { return x_display_treated; };
1604 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1605 bool get_display_skipped() const { return x_display_skipped; };
1606 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1607 comparison_fields get_what_to_check() const { return x_what_to_check; };
1608 bool get_alter_atime() const { return x_alter_atime; };
1609 bool get_furtive_read_mode() const { return x_furtive_read; };
1610 const infinint & get_hourshift() const { return x_hourshift; };
1611 bool get_compare_symlink_date() const { return x_compare_symlink_date; };
1612 const fsa_scope & get_fsa_scope() const { return x_scope; };
1613 bool get_in_place() const { return x_in_place; };
1614
1615 private:
1616 mask * x_selection;
1617 mask * x_subtree;
1618 bool x_info_details;
1619 bool x_display_treated;
1620 bool x_display_treated_only_dir;
1621 bool x_display_skipped;
1622 mask * x_ea_mask;
1623 comparison_fields x_what_to_check;
1624 bool x_alter_atime;
1625 bool x_old_alter_atime;
1626 bool x_furtive_read;
1627 infinint x_hourshift;
1628 bool x_compare_symlink_date;
1629 fsa_scope x_scope;
1630 bool x_in_place;
1631
1632 void destroy() noexcept;
1633 void nullifyptr() noexcept;
1634 void copy_from(const archive_options_diff & ref);
1635 void move_from(archive_options_diff && ref) noexcept;
1636 };
1637
1638
1639
1640
1644
1647 {
1648 public:
1649 archive_options_test() { nullifyptr(); clear(); };
1650 archive_options_test(const archive_options_test & ref) { copy_from(ref); };
1651 archive_options_test(archive_options_test && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1652 archive_options_test & operator = (const archive_options_test & ref) { destroy(); copy_from(ref); return *this; };
1653 archive_options_test & operator = (archive_options_test && ref) noexcept { move_from(std::move(ref)); return *this; };
1654 ~archive_options_test() { destroy(); };
1655
1656 void clear();
1657
1659 // setting methods
1660
1662 void set_selection(const mask & selection);
1663
1665 void set_subtree(const mask & subtree);
1666
1673 void set_info_details(bool info_details) { x_info_details = info_details; };
1674
1676 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1677
1681 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1682
1684 void set_empty(bool empty) { x_empty = empty; };
1685
1686
1688 // getting methods
1689
1690 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1691 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1692 bool get_info_details() const { return x_info_details; };
1693 bool get_display_treated() const { return x_display_treated; };
1694 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1695 bool get_display_skipped() const { return x_display_skipped; };
1696 bool get_empty() const { return x_empty; };
1697
1698 private:
1699 mask * x_selection;
1700 mask * x_subtree;
1701 bool x_info_details;
1702 bool x_display_treated;
1703 bool x_display_treated_only_dir;
1704 bool x_display_skipped;
1705 bool x_empty;
1706
1707 void destroy() noexcept;
1708 void nullifyptr() noexcept;
1709 void copy_from(const archive_options_test & ref);
1710 void move_from(archive_options_test && ref) noexcept;
1711 };
1712
1713
1717
1720 {
1721 public:
1722 // default constructors and destructor.
1723
1726 archive_options_repair(archive_options_repair && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
1727 archive_options_repair & operator = (const archive_options_repair & ref) { copy_from(ref); return *this; };
1728 archive_options_repair & operator = (archive_options_repair && ref) noexcept { move_from(std::move(ref)); return *this; };
1729 ~archive_options_repair() = default;
1730
1732 // set back to default (this is the state just after the object is constructed
1733 // this method is to be used to reuse a given object
1734
1736 void clear();
1737
1738
1740 // setting methods
1741
1743 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
1744
1746 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1747
1754 void set_info_details(bool info_details) { x_info_details = info_details; };
1755
1760 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1761
1763 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1764
1766 void set_display_finished(bool display_finished) { x_display_finished = display_finished; };
1767
1769 void set_pause(const infinint & pause) { x_pause = pause; };
1770
1772
1776 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
1777 {
1778 x_file_size = file_size;
1779 if(first_file_size.is_zero())
1780 x_first_file_size = file_size;
1781 else
1782 x_first_file_size = first_file_size;
1783 };
1784
1786
1796 void set_execute(const std::string & execute) { x_execute = execute; };
1797
1799 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
1800
1803 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
1804
1806 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
1807
1816 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
1817
1821 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
1822
1824 void set_empty(bool empty) { x_empty = empty; };
1825
1827 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
1828
1830 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
1831
1833 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
1834
1836 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
1837
1842
1844 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
1845
1847 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; };
1848
1850
1853 void set_multi_threaded(bool val) { x_multi_threaded_crypto = 2; x_multi_threaded_compress = 2; };
1854
1856 void set_multi_threaded_crypto(U_I num) { x_multi_threaded_crypto = num; };
1857
1859 void set_multi_threaded_compress(U_I num) { x_multi_threaded_compress = num; };
1860
1861
1863 // getting methods
1864
1865 bool get_allow_over() const { return x_allow_over; };
1866 bool get_warn_over() const { return x_warn_over; };
1867 bool get_info_details() const { return x_info_details; };
1868 bool get_display_treated() const { return x_display_treated; };
1869 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1870 bool get_display_skipped() const { return x_display_skipped; };
1871 bool get_display_finished() const { return x_display_finished; };
1872 const infinint & get_pause() const { return x_pause; };
1873 const infinint & get_slice_size() const { return x_file_size; };
1874 const infinint & get_first_slice_size() const { return x_first_file_size; };
1875 const std::string & get_execute() const { return x_execute; };
1876 crypto_algo get_crypto_algo() const { return x_crypto; };
1877 const secu_string & get_crypto_pass() const { return x_pass; };
1878 U_32 get_crypto_size() const { return x_crypto_size; };
1879 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
1880 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
1881 bool get_empty() const { return x_empty; };
1882 const std::string & get_slice_permission() const { return x_slice_permission; };
1883 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
1884 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
1885 const std::string & get_user_comment() const { return x_user_comment; };
1886 hash_algo get_hash_algo() const { return x_hash; };
1887 infinint get_slice_min_digits() const { return x_slice_min_digits; };
1888 const std::shared_ptr<entrepot> & get_entrepot() const { return x_entrepot; };
1889 U_I get_multi_threaded_crypto() const { return x_multi_threaded_crypto; };
1890 U_I get_multi_threaded_compress() const { return x_multi_threaded_compress; };
1891
1892 private:
1893 bool x_allow_over;
1894 bool x_warn_over;
1895 bool x_info_details;
1896 bool x_display_treated;
1897 bool x_display_treated_only_dir;
1898 bool x_display_skipped;
1899 bool x_display_finished;
1900 infinint x_pause;
1901 infinint x_file_size;
1902 infinint x_first_file_size;
1903 std::string x_execute;
1904 crypto_algo x_crypto;
1905 secu_string x_pass;
1906 U_32 x_crypto_size;
1907 std::vector<std::string> x_gnupg_recipients;
1908 std::vector<std::string> x_gnupg_signatories;
1909 bool x_empty;
1910 std::string x_slice_permission;
1911 std::string x_slice_user_ownership;
1912 std::string x_slice_group_ownership;
1913 std::string x_user_comment;
1914 hash_algo x_hash;
1915 infinint x_slice_min_digits;
1916 std::shared_ptr<entrepot> x_entrepot;
1917 U_I x_multi_threaded_crypto;
1918 U_I x_multi_threaded_compress;
1919
1920 void nullifyptr() noexcept {};
1921 void copy_from(const archive_options_repair & ref);
1922 void move_from(archive_options_repair && ref) noexcept;
1923 };
1924
1926
1927} // end of namespace
1928
1929#endif
set of datastructures used to interact with a catalogue object
exception used when a requested fearture has not beed activated at compilation time
Definition: erreurs.hpp:366
exception used to signal range error
Definition: erreurs.hpp:220
class holding optional parameters used to create an archive
void clear()
reset all the options to their default values
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
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...
void set_crypto_pass(const secu_string &pass)
void set_compression_block_size(U_I compression_block_size)
set the compression block size
void set_auto_zeroing_neg_dates(bool val)
whether to automatically zeroing negative dates read from the filesystem (just warn,...
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...
void set_display_finished(bool display_finished)
whether to display a summary for each completed directory with total saved data and compression ratio
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
void set_backup_hook(const std::string &execute, const mask &which_files)
defines the backup hook for files
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)
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
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_security_check(bool check)
whether to check for ctime changes since with the archive of reference
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
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 ...
void set_delta_signature(bool val)
whether signature to base binary delta on the future has to be calculated and stored beside saved fil...
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
void set_modified_data_detection(modified_data_detection val)
defines when to resave a file's data which inode metadata changed
void set_furtive_read_mode(bool furtive_read)
whether to use furtive read mode (if activated, alter_atime() has no meaning/use)
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive
std::shared_ptr< archive > x_ref_arch
just contains the address of an existing object, no local copy of object is done here
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
void set_cache_directory_tagging(bool cache_directory_tagging)
whether to consider the Cache Directory Tagging Standard
void set_compr_mask(const mask &compr_mask)
defines files to compress
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...
mask * x_ea_mask
points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
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...
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
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...
void set_iteration_count(const infinint &val)
key derivation
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
void set_delta_mask(const mask &delta_mask)
whether to derogate to defaut delta file consideration while calculation delta signatures
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
mask * x_subtree
points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
void set_delta_diff(bool val)
whether binary delta has to be computed for differential/incremental backup
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_hourshift(const infinint &hourshift)
ignore differences of at most this integer number of hours while looking for changes in dates
mask * x_selection
points to a local copy of mask (must be allocated / releases by the archive_option_create object)
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA activated at com...
void set_nodump(bool nodump)
defines whether to ignore files with the nodump flag set
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
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
void set_exclude_by_ea(const std::string &ea_name)
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_compression(compression compr_algo)
set the compression algorithm to be used
mask * x_compr_mask
points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
void set_ignore_unknown_inode_type(bool val)
whether to ignore unknown inode types instead of issuing a warning
void set_snapshot(bool snapshot)
whether to make an emtpy archive only referencing the current state of files in the filesystem
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void set_reference(std::shared_ptr< archive > ref_arch)
set the archive to take as reference (nullptr for a full backup)
void set_alter_atime(bool alter_atime)
whether to alter atime or ctime in the filesystem when reading files to save
bool x_old_alter_atime
used to backup origina alter_atime value when activating furtive read mode
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_display_treated(bool display_treated, bool only_dir)
defines whether to show treated files
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
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...
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
void set_selection(const mask &selection)
defines the filenames to only save (except directory) as those that match the given mask
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
set the list of recipients that will be able to read the archive
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
void set_empty(bool empty)
whether to make a dry-run operation
class holding optional parameters used to extract files from an existing archive
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
void set_empty_dir(bool empty_dir)
whether to restore directories where no file has been triggered for backup (no file/inode change,...
void set_ignore_unix_sockets(bool val)
whether to ignore unix sockets while restoring
void set_overwriting_rules(const crit_action &over)
overwriting policy
void set_display_treated(bool display_treated, bool only_dir)
void set_info_details(bool info_details)
void set_flat(bool flat)
whether to ignore directory structure and restore all files in the same directory
void set_only_deleted(bool val)
only consider deleted files (if set, no data get restored)
void set_dirty_behavior(t_dirty val)
alternative method to modify dirty behavior
void set_ignore_deleted(bool val)
do not consider deleted files (if set, no inode will be removed)
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
void set_in_place(bool arg)
whether to ignore fs_root and use in-place path stored in the archive
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
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_empty(bool empty)
defines whether we need to store ignored directories as empty
void set_selection(const mask &selection)
defines the filenames to only save (except directory) as those that match the given mask
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_dirty_behavior(bool ignore, bool warn)
whether to restore dirty files (those that changed during backup), warn before restoring or ignoring ...
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA activated at com...
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 (...
class holding optional parameters used to isolate an existing archive
void set_crypto_size(U_32 crypto_size)
size of the encryption by block to use
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
void set_warn_over(bool warn_over)
whether a warning shall be issued before overwriting
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_delta_mask(const mask &delta_mask)
whether to derogate to defaut delta file consideration while calculation delta signatures
void set_delta_signature(bool val)
whether signature to base binary delta on the future has to be calculated and stored beside saved fil...
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
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,...
void set_crypto_algo(crypto_algo crypto)
cypher to use
void set_allow_over(bool allow_over)
whether overwritting is allowed
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_compression_level(U_I compression_level)
the compression level (from 1 to 9)
void set_delta_sig_min_size(const infinint &val)
void set_multi_threaded(bool val)
whether libdar is allowed to created several thread to work possibily faster on multicore CPU (requir...
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_execute(const std::string &execute)
command to execute after each slice creation
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
void set_compression(compression algo)
the compression algorithm used
void set_compression_block_size(U_I compression_block_size)
set the compression block size
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
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...
void set_info_details(bool info_details)
whether the user needs detailed output of the operation
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
void set_iteration_count(const infinint &val)
key derivation
void set_crypto_pass(const secu_string &pass)
password / passphrase to encrypt the data with (empty string for interactive question)
void set_empty(bool empty)
whether to make a dry-run operation
class holding optional parameters used to list the contents of an existing archive
void set_subtree(const mask &subtree)
mask applied to the full path, only those matching it will be listed
void set_display_ea(bool display_ea)
whether to fetch EA for listing
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
void set_filter_unsaved(bool filter_unsaved)
whether to only show entries that have their data fully saved
void set_selection(const mask &selection)
mask applied to filename, only those marching it will be listed
void set_info_details(bool info_details)
whether output should be verbosed --> to be moved to shell output
void set_slicing_location(bool val)
whether to calculate the slice location of each file
class holding optional parameters used to proceed to the merge operation
void set_sequential_marks(bool sequential)
whether to activate escape sequence aka tape marks to allow sequential reading of the archive
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_compr_mask(const mask &compr_mask)
defines files to compress
void set_sig_block_len(delta_sig_block_size val)
block size to use to build delta signatures
void set_empty(bool empty)
defines whether we do a dry-run execution
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
void set_crypto_pass(const secu_string &pass)
void set_display_treated(bool display_treated, bool only_dir)
defines whether to show treated files
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
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...
void set_overwriting_rules(const crit_action &overwrite)
policy to solve merging conflict
void set_delta_mask(const mask &delta_mask)
whether to derogate to defaut delta file consideration while calculation delta signatures
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
void set_iteration_count(const infinint &val)
key derivation
void set_compression(compression compr_algo)
set the compression algorithm to be used
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_keep_compressed(bool keep_compressed)
make dar ignore the 'algo' argument and do not uncompress / compress files that are selected for merg...
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
void set_kdf_hash(hash_algo algo)
hash algo used for key derivation
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
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...
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
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...
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
void set_compression_block_size(U_I compression_block_size)
set the compression block size (0 for streamed compression)
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
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...
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
void set_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA are considered)
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
void set_hash_algo(hash_algo hash)
specify whether to produce a hash file of the slice and which hash algo to use
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_selection(const mask &selection)
defines the filenames to only save (except directory) as those that match the given mask
class holding optional parameters used to read an existing archive
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 "-")
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use to retrieve slices
void set_crypto_algo(crypto_algo val)
defines the the crypto cypher to use to read the archive (default is crypto_none)
void set_ref_crypto_size(U_32 ref_crypto_size)
defines the crypto size for the reference catalogue
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
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...
void set_crypto_pass(const secu_string &pass)
defines the password or passphrase to decrypt (unused if encryption is not set)
archive_options_read()
build an object and set options to their default values
void set_multi_threaded(bool val)
whether libdar is allowed to create several thread to work possibly faster on multicore CPU (need lib...
void set_ref_crypto_pass(const secu_string &ref_pass)
defines the pass for the reference catalogue
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...
void clear()
reset all the options to their default values
void set_ignore_signature_check_failure(bool val)
whether to warn (true) or ignore (false) signature failure (default is true)
void unset_external_catalogue()
clear any reference to an external catalogue
void set_ref_crypto_algo(crypto_algo ref_crypto)
defines the crypto algo for the reference catalogue
void set_lax(bool val)
defines whether any archive coherence error, system error or media error lead to the abortion of the ...
void set_info_details(bool info_details)
defines whether the user needs detailed output of the operation
void set_header_only(bool val)
whether we only read the archive header and exit
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...
void set_ref_execute(const std::string &ref_execute)
set the command to execute before reading each slice of the reference catalogue
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 "-")
void set_execute(const std::string &execute)
set the command to execute before reading each slice (empty string for no script)
void set_default_crypto_size()
set the encryption block size to the default value
void set_sequential_read(bool val)
defines whether to try reading the archive sequentially (ala tar) or using the final catalogue
void set_crypto_size(U_32 crypto_size)
the encryption block size to use to decrypt
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
archive_options_read(const archive_options_read &ref)
the copy constructor, assignment operator and destructor
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 ...
class holding optional parameters used to create an archive
void set_display_finished(bool display_finished)
whether to display a summary for each completed directory with total saved data and compression ratio
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
void set_multi_threaded_compress(U_I num)
how much thread libdar will use for compression (need libthreadar too and compression_block_size > 0)
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
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...
void set_slice_user_ownership(const std::string &slice_user_ownership)
if not an empty string set the user ownership of slices accordingly
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_slice_permission(const std::string &slice_permission)
if not an empty string set the slice permission according to the octal value given.
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void clear()
reset all the options to their default values
void set_info_details(bool info_details)
void set_slice_group_ownership(const std::string &slice_group_ownership)
if not an empty string set the group ownership of slices accordingly
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...
void set_empty(bool empty)
whether to make a dry-run operation
void set_multi_threaded_crypto(U_I num)
how much thread libdar will use for cryptography (need libthreadar to be effective)
void set_display_treated(bool display_treated, bool only_dir)
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
void set_crypto_pass(const secu_string &pass)
void set_hash_algo(hash_algo hash)
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_entrepot(const std::shared_ptr< entrepot > &entr)
defines the protocol to use for slices
class holding optional parameters used to test the structure coherence of an existing archive
void set_selection(const mask &selection)
list of filenames to consider (directory not concerned by this fiter)
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
void set_empty(bool empty)
dry-run exectution if set to true
void set_display_treated(bool display_treated, bool only_dir)
void set_info_details(bool info_details)
the global action for overwriting
Definition: crit_action.hpp:81
the arbitrary large positive integer class
the generic class, parent of all masks
Definition: mask.hpp:62
the class path is here to manipulate paths in the Unix notation: using'/'
Definition: path.hpp:51
class secu_string
Definition: secu_string.hpp:54
nested namespace containing routines that give features activated at compile time
compression parameters for API
contains classes that let the user define the policy for overwriting files
the crypto algoritm definition
structure used to define how to select block size for delta signature
defines the entrepot interface.
gather the ids of different filesystem to provide a filter based on filesystem
filesystem specific attributes available families and fsa_scope definition
modified_data_detection
how to detect data has changed when some fields
Definition: archive_aux.hpp:44
comparison_fields
how to consider file change during comparison and incremental backup
Definition: archive_aux.hpp:53
std::set< fsa_family > fsa_scope
set of fsa families
Definition: fsa_family.hpp:70
hash_algo
hashing algorithm available
Definition: archive_aux.hpp:63
compression
the different compression algorithm available
Definition: compression.hpp:46
crypto_algo
the different cypher available for encryption (strong or weak)
Definition: crypto.hpp:50
are defined here basic integer types that tend to be portable
here lies a collection of mask classes
here lies a mask that selects files present in a given list
bool librsync() noexcept
returns whether delta compression is available and delta diff stuff with it
bool furtive_read() noexcept
returns whether libdar can support furtive read mode when run by privileged user
bool nodump() noexcept
returns whether nodump flag support has been activated at compilation time
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
this file contains the definition of secu_string class, a std::string like class but allocated in sec...
defines how to calculate delta signature block size based of file size to delta sign
void check() const
check the sanity of the provided values