Disk ARchive  2.7.14
Full featured and portable backup and archiving tool
macro_tools.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2024 Denis Corbin
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 //
19 // to contact the author, see the AUTHOR file
20 /*********************************************************************/
21 
25 
26 #ifndef MACRO_TOOLS_HPP
27 #define MACRO_TOOLS_HPP
28 
29 #include "../my_config.h"
30 
31 extern "C"
32 {
33 #if HAVE_LIMITS_H
34 #include <limits.h>
35 #endif
36 }
37 #include <string>
38 #include <vector>
39 
40 #include "catalogue.hpp"
41 #include "compression.hpp"
42 #include "infinint.hpp"
43 #include "header_version.hpp"
44 #include "generic_file.hpp"
45 #include "crypto.hpp"
46 #include "pile.hpp"
47 #include "entrepot.hpp"
48 #include "range.hpp"
49 #include "slice_layout.hpp"
50 #include "tuyau.hpp"
51 #include "trivial_sar.hpp"
52 #include "proto_compressor.hpp"
53 
54 
55 #define BUFFER_SIZE 102400
56 #ifdef SSIZE_MAX
57 #if SSIZE_MAX < BUFFER_SIZE
58 #undef BUFFER_SIZE
59 #define BUFFER_SIZE SSIZE_MAX
60 #endif
61 #endif
62 
63 namespace libdar
64 {
65 
68 
69  constexpr U_I GLOBAL_ELASTIC_BUFFER_SIZE = 51200;
70 
71  extern const archive_version macro_tools_supported_version;
72  extern const std::string LIBDAR_STACK_LABEL_UNCOMPRESSED;
73  extern const std::string LIBDAR_STACK_LABEL_CLEAR;
74  extern const std::string LIBDAR_STACK_LABEL_UNCYPHERED;
75  extern const std::string LIBDAR_STACK_LABEL_LEVEL1;
76 
78  extern trivial_sar *macro_tools_open_archive_tuyau(const std::shared_ptr<user_interaction> & dialog,
79  S_I fd,
80  gf_mode mode,
81  const label & internal_name,
82  const label & data_name,
83  bool slice_header_format_07,
84  const std::string & execute);
85 
86 
88 
109 
110  extern void macro_tools_open_archive(const std::shared_ptr<user_interaction> & dialog,
111  const std::shared_ptr<entrepot> & where,
112  const std::string &basename,
113  const infinint & min_digits,
114  const std::string &extension,
115  crypto_algo crypto,
116  const secu_string &pass,
117  U_32 crypto_size,
118  pile & stack,
119  header_version &ver,
120  const std::string &input_pipe,
121  const std::string &output_pipe,
122  const std::string & execute,
123  infinint & second_terminateur_offset,
124  bool lax,
125  bool has_external_cat,
126  bool sequential_read,
127  bool info_details,
128  std::list<signator> & gnupg_signed,
129  slice_layout & sl,
130  U_I multi_threaded_crypto,
131  U_I multi_threaded_compress,
132  bool header_only
133  );
134  // all allocated objects (ret1, ret2, scram), must be deleted when no more needed by the caller of this routine
135 
137  extern catalogue *macro_tools_get_derivated_catalogue_from(const std::shared_ptr<user_interaction> & dialog,
138  pile & data_stack, // where to get the files and EA from
139  pile & cata_stack, // where to get the catalogue from
140  const header_version & ver, // version format as defined in the header of the archive to read
141  bool info_details, // verbose display (throught user_interaction)
142  infinint &cat_size, // return size of archive in file (not in memory !)
143  const infinint & second_terminateur_offset, // location of the second terminateur (zero if none exist)
144  std::list<signator> & signatories, // returns the list of signatories (empty if archive is was not signed)
145  bool lax_mode); // whether to do relaxed checkings
146 
148  extern catalogue *macro_tools_get_catalogue_from(const std::shared_ptr<user_interaction> & dialog,
149  pile & stack, // raw data access object
150  const header_version & ver, // version format as defined in the header of the archive to read
151  bool info_details, // verbose display (throught user_interaction)
152  infinint &cat_size, // return size of archive in file (not in memory !)
153  const infinint & second_terminateur_offset,
154  std::list<signator> & signatories, // returns the list of signatories (empty if archive is was not signed)
155  bool lax_mode);
156 
158  extern catalogue *macro_tools_read_catalogue(const std::shared_ptr<user_interaction> & dialog,
159  const header_version & ver,
160  const pile_descriptor & cata_pdesc,
161  const infinint & cat_size,
162  std::list<signator> & signatories,
163  bool lax_mode,
164  const label & lax_layer1_data_name,
165  bool only_detruits);
166 
167  extern catalogue *macro_tools_lax_search_catalogue(const std::shared_ptr<user_interaction> & dialog,
168  pile & stack,
169  const archive_version & edition,
170  compression compr_algo,
171  bool info_details,
172  bool even_partial_catalogues,
173  const label & layer1_data_name);
174 
175  // return the offset of the beginning of the catalogue.
176  extern infinint macro_tools_get_terminator_start(generic_file & f, const archive_version & reading_ver);
177 
179 
237 
238  extern void macro_tools_create_layers(const std::shared_ptr<user_interaction> & dialog,
239  pile & layers,
240  header_version & ver,
241  slice_layout & slicing,
242  const slice_layout *ref_slicing,
243  const std::shared_ptr<entrepot> & sauv_path_t,
244  const std::string & filename,
245  const std::string & extension,
246  bool allow_over,
247  bool warn_over,
248  bool info_details,
249  const infinint & pause,
250  compression algo,
251  U_I compression_level,
252  U_I compression_block_size,
253  const infinint & file_size,
254  const infinint & first_file_size,
255  const std::string & execute,
256  crypto_algo crypto,
257  const secu_string & pass,
258  U_32 crypto_size,
259  const std::vector<std::string> & gnupg_recipients,
260  const std::vector<std::string> & gnupg_signatories,
261  bool empty,
262  const std::string & slice_permission,
263  bool add_marks_for_sequential_reading,
264  const std::string & user_comment,
265  hash_algo hash,
266  const infinint & slice_min_digits,
267  const label & internal_name,
268  const label & data_name,
269  const infinint & iteration_count,
270  hash_algo kdf_hash,
271  U_I multi_threaded_crypto,
272  U_I multi_threaded_compress);
273 
275 
286  extern void macro_tools_close_layers(const std::shared_ptr<user_interaction> & dialog,
287  pile & layers,
288  const header_version & ver,
289  const catalogue & cat,
290  bool info_details,
291  crypto_algo crypto,
292  compression algo,
293  const std::vector<std::string> & gnupg_recipients,
294  const std::vector<std::string> & gnupg_signatories,
295  bool empty);
296 
297 
299 
304  extern range macro_tools_get_slices(const cat_nomme *obj, slice_layout sl);
305 
307 
314  extern void macro_tools_open_pipes(const std::shared_ptr<user_interaction> & dialog,
315  const std::string &input,
316  const std::string & output,
317  tuyau *&in,
318  tuyau *&out);
319 
321 
327  generic_file & base,
328  U_I compression_level,
329  U_I num_workers);
330 
332 
338  extern proto_compressor* macro_tools_build_block_compressor(compression algo,
339  generic_file & base,
340  U_I compression_level,
341  U_I num_workers,
342  U_I block_size);
343 
345 
346 } // end of namespace
347 
348 
349 #endif
here is defined the classe used to manage catalogue of archives
class archive_version manages the version of the archive format
the base class for all entry that have a name
Definition: cat_nomme.hpp:45
the catalogue class which gather all objects contained in a give archive
Definition: catalogue.hpp:60
this is the interface class from which all other data transfer classes inherit
manages the archive header and trailer
the arbitrary large positive integer class
manage label data structure used in archive slice headers
Definition: label.hpp:43
stores a stack of generic_files writing/reading on each others
Definition: pile.hpp:44
stores a range of integers or a set of ranges
Definition: range.hpp:44
class secu_string
Definition: secu_string.hpp:54
pipe implementation under the generic_file interface.
Definition: tuyau.hpp:49
compression parameters for API
the crypto algoritm definition
defines the entrepot interface.
class generic_file is defined here as well as class fichier
hash_algo
hashing algorithm available
Definition: archive_aux.hpp:63
compression
the different compression algorithm available
Definition: compression.hpp:46
crypto_algo
the different cypher available for encryption (strong or weak)
Definition: crypto.hpp:50
proto_compressor * macro_tools_build_block_compressor(compression algo, generic_file &base, U_I compression_level, U_I num_workers, U_I block_size)
return a proto_compressor object realizing the desired (de)compression level/algo on to of "base" in ...
void macro_tools_create_layers(const std::shared_ptr< user_interaction > &dialog, pile &layers, header_version &ver, slice_layout &slicing, const slice_layout *ref_slicing, const std::shared_ptr< entrepot > &sauv_path_t, const std::string &filename, const std::string &extension, bool allow_over, bool warn_over, bool info_details, const infinint &pause, compression algo, U_I compression_level, U_I compression_block_size, const infinint &file_size, const infinint &first_file_size, const std::string &execute, crypto_algo crypto, const secu_string &pass, U_32 crypto_size, const std::vector< std::string > &gnupg_recipients, const std::vector< std::string > &gnupg_signatories, bool empty, const std::string &slice_permission, bool add_marks_for_sequential_reading, const std::string &user_comment, hash_algo hash, const infinint &slice_min_digits, const label &internal_name, const label &data_name, const infinint &iteration_count, hash_algo kdf_hash, U_I multi_threaded_crypto, U_I multi_threaded_compress)
build layers for a new archive
catalogue * macro_tools_get_catalogue_from(const std::shared_ptr< user_interaction > &dialog, pile &stack, const header_version &ver, bool info_details, infinint &cat_size, const infinint &second_terminateur_offset, std::list< signator > &signatories, bool lax_mode)
uses terminator to skip to the position where to find the catalogue and read it
void macro_tools_close_layers(const std::shared_ptr< user_interaction > &dialog, pile &layers, const header_version &ver, const catalogue &cat, bool info_details, crypto_algo crypto, compression algo, const std::vector< std::string > &gnupg_recipients, const std::vector< std::string > &gnupg_signatories, bool empty)
dumps the catalogue and close all the archive layers to terminate the archive
range macro_tools_get_slices(const cat_nomme *obj, slice_layout sl)
gives the location of data EA and FSA (when they are saved) of the object given in argument
trivial_sar * macro_tools_open_archive_tuyau(const std::shared_ptr< user_interaction > &dialog, S_I fd, gf_mode mode, const label &internal_name, const label &data_name, bool slice_header_format_07, const std::string &execute)
create an container to write an archive to a pipe
void macro_tools_open_pipes(const std::shared_ptr< user_interaction > &dialog, const std::string &input, const std::string &output, tuyau *&in, tuyau *&out)
open a pair of tuyau objects encapsulating two named pipes.
catalogue * macro_tools_read_catalogue(const std::shared_ptr< user_interaction > &dialog, const header_version &ver, const pile_descriptor &cata_pdesc, const infinint &cat_size, std::list< signator > &signatories, bool lax_mode, const label &lax_layer1_data_name, bool only_detruits)
read the catalogue from cata_stack assuming the cata_stack is positionned at the beginning of the are...
proto_compressor * macro_tools_build_streaming_compressor(compression algo, generic_file &base, U_I compression_level, U_I num_workers)
return a proto_compressor object realizing the desired (de)compression level/aglo on top of "base" in...
catalogue * macro_tools_get_derivated_catalogue_from(const std::shared_ptr< user_interaction > &dialog, pile &data_stack, pile &cata_stack, const header_version &ver, bool info_details, infinint &cat_size, const infinint &second_terminateur_offset, std::list< signator > &signatories, bool lax_mode)
uses terminator to skip to the position where to find the catalogue and read it, taking care of havin...
gf_mode
generic_file openning modes
Definition: gf_mode.hpp:44
void macro_tools_open_archive(const std::shared_ptr< user_interaction > &dialog, const std::shared_ptr< entrepot > &where, const std::string &basename, const infinint &min_digits, const std::string &extension, crypto_algo crypto, const secu_string &pass, U_32 crypto_size, pile &stack, header_version &ver, const std::string &input_pipe, const std::string &output_pipe, const std::string &execute, infinint &second_terminateur_offset, bool lax, bool has_external_cat, bool sequential_read, bool info_details, std::list< signator > &gnupg_signed, slice_layout &sl, U_I multi_threaded_crypto, U_I multi_threaded_compress, bool header_only)
setup the given pile object to contain a stack of generic_files suitable to read an archive
archive global header/trailer structure is defined here
switch module to limitint (32 ou 64 bits integers) or infinint
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
class pile definition. Used to manage a stack of generic_file objects
abstracted ancestor class for compressor and parallel_compressor classes
class than provide a way to manipulate and represent range of integer numbers (infinint)
object describing the slicing of an archive
the trivial_sar classes manages the slicing layer when single slice is used
defines the implementation of pipe under the generic_file interface.