Disk ARchive  2.5.11
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-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 
60  {
61  public:
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 
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; };
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 
190  void set_header_only(bool val) { x_header_only = val; };
191 
192 
193 
195  // getting methods (mainly used inside libdar, but kept public and part of the API in the case it is needed)
196 
197 
198  crypto_algo get_crypto_algo() const { return x_crypto; };
199  const secu_string & get_crypto_pass() const { return x_pass; };
200  U_32 get_crypto_size() const { return x_crypto_size; };
201  const std::string & get_input_pipe() const { return x_input_pipe; };
202  const std::string & get_output_pipe() const { return x_output_pipe; };
203  const std::string & get_execute() const { return x_execute; };
204  bool get_info_details() const { return x_info_details; };
205  bool get_lax() const { return x_lax; };
206  bool get_sequential_read() const { return x_sequential_read; };
207  infinint get_slice_min_digits() const { return x_slice_min_digits; };
208  const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
209  bool get_ignore_signature_check_failure() const { return x_ignore_signature_check_failure; };
210  bool get_multi_threaded() const { return x_multi_threaded; };
211 
212  // All methods that follow concern the archive where to fetch the (isolated) catalogue from
213  bool is_external_catalogue_set() const { return external_cat; };
214  const path & get_ref_path() const;
215  const std::string & get_ref_basename() const;
216  crypto_algo get_ref_crypto_algo() const { return x_ref_crypto; };
217  const secu_string & get_ref_crypto_pass() const { return x_ref_pass; };
218  U_32 get_ref_crypto_size() const { return x_ref_crypto_size; };
219  const std::string & get_ref_execute() const { return x_ref_execute; };
220  infinint get_ref_slice_min_digits() const { return x_ref_slice_min_digits; };
221  const entrepot & get_ref_entrepot() const { if(x_ref_entrepot == nullptr) throw SRC_BUG; return *x_ref_entrepot; };
222  bool get_header_only() const { return x_header_only; };
223 
224 
225  private:
226  crypto_algo x_crypto;
227  secu_string x_pass;
228  U_32 x_crypto_size;
229  std::string x_input_pipe;
230  std::string x_output_pipe;
231  std::string x_execute;
232  bool x_info_details;
233  bool x_lax;
234  bool x_sequential_read;
235  infinint x_slice_min_digits;
236  entrepot *x_entrepot;
237  bool x_ignore_signature_check_failure;
238  bool x_multi_threaded;
239 
240 
241  // external catalogue relative fields
242  bool external_cat;
243  path x_ref_chem;
244  std::string x_ref_basename;
245  crypto_algo x_ref_crypto;
246  secu_string x_ref_pass;
247  U_32 x_ref_crypto_size;
248  std::string x_ref_execute;
249  infinint x_ref_slice_min_digits;
250  entrepot *x_ref_entrepot;
251  bool x_header_only;
252 
253  void copy_from(const archive_options_read & ref);
254  void destroy();
255  };
256 
257 
261 
264  {
265  public:
266  // default constructors and destructor.
267 
270  const archive_options_create & operator = (const archive_options_create & ref) { destroy(); copy_from(ref); return *this; };
271  ~archive_options_create() { destroy(); };
272 
274  // set back to default (this is the state just after the object is constructed
275  // this method is to be used to reuse a given object
276 
278  void clear();
279 
280 
282  // setting methods
283 
285  void set_reference(archive *ref_arch) { x_ref_arch = ref_arch; };
286 
288  void set_selection(const mask & selection);
289 
291  void set_subtree(const mask & subtree);
292 
294  void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
295 
297  void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
298 
305  void set_info_details(bool info_details) { x_info_details = info_details; };
306 
311  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
312 
314  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
315 
317  void set_display_finished(bool display_finished) { x_display_finished = display_finished; };
318 
320  void set_pause(const infinint & pause) { x_pause = pause; };
321 
323  void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
324 
326  void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
327 
329  void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
330 
332 
336  void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
337  {
338  x_file_size = file_size;
339  if(first_file_size.is_zero())
340  x_first_file_size = file_size;
341  else
342  x_first_file_size = first_file_size;
343  };
344 
345 
347  void set_ea_mask(const mask & ea_mask);
348 
350  void set_execute(const std::string & execute) { x_execute = execute; };
351 
353  void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
354 
357  void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
358 
360  void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
361 
368  void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
369 
370 
372  void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
373 
375  void set_compr_mask(const mask & compr_mask);
376 
378  void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
379 
381  void set_nodump(bool nodump) { x_nodump = nodump; };
382 
385  void set_exclude_by_ea(const std::string & ea_name)
386  { exclude_by_ea = (ea_name == "" ? "user.libdar_no_backup" : ea_name); };
387 
389  void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
390 
392  void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
393 
395  void set_empty(bool empty) { x_empty = empty; };
396 
398 
401  void set_alter_atime(bool alter_atime)
402  {
403  if(x_furtive_read)
404  x_old_alter_atime = alter_atime;
405  else
406  x_alter_atime = alter_atime;
407  };
408 
411  {
412  NLS_SWAP_IN;
413  try
414  {
415 
416 #if FURTIVE_READ_MODE_AVAILABLE
417  x_furtive_read = furtive_read;
418  if(furtive_read)
419  {
420  x_old_alter_atime = x_alter_atime;
421  x_alter_atime = true;
422  // this is required to avoid libdar manipulating ctime of inodes
423  }
424  else
425  x_alter_atime = x_old_alter_atime;
426 #else
427  if(furtive_read)
428  throw Ecompilation(gettext("Furtive read mode"));
429  x_furtive_read = false;
430 #endif
431  }
432  catch(...)
433  {
434  NLS_SWAP_OUT;
435  throw;
436  }
437  NLS_SWAP_OUT;
438  };
439 
441  void set_same_fs(bool same_fs) { x_same_fs = same_fs; };
442 
444  void set_snapshot(bool snapshot) { x_snapshot = snapshot; };
445 
447  void set_cache_directory_tagging(bool cache_directory_tagging) { x_cache_directory_tagging = cache_directory_tagging; };
448 
450  void set_fixed_date(const infinint & fixed_date) { x_fixed_date = fixed_date; };
451 
453  void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
454 
456  void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
457 
459  void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
460 
462  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; };
463 
465  void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
466 
468  void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
469 
471  void set_security_check(bool check) { x_security_check = check; };
472 
474  void set_user_comment(const std::string & comment) { x_user_comment = comment; };
475 
479  void set_hash_algo(hash_algo hash) { x_hash = hash; };
480 
482  void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
483 
485  void set_backup_hook(const std::string & execute, const mask & which_files);
486 
488  void set_ignore_unknown_inode_type(bool val) { x_ignore_unknown = val; };
489 
491  void set_entrepot(const entrepot & entr);
492 
494  void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
495 
497  void set_multi_threaded(bool val) { x_multi_threaded = val; };
498 
499 
501  // getting methods
502 
503  archive *get_reference() const { return x_ref_arch; };
504  const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
505  const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
506  bool get_allow_over() const { return x_allow_over; };
507  bool get_warn_over() const { return x_warn_over; };
508  bool get_info_details() const { return x_info_details; };
509  bool get_display_treated() const { return x_display_treated; };
510  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
511  bool get_display_skipped() const { return x_display_skipped; };
512  bool get_display_finished() const { return x_display_finished; };
513  const infinint & get_pause() const { return x_pause; };
514  bool get_empty_dir() const { return x_empty_dir; };
515  compression get_compression() const { return x_compr_algo; };
516  U_I get_compression_level() const { return x_compression_level; };
517  const infinint & get_slice_size() const { return x_file_size; };
518  const infinint & get_first_slice_size() const { return x_first_file_size; };
519  const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
520  const std::string & get_execute() const { return x_execute; };
521  crypto_algo get_crypto_algo() const { return x_crypto; };
522  const secu_string & get_crypto_pass() const { return x_pass; };
523  U_32 get_crypto_size() const { return x_crypto_size; };
524  const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
525  const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
526  const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
527  const infinint & get_min_compr_size() const { return x_min_compr_size; };
528  bool get_nodump() const { return x_nodump; };
529  const std::string & get_exclude_by_ea() const { return exclude_by_ea; };
530  cat_inode::comparison_fields get_comparison_fields() const { return x_what_to_check; };
531  const infinint & get_hourshift() const { return x_hourshift; };
532  bool get_empty() const { return x_empty; };
533  bool get_alter_atime() const { return x_alter_atime; };
534  bool get_furtive_read_mode() const { return x_furtive_read; };
535  bool get_same_fs() const { return x_same_fs; };
536  bool get_snapshot() const { return x_snapshot; };
537  bool get_cache_directory_tagging() const { return x_cache_directory_tagging; };
538  const infinint & get_fixed_date() const { return x_fixed_date; };
539  const std::string & get_slice_permission() const { return x_slice_permission; };
540  const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
541  const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
542  const infinint & get_repeat_count() const { return x_repeat_count; };
543  const infinint & get_repeat_byte() const { return x_repeat_byte; };
544  bool get_sequential_marks() const { return x_sequential_marks; };
545  infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
546  bool get_security_check() const { return x_security_check; };
547  const std::string & get_user_comment() const { return x_user_comment; };
548  hash_algo get_hash_algo() const { return x_hash; };
549  infinint get_slice_min_digits() const { return x_slice_min_digits; };
550  const std::string & get_backup_hook_file_execute() const { return x_backup_hook_file_execute; };
551  const mask & get_backup_hook_file_mask() const { return *x_backup_hook_file_mask; };
552  bool get_ignore_unknown_inode_type() const { return x_ignore_unknown; };
553  const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
554  const fsa_scope & get_fsa_scope() const { return x_scope; };
555  bool get_multi_threaded() const { return x_multi_threaded; };
556 
557  private:
558  archive *x_ref_arch; //< just contains the address of an existing object, no local copy of object is done here
559  mask * x_selection; //< points to a local copy of mask (must be allocated / releases by the archive_option_create object)
560  mask * x_subtree; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
561  bool x_allow_over;
562  bool x_warn_over;
563  bool x_info_details;
564  bool x_display_treated;
565  bool x_display_treated_only_dir;
566  bool x_display_skipped;
567  bool x_display_finished;
568  infinint x_pause;
569  bool x_empty_dir;
570  compression x_compr_algo;
571  U_I x_compression_level;
572  infinint x_file_size;
573  infinint x_first_file_size;
574  mask * x_ea_mask; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
575  std::string x_execute;
576  crypto_algo x_crypto;
577  secu_string x_pass;
578  U_32 x_crypto_size;
579  std::vector<std::string> x_gnupg_recipients;
580  std::vector<std::string> x_gnupg_signatories;
581  mask * x_compr_mask; //< points to a local copy of mask (must be allocated / releases by the archive_option_create objects)
582  infinint x_min_compr_size;
583  bool x_nodump;
584  std::string exclude_by_ea;
585  cat_inode::comparison_fields x_what_to_check;
586  infinint x_hourshift;
587  bool x_empty;
588  bool x_alter_atime;
589  bool x_old_alter_atime; //< used to backup origina alter_atime value when activating furtive read mode
590  bool x_furtive_read;
591  bool x_same_fs;
592  bool x_snapshot;
593  bool x_cache_directory_tagging;
594  infinint x_fixed_date;
595  std::string x_slice_permission;
596  std::string x_slice_user_ownership;
597  std::string x_slice_group_ownership;
598  infinint x_repeat_count;
599  infinint x_repeat_byte;
600  bool x_sequential_marks;
601  infinint x_sparse_file_min_size;
602  bool x_security_check;
603  std::string x_user_comment;
604  hash_algo x_hash;
605  infinint x_slice_min_digits;
606  mask * x_backup_hook_file_mask;
607  std::string x_backup_hook_file_execute;
608  bool x_ignore_unknown;
609  entrepot *x_entrepot;
610  fsa_scope x_scope;
611  bool x_multi_threaded;
612 
613  void destroy();
614  void copy_from(const archive_options_create & ref);
615  void destroy_mask(mask * & ptr);
616  void clean_mask(mask * & ptr);
617  void check_mask(const mask & m);
618  };
619 
620 
621 
622 
623 
624 
628 
631  {
632  public:
633  archive_options_isolate() { x_entrepot = nullptr; clear(); };
634  archive_options_isolate(const archive_options_isolate & ref) { x_entrepot = nullptr; copy_from(ref); };
635  const archive_options_isolate & operator = (const archive_options_isolate & ref) { destroy(); copy_from(ref); return *this; };
636  ~archive_options_isolate() { destroy(); };
637 
638 
639  void clear();
640 
642  // setting methods
643 
645  void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
646 
648  void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
649 
651  void set_info_details(bool info_details) { x_info_details = info_details; };
652 
654  void set_pause(const infinint & pause) { x_pause = pause; };
655 
657  void set_compression(compression algo) { x_algo = algo; };
658 
660  void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
661 
663 
667  void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
668  {
669  x_file_size = file_size;
670  if(first_file_size.is_zero())
671  x_first_file_size = file_size;
672  else
673  x_first_file_size = first_file_size;
674  };
675 
677  void set_execute(const std::string & execute) { x_execute = execute; };
678 
680  void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
681 
683  void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
684 
686  void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
687 
690  void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
691 
693  void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
694 
696  void set_empty(bool empty) { x_empty = empty; };
697 
699  void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
700 
702  void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
703 
705  void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
706 
708  void set_user_comment(const std::string & comment) { x_user_comment = comment; };
709 
711  void set_hash_algo(hash_algo hash) { x_hash = hash; };
712 
714  void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
715 
717  void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
718 
720  void set_entrepot(const entrepot & entr);
721 
723  void set_multi_threaded(bool val) { x_multi_threaded = val; };
724 
725 
727  // getting methods
728 
729  bool get_allow_over() const { return x_allow_over; };
730  bool get_warn_over() const { return x_warn_over; };
731  bool get_info_details() const { return x_info_details; };
732  const infinint & get_pause() const { return x_pause; };
733  compression get_compression() const { return x_algo; };
734  U_I get_compression_level() const { return x_compression_level; };
735  const infinint & get_slice_size() const { return x_file_size; };
736  const infinint & get_first_slice_size() const { return x_first_file_size; };
737  const std::string & get_execute() const { return x_execute; };
738  crypto_algo get_crypto_algo() const { return x_crypto; };
739  const secu_string & get_crypto_pass() const { return x_pass; };
740  U_32 get_crypto_size() const { return x_crypto_size; };
741  const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
742  const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
743  bool get_empty() const { return x_empty; };
744  const std::string & get_slice_permission() const { return x_slice_permission; };
745  const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
746  const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
747  const std::string & get_user_comment() const { return x_user_comment; };
748  hash_algo get_hash_algo() const { return x_hash; };
749  infinint get_slice_min_digits() const { return x_slice_min_digits; };
750  bool get_sequential_marks() const { return x_sequential_marks; };
751  const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
752  bool get_multi_threaded() const { return x_multi_threaded; };
753 
754 
755  private:
756  bool x_allow_over;
757  bool x_warn_over;
758  bool x_info_details;
759  infinint x_pause;
760  compression x_algo;
761  U_I x_compression_level;
762  infinint x_file_size;
763  infinint x_first_file_size;
764  std::string x_execute;
765  crypto_algo x_crypto;
766  secu_string x_pass;
767  U_32 x_crypto_size;
768  std::vector<std::string> x_gnupg_recipients;
769  std::vector<std::string> x_gnupg_signatories;
770  bool x_empty;
771  std::string x_slice_permission;
772  std::string x_slice_user_ownership;
773  std::string x_slice_group_ownership;
774  std::string x_user_comment;
775  hash_algo x_hash;
776  infinint x_slice_min_digits;
777  bool x_sequential_marks;
778  entrepot *x_entrepot;
779  bool x_multi_threaded;
780 
781  void copy_from(const archive_options_isolate & ref);
782  void destroy();
783  };
784 
785 
786 
790 
793  {
794  public:
795 
796  archive_options_merge() { x_selection = x_subtree = x_ea_mask = x_compr_mask = nullptr; x_overwrite = nullptr; x_entrepot = nullptr; clear(); };
797  archive_options_merge(const archive_options_merge & ref) { copy_from(ref); };
798  const archive_options_merge & operator = (const archive_options_merge & ref) { destroy(); copy_from(ref); return *this; };
799  ~archive_options_merge() { destroy(); };
800 
801  void clear();
802 
804  // setting methods
805 
806  void set_auxilliary_ref(archive *ref) { x_ref = ref; };
807 
809  void set_selection(const mask & selection);
810 
812  void set_subtree(const mask & subtree);
813 
815  void set_allow_over(bool allow_over) { x_allow_over = allow_over; };
816 
818  void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
819 
821  void set_overwriting_rules(const crit_action & overwrite);
822 
829  void set_info_details(bool info_details) { x_info_details = info_details; };
830 
835  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
836 
838  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
839 
841  void set_pause(const infinint & pause) { x_pause = pause; };
842 
844  void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
845 
847  void set_compression(compression compr_algo) { x_compr_algo = compr_algo; };
848 
850  void set_compression_level(U_I compression_level) { x_compression_level = compression_level; };
851 
853 
857  void set_slicing(const infinint & file_size, const infinint & first_file_size = 0)
858  {
859  x_file_size = file_size;
860  if(first_file_size.is_zero())
861  x_first_file_size = file_size;
862  else
863  x_first_file_size = first_file_size;
864  };
865 
867  void set_ea_mask(const mask & ea_mask);
868 
870  void set_execute(const std::string & execute) { x_execute = execute; };
871 
873  void set_crypto_algo(crypto_algo crypto) { x_crypto = crypto; };
874 
877  void set_crypto_pass(const secu_string & pass) { x_pass = pass; };
878 
880  void set_crypto_size(U_32 crypto_size) { x_crypto_size = crypto_size; };
881 
884  void set_gnupg_recipients(const std::vector<std::string> & gnupg_recipients) { x_gnupg_recipients = gnupg_recipients; };
885 
887  void set_gnupg_signatories(const std::vector<std::string> & gnupg_signatories) { x_gnupg_signatories = gnupg_signatories; };
888 
890  void set_compr_mask(const mask & compr_mask);
891 
893  void set_min_compr_size(const infinint & min_compr_size) { x_min_compr_size = min_compr_size; };
894 
896  void set_empty(bool empty) { x_empty = empty; };
897 
899  void set_keep_compressed(bool keep_compressed) { x_keep_compressed = keep_compressed; };
900 
902  void set_slice_permission(const std::string & slice_permission) { x_slice_permission = slice_permission; };
903 
905  void set_slice_user_ownership(const std::string & slice_user_ownership) { x_slice_user_ownership = slice_user_ownership; };
906 
908  void set_slice_group_ownership(const std::string & slice_group_ownership) { x_slice_group_ownership = slice_group_ownership; };
909 
911  void set_decremental_mode(bool mode) { x_decremental = mode; };
912 
914  void set_sequential_marks(bool sequential) { x_sequential_marks = sequential; };
915 
917  void set_sparse_file_min_size(const infinint & size) { x_sparse_file_min_size = size; };
918 
920  void set_user_comment(const std::string & comment) { x_user_comment = comment; };
921 
923  void set_hash_algo(hash_algo hash) { x_hash = hash; };
924 
926  void set_slice_min_digits(infinint val) { x_slice_min_digits = val; };
927 
929  void set_entrepot(const entrepot & entr);
930 
932  void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
933 
935  void set_multi_threaded(bool val) { x_multi_threaded = val; };
936 
937 
939  // getting methods
940 
941  archive * get_auxilliary_ref() const { return x_ref; };
942  const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
943  const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
944  bool get_allow_over() const { return x_allow_over; };
945  bool get_warn_over() const { return x_warn_over; };
946  const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
947  bool get_info_details() const { return x_info_details; };
948  bool get_display_treated() const { return x_display_treated; };
949  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
950  bool get_display_skipped() const { return x_display_skipped; };
951  const infinint & get_pause() const { return x_pause; };
952  bool get_empty_dir() const { return x_empty_dir; };
953  compression get_compression() const { return x_compr_algo; };
954  U_I get_compression_level() const { return x_compression_level; };
955  const infinint & get_slice_size() const { return x_file_size; };
956  const infinint & get_first_slice_size() const { return x_first_file_size; };
957  const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
958  const std::string & get_execute() const { return x_execute; };
959  crypto_algo get_crypto_algo() const { return x_crypto; };
960  const secu_string & get_crypto_pass() const { return x_pass; };
961  U_32 get_crypto_size() const { return x_crypto_size; };
962  const std::vector<std::string> & get_gnupg_recipients() const { return x_gnupg_recipients; };
963  const std::vector<std::string> & get_gnupg_signatories() const { return x_gnupg_signatories; };
964  const mask & get_compr_mask() const { if(x_compr_mask == nullptr) throw SRC_BUG; return *x_compr_mask; };
965  const infinint & get_min_compr_size() const { return x_min_compr_size; };
966  bool get_empty() const { return x_empty; };
967  bool get_keep_compressed() const { return x_keep_compressed; };
968  const std::string & get_slice_permission() const { return x_slice_permission; };
969  const std::string & get_slice_user_ownership() const { return x_slice_user_ownership; };
970  const std::string & get_slice_group_ownership() const { return x_slice_group_ownership; };
971  bool get_decremental_mode() const { return x_decremental; };
972  bool get_sequential_marks() const { return x_sequential_marks; };
973  infinint get_sparse_file_min_size() const { return x_sparse_file_min_size; };
974  const std::string & get_user_comment() const { return x_user_comment; };
975  hash_algo get_hash_algo() const { return x_hash; };
976  infinint get_slice_min_digits() const { return x_slice_min_digits; };
977  const entrepot & get_entrepot() const { if(x_entrepot == nullptr) throw SRC_BUG; return *x_entrepot; };
978  const fsa_scope & get_fsa_scope() const { return x_scope; };
979  bool get_multi_threaded() const { return x_multi_threaded; };
980 
981  private:
982  archive * x_ref; //< points to an external existing object, must never be deleted by "this"
983  mask * x_selection;
984  mask * x_subtree;
985  bool x_allow_over;
986  bool x_warn_over;
987  crit_action * x_overwrite;
988  bool x_info_details;
989  bool x_display_treated;
990  bool x_display_treated_only_dir;
991  bool x_display_skipped;
992  infinint x_pause;
993  bool x_empty_dir;
994  compression x_compr_algo;
995  U_I x_compression_level;
996  infinint x_file_size;
997  infinint x_first_file_size;
998  mask * x_ea_mask;
999  std::string x_execute;
1000  crypto_algo x_crypto;
1001  secu_string x_pass;
1002  U_32 x_crypto_size;
1003  std::vector<std::string> x_gnupg_recipients;
1004  std::vector<std::string> x_gnupg_signatories;
1005  mask * x_compr_mask;
1006  infinint x_min_compr_size;
1007  bool x_empty;
1008  bool x_keep_compressed;
1009  std::string x_slice_permission;
1010  std::string x_slice_user_ownership;
1011  std::string x_slice_group_ownership;
1012  bool x_decremental;
1013  bool x_sequential_marks;
1014  infinint x_sparse_file_min_size;
1015  std::string x_user_comment;
1016  hash_algo x_hash;
1017  infinint x_slice_min_digits;
1018  entrepot *x_entrepot;
1019  fsa_scope x_scope;
1020  bool x_multi_threaded;
1021 
1022  void destroy();
1023  void copy_from(const archive_options_merge & ref);
1024  };
1025 
1026 
1030 
1033  {
1034  public:
1035  enum t_dirty { dirty_ignore, dirty_warn, dirty_ok };
1036 
1037  archive_options_extract() { x_selection = x_subtree = x_ea_mask = nullptr; x_overwrite = nullptr; clear(); };
1038  archive_options_extract(const archive_options_extract & ref) { copy_from(ref); };
1039  const archive_options_extract & operator = (const archive_options_extract & ref) { destroy(); copy_from(ref); return *this; };
1040  ~archive_options_extract() { destroy(); };
1041 
1042  void clear();
1043 
1045  // setting methods
1046 
1048  void set_selection(const mask & selection);
1049 
1051  void set_subtree(const mask & subtree);
1052 
1054  void set_warn_over(bool warn_over) { x_warn_over = warn_over; };
1055 
1062  void set_info_details(bool info_details) { x_info_details = info_details; };
1063 
1067  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1068 
1070  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1071 
1073  void set_ea_mask(const mask & ea_mask);
1074 
1076  void set_flat(bool flat) { x_flat = flat; };
1077 
1079  void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1080 
1082  void set_warn_remove_no_match(bool warn_remove_no_match) { x_warn_remove_no_match = warn_remove_no_match; };
1083 
1085  void set_empty(bool empty) { x_empty = empty; };
1086 
1088  void set_empty_dir(bool empty_dir) { x_empty_dir = empty_dir; };
1089 
1091 
1094  void set_dirty_behavior(bool ignore, bool warn) { x_dirty = ignore ? dirty_ignore : (warn ? dirty_warn : dirty_ok); };
1095 
1097  void set_dirty_behavior(t_dirty val) { x_dirty = val; };
1098 
1100  void set_overwriting_rules(const crit_action & over);
1101 
1103 
1105  void set_only_deleted(bool val) { x_only_deleted = val; };
1106 
1107 
1109 
1111  void set_ignore_deleted(bool val) { x_ignore_deleted = val; };
1112 
1114  void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1115 
1116 
1118  // getting methods
1119 
1120  const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1121  const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1122  bool get_warn_over() const { return x_warn_over; };
1123  bool get_info_details() const { return x_info_details; };
1124  bool get_display_treated() const { return x_display_treated; };
1125  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1126  bool get_display_skipped() const { return x_display_skipped; };
1127  const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1128  bool get_flat() const { return x_flat; };
1129  cat_inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
1130  bool get_warn_remove_no_match() const { return x_warn_remove_no_match; };
1131  bool get_empty() const { return x_empty; };
1132  bool get_empty_dir() const { return x_empty_dir; };
1133  t_dirty get_dirty_behavior() const { return x_dirty; }
1134  const crit_action & get_overwriting_rules() const { if(x_overwrite == nullptr) throw SRC_BUG; return *x_overwrite; };
1135  bool get_only_deleted() const { return x_only_deleted; };
1136  bool get_ignore_deleted() const { return x_ignore_deleted; };
1137  const fsa_scope & get_fsa_scope() const { return x_scope; };
1138 
1139  private:
1140  mask * x_selection;
1141  mask * x_subtree;
1142  bool x_warn_over;
1143  bool x_info_details;
1144  bool x_display_treated;
1145  bool x_display_treated_only_dir;
1146  bool x_display_skipped;
1147  mask * x_ea_mask;
1148  bool x_flat;
1149  cat_inode::comparison_fields x_what_to_check;
1150  bool x_warn_remove_no_match;
1151  bool x_empty;
1152  bool x_empty_dir;
1153  t_dirty x_dirty;
1154  crit_action *x_overwrite;
1155  bool x_only_deleted;
1156  bool x_ignore_deleted;
1157  fsa_scope x_scope;
1158 
1159  void destroy();
1160  void copy_from(const archive_options_extract & ref);
1161  };
1162 
1163 
1164 
1165 
1169 
1172  {
1173  public:
1174  archive_options_listing() { x_selection = x_subtree = nullptr; x_slicing_first = x_slicing_others = nullptr; clear(); };
1175  archive_options_listing(const archive_options_listing & ref) { copy_from(ref); };
1176  const archive_options_listing & operator = (const archive_options_listing & ref) { destroy(); copy_from(ref); return *this; };
1177  ~archive_options_listing() { destroy(); };
1178 
1179  void clear();
1180 
1182 
1184  {
1185  normal, //< the tar-like listing (this is the default)
1186  tree, //< the original dar's tree listing (for those that like forest)
1187  xml, //< the xml catalogue output
1188  slicing //< the slicing output (give info about where files are located)
1189  };
1190 
1192  // setting methods
1193 
1194  void set_info_details(bool info_details) { x_info_details = info_details; };
1195  void set_list_mode(listformat list_mode) { x_list_mode = list_mode; };
1196  void set_selection(const mask & selection);
1197  void set_subtree(const mask & subtree);
1198  void set_filter_unsaved(bool filter_unsaved) { x_filter_unsaved = filter_unsaved; };
1199  void set_display_ea(bool display_ea) { x_display_ea = display_ea; };
1200  void set_user_slicing(const infinint & slicing_first, const infinint & slicing_others);
1201  void set_sizes_in_bytes(bool arg) { x_sizes_in_bytes = arg; };
1202 
1204  // getting methods
1205 
1206  bool get_info_details() const { return x_info_details; };
1207  listformat get_list_mode() const { return x_list_mode; };
1208  const mask & get_selection() const;
1209  const mask & get_subtree() const;
1210  bool get_filter_unsaved() const { return x_filter_unsaved; };
1211  bool get_display_ea() const { return x_display_ea; };
1212  bool get_user_slicing(infinint & slicing_first, infinint & slicing_others) const;
1213  bool get_sizes_in_bytes() const { return x_sizes_in_bytes; };
1214 
1215  private:
1216  bool x_info_details;
1217  listformat x_list_mode;
1218  mask * x_selection;
1219  mask * x_subtree;
1220  bool x_filter_unsaved;
1221  bool x_display_ea;
1222  infinint *x_slicing_first;
1223  infinint *x_slicing_others;
1224  bool x_sizes_in_bytes;
1225 
1226  void destroy();
1227  void copy_from(const archive_options_listing & ref);
1228  };
1229 
1230 
1234 
1235 
1236  class archive_options_diff : public on_pool
1237  {
1238  public:
1239  archive_options_diff() { x_selection = x_subtree = x_ea_mask = nullptr; clear(); };
1240  archive_options_diff(const archive_options_diff & ref) { copy_from(ref); };
1241  const archive_options_diff & operator = (const archive_options_diff & ref) { destroy(); copy_from(ref); return *this; };
1242  ~archive_options_diff() { destroy(); };
1243 
1244  void clear();
1245 
1247  // setting methods
1248 
1250  void set_selection(const mask & selection);
1251 
1253  void set_subtree(const mask & subtree);
1254 
1261  void set_info_details(bool info_details) { x_info_details = info_details; };
1262 
1266  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1267 
1269  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1270 
1272  void set_ea_mask(const mask & ea_mask);
1273 
1275  void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1276 
1278 
1281  void set_alter_atime(bool alter_atime)
1282  {
1283  if(x_furtive_read)
1284  x_old_alter_atime = alter_atime;
1285  else
1286  x_alter_atime = alter_atime;
1287  };
1288 
1290  void set_furtive_read_mode(bool furtive_read);
1291 
1293  void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
1294 
1296  void set_compare_symlink_date(bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };
1297 
1299  void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1300 
1301 
1303  // getting methods
1304 
1305  const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1306  const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1307  bool get_info_details() const { return x_info_details; };
1308  bool get_display_treated() const { return x_display_treated; };
1309  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1310  bool get_display_skipped() const { return x_display_skipped; };
1311  const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1312  cat_inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
1313  bool get_alter_atime() const { return x_alter_atime; };
1314  bool get_furtive_read_mode() const { return x_furtive_read; };
1315  const infinint & get_hourshift() const { return x_hourshift; };
1316  bool get_compare_symlink_date() const { return x_compare_symlink_date; };
1317  const fsa_scope & get_fsa_scope() const { return x_scope; };
1318 
1319  private:
1320  mask * x_selection;
1321  mask * x_subtree;
1322  bool x_info_details;
1323  bool x_display_treated;
1324  bool x_display_treated_only_dir;
1325  bool x_display_skipped;
1326  mask * x_ea_mask;
1327  cat_inode::comparison_fields x_what_to_check;
1328  bool x_alter_atime;
1329  bool x_old_alter_atime;
1330  bool x_furtive_read;
1331  infinint x_hourshift;
1332  bool x_compare_symlink_date;
1333  fsa_scope x_scope;
1334 
1335  void destroy();
1336  void copy_from(const archive_options_diff & ref);
1337  };
1338 
1339 
1340 
1341 
1345 
1348  {
1349  public:
1350  archive_options_test() { x_selection = x_subtree = nullptr; clear(); };
1351  archive_options_test(const archive_options_test & ref) { copy_from(ref); };
1352  const archive_options_test & operator = (const archive_options_test & ref) { destroy(); copy_from(ref); return *this; };
1353  ~archive_options_test() { destroy(); };
1354 
1355  void clear();
1356 
1358  // setting methods
1359 
1361  void set_selection(const mask & selection);
1362 
1364  void set_subtree(const mask & subtree);
1365 
1372  void set_info_details(bool info_details) { x_info_details = info_details; };
1373 
1375  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1376 
1380  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1381 
1383  void set_empty(bool empty) { x_empty = empty; };
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_info_details() const { return x_info_details; };
1392  bool get_display_treated() const { return x_display_treated; };
1393  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1394  bool get_display_skipped() const { return x_display_skipped; };
1395  bool get_empty() const { return x_empty; };
1396 
1397  private:
1398  mask * x_selection;
1399  mask * x_subtree;
1400  bool x_info_details;
1401  bool x_display_treated;
1402  bool x_display_treated_only_dir;
1403  bool x_display_skipped;
1404  bool x_empty;
1405 
1406  void destroy();
1407  void copy_from(const archive_options_test & ref);
1408  };
1409 
1411 
1412 } // end of namespace
1413 
1414 #endif
contains classes that let the user define the policy for overwriting files
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_fsa_scope(const fsa_scope &scope)
defines the FSA (Filesystem Specific Attribute) to only consider (by default all FSA are considered) ...
defines the entrepot interface. Entrepot interface defines a generic way to interact with files (slic...
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
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 ...
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 ...
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_alter_atime(bool alter_atime)
whether to alter atime or ctime in the filesystem when reading files to save
filesystem specific attributes available families and fsa_scope definition
void set_display_treated(bool display_treated, bool only_dir)
the generic class, parent of all masks
Definition: mask.hpp:62
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_multi_threaded(bool val)
whether libdar is allowed to create several thread to work possilbiy faster on multicore CPU (need li...
void set_display_treated(bool display_treated, bool only_dir)
bool furtive_read()
returns whether libdar can support furtive read mode when run by privileged user
void set_crypto_algo(crypto_algo crypto)
cypher to use
are defined here basic integer types that tend to be portable
void set_ignore_unknown_inode_type(bool val)
whether to ignore unknown inode types instead of issuing a warning
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_sequential_marks(bool sequential)
whether to activate escape sequence aka tape marks to allow sequential reading of the archive ...
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_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
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_crypto_pass(const secu_string &pass)
void set_crypto_size(U_32 crypto_size)
the encryption block size to use to decrypt
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_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_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_execute(const std::string &execute)
set the command to execute before reading each slice (empty string for no script) ...
void set_header_only(bool val)
whether we only read the archive header and exit
void set_empty(bool empty)
whether to make a dry-run operation
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
archive_options_read(const archive_options_read &ref)
the copy constructor, assignment operator and destructor
void set_only_deleted(bool val)
only consider deleted files (if set, no data get restored)
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
exception used when a requested fearture has not beed activated at compilation time ...
Definition: erreurs.hpp:285
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_crypto_algo(crypto_algo crypto)
set the cypher to use
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 ...
class holding optional parameters used to test the structure coherence of an existing archive ...
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive ...
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_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_execute(const std::string &execute)
set the command to execute after each slice creation
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
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_default_crypto_size()
set the encryption block size to the default value
void set_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_exclude_by_ea(const std::string &ea_name)
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 ...
archive_options_read()
build an object and set options to their default values
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_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 (...
void set_empty_dir(bool empty_dir)
whether to restore directories where no file has been triggered for backup (no file/inode change...
void clear()
reset all the options to their default values
void set_hourshift(const infinint &hourshift)
ignore differences of at most this integer number of hours while looking for changes in dates ...
void set_reference(archive *ref_arch)
set the archive to take as reference (nullptr for a full backup)
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_crypto_pass(const secu_string &pass)
defines the password or passphrase to decrypt (unused if encryption is not set)
void set_furtive_read_mode(bool furtive_read)
whether to use furtive read mode (if activated, alter_atime() has no meaning/use) ...
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...
the crypto algoritm definition
void set_entrepot(const entrepot &entr)
defines the protocol to use to retrieve slices
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
void set_ref_entrepot(const entrepot &entr)
defines the protocol to use to retrieve slices of the reference archive (where the external catalogue...
void set_empty(bool empty)
defines whether we need to store ignored directories as empty
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_gnupg_recipients(const std::vector< std::string > &gnupg_recipients)
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
void set_allow_over(bool allow_over)
whether overwritting is allowed
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_info_details(bool info_details)
whether the user needs detailed output of the operation
void set_ignore_signature_check_failure(bool val)
whether to warn (true) or ignore (false) signature failure (default is true)
void set_empty(bool empty)
whether to make a dry-run operation
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_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_compression(compression algo)
the compression algorithm used
void set_crypto_size(U_32 crypto_size)
set the size of the encryption by block to use
void set_empty(bool empty)
dry-run exectution if set to true
void set_sequential_marks(bool sequential)
whether to add escape sequence aka tape marks to allow sequential reading of the archive ...
the archive class realizes the most general operations on archives
Definition: archive.hpp:56
void set_snapshot(bool snapshot)
whether to make an emtpy archive only referencing the current state of files in the filesystem ...
void set_ref_crypto_size(U_32 ref_crypto_size)
defines the crypto size for the reference catalogue
crypto_algo
Definition: crypto.hpp:51
void set_empty(bool empty)
defines whether we do a dry-run execution
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_allow_over(bool allow_over)
defines whether overwritting is allowed or not
void set_user_comment(const std::string &comment)
specify a user comment in the archive (always in clear text!)
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_crypto_pass(const secu_string &pass)
password / passphrase to encrypt the data with (empty string for interactive question) ...
exception used when memory has been exhausted
Definition: erreurs.hpp:111
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)
defines whether the user needs detailed output of the operation
void set_ref_crypto_pass(const secu_string &ref_pass)
defines the pass for the reference catalogue
void set_compression_level(U_I compression_level)
the compression level (from 1 to 9)
void set_display_skipped(bool display_skipped)
whether to display files that have been excluded by filters
void set_dirty_behavior(bool ignore, bool warn)
whether to restore dirty files (those that changed during backup), warn before restoring or ignoring ...
listformat
defines the way archive listing is done:
void set_keep_compressed(bool keep_compressed)
make dar ignore the &#39;algo&#39; argument and do not uncompress / compress files that are selected for merg...
the global action for overwriting
Definition: criterium.hpp:77
void set_crypto_size(U_32 crypto_size)
size of the encryption by block to use
class holding optional parameters used to extract files from an existing archive
void set_info_details(bool info_details)
void set_warn_over(bool warn_over)
whether a warning shall be issued before overwriting
void set_compression(compression compr_algo)
set the compression algorithm to be used
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_flat(bool flat)
whether to ignore directory structure and restore all files in the same directory ...
void set_info_details(bool info_details)
void set_cache_directory_tagging(bool cache_directory_tagging)
whether to consider the Cache Directory Tagging Standard
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...
class hash_fichier definition.This is an inherited class from class fichier Objects of that class are...
void set_info_details(bool info_details)
here lies a collection of mask classes
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
void set_ignore_deleted(bool val)
do not consider deleted files (if set, no inode will be removed)
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...
void set_dirty_behavior(t_dirty val)
alternative method to modify dirty behavior
void set_hash_algo(hash_algo hash)
void set_compression(compression compr_algo)
set the compression algorithm to be used
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_crypto_pass(const secu_string &pass)
class secu_string
Definition: secu_string.hpp:57
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_crypto_algo(crypto_algo crypto)
set the cypher to use
compression
the different compression algorithm available
Definition: compressor.hpp:43
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 "-")
provides a set of macro to change the NLS from user application domaine to libdar domain and vicevers...
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 ...
bool nodump()
returns whether nodump flag support has been activated at compilation time
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_execute(const std::string &execute)
command to execute after each slice creation
compression engine implementation
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_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
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_ref_crypto_algo(crypto_algo ref_crypto)
defines the crypto algo for the reference catalogue
void set_display_treated(bool display_treated, bool only_dir)
this is the base class of object that can be allocated on a memory pool
class holding optional parameters used to list the contents of an existing archive ...
void set_info_details(bool info_details)
void set_multi_threaded(bool val)
whether libdar is allowed to spawn several threads to possibily work faster on multicore CPU (require...
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
the arbitrary large positive integer class
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)
void unset_external_catalogue()
clear any reference to an external catalogue
void set_crypto_algo(crypto_algo val)
void set_ref_execute(const std::string &ref_execute)
set the command to execute before reading each slice of the reference catalogue
void set_warn_over(bool warn_over)
defines whether a warning shall be issued before overwriting
void set_multi_threaded(bool val)
whether libdar is allowed to created several thread to work possibily faster on multicore CPU (requir...
class holding optional parameters used to read an existing archive
class holding optional parameters used to proceed to the merge operation
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_security_check(bool check)
whether to check for ctime changes since with the archive of reference
void set_slicing(const infinint &file_size, const infinint &first_file_size=0)
define the archive slicing
class holding optional parameters used to create an archive
void set_nodump(bool nodump)
defines whether to ignore files with the nodump flag set
void set_allow_over(bool allow_over)
defines whether overwritting is allowed or not
this file contains the definition of secu_string class, a std::string like class but allocated in sec...
class holding optional parameters used to isolate an existing archive
the Entrepot interface
Definition: entrepot.hpp:61
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
comparison_fields
flag used to only consider certain fields when comparing/restoring inodes
Definition: cat_inode.hpp:60
void set_display_treated(bool display_treated, bool only_dir)
void set_lax(bool val)
defines whether any archive coherence error, system error or media error lead to the abortion of the ...
here is defined the many classed which is build of the catalogue
void set_sparse_file_min_size(const infinint &size)
whether to try to detect sparse files
void set_empty_dir(bool empty_dir)
defines whether we need to store ignored directories as empty
void set_min_compr_size(const infinint &min_compr_size)
defines file size under which to never compress
void set_sequential_read(bool val)
defines whether to try reading the archive sequentially (ala tar) or using the final catalogue ...
the class path is here to manipulate paths in the Unix notation: using&#39;/&#39;
Definition: path.hpp:50
void set_compression_level(U_I compression_level)
set the compression level (from 1 to 9)