Disk ARchive: sar.hpp Source File

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