Disk ARchive  2.6.8
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;
200  // these following variables are modified by open_file / open_file_init
201  // else the are used only for reading
210  bool force_perm;
211  U_I perm;
213  char of_flag;
214  bool initial;
215  // these are the option flags
218  //
220  bool lax;
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);
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:62
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:42
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:65
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:43
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:61
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:54
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:54
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:76
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:73
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:58
libdar::sar::operator=
sar & operator=(const sar &ref)=delete
assignment operator
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::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
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:46