Disk ARchive  2.6.2
Full featured and portable backup and archiving tool
command_line.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2019 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 COMMAND_LINE_HPP
27 #define COMMAND_LINE_HPP
28 
29 #include "../my_config.h"
30 #include <string>
31 #include <deque>
32 #include <vector>
33 #include "libdar.hpp"
34 
35 using namespace std;
36 using namespace libdar;
37 
40 
41 enum operation { noop, extract, create, diff, test, listing, isolate, merging, version_or_help, repairing };
42  // noop stands for no-operation. get_args() never returns such value,
43  // it is just necessary within the command_line module
44 
45 enum dirty_behavior { dirtyb_ignore, dirtyb_warn, dirtyb_ok };
46 
48 struct ent_params
49 {
50  string ent_proto;
51  string ent_login;
53  string ent_host;
54  string ent_port;
57 
58  void clear()
59  { ent_proto.clear(); ent_login.clear(); ent_pass.clear();
60  ent_host.clear(); ent_port.clear(); network_retry = 3;
61  auth_from_file = false; };
62 };
63 
65 struct line_param
66 {
67  operation op;
70  string filename;
72  string * ref_filename;
77  bool allow_over;
78  bool warn_over;
79  bool info_details;
88  bool beep;
89  bool empty_dir;
91  string input_pipe;
92  string output_pipe;
94  string execute;
95  string execute_ref;
97  vector<string> signatories;
101  bool flat;
103  bool nodump;
109  bool empty;
110  bool alter_atime;
111  bool same_fs;
112  bool snapshot;
114  U_32 crypto_size;
118  string * aux_filename;
120  string aux_execute;
124  bool quiet;
126  string slice_perm;
127  string slice_user;
128  string slice_group;
131  bool decremental;
133  bool lax;
137  dirty_behavior dirty;
139  string user_comment;
145  bool not_deleted;
148  bool list_ea;
153  bool delta_sig;
155  bool delta_diff;
161  bool header_only;
167 
168  // constructor for line_param
169  line_param()
170  {
171  fs_root = nullptr;
172  sauv_root = nullptr;
173  ref_root = nullptr;
174  selection = nullptr;
175  subtree = nullptr;
176  ref_filename = nullptr;
177  ea_mask = nullptr;
178  compress_mask = nullptr;
179  aux_root = nullptr;
180  aux_filename = nullptr;
181  overwrite = nullptr;
182  backup_hook_mask = nullptr;
183  };
184 
185  // destructor for line_param
186  ~line_param()
187  {
188  if(fs_root != nullptr)
189  delete fs_root;
190  if(sauv_root != nullptr)
191  delete sauv_root;
192  if(ref_root != nullptr)
193  delete ref_root;
194  if(selection != nullptr)
195  delete selection;
196  if(subtree != nullptr)
197  delete subtree;
198  if(ref_filename != nullptr)
199  delete ref_filename;
200  if(ea_mask != nullptr)
201  delete ea_mask;
202  if(compress_mask != nullptr)
203  delete compress_mask;
204  if(aux_root != nullptr)
205  delete aux_root;
206  if(aux_filename != nullptr)
207  delete aux_filename;
208  if(overwrite != nullptr)
209  delete overwrite;
210  if(backup_hook_mask != nullptr)
211  delete backup_hook_mask;
212  };
213 };
214 
216 
217 extern bool get_args(shared_ptr<user_interaction> & dialog,
218  const char *home,
219  const deque<string> & dar_dcf_path,
220  const deque<string> & dar_duc_path,
221  S_I argc,
222  char * const argv[],
223  line_param & param);
224 
225 
226 #if HAVE_GETOPT_LONG
227 const struct option *get_long_opt();
228 #endif
229 
230 const char *get_short_opt();
231 
233 
234 #endif
comparison_fields
how to consider file change during comparison and incremental backup
Definition: archive_aux.hpp:52
modified_data_detection modet
how to detect that a file has changed since the archive of reference was done
infinint first_file_size
sice of the first slice to create
hash_algo kdf_hash
hash algo used for key derivation function
infinint sparse_file_min_size
minimum size of a zeroed byte sequence to be considered as a hole and stored this way in the archive ...
all parameters retreived from command-line
bool lax
whether to activate the last chance recovery mode (use with caution!)
the generic class, parent of all masks
Definition: mask.hpp:61
bool quiet
whether to display final summary for the operation
bool delta_sig
whether to calculate rsync signature of files
string input_pipe
if not an empty string, name of the pipe through which to read data from dar_slave ...
bool sizes_in_bytes
whether to display sizes in bytes of to the larges unit (Mo, Go, To,...)
bool info_details
whether to show processing messages
infinint num_digits
minimum number of decimal for the slice number
string backup_hook_execute
which command to execute as backup hook
string slice_user
user to set when creating a slice
U_I network_retry
libcurl entrepot network retry time
bool cache_directory_tagging
whether to ignore directory contents where a the cache directory tagging files is found ...
U_32 crypto_size_ref
block size by which to uncypher data from the archive of reference
infinint delta_sig_min_size
size below which to never calculate delta signatures
infinint hourshift
consider equal two dates that have an integer hour of difference equal or less than hourshift ...
bool only_deleted
whether to only consider deleted files
mask * delta_mask
which file to calculate delta sig when not using the default mask
bool same_fs
whether to stick to a same filesystem
string * ref_filename
basename of the archive of reference (nullptr => no archive of reference)
bool alter_atime
whether to reset the atime of file read during backup to their original value (resetting atime does m...
path * fs_root
filesystem root
bool snapshot
whether to perform a snapshot backup
string slice_group
group to set when creating a slice
bool multi_threaded
allows libdar to use multiple threads (requires libthreadar)
string filename
basename of the archive to operate on
entrepot relative parameters
string execute_ref
if not an empty string, the command to execute between slices of the archive of reference ...
U_32 aux_crypto_size
block size by which to cypher/uncypher data to/from the auxiliary archive of reference ...
string ignored_as_symlink
column separated list of absolute paths of links to follow rather to record as such ...
operation op
which operation to perform
fsa_scope scope
FSA scope to consider for the operation.
bool empty_dir
whether to store skipped directories as empty, whether to avoid restoring directory where no data is ...
ent_params remote
remote entrepot coordinates
STL namespace.
bool keep_compressed
when merging, whether to not uncompress/re-compress data in the process
vector< string > signatories
list of email&#39;s key to use to sign the archive
bool display_finished
whether to display summary (space/compression ratio) for each completed directory ...
string ent_proto
entrepot protocol
archive_options_listing_shell::listformat list_mode
type of listing to follow
mask * backup_hook_mask
which file have to considered for backup hook
bool display_skipped
whether to display skipped files
infinint pause
whether to pause between slices
bool furtive_read_mode
whether to use the furtive read mode
string execute
if not an empty string, the command to execute between slices
bool filter_unsaved
whether to not list files that are not saved in the archive
string output_pipe
if not an empty string, name of the pipe through which to write orders to dar_slave ...
infinint aux_num_digits
minimum number of decimal for the slice number of the auxiliary archive of reference ...
mask * subtree
filter files for the operation based on path+filename
secu_string ent_pass
entrepot password
bool beep
whether to ring the terminal upon user interaction request
mask * ea_mask
which EA to work on
infinint fixed_date
the data for the snapshot backup
bool allow_over
whether to allow slice overwriting
path * sauv_root
where is the archive to operate on (create, read, etc.)
bool sequential_read
whether to follow escape sequential marks to achieve a sequential reading of the archive ...
secu_string aux_pass
crypto to use for the auxiliary archive
const crit_action * overwrite
the overwriting policy
string ent_host
entrepot hostname
bool not_deleted
whether to ignore deleted files
bool display_treated_only_dir
whether to show treated files&#39;s current working directory
void clear()
clear the string (set to an empty string)
bool display_masks
whether to display masks value
the global action for overwriting
Definition: crit_action.hpp:81
U_I compression_level
compression level to use when generating an archive
bool warn_over
whether to warn before overwriting files or slices
bool nodump
whether to ignore files having the "nodump" flag set when performing a backup
bool no_compare_symlink_date
whether to report difference in dates of symlinks while diffing an archive with filesystem ...
U_32 crypto_size
block size by which to cypher data
string ea_name_for_exclusion
EA name to use for file exclusion, or empty string for the default EA name.
bool delta_diff
whether to save binary diff or whole file&#39;s data during a differential backup
mask * selection
filter files for the operation based on filename only
bool zeroing_neg_dates
whether to automatically zeroing negative dates while reading inode from filesystem ...
std::set< fsa_family > fsa_scope
set of fsa families
Definition: fsa_family.hpp:70
ent_params ref_remote
remote entrepot coordinates for archive of reference
compression algo
compression algorithm to use when generating an archive
bool decremental
whether to produce a decremental backup (when merging)
bool get_args(shared_ptr< user_interaction > &dialog, const char *home, const deque< string > &dar_dcf_path, const deque< string > &dar_duc_path, S_I argc, char *const argv[], line_param &param)
main routine to extract parameters from command-line and included files
ent_params aux_remote
remote entrepot coordinates for the auxiliary archive
string ent_port
entrepot port
bool auth_from_file
whether ~/.netrc and ~/.ssh files should be considered for credentials
modified_data_detection
how to detect data has changed when some fields
Definition: archive_aux.hpp:43
bool warn_remove_no_match
whether to warn file about to be removed during a restoration, when they to no match the expected typ...
class secu_string
Definition: secu_string.hpp:57
dirty_behavior dirty
what to do when comes the time to restore a file that is flagged as dirty
compression
the different compression algorithm available
Definition: compression.hpp:45
string user_comment
user comment to add to the archive
bool exclude_by_ea
whether inode have to be check against a given EA before backup
infinint iteration_count
iteration count used when creating/isolating/merging an encrypted archive (key derivation) ...
string * aux_filename
basename of the auxiliary archive if reference (nullptr => no auxiliary of reference) ...
the main file of the libdar API definitions
path * ref_root
where is the archive of reference
string slice_perm
permission to set when creating a slice
bool display_treated
whether to show treated files
infinint repeat_count
number of time to try saving a file if it changes at the time it is read for backup ...
infinint ref_num_digits
minimum number of decimal for the slice number of the archive of reference
hash_algo
hashing algorithm available
Definition: archive_aux.hpp:62
bool use_sequential_marks
whether to add escape sequential marks in the archive
the arbitrary large positive integer class
hash_algo hash
whether to produce a hash file, and which algoritm to use for that hash
bool security_check
whether to signal possible root-kit presence
bool flat
whether to ignore directory structure when restoring data
secu_string pass
if not an empty string, encrypt the archive with the given algo:pass string
secu_string pass_ref
if not an empty string, use the provided encryption scheme to read the archive of reference ...
bool blind_signatures
whether to ignore signature check failures
bool header_only
whether we just display the header of archives to be read
infinint file_size
size of the slices to create (except the first)
string ent_login
entrepot login
bool list_ea
whether to list Extended Attribute of files
comparison_fields what_to_check
what fields to take into account when comparing/restoring files,
path * aux_root
where is the auxiliary archive of reference [used for merging but also when creating an archive...
bool ignore_unknown_inode
whether to ignore unknown inode types
listformat
defines the way archive listing is done:
infinint min_compr_size
below which size to never try compressing files
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:46
mask * compress_mask
which file to compress
bool empty
whether to do a dry-run execution
string aux_execute
command to be run between the slice of the auxiliary archive of reference
the class path is here to manipulate paths in the Unix notation: using&#39;/&#39;
Definition: path.hpp:50
infinint repeat_byte
archive total maximum amount of byte to waste re-saving changing files