Disk ARchive 2.7.14
Full featured and portable backup and archiving tool
Loading...
Searching...
No Matches
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,
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,
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);
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
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
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
hash_algo
hashing algorithm available
gf_mode
generic_file openning modes
slice header structure is defined here
include macro defined by the configure script and some specific additional ones
libdar namespace encapsulate all libdar symbols
object describing the slicing of an archive
defines the entrepot interface.
class generic_file is defined here as well as class fichier
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...