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