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

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

archive_options.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2052 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 //
19 // to contact the author : http://dar.linux.free.fr/email.html
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 "compressor.hpp"
34 #include "catalogue.hpp"
35 #include "criterium.hpp"
36 #include "hash_fichier.hpp"
37 #include "secu_string.hpp"
38 #include "nls_swap.hpp"
39 #include "entrepot.hpp"
40 #include "fsa_family.hpp"
41 #include "on_pool.hpp"
42
43 #include <string>
44
45 namespace libdar
46 {
47 class archive; // needed to be able to use pointer on archive object.
48
49
53
56
57
59 class archive_options_read : public on_pool
60 {
61 public:
63 archive_options_read();
64
66 archive_options_read(const archive_options_read & ref) : x_ref_chem(ref.x_ref_chem) { copy_from(ref); };
67 const archive_options_read & operator = (const archive_options_read & ref) { destroy(); copy_from(ref); return *this; };
68 ~archive_options_read() { destroy(); };
69
70
72 // set back to default (this is the state just after the object is constructed
73 // this method is to be used to reuse a given object
74
76 void clear();
77
78
80 // setting methods
81
82
89 void set_crypto_algo(crypto_algo val) { x_crypto = val; };
90
92 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
93
95 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
96
98 void set_default_crypto_size();
99
101
104 void set_input_pipe(const std::string & input_pipe) { x_input_pipe = input_pipe; };
105
107
110 void set_output_pipe(const std::string & output_pipe) { x_output_pipe = output_pipe; };
111
113
121 void set_execute(const std::string & execute) { x_execute = execute; };
122
124 void set_info_details(bool info_details) { x_info_details = info_details; };
125
127
131 void set_lax(bool val) { x_lax = val; };
132
134
136
137 void set_sequential_read(bool val) { x_sequential_read = val; };
138
140
141 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
142
143
145 void set_entrepot(const entrepot & entr) { if(x_entrepot != nullptr) delete x_entrepot; x_entrepot = entr.clone(); if(x_entrepot == nullptr) throw Ememory("archive_options_read::set_entrepot"); };
146
148 void set_ignore_signature_check_failure(bool val) { x_ignore_signature_check_failure = val; };
149
151 void set_multi_threaded(bool val) { x_multi_threaded = val; };
152
153
155
157 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; };
159 void unset_external_catalogue();
160
162 void set_ref_crypto_algo(crypto_algo ref_crypto) { x_ref_crypto = ref_crypto; };
163
165 void set_ref_crypto_pass(const secu_string & ref_pass) { x_ref_pass = ref_pass; };
166
168 void set_ref_crypto_size(U_32 ref_crypto_size) { x_ref_crypto_size = ref_crypto_size; };
169
171
179 void set_ref_execute(const std::string & ref_execute) { x_ref_execute = ref_execute; };
180
181
183
184 void set_ref_slice_min_digits(infinint val) { x_ref_slice_min_digits = val; };
185
187 void set_ref_entrepot(const entrepot & entr) { if(x_ref_entrepot != nullptr) delete x_ref_entrepot; x_ref_entrepot = entr.clone(); if(x_ref_entrepot == nullptr) throw Ememory("archive_options_read::set_entrepot"); };
188
189
190
191
193 // getting methods (mainly used inside libdar, but kept public and part of the API in the case it is needed)
194
195
196 crypto_algo get_crypto_algo() const { return x_crypto; };
197 const secu_string & get_crypto_pass() const { return x_pass; };
198 U_32 get_crypto_size() const { return x_crypto_size; };
199 const std::string & get_input_pipe() const { return x_input_pipe; };
200 const std::string & get_output_pipe() const { return x_output_pipe; };
201 const std::string & get_execute() const { return x_execute; };
202 bool get_info_details() const { return x_info_details; };
203 bool get_lax() const { return x_lax; };
204 bool get_sequential_read() const { return x_sequential_read; };
205 infinint get_slice_min_digits() const { return x_slice_min_digits; };
206 const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
207 bool get_ignore_signature_check_failure() const { return x_ignore_signature_check_failure; };
208 bool get_multi_threaded() const { return x_multi_threaded; };
209
210 // All methods that follow concern the archive where to fetch the (isolated) catalogue from
211 bool is_external_catalogue_set() const { return external_cat; };
212 const path & get_ref_path() const;
213 const std::string & get_ref_basename() const;
214 crypto_algo get_ref_crypto_algo() const { return x_ref_crypto; };
215 const secu_string & get_ref_crypto_pass() const { return x_ref_pass; };
216 U_32 get_ref_crypto_size() const { return x_ref_crypto_size; };
217 const std::string & get_ref_execute() const { return x_ref_execute; };
218 infinint get_ref_slice_min_digits() const { return x_ref_slice_min_digits; };
219 const entrepot & get_ref_entrepot() const { if(x_ref_entrepot == nullptr) throw SRC_BUG; return *x_ref_entrepot; };
220
221
222 private:
223 crypto_algo x_crypto;
224 secu_string x_pass;
225 U_32 x_crypto_size;
226 std::string x_input_pipe;
227 std::string x_output_pipe;
228 std::string x_execute;
229 bool x_info_details;
230 bool x_lax;
231 bool x_sequential_read;
232 infinint x_slice_min_digits;
233 entrepot *x_entrepot;
234 bool x_ignore_signature_check_failure;
235 bool x_multi_threaded;
236
237
238 // external catalogue relative fields
239 bool external_cat;
240 path x_ref_chem;
241 std::string x_ref_basename;
242 crypto_algo x_ref_crypto;
243 secu_string x_ref_pass;
244 U_32 x_ref_crypto_size;
245 std::string x_ref_execute;
246 infinint x_ref_slice_min_digits;
247 entrepot *x_ref_entrepot;
248
249 void copy_from(const archive_options_read & ref);
250 void destroy();
251 };
252
253
257
259 class archive_options_create : public on_pool
260 {
261 public:
262 // default constructors and destructor.
263
264 archive_options_create();
265 archive_options_create(const archive_options_create & ref);
266 const archive_options_create & operator = (const archive_options_create & ref) { destroy(); copy_from(ref); return *this; };
267 ~archive_options_create() { destroy(); };
268
270 // set back to default (this is the state just after the object is constructed
271 // this method is to be used to reuse a given object
272
274 void clear();
275
276
278 // setting methods
279
281 void set_reference(archive *ref_arch) { x_ref_arch = ref_arch; };
282
284 void set_selection(const mask & selection);
285
287 void set_subtree(const mask & subtree);
288
290 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
291
293 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
294
301 void set_info_details(bool info_details) { x_info_details = info_details; };
302
307 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
308
310 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
311
313 void set_display_finished(bool display_finished) { x_display_finished = display_finished; };
314
316 void set_pause(const infinint & pause) { x_pause = pause; };
317
319 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
320
322 void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
323
325 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
326
328
332 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
333 {
334 x_file_size = file_size;
335 if(first_file_size.is_zero())
336 x_first_file_size = file_size;
337 else
338 x_first_file_size = first_file_size;
339 };
340
341
343 void set_ea_mask(const mask & ea_mask);
344
346 void set_execute(const std::string & execute) { x_execute = execute; };
347
349 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
350
353 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
354
356 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
357
364 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
365
366
368 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
369
371 void set_compr_mask(const mask & compr_mask);
372
374 void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
375
377 void set_nodump(bool nodump) { x_nodump = nodump; };
378
381 void set_exclude_by_ea(const std::string & ea_name)
382 { exclude_by_ea = (ea_name == "" ? "user.libdar_no_backup" : ea_name); };
383
385 void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
386
388 void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
389
391 void set_empty(bool empty) { x_empty = empty; };
392
394
397 void set_alter_atime(bool alter_atime)
398 {
399 if(x_furtive_read)
400 x_old_alter_atime = alter_atime;
401 else
402 x_alter_atime = alter_atime;
403 };
404
406 void set_furtive_read_mode(bool furtive_read)
407 {
408 NLS_SWAP_IN;
409 try
410 {
411
412 #if FURTIVE_READ_MODE_AVAILABLE
413 x_furtive_read = furtive_read;
414 if(furtive_read)
415 {
416 x_old_alter_atime = x_alter_atime;
417 x_alter_atime = true;
418 // this is required to avoid libdar manipulating ctime of inodes
419 }
420 else
421 x_alter_atime = x_old_alter_atime;
422 #else
423 if(furtive_read)
424 throw Ecompilation(gettext("Furtive read mode"));
425 x_furtive_read = false;
426 #endif
427 }
428 catch(...)
429 {
430 NLS_SWAP_OUT;
431 throw;
432 }
433 NLS_SWAP_OUT;
434 };
435
437 void set_same_fs(bool same_fs) { x_same_fs = same_fs; };
438
440 void set_snapshot(bool snapshot) { x_snapshot = snapshot; };
441
443 void set_cache_directory_tagging(bool cache_directory_tagging) { x_cache_directory_tagging = cache_directory_tagging; };
444
446 void set_fixed_date(const infinint & fixed_date) { x_fixed_date = fixed_date; };
447
449 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
450
452 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
453
455 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
456
458 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; };
459
461 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
462
464 void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
465
467 void set_security_check(bool check) { x_security_check = check; };
468
470 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
471
475 void set_hash_algo(hash_algo hash) { x_hash = hash; };
476
478 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
479
481 void set_backup_hook(const std::string & execute, const mask & which_files);
482
484 void set_ignore_unknown_inode_type(bool val) { x_ignore_unknown = val; };
485
487 void set_entrepot(const entrepot & entr);
488
490 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
491
493 void set_multi_threaded(bool val) { x_multi_threaded = val; };
494
495
497 // getting methods
498
499 archive *get_reference() const { return x_ref_arch; };
500 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
501 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
502 bool get_allow_over() const { return x_allow_over; };
503 bool get_warn_over() const { return x_warn_over; };
504 bool get_info_details() const { return x_info_details; };
505 bool get_display_treated() const { return x_display_treated; };
506 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
507 bool get_display_skipped() const { return x_display_skipped; };
508 bool get_display_finished() const { return x_display_finished; };
509 const infinint & get_pause() const { return x_pause; };
510 bool get_empty_dir() const { return x_empty_dir; };
511 compression get_compression() const { return x_compr_algo; };
512 U_I get_compression_level() const { return x_compression_level; };
513 const infinint & get_slice_size() const { return x_file_size; };
514 const infinint & get_first_slice_size() const { return x_first_file_size; };
515 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
516 const std::string & get_execute() const { return x_execute; };
517 crypto_algo get_crypto_algo() const { return x_crypto; };
518 const secu_string & get_crypto_pass() const { return x_pass; };
519 U_32 get_crypto_size() const { return x_crypto_size; };
520 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
521 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
522 const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
523 const infinint & get_min_compr_size() const { return x_min_compr_size; };
524 bool get_nodump() const { return x_nodump; };
525 const std::string & get_exclude_by_ea() const { return exclude_by_ea; };
526 cat_inode::comparison_fields get_comparison_fields() const { return x_what_to_check; };
527 const infinint & get_hourshift() const { return x_hourshift; };
528 bool get_empty() const { return x_empty; };
529 bool get_alter_atime() const { return x_alter_atime; };
530 bool get_furtive_read_mode() const { return x_furtive_read; };
531 bool get_same_fs() const { return x_same_fs; };
532 bool get_snapshot() const { return x_snapshot; };
533 bool get_cache_directory_tagging() const { return x_cache_directory_tagging; };
534 const infinint & get_fixed_date() const { return x_fixed_date; };
535 const std::string & get_slice_permission() const { return x_slice_permission; };
536 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
537 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
538 const infinint & get_repeat_count() const { return x_repeat_count; };
539 const infinint & get_repeat_byte() const { return x_repeat_byte; };
540 bool get_sequential_marks() const { return x_sequential_marks; };
541 infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
542 bool get_security_check() const { return x_security_check; };
543 const std::string & get_user_comment() const { return x_user_comment; };
544 hash_algo get_hash_algo() const { return x_hash; };
545 infinint get_slice_min_digits() const { return x_slice_min_digits; };
546 const std::string & get_backup_hook_file_execute() const { return x_backup_hook_file_execute; };
547 const mask & get_backup_hook_file_mask() const { return *x_backup_hook_file_mask; };
548 bool get_ignore_unknown_inode_type() const { return x_ignore_unknown; };
549 const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
550 const fsa_scope & get_fsa_scope() const { return x_scope; };
551 bool get_multi_threaded() const { return x_multi_threaded; };
552
553 private:
554 archive *x_ref_arch; //< just contains the address of an existing object, no local copy of object is done here
555 mask * x_selection; //< points to a local copy of mask (must be allocated / releases by the archive_option_create object)
556 mask * x_subtree; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
557 bool x_allow_over;
558 bool x_warn_over;
559 bool x_info_details;
560 bool x_display_treated;
561 bool x_display_treated_only_dir;
562 bool x_display_skipped;
563 bool x_display_finished;
564 infinint x_pause;
565 bool x_empty_dir;
566 compression x_compr_algo;
567 U_I x_compression_level;
568 infinint x_file_size;
569 infinint x_first_file_size;
570 mask * x_ea_mask; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
571 std::string x_execute;
572 crypto_algo x_crypto;
573 secu_string x_pass;
574 U_32 x_crypto_size;
575 std::vector<std::string> x_gnupg_recipients;
576 std::vector<std::string> x_gnupg_signatories;
577 mask * x_compr_mask; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
578 infinint x_min_compr_size;
579 bool x_nodump;
580 std::string exclude_by_ea;
581 cat_inode::comparison_fields x_what_to_check;
582 infinint x_hourshift;
583 bool x_empty;
584 bool x_alter_atime;
585 bool x_old_alter_atime; //< used to backup origina alter_atime value when activating furtive read mode
586 bool x_furtive_read;
587 bool x_same_fs;
588 bool x_snapshot;
589 bool x_cache_directory_tagging;
590 infinint x_fixed_date;
591 std::string x_slice_permission;
592 std::string x_slice_user_ownership;
593 std::string x_slice_group_ownership;
594 infinint x_repeat_count;
595 infinint x_repeat_byte;
596 bool x_sequential_marks;
597 infinint x_sparse_file_min_size;
598 bool x_security_check;
599 std::string x_user_comment;
600 hash_algo x_hash;
601 infinint x_slice_min_digits;
602 mask * x_backup_hook_file_mask;
603 std::string x_backup_hook_file_execute;
604 bool x_ignore_unknown;
605 entrepot *x_entrepot;
606 fsa_scope x_scope;
607 bool x_multi_threaded;
608
609 void destroy();
610 void copy_from(const archive_options_create & ref);
611 void destroy_mask(mask * & ptr);
612 void clean_mask(mask * & ptr);
613 void check_mask(const mask & m);
614 };
615
616
617
618
619
620
624
626 class archive_options_isolate : public on_pool
627 {
628 public:
629 archive_options_isolate() { x_entrepot = nullptr; clear(); };
630 archive_options_isolate(const archive_options_isolate & ref) { x_entrepot = nullptr; copy_from(ref); };
631 const archive_options_isolate & operator = (const archive_options_isolate & ref) { destroy(); copy_from(ref); return *this; };
632 ~archive_options_isolate() { destroy(); };
633
634
635 void clear();
636
638 // setting methods
639
641 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
642
644 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
645
647 void set_info_details(bool info_details) { x_info_details = info_details; };
648
650 void set_pause(const infinint & pause) { x_pause = pause; };
651
653 void set_compression(compression algo) { x_algo = algo; };
654
656 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
657
659
663 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
664 {
665 x_file_size = file_size;
666 if(first_file_size.is_zero())
667 x_first_file_size = file_size;
668 else
669 x_first_file_size = first_file_size;
670 };
671
673 void set_execute(const std::string & execute) { x_execute = execute; };
674
676 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
677
679 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
680
682 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
683
686 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
687
689 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
690
692 void set_empty(bool empty) { x_empty = empty; };
693
695 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
696
698 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
699
701 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
702
704 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
705
707 void set_hash_algo(hash_algo hash) { x_hash = hash; };
708
710 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
711
713 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
714
716 void set_entrepot(const entrepot & entr);
717
719 void set_multi_threaded(bool val) { x_multi_threaded = val; };
720
721
723 // getting methods
724
725 bool get_allow_over() const { return x_allow_over; };
726 bool get_warn_over() const { return x_warn_over; };
727 bool get_info_details() const { return x_info_details; };
728 const infinint & get_pause() const { return x_pause; };
729 compression get_compression() const { return x_algo; };
730 U_I get_compression_level() const { return x_compression_level; };
731 const infinint & get_slice_size() const { return x_file_size; };
732 const infinint & get_first_slice_size() const { return x_first_file_size; };
733 const std::string & get_execute() const { return x_execute; };
734 crypto_algo get_crypto_algo() const { return x_crypto; };
735 const secu_string & get_crypto_pass() const { return x_pass; };
736 U_32 get_crypto_size() const { return x_crypto_size; };
737 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
738 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
739 bool get_empty() const { return x_empty; };
740 const std::string & get_slice_permission() const { return x_slice_permission; };
741 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
742 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
743 const std::string & get_user_comment() const { return x_user_comment; };
744 hash_algo get_hash_algo() const { return x_hash; };
745 infinint get_slice_min_digits() const { return x_slice_min_digits; };
746 bool get_sequential_marks() const { return x_sequential_marks; };
747 const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
748 bool get_multi_threaded() const { return x_multi_threaded; };
749
750
751 private:
752 bool x_allow_over;
753 bool x_warn_over;
754 bool x_info_details;
755 infinint x_pause;
756 compression x_algo;
757 U_I x_compression_level;
758 infinint x_file_size;
759 infinint x_first_file_size;
760 std::string x_execute;
761 crypto_algo x_crypto;
762 secu_string x_pass;
763 U_32 x_crypto_size;
764 std::vector<std::string> x_gnupg_recipients;
765 std::vector<std::string> x_gnupg_signatories;
766 bool x_empty;
767 std::string x_slice_permission;
768 std::string x_slice_user_ownership;
769 std::string x_slice_group_ownership;
770 std::string x_user_comment;
771 hash_algo x_hash;
772 infinint x_slice_min_digits;
773 bool x_sequential_marks;
774 entrepot *x_entrepot;
775 bool x_multi_threaded;
776
777 void copy_from(const archive_options_isolate & ref);
778 void destroy();
779 };
780
781
782
786
788 class archive_options_merge : public on_pool
789 {
790 public:
791
792 archive_options_merge() { x_selection = x_subtree = x_ea_mask = x_compr_mask = nullptr; x_overwrite = nullptr; x_entrepot = nullptr; clear(); };
793 archive_options_merge(const archive_options_merge & ref) { copy_from(ref); };
794 const archive_options_merge & operator = (const archive_options_merge & ref) { destroy(); copy_from(ref); return *this; };
795 ~archive_options_merge() { destroy(); };
796
797 void clear();
798
800 // setting methods
801
802 void set_auxilliary_ref(archive *ref) { x_ref = ref; };
803
805 void set_selection(const mask & selection);
806
808 void set_subtree(const mask & subtree);
809
811 void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
812
814 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
815
817 void set_overwriting_rules(const crit_action & overwrite);
818
825 void set_info_details(bool info_details) { x_info_details = info_details; };
826
831 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
832
834 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
835
837 void set_pause(const infinint & pause) { x_pause = pause; };
838
840 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
841
843 void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
844
846 void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
847
849
853 void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
854 {
855 x_file_size = file_size;
856 if(first_file_size.is_zero())
857 x_first_file_size = file_size;
858 else
859 x_first_file_size = first_file_size;
860 };
861
863 void set_ea_mask(const mask & ea_mask);
864
866 void set_execute(const std::string & execute) { x_execute = execute; };
867
869 void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
870
873 void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
874
876 void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
877
880 void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
881
883 void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
884
886 void set_compr_mask(const mask & compr_mask);
887
889 void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
890
892 void set_empty(bool empty) { x_empty = empty; };
893
895 void set_keep_compressed(bool keep_compressed) { x_keep_compressed = keep_compressed; };
896
898 void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
899
901 void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
902
904 void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
905
907 void set_decremental_mode(bool mode) { x_decremental = mode; };
908
910 void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
911
913 void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
914
916 void set_user_comment(const std::string & comment) { x_user_comment = comment; };
917
919 void set_hash_algo(hash_algo hash) { x_hash = hash; };
920
922 void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
923
925 void set_entrepot(const entrepot & entr);
926
928 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
929
931 void set_multi_threaded(bool val) { x_multi_threaded = val; };
932
933
935 // getting methods
936
937 archive * get_auxilliary_ref() const { return x_ref; };
938 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
939 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
940 bool get_allow_over() const { return x_allow_over; };
941 bool get_warn_over() const { return x_warn_over; };
942 const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
943 bool get_info_details() const { return x_info_details; };
944 bool get_display_treated() const { return x_display_treated; };
945 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
946 bool get_display_skipped() const { return x_display_skipped; };
947 const infinint & get_pause() const { return x_pause; };
948 bool get_empty_dir() const { return x_empty_dir; };
949 compression get_compression() const { return x_compr_algo; };
950 U_I get_compression_level() const { return x_compression_level; };
951 const infinint & get_slice_size() const { return x_file_size; };
952 const infinint & get_first_slice_size() const { return x_first_file_size; };
953 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
954 const std::string & get_execute() const { return x_execute; };
955 crypto_algo get_crypto_algo() const { return x_crypto; };
956 const secu_string & get_crypto_pass() const { return x_pass; };
957 U_32 get_crypto_size() const { return x_crypto_size; };
958 const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
959 const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
960 const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
961 const infinint & get_min_compr_size() const { return x_min_compr_size; };
962 bool get_empty() const { return x_empty; };
963 bool get_keep_compressed() const { return x_keep_compressed; };
964 const std::string & get_slice_permission() const { return x_slice_permission; };
965 const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
966 const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
967 bool get_decremental_mode() const { return x_decremental; };
968 bool get_sequential_marks() const { return x_sequential_marks; };
969 infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
970 const std::string & get_user_comment() const { return x_user_comment; };
971 hash_algo get_hash_algo() const { return x_hash; };
972 infinint get_slice_min_digits() const { return x_slice_min_digits; };
973 const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
974 const fsa_scope & get_fsa_scope() const { return x_scope; };
975 bool get_multi_threaded() const { return x_multi_threaded; };
976
977 private:
978 archive * x_ref; //< points to an external existing object, must never be deleted by "this"
979 mask * x_selection;
980 mask * x_subtree;
981 bool x_allow_over;
982 bool x_warn_over;
983 crit_action * x_overwrite;
984 bool x_info_details;
985 bool x_display_treated;
986 bool x_display_treated_only_dir;
987 bool x_display_skipped;
988 infinint x_pause;
989 bool x_empty_dir;
990 compression x_compr_algo;
991 U_I x_compression_level;
992 infinint x_file_size;
993 infinint x_first_file_size;
994 mask * x_ea_mask;
995 std::string x_execute;
996 crypto_algo x_crypto;
997 secu_string x_pass;
998 U_32 x_crypto_size;
999 std::vector<std::string> x_gnupg_recipients;
1000 std::vector<std::string> x_gnupg_signatories;
1001 mask * x_compr_mask;
1002 infinint x_min_compr_size;
1003 bool x_empty;
1004 bool x_keep_compressed;
1005 std::string x_slice_permission;
1006 std::string x_slice_user_ownership;
1007 std::string x_slice_group_ownership;
1008 bool x_decremental;
1009 bool x_sequential_marks;
1010 infinint x_sparse_file_min_size;
1011 std::string x_user_comment;
1012 hash_algo x_hash;
1013 infinint x_slice_min_digits;
1014 entrepot *x_entrepot;
1015 fsa_scope x_scope;
1016 bool x_multi_threaded;
1017
1018 void destroy();
1019 void copy_from(const archive_options_merge & ref);
1020 };
1021
1022
1026
1028 class archive_options_extract : public on_pool
1029 {
1030 public:
1031 enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };
1032
1033 archive_options_extract() { x_selection = x_subtree = x_ea_mask = nullptr; x_overwrite = nullptr; clear(); };
1034 archive_options_extract(const archive_options_extract & ref) { copy_from(ref); };
1035 const archive_options_extract & operator = (const archive_options_extract & ref) { destroy(); copy_from(ref); return *this; };
1036 ~archive_options_extract() { destroy(); };
1037
1038 void clear();
1039
1041 // setting methods
1042
1044 void set_selection(const mask & selection);
1045
1047 void set_subtree(const mask & subtree);
1048
1050 void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1051
1058 void set_info_details(bool info_details) { x_info_details = info_details; };
1059
1063 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1064
1066 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1067
1069 void set_ea_mask(const mask & ea_mask);
1070
1072 void set_flat(bool flat) { x_flat = flat; };
1073
1075 void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1076
1078 void set_warn_remove_no_match(bool warn_remove_no_match) { x_warn_remove_no_match = warn_remove_no_match; };
1079
1081 void set_empty(bool empty) { x_empty = empty; };
1082
1084 void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
1085
1087
1090 void set_dirty_behavior(bool ignore, bool warn) { x_dirty = ignore ? dirty_ignore : (warn ? dirty_warn : dirty_ok); };
1091
1093 void set_dirty_behavior(t_dirty val) { x_dirty = val; };
1094
1096 void set_overwriting_rules(const crit_action & over);
1097
1099
1101 void set_only_deleted(bool val) { x_only_deleted = val; };
1102
1103
1105
1107 void set_ignore_deleted(bool val) { x_ignore_deleted = val; };
1108
1110 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1111
1112
1114 // getting methods
1115
1116 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1117 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1118 bool get_warn_over() const { return x_warn_over; };
1119 bool get_info_details() const { return x_info_details; };
1120 bool get_display_treated() const { return x_display_treated; };
1121 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1122 bool get_display_skipped() const { return x_display_skipped; };
1123 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1124 bool get_flat() const { return x_flat; };
1125 cat_inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
1126 bool get_warn_remove_no_match() const { return x_warn_remove_no_match; };
1127 bool get_empty() const { return x_empty; };
1128 bool get_empty_dir() const { return x_empty_dir; };
1129 t_dirty get_dirty_behavior() const { return x_dirty; }
1130 const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
1131 bool get_only_deleted() const { return x_only_deleted; };
1132 bool get_ignore_deleted() const { return x_ignore_deleted; };
1133 const fsa_scope & get_fsa_scope() const { return x_scope; };
1134
1135 private:
1136 mask * x_selection;
1137 mask * x_subtree;
1138 bool x_warn_over;
1139 bool x_info_details;
1140 bool x_display_treated;
1141 bool x_display_treated_only_dir;
1142 bool x_display_skipped;
1143 mask * x_ea_mask;
1144 bool x_flat;
1145 cat_inode::comparison_fields x_what_to_check;
1146 bool x_warn_remove_no_match;
1147 bool x_empty;
1148 bool x_empty_dir;
1149 t_dirty x_dirty;
1150 crit_action *x_overwrite;
1151 bool x_only_deleted;
1152 bool x_ignore_deleted;
1153 fsa_scope x_scope;
1154
1155 void destroy();
1156 void copy_from(const archive_options_extract & ref);
1157 };
1158
1159
1160
1161
1165
1167 class archive_options_listing : public on_pool
1168 {
1169 public:
1170 archive_options_listing() { x_selection = x_subtree = nullptr; x_slicing_first = x_slicing_others = nullptr; clear(); };
1171 archive_options_listing(const archive_options_listing & ref) { copy_from(ref); };
1172 const archive_options_listing & operator = (const archive_options_listing & ref) { destroy(); copy_from(ref); return *this; };
1173 ~archive_options_listing() { destroy(); };
1174
1175 void clear();
1176
1178
1179 enum listformat
1180 {
1181 normal, //< the tar-like listing (this is the default)
1182 tree, //< the original dar's tree listing (for those that like forest)
1183 xml, //< the xml catalogue output
1184 slicing //< the slicing output (give info about where files are located)
1185 };
1186
1188 // setting methods
1189
1190 void set_info_details(bool info_details) { x_info_details = info_details; };
1191 void set_list_mode(listformat list_mode) { x_list_mode = list_mode; };
1192 void set_selection(const mask & selection);
1193 void set_subtree(const mask & subtree);
1194 void set_filter_unsaved(bool filter_unsaved) { x_filter_unsaved = filter_unsaved; };
1195 void set_display_ea(bool display_ea) { x_display_ea = display_ea; };
1196 void set_user_slicing(const infinint & slicing_first, const infinint & slicing_others);
1197 void set_sizes_in_bytes(bool arg) { x_sizes_in_bytes = arg; };
1198
1200 // getting methods
1201
1202 bool get_info_details() const { return x_info_details; };
1203 listformat get_list_mode() const { return x_list_mode; };
1204 const mask & get_selection() const;
1205 const mask & get_subtree() const;
1206 bool get_filter_unsaved() const { return x_filter_unsaved; };
1207 bool get_display_ea() const { return x_display_ea; };
1208 bool get_user_slicing(infinint & slicing_first, infinint & slicing_others) const;
1209 bool get_sizes_in_bytes() const { return x_sizes_in_bytes; };
1210
1211 private:
1212 bool x_info_details;
1213 listformat x_list_mode;
1214 mask * x_selection;
1215 mask * x_subtree;
1216 bool x_filter_unsaved;
1217 bool x_display_ea;
1218 infinint *x_slicing_first;
1219 infinint *x_slicing_others;
1220 bool x_sizes_in_bytes;
1221
1222 void destroy();
1223 void copy_from(const archive_options_listing & ref);
1224 };
1225
1226
1230
1231
1232 class archive_options_diff : public on_pool
1233 {
1234 public:
1235 archive_options_diff() { x_selection = x_subtree = x_ea_mask = nullptr; clear(); };
1236 archive_options_diff(const archive_options_diff & ref) { copy_from(ref); };
1237 const archive_options_diff & operator = (const archive_options_diff & ref) { destroy(); copy_from(ref); return *this; };
1238 ~archive_options_diff() { destroy(); };
1239
1240 void clear();
1241
1243 // setting methods
1244
1246 void set_selection(const mask & selection);
1247
1249 void set_subtree(const mask & subtree);
1250
1257 void set_info_details(bool info_details) { x_info_details = info_details; };
1258
1262 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1263
1265 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1266
1268 void set_ea_mask(const mask & ea_mask);
1269
1271 void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1272
1274
1277 void set_alter_atime(bool alter_atime)
1278 {
1279 if(x_furtive_read)
1280 x_old_alter_atime = alter_atime;
1281 else
1282 x_alter_atime = alter_atime;
1283 };
1284
1286 void set_furtive_read_mode(bool furtive_read);
1287
1289 void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
1290
1292 void set_compare_symlink_date(bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };
1293
1295 void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1296
1297
1299 // getting methods
1300
1301 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1302 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1303 bool get_info_details() const { return x_info_details; };
1304 bool get_display_treated() const { return x_display_treated; };
1305 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1306 bool get_display_skipped() const { return x_display_skipped; };
1307 const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1308 cat_inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
1309 bool get_alter_atime() const { return x_alter_atime; };
1310 bool get_furtive_read_mode() const { return x_furtive_read; };
1311 const infinint & get_hourshift() const { return x_hourshift; };
1312 bool get_compare_symlink_date() const { return x_compare_symlink_date; };
1313 const fsa_scope & get_fsa_scope() const { return x_scope; };
1314
1315 private:
1316 mask * x_selection;
1317 mask * x_subtree;
1318 bool x_info_details;
1319 bool x_display_treated;
1320 bool x_display_treated_only_dir;
1321 bool x_display_skipped;
1322 mask * x_ea_mask;
1323 cat_inode::comparison_fields x_what_to_check;
1324 bool x_alter_atime;
1325 bool x_old_alter_atime;
1326 bool x_furtive_read;
1327 infinint x_hourshift;
1328 bool x_compare_symlink_date;
1329 fsa_scope x_scope;
1330
1331 void destroy();
1332 void copy_from(const archive_options_diff & ref);
1333 };
1334
1335
1336
1337
1341
1343 class archive_options_test : public on_pool
1344 {
1345 public:
1346 archive_options_test() { x_selection = x_subtree = nullptr; clear(); };
1347 archive_options_test(const archive_options_test & ref) { copy_from(ref); };
1348 const archive_options_test & operator = (const archive_options_test & ref) { destroy(); copy_from(ref); return *this; };
1349 ~archive_options_test() { destroy(); };
1350
1351 void clear();
1352
1354 // setting methods
1355
1357 void set_selection(const mask & selection);
1358
1360 void set_subtree(const mask & subtree);
1361
1368 void set_info_details(bool info_details) { x_info_details = info_details; };
1369
1371 void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1372
1376 void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1377
1379 void set_empty(bool empty) { x_empty = empty; };
1380
1381
1383 // getting methods
1384
1385 const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1386 const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1387 bool get_info_details() const { return x_info_details; };
1388 bool get_display_treated() const { return x_display_treated; };
1389 bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1390 bool get_display_skipped() const { return x_display_skipped; };
1391 bool get_empty() const { return x_empty; };
1392
1393 private:
1394 mask * x_selection;
1395 mask * x_subtree;
1396 bool x_info_details;
1397 bool x_display_treated;
1398 bool x_display_treated_only_dir;
1399 bool x_display_skipped;
1400 bool x_empty;
1401
1402 void destroy();
1403 void copy_from(const archive_options_test & ref);
1404 };
1405
1407
1408 } // end of namespace
1409
1410 #endif
libdar::on_pool
Definition: on_pool.hpp:52
criterium.hpp
contains classes that let the user define the policy for overwriting files
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:701
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_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:928
entrepot.hpp
defines the entrepot interface. Entrepot interface defines a generic way to interact with files (slic...
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:1371
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:157
libdar::archive_options_create::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
Definition: archive_options.hpp:368
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:866
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:397
fsa_family.hpp
filesystem specific attributes available families and fsa_scope definition
libdar::archive_options_extract::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition: archive_options.hpp:1063
libdar::archive_options_create::set_subtree
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
libdar::mask
the generic class, parent of all masks
Definition: mask.hpp:61
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:356
libdar::archive_options_read::set_multi_threaded
void set_multi_threaded(bool val)
whether libdar is allowed to create several thread to work possilbiy faster on multicore CPU (need li...
Definition: archive_options.hpp:151
libdar::archive_options_create::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition: archive_options.hpp:307
libdar::compile_time::furtive_read
bool furtive_read()
returns whether libdar can support furtive read mode when run by privileged user
libdar::archive_options_isolate::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
cypher to use
Definition: archive_options.hpp:676
integers.hpp
are defined here basic integer types that tend to be portable
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:484
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:698
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:910
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:1110
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:310
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:904
libdar::archive_options_create::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
Definition: archive_options.hpp:353
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:95
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:455
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:907
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:1078
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:121
libdar::archive_options_create::set_empty
void set_empty(bool empty)
whether to make a dry-run operation
Definition: archive_options.hpp:391
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:834
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:66
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:1101
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:1050
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:901
libdar::Ecompilation
exception used when a requested fearture has not beed activated at compilation time ...
Definition: erreurs.hpp:285
libdar::archive_options_merge::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
Definition: archive_options.hpp:880
libdar::archive_options_merge::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
Definition: archive_options.hpp:869
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:446
libdar::archive_options_test
class holding optional parameters used to test the structure coherence of an existing archive ...
Definition: archive_options.hpp:1343
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:713
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:695
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:916
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:346
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:374
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:141
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_isolate::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
Definition: archive_options.hpp:686
libdar::archive_options_create::set_exclude_by_ea
void set_exclude_by_ea(const std::string &ea_name)
Definition: archive_options.hpp:381
libdar::archive_options_isolate::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
Definition: archive_options.hpp:689
libdar::archive_options_read::archive_options_read
archive_options_read()
build an object and set options to their default values
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:452
libdar::archive_options_extract::set_what_to_check
void set_what_to_check(cat_inode::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:1075
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:1084
libdar::archive_options_merge::set_overwriting_rules
void set_overwriting_rules(const crit_action &overwrite)
policy to solve merging conflict
libdar::archive_options_read::clear
void clear()
reset all the options to their default values
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:388
libdar::archive_options_create::set_reference
void set_reference(archive *ref_arch)
set the archive to take as reference (nullptr for a full backup)
Definition: archive_options.hpp:281
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
Definition: archive_options.hpp:707
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:92
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) ...
Definition: archive_options.hpp:406
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:650
crypto.hpp
the crypto algoritm definition
libdar::archive_options_read::set_entrepot
void set_entrepot(const entrepot &entr)
defines the protocol to use to retrieve slices
Definition: archive_options.hpp:145
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:470
libdar::archive_options_read::set_ref_entrepot
void set_ref_entrepot(const entrepot &entr)
defines the protocol to use to retrieve slices of the reference archive (where the external catalogue...
Definition: archive_options.hpp:187
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:1081
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:313
libdar::archive_options_create::set_gnupg_recipients
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
Definition: archive_options.hpp:364
libdar::archive_options_merge::set_subtree
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
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:464
libdar::archive_options_isolate::set_allow_over
void set_allow_over(bool allow_over)
whether overwritting is allowed
Definition: archive_options.hpp:641
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:814
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:647
libdar::archive_options_read::set_ignore_signature_check_failure
void set_ignore_signature_check_failure(bool val)
whether to warn (true) or ignore (false) signature failure (default is true)
Definition: archive_options.hpp:148
libdar::archive_options_isolate::set_empty
void set_empty(bool empty)
whether to make a dry-run operation
Definition: archive_options.hpp:692
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:449
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:710
libdar::archive_options_isolate::set_compression
void set_compression(compression algo)
the compression algorithm used
Definition: archive_options.hpp:653
libdar::archive_options_extract::set_ea_mask
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
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:876
libdar::archive_options_test::set_empty
void set_empty(bool empty)
dry-run exectution if set to true
Definition: archive_options.hpp:1379
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:461
libdar::archive
the archive class realizes the most general operations on archives
Definition: archive.hpp:56
libdar::archive_options_test::set_subtree
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
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:440
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:168
libdar::crypto_algo
crypto_algo
the different cypher available for encryption (strong or weak)
Definition: crypto.hpp:51
libdar::archive_options_merge::set_empty
void set_empty(bool empty)
defines whether we do a dry-run execution
Definition: archive_options.hpp:892
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:437
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:811
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:704
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:490
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:679
libdar::Ememory
exception used when memory has been exhausted
Definition: erreurs.hpp:111
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:478
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:124
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:165
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:656
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:1066
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:1090
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_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:895
libdar::crit_action
the global action for overwriting
Definition: criterium.hpp:77
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:682
libdar::archive_options_extract
class holding optional parameters used to extract files from an existing archive
Definition: archive_options.hpp:1028
libdar::archive_options_create::set_info_details
void set_info_details(bool info_details)
Definition: archive_options.hpp:301
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:644
libdar::archive_options_merge::set_compression
void set_compression(compression compr_algo)
set the compression algorithm to be used
Definition: archive_options.hpp:843
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:922
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:1072
libdar::archive_options_extract::set_info_details
void set_info_details(bool info_details)
Definition: archive_options.hpp:1058
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:443
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:837
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_listing::listformat
listformat
defines the way archive listing is done:
Definition: archive_options.hpp:1179
hash_fichier.hpp
class hash_fichier definition.This is an inherited class from class fichier Objects of that class are...
libdar::archive_options_test::set_info_details
void set_info_details(bool info_details)
Definition: archive_options.hpp:1368
libdar::archive_options_extract::set_subtree
void set_subtree(const mask &subtree)
defines the directory and files to consider (this mask will be applied to the absolute path of files ...
mask.hpp
here lies a collection of mask classes
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:931
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:1107
libdar::archive_options_merge::set_entrepot
void set_entrepot(const entrepot &entr)
defines the protocol to use for slices
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_what_to_check
void set_what_to_check(cat_inode::comparison_fields what_to_check)
set the fields to consider when comparing inodes with reference archive (see cat_inode::comparison_fi...
Definition: archive_options.hpp:385
libdar::archive_options_extract::set_dirty_behavior
void set_dirty_behavior(t_dirty val)
alternative method to modify dirty behavior
Definition: archive_options.hpp:1093
libdar::archive_options_create::set_hash_algo
void set_hash_algo(hash_algo hash)
Definition: archive_options.hpp:475
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_compression
void set_compression(compression compr_algo)
set the compression algorithm to be used
Definition: archive_options.hpp:322
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:458
libdar::archive_options_merge::set_crypto_pass
void set_crypto_pass(const secu_string &pass)
Definition: archive_options.hpp:873
libdar::secu_string
class secu_string
Definition: secu_string.hpp:57
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:184
libdar::archive_options_create::set_crypto_algo
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
Definition: archive_options.hpp:349
libdar::compression
compression
the different compression algorithm available
Definition: compressor.hpp:43
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:104
nls_swap.hpp
provides a set of macro to change the NLS from user application domaine to libdar domain and vicevers...
libdar::archive_options_merge::set_gnupg_signatories
void set_gnupg_signatories(const std::vector< std::string > &gnupg_signatories)
the private keys matching the email of the provided list are used to sign the archive random key ...
Definition: archive_options.hpp:883
libdar::compile_time::nodump
bool nodump()
returns whether nodump flag support has been activated at compilation time
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:898
libdar::archive_options_isolate::set_execute
void set_execute(const std::string &execute)
command to execute after each slice creation
Definition: archive_options.hpp:673
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 ...
compressor.hpp
compression engine implementation
libdar::archive_options_merge::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:316
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:853
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
Definition: archive_options.hpp:919
libdar::archive_options_create::set_entrepot
void set_entrepot(const entrepot &entr)
defines the protocol to use for slices
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:162
libdar::archive_options_merge::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition: archive_options.hpp:831
on_pool.hpp
this is the base class of object that can be allocated on a memory pool
libdar::archive_options_listing
class holding optional parameters used to list the contents of an existing archive ...
Definition: archive_options.hpp:1167
libdar::archive_options_merge::set_info_details
void set_info_details(bool info_details)
Definition: archive_options.hpp:825
libdar::archive_options_create::set_compr_mask
void set_compr_mask(const mask &compr_mask)
defines files to compress
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:493
libdar::hash_algo
hash_algo
Definition: hash_fichier.hpp:57
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:319
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:332
libdar::infinint
the arbitrary large positive integer class
Definition: real_infinint.hpp:59
libdar::archive_options_create::clear
void clear()
reset all the options to their default values
libdar::cat_inode::comparison_fields
comparison_fields
flag used to only consider certain fields when comparing/restoring inodes
Definition: cat_inode.hpp:60
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:846
libdar::archive_options_read::unset_external_catalogue
void unset_external_catalogue()
clear any reference to an external catalogue
libdar::archive_options_read::set_crypto_algo
void set_crypto_algo(crypto_algo val)
Definition: archive_options.hpp:89
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:179
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:293
libdar::archive_options_extract::set_overwriting_rules
void set_overwriting_rules(const crit_action &over)
overwriting policy
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:719
libdar::archive_options_read
class holding optional parameters used to read an existing archive
Definition: archive_options.hpp:59
libdar::archive_options_isolate::set_entrepot
void set_entrepot(const entrepot &entr)
defines the protocol to use for slices
libdar::archive_options_merge
class holding optional parameters used to proceed to the merge operation
Definition: archive_options.hpp:788
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:110
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:467
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:663
libdar::archive_options_create
class holding optional parameters used to create an archive
Definition: archive_options.hpp:259
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:377
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:290
secu_string.hpp
this file contains the definition of secu_string class, a std::string like class but allocated in sec...
libdar::archive_options_isolate
class holding optional parameters used to isolate an existing archive
Definition: archive_options.hpp:626
libdar::entrepot
the Entrepot interface
Definition: entrepot.hpp:61
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
libdar::archive_options_test::set_display_treated
void set_display_treated(bool display_treated, bool only_dir)
Definition: archive_options.hpp:1376
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:131
catalogue.hpp
here is defined the many classed which is build of the catalogue
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:913
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:840
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:889
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:137
libdar::archive_options_create::set_ea_mask
void set_ea_mask(const mask &ea_mask)
defines which Extended Attributes to save
libdar::path
the class path is here to manipulate paths in the Unix notation: using'/'
Definition: path.hpp:50
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:325