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

sar.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2020 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 : http://dar.linux.free.fr/email.html
20 /*********************************************************************/
21
25
26 #ifndef SAR_HPP
27 #define SAR_HPP
28
29 #include "../my_config.h"
30
31 #include <string>
32 #include "infinint.hpp"
33 #include "generic_file.hpp"
34 #include "header.hpp"
35 #include "integers.hpp"
36 #include "entrepot.hpp"
37 #include "slice_layout.hpp"
38 #include "contextual.hpp"
39 #include "mem_ui.hpp"
40
41 namespace libdar
42 {
43 // contextual is defined in generic_file module
44
47
49
54 class sar : public generic_file, public contextual, protected mem_ui
55 {
56 public:
57
59
81 sar(const std::shared_ptr<user_interaction> & dialog,
82 const std::string & base_name,
83 const std::string & extension,
84 const std::shared_ptr<entrepot> & where,
85 bool by_the_end,
86 const infinint & x_min_digits,
87 bool lax = false,
88 const std::string & execute = "");
89
90
92
113 sar(const std::shared_ptr<user_interaction> & dialog,
114 gf_mode open_mode,
115 const std::string & base_name,
116 const std::string & extension,
117 const infinint & file_size,
118 const infinint & first_file_size,
119 bool x_warn_overwrite,
120 bool x_allow_overwrite,
121 const infinint & pause,
122 const std::shared_ptr<entrepot> & where,
123 const label & internal_name,
124 const label & data_name,
125 bool force_permission,
126 U_I permission,
127 hash_algo x_hash,
128 const infinint & x_min_digits,
129 bool format_07_compatible,
130 const std::string & execute = "");
131
133 sar(const sar & ref) = delete;
134
136 sar(sar && ref) noexcept = delete;
137
139 sar & operator = (const sar & ref) = delete;
140
142 sar & operator = (sar && ref) noexcept = delete;
143
145 ~sar();
146
147 // inherited from generic_file
148 virtual bool skippable(skippability direction, const infinint & amount) override;
149 virtual bool skip(const infinint &pos) override;
150 virtual bool skip_to_eof() override;
151 virtual bool skip_relative(S_I x) override;
152 virtual infinint get_position() const override;
153
154 // informational routines
155 const slice_layout & get_slicing() const { return slicing; };
156 bool get_total_file_number(infinint &num) const { num = of_last_file_num; return of_last_file_known; };
157 bool get_last_file_size(infinint &num) const { num = of_last_file_size; return of_last_file_known; };
158
159 // disable execution of user command when destroying the current object
160 void disable_natural_destruction() { natural_destruction = false; };
161
162 // enable back execution of user command when destroying the current object
163 void enable_natural_destruction() { natural_destruction = true; };
164
165 // true if sar's header is from an old archive format (<= "07")
166 virtual bool is_an_old_start_end_archive() const override { return slicing.older_sar_than_v8; };
167
168 // return the internal_name used to link slices toghether
169 const label & get_internal_name_used() const { return of_internal_name; };
170
171 // return the data_name used to link slices toghether
172 virtual const label & get_data_name() const override { return of_data_name; };
173
174 const std::shared_ptr<entrepot> & get_entrepot() const { return entr; };
175
177 const infinint & get_first_slice_header_size() const { return slicing.first_slice_header; };
178
180 const infinint & get_non_first_slice_header_size() const { return slicing.other_slice_header; };
181
182 protected :
183 virtual void inherited_read_ahead(const infinint & amount) override;
184 virtual U_I inherited_read(char *a, U_I size) override;
185 virtual void inherited_write(const char *a, U_I size) override;
186 virtual void inherited_sync_write() override {}; // nothing to do
187 virtual void inherited_flush_read() override {}; // nothing to do
188 virtual void inherited_terminate() override;
189
190 private :
191 std::shared_ptr<entrepot> entr;
192 std::string base;
193 std::string ext;
194 std::string hook;
195 slice_layout slicing;
196 infinint file_offset;
197 hash_algo hash;
198 infinint min_digits;
199 bool natural_destruction;
200 // these following variables are modified by open_file / open_file_init
201 // else the are used only for reading
202 infinint of_current;
203 infinint size_of_current;
204 infinint of_max_seen;
205 bool of_last_file_known;
206 infinint of_last_file_num;
207 infinint of_last_file_size;
208 label of_internal_name;
209 label of_data_name;
210 bool force_perm;
211 U_I perm;
212 fichier_global *of_fd;
213 char of_flag;
214 bool initial;
215 // these are the option flags
216 bool opt_warn_overwrite;
217 bool opt_allow_overwrite;
218 //
219 infinint pause;
220 bool lax;
221 infinint to_read_ahead;
222
223 bool skip_forward(U_I x);
224 bool skip_backward(U_I x);
225 void close_file(bool terminal);
226 void open_readonly(const std::string & fic,
227 const infinint &num,
228 bool bytheend
229 );
230 void open_writeonly(const std::string & fic,
231 const infinint &num,
232 bool bytheend
233 );
234 void open_file_init();
235 void open_file(infinint num, bool bytheend);
236 void set_offset(infinint offset);
237 void open_last_file(bool bytheend);
238 bool is_current_eof_a_normal_end_of_slice() const;
239 infinint bytes_still_to_read_in_slice() const;
240 header make_write_header(const infinint &num, char flag);
241
242 // function to lauch the eventually existing command to execute after/before each slice
243 void hook_execute(const infinint &num);
244 };
245
247
248 } // end of namespace
249
250 #endif
libdar::hash_algo
hash_algo
hashing algorithm available
Definition: archive_aux.hpp:63
libdar::sar::skippable
virtual bool skippable(skippability direction, const infinint &amount) override
whether the implementation is able to skip
libdar::sar::hash
hash_algo hash
whether to build a hashing when creating slices, and if so, which algorithm to use
Definition: sar.hpp:197
libdar::sar::lax
bool lax
whether to try to go further reading problems
Definition: sar.hpp:220
libdar::sar::of_flag
char of_flag
flags of the open file
Definition: sar.hpp:213
libdar::sar::of_data_name
label of_data_name
internal name linked to data (transparent to dar_xform and used by isolated catalogue as reference)
Definition: sar.hpp:209
libdar::label
manage label data structure used in archive slice headers
Definition: label.hpp:43
libdar::sar::perm
U_I perm
if force_perm is true, value to use for slice permission
Definition: sar.hpp:211
libdar::sar::bytes_still_to_read_in_slice
infinint bytes_still_to_read_in_slice() const
returns the number of bytes expected before the end of slice
contextual.hpp
class contextual adds the information of phases in the generic_file
libdar::header
this class manages the header of each slice
Definition: header.hpp:66
libdar::sar::is_an_old_start_end_archive
virtual bool is_an_old_start_end_archive() const override
returns whether the archive is a old archive (format < 8)
Definition: sar.hpp:166
libdar::sar::sar
sar(const std::shared_ptr< user_interaction > &dialog, const std::string &base_name, const std::string &extension, const std::shared_ptr< entrepot > &where, bool by_the_end, const infinint &x_min_digits, bool lax=false, const std::string &execute="")
this constructor reads data from a set of slices
integers.hpp
are defined here basic integer types that tend to be portable
libdar::sar::pause
infinint pause
do we pause between slices
Definition: sar.hpp:219
libdar::sar::file_offset
infinint file_offset
current reading/writing position in the current slice (relative to the whole slice file,...
Definition: sar.hpp:196
libdar::gf_mode
gf_mode
generic_file openning modes
Definition: gf_mode.hpp:44
libdar::sar::of_current
infinint of_current
number of the open slice
Definition: sar.hpp:202
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
libdar::infinint
the arbitrary large positive integer class
Definition: real_infinint.hpp:62
libdar::sar::inherited_flush_read
virtual void inherited_flush_read() override
reset internal engine, flush caches in order to read the data at current position
Definition: sar.hpp:187
libdar::sar::get_data_name
virtual const label & get_data_name() const override
obtain the data_name of the archive (label associated with the archive's data)
Definition: sar.hpp:172
libdar::sar
Sar class stands for Segmentation And Reassembly class.
Definition: sar.hpp:55
libdar::sar::of_last_file_size
infinint of_last_file_size
size of the last slice (if met)
Definition: sar.hpp:207
libdar::sar::entr
std::shared_ptr< entrepot > entr
where are stored slices
Definition: sar.hpp:191
libdar::sar::skip
virtual bool skip(const infinint &pos) override
skip at the absolute position
libdar::sar::~sar
~sar()
destructor
libdar::sar::get_first_slice_header_size
const infinint & get_first_slice_header_size() const
get the first slice header
Definition: sar.hpp:177
libdar::sar::is_current_eof_a_normal_end_of_slice
bool is_current_eof_a_normal_end_of_slice() const
return true if current reading position is at end of slice
libdar::sar::of_fd
fichier_global * of_fd
file object currently openned
Definition: sar.hpp:212
libdar::sar::initial
bool initial
do not launch hook command-line during sar initialization
Definition: sar.hpp:214
libdar::sar::skip_forward
bool skip_forward(U_I x)
skip forward in sar global contents
libdar::sar::opt_warn_overwrite
bool opt_warn_overwrite
a warning must be issued before overwriting a slice
Definition: sar.hpp:216
libdar::sar::inherited_write
virtual void inherited_write(const char *a, U_I size) override
implementation of the write() operation
libdar::sar::open_writeonly
void open_writeonly(const std::string &fic, const infinint &num, bool bytheend)
libdar::sar::close_file
void close_file(bool terminal)
close current openned file, adding (in write mode only) a terminal mark (last slice) or not
libdar::mem_ui
class mem_ui to keep a copy of a user_interaction object
Definition: mem_ui.hpp:55
libdar::sar::of_last_file_known
bool of_last_file_known
whether the T terminal slice has been met
Definition: sar.hpp:205
libdar::sar::skip_relative
virtual bool skip_relative(S_I x) override
skip relatively to the current position
entrepot.hpp
defines the entrepot interface. Entrepot interface defines a generic way to interact with files (slic...
libdar::sar::skip_to_eof
virtual bool skip_to_eof() override
skip to the end of file
libdar::sar::of_internal_name
label of_internal_name
internal name shared in all slice header
Definition: sar.hpp:208
generic_file.hpp
class generic_file is defined here as well as class fichier
header.hpp
slice header structure is defined here
slice_layout.hpp
object describing the slicing of an archive
libdar::sar::min_digits
infinint min_digits
minimum number of digits the slices number is stored with in the filename
Definition: sar.hpp:198
libdar::sar::inherited_terminate
virtual void inherited_terminate() override
destructor-like call, except that it is allowed to throw exceptions
libdar::sar::skip_backward
bool skip_backward(U_I x)
skip backward in sar global contents
libdar::sar::set_offset
void set_offset(infinint offset)
skip to current slice relative offset
libdar::sar::ext
std::string ext
archive extension
Definition: sar.hpp:193
libdar::sar::force_perm
bool force_perm
true if any future slice has its permission to be set explicitely
Definition: sar.hpp:210
libdar::sar::to_read_ahead
infinint to_read_ahead
amount of data to read ahead for next slices
Definition: sar.hpp:221
libdar::generic_file
this is the interface class from which all other data transfer classes inherit
Definition: generic_file.hpp:77
libdar::sar::inherited_read_ahead
virtual void inherited_read_ahead(const infinint &amount) override
tells the object that several calls to read() will follow to probably obtain at least the given amoun...
libdar::sar::inherited_read
virtual U_I inherited_read(char *a, U_I size) override
implementation of read() operation
libdar::sar::open_file
void open_file(infinint num, bool bytheend)
close current slice and open the slice 'num'
libdar::sar::of_max_seen
infinint of_max_seen
highest slice number seen so far
Definition: sar.hpp:204
libdar::sar::open_readonly
void open_readonly(const std::string &fic, const infinint &num, bool bytheend)
libdar::sar::of_last_file_num
infinint of_last_file_num
number of the last slice (if met)
Definition: sar.hpp:206
libdar::sar::get_non_first_slice_header_size
const infinint & get_non_first_slice_header_size() const
get the non first slice header
Definition: sar.hpp:180
libdar::sar::open_last_file
void open_last_file(bool bytheend)
open the last slice, ask the user, test, until last slice available
libdar::contextual
the contextual class adds the information of phases in the generic_file
Definition: contextual.hpp:74
libdar::sar::inherited_sync_write
virtual void inherited_sync_write() override
write down any pending data
Definition: sar.hpp:186
libdar::sar::base
std::string base
archive base name
Definition: sar.hpp:192
libdar::sar::slicing
slice_layout slicing
slice layout
Definition: sar.hpp:195
libdar::fichier_global
abstraction of filesystem files for entrepot
Definition: fichier_global.hpp:59
libdar::sar::operator=
sar & operator=(const sar &ref)=delete
assignment operator
libdar::sar::sar
sar(const std::shared_ptr< user_interaction > &dialog, gf_mode open_mode, const std::string &base_name, const std::string &extension, const infinint &file_size, const infinint &first_file_size, bool x_warn_overwrite, bool x_allow_overwrite, const infinint &pause, const std::shared_ptr< entrepot > &where, const label &internal_name, const label &data_name, bool force_permission, U_I permission, hash_algo x_hash, const infinint &x_min_digits, bool format_07_compatible, const std::string &execute="")
this constructor creates a new set of slices
libdar::sar::opt_allow_overwrite
bool opt_allow_overwrite
is slice overwriting allowed
Definition: sar.hpp:217
libdar::sar::size_of_current
infinint size_of_current
size of the current slice (used in reading mode only)
Definition: sar.hpp:203
libdar::sar::sar
sar(const sar &ref)=delete
the copy constructor
libdar::sar::open_file_init
void open_file_init()
initialize some of_* fields
libdar::sar::natural_destruction
bool natural_destruction
whether to execute commands between slices on object destruction
Definition: sar.hpp:199
libdar::sar::hook
std::string hook
command line to execute between slices
Definition: sar.hpp:194
libdar::sar::get_position
virtual infinint get_position() const override
get the current read/write position
libdar::sar::sar
sar(sar &&ref) noexcept=delete
move constructor
mem_ui.hpp
class mem_ui definition. This class is to be used as parent class to handle user_interaction object m...
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47