Disk ARchive  2.7.14
Full featured and portable backup and archiving tool
header_version.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 HEADER_VERSION_HPP
27 #define HEADER_VERSION_HPP
28 
29 #include "../my_config.h"
30 #include "infinint.hpp"
31 #include "generic_file.hpp"
32 #include "archive_version.hpp"
33 #include "crypto.hpp"
34 #include "slice_layout.hpp"
35 #include "compression.hpp"
36 #include "user_interaction.hpp"
37 #include "memory_file.hpp"
38 #include "archive_aux.hpp"
39 
40 namespace libdar
41 {
42 
45 
48  {
49  public:
51  header_version(const header_version & ref) { copy_from(ref); };
52  header_version(header_version && ref) noexcept { nullifyptr(); move_from(std::move(ref)); };
53  header_version & operator = (const header_version & ref) { detruit(); copy_from(ref); return * this; };
54  header_version & operator = (header_version && ref) noexcept { move_from(std::move(ref)); return *this; };
55  ~header_version() { detruit(); };
56 
58  void read(generic_file &f, user_interaction & dialog, bool lax_mode);
59 
61  void write(generic_file &f) const;
62 
63  // settings
64 
65  void set_edition(const archive_version & ed) { edition = ed; };
66  void set_compression_algo(const compression & zip) { algo_zip = zip; };
67  void set_command_line(const std::string & line) { cmd_line = line; };
68  void set_initial_offset(const infinint & offset) { initial_offset = offset; };
69  void set_sym_crypto_algo(const crypto_algo & algo) { sym = algo; };
70 
72  void set_crypted_key(memory_file *key) { if(key == nullptr) throw SRC_BUG; clear_crypted_key(); crypted_key = key; };
73  void clear_crypted_key() { if(crypted_key != nullptr) { delete crypted_key; crypted_key = nullptr; } };
74 
76  void set_slice_layout(slice_layout *layout) { if(layout == nullptr) throw SRC_BUG; clear_slice_layout(); ref_layout = layout; };
77  void clear_slice_layout() { if(ref_layout != nullptr) { delete ref_layout; ref_layout = nullptr; } };
78 
79  void set_tape_marks(bool presence) { has_tape_marks = presence; };
80  void set_signed(bool is_signed) { arch_signed = is_signed; };
81 
82  void set_salt(const std::string & arg) { salt = arg; has_kdf_params = true; };
83  void set_iteration_count(const infinint & arg) { iteration_count = arg; has_kdf_params = true; };
84  void set_kdf_hash(hash_algo algo);
85 
86  void set_compression_block_size(const infinint & bs) { compr_bs = bs; };
87 
88  // gettings
89 
90  const archive_version & get_edition() const { return edition; };
91  compression get_compression_algo() const { return algo_zip; };
92  const std::string & get_command_line() const { return cmd_line; };
93  const infinint & get_initial_offset() const { return initial_offset; };
94 
95  bool is_ciphered() const { return ciphered || sym != crypto_algo::none; };
96  bool is_signed() const { return arch_signed; };
97  crypto_algo get_sym_crypto_algo() const { return sym; };
98  std::string get_sym_crypto_name() const;
99  std::string get_asym_crypto_name() const;
100  memory_file *get_crypted_key() const { return crypted_key; };
101  const slice_layout *get_slice_layout() const { return ref_layout; };
102  bool get_tape_marks() const { return has_tape_marks; };
103  const std::string & get_salt() const { return salt; };
104  const infinint & get_iteration_count() const { return iteration_count; };
105  hash_algo get_kdf_hash() const { return kdf_hash; };
106  const infinint & get_compression_block_size() const { return compr_bs; };
107 
108  // display
109 
110  void display(user_interaction & dialg) const;
111 
112  // clear
113 
114  void clear();
115 
116  private:
119  std::string cmd_line;
121  // has to be set to zero when it is unknown, in that case this field is not dump to archive
124  slice_layout *ref_layout;
126 
127  bool ciphered;
128  bool arch_signed;
130  std::string salt;
134 
135  void nullifyptr() noexcept { crypted_key = nullptr; ref_layout = nullptr; };
136  void copy_from(const header_version & ref);
137  void move_from(header_version && ref) noexcept;
138  void detruit();
139 
140 
141  static constexpr U_I PRE_FORMAT_10_ITERATION = 2000;
142 
143  };
144 
145 } // end of namespace
146 
147 #endif
set of datastructures used to interact with a catalogue object
class archive_version that rules which archive format to follow
class archive_version manages the version of the archive format
this is the interface class from which all other data transfer classes inherit
manages the archive header and trailer
the arbitrary large positive integer class
generic_file stored in memory
Definition: memory_file.hpp:41
This is a pure virtual class that is used by libdar when interaction with the user is required.
compression parameters for API
the crypto algoritm definition
class generic_file is defined here as well as class fichier
hash_algo
hashing algorithm available
Definition: archive_aux.hpp:63
compression
the different compression algorithm available
Definition: compression.hpp:46
crypto_algo
the different cypher available for encryption (strong or weak)
Definition: crypto.hpp:50
@ none
no encryption
archive_version edition
archive format
void set_slice_layout(slice_layout *layout)
the object pointed to by layout is passed under the responsibility of this header_version object
void set_crypted_key(memory_file *key)
the object pointed to by key passes to the responsibility of this header_version object
std::string salt
used for key derivation
bool has_tape_marks
whether the archive contains tape marks aka escape marks aka sequence marks
hash_algo kdf_hash
used for key derivation
memory_file * crypted_key
optional field containing the asymmetrically ciphered key used for strong encryption ciphering
bool has_kdf_params
has salt/ineration/kdf_hash fields valid
void read(generic_file &f, user_interaction &dialog, bool lax_mode)
read the header or trailer from the archive
void write(generic_file &f) const
write down the object to the archive (as header if wrote at the beginning of the archive,...
compression algo_zip
compression algorithm used
slice_layout * ref_layout
optional field used in isolated catalogues to record the slicing layout of their archive of reference
infinint iteration_count
used for key derivation
bool arch_signed
whether the archive is signed
std::string cmd_line
used long ago to store cmd_line, then abandonned, then recycled as a user comment field
static constexpr U_I PRE_FORMAT_10_ITERATION
fixed value used for key derivation before archive format 10
bool ciphered
whether the archive is ciphered, even if we do not know its crypto algorithm (old archives)
infinint compr_bs
the compression block size (0 for legacy compression mode)
infinint initial_offset
defines at which offset starts the archive (passed the archive header), this field is obiously only u...
crypto_algo sym
strong encryption algorithm used for symmetrical encryption
switch module to limitint (32 ou 64 bits integers) or infinint
Memory_file is a generic_file class that only uses virtual memory.
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
object describing the slicing of an archive
defines the interaction interface between libdar and users.