Disk ARchive  2.5.6
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 
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 
260  {
261  public:
262  // default constructors and destructor.
263 
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 
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 
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 
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 
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 
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 
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 
1199  // getting methods
1200 
1201  bool get_info_details() const { return x_info_details; };
1202  listformat get_list_mode() const { return x_list_mode; };
1203  const mask & get_selection() const;
1204  const mask & get_subtree() const;
1205  bool get_filter_unsaved() const { return x_filter_unsaved; };
1206  bool get_display_ea() const { return x_display_ea; };
1207  bool get_user_slicing(infinint & slicing_first, infinint & slicing_others) const;
1208 
1209  private:
1210  bool x_info_details;
1211  listformat x_list_mode;
1212  mask * x_selection;
1213  mask * x_subtree;
1214  bool x_filter_unsaved;
1215  bool x_display_ea;
1216  infinint *x_slicing_first;
1217  infinint *x_slicing_others;
1218 
1219  void destroy();
1220  void copy_from(const archive_options_listing & ref);
1221  };
1222 
1223 
1227 
1228 
1229  class archive_options_diff : public on_pool
1230  {
1231  public:
1232  archive_options_diff() { x_selection = x_subtree = x_ea_mask = nullptr; clear(); };
1233  archive_options_diff(const archive_options_diff & ref) { copy_from(ref); };
1234  const archive_options_diff & operator = (const archive_options_diff & ref) { destroy(); copy_from(ref); return *this; };
1235  ~archive_options_diff() { destroy(); };
1236 
1237  void clear();
1238 
1240  // setting methods
1241 
1243  void set_selection(const mask & selection);
1244 
1246  void set_subtree(const mask & subtree);
1247 
1254  void set_info_details(bool info_details) { x_info_details = info_details; };
1255 
1259  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1260 
1262  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1263 
1265  void set_ea_mask(const mask & ea_mask);
1266 
1268  void set_what_to_check(cat_inode::comparison_fields what_to_check) { x_what_to_check = what_to_check; };
1269 
1271 
1274  void set_alter_atime(bool alter_atime)
1275  {
1276  if(x_furtive_read)
1277  x_old_alter_atime = alter_atime;
1278  else
1279  x_alter_atime = alter_atime;
1280  };
1281 
1283  void set_furtive_read_mode(bool furtive_read);
1284 
1286  void set_hourshift(const infinint & hourshift) { x_hourshift = hourshift; };
1287 
1289  void set_compare_symlink_date(bool compare_symlink_date) { x_compare_symlink_date = compare_symlink_date; };
1290 
1292  void set_fsa_scope(const fsa_scope & scope) { x_scope = scope; };
1293 
1294 
1296  // getting methods
1297 
1298  const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1299  const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1300  bool get_info_details() const { return x_info_details; };
1301  bool get_display_treated() const { return x_display_treated; };
1302  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1303  bool get_display_skipped() const { return x_display_skipped; };
1304  const mask & get_ea_mask() const { if(x_ea_mask == nullptr) throw SRC_BUG; return *x_ea_mask; };
1305  cat_inode::comparison_fields get_what_to_check() const { return x_what_to_check; };
1306  bool get_alter_atime() const { return x_alter_atime; };
1307  bool get_furtive_read_mode() const { return x_furtive_read; };
1308  const infinint & get_hourshift() const { return x_hourshift; };
1309  bool get_compare_symlink_date() const { return x_compare_symlink_date; };
1310  const fsa_scope & get_fsa_scope() const { return x_scope; };
1311 
1312  private:
1313  mask * x_selection;
1314  mask * x_subtree;
1315  bool x_info_details;
1316  bool x_display_treated;
1317  bool x_display_treated_only_dir;
1318  bool x_display_skipped;
1319  mask * x_ea_mask;
1320  cat_inode::comparison_fields x_what_to_check;
1321  bool x_alter_atime;
1322  bool x_old_alter_atime;
1323  bool x_furtive_read;
1324  infinint x_hourshift;
1325  bool x_compare_symlink_date;
1326  fsa_scope x_scope;
1327 
1328  void destroy();
1329  void copy_from(const archive_options_diff & ref);
1330  };
1331 
1332 
1333 
1334 
1338 
1341  {
1342  public:
1343  archive_options_test() { x_selection = x_subtree = nullptr; clear(); };
1344  archive_options_test(const archive_options_test & ref) { copy_from(ref); };
1345  const archive_options_test & operator = (const archive_options_test & ref) { destroy(); copy_from(ref); return *this; };
1346  ~archive_options_test() { destroy(); };
1347 
1348  void clear();
1349 
1351  // setting methods
1352 
1354  void set_selection(const mask & selection);
1355 
1357  void set_subtree(const mask & subtree);
1358 
1365  void set_info_details(bool info_details) { x_info_details = info_details; };
1366 
1368  void set_display_skipped(bool display_skipped) { x_display_skipped = display_skipped; };
1369 
1373  void set_display_treated(bool display_treated, bool only_dir) { x_display_treated = display_treated; x_display_treated_only_dir = only_dir; };
1374 
1376  void set_empty(bool empty) { x_empty = empty; };
1377 
1378 
1380  // getting methods
1381 
1382  const mask & get_selection() const { if(x_selection == nullptr) throw SRC_BUG; return *x_selection; };
1383  const mask & get_subtree() const { if(x_subtree == nullptr) throw SRC_BUG; return *x_subtree; };
1384  bool get_info_details() const { return x_info_details; };
1385  bool get_display_treated() const { return x_display_treated; };
1386  bool get_display_treated_only_dir() const { return x_display_treated_only_dir; };
1387  bool get_display_skipped() const { return x_display_skipped; };
1388  bool get_empty() const { return x_empty; };
1389 
1390  private:
1391  mask * x_selection;
1392  mask * x_subtree;
1393  bool x_info_details;
1394  bool x_display_treated;
1395  bool x_display_treated_only_dir;
1396  bool x_display_skipped;
1397  bool x_empty;
1398 
1399  void destroy();
1400  void copy_from(const archive_options_test & ref);
1401  };
1402 
1404 
1405 } // end of namespace
1406 
1407 #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:61
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_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)