Disk ARchive  2.6.6
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-2019 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 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; };
83  void set_iteration_count(const infinint & arg) { iteration_count = arg; };
84  void set_kdf_hash(hash_algo algo);
85 
86  // gettings
87 
88  const archive_version & get_edition() const { return edition; };
89  compression get_compression_algo() const { return algo_zip; };
90  const std::string & get_command_line() const { return cmd_line; };
91  const infinint & get_initial_offset() const { return initial_offset; };
92 
93  bool is_ciphered() const { return ciphered || sym != crypto_algo::none; };
94  bool is_signed() const { return arch_signed; };
95  crypto_algo get_sym_crypto_algo() const { return sym; };
96  std::string get_sym_crypto_name() const;
97  std::string get_asym_crypto_name() const;
98  memory_file *get_crypted_key() const { return crypted_key; };
99  const slice_layout *get_slice_layout() const { return ref_layout; };
100  bool get_tape_marks() const { return has_tape_marks; };
101  const std::string & get_salt() const { return salt; };
102  const infinint & get_iteration_count() const { return iteration_count; };
103  hash_algo get_kdf_hash() const { return kdf_hash; };
104 
105  // display
106 
107  void display(user_interaction & dialg) const;
108 
109  // clear
110 
111  void clear();
112 
113  private:
116  std::string cmd_line;
118  // has to be set to zero when it is unknown, in that case this field is not dump to archive
121  slice_layout *ref_layout;
123 
124  bool ciphered;
125  bool arch_signed;
126  std::string salt;
129 
130  void nullifyptr() noexcept { crypted_key = nullptr; ref_layout = nullptr; };
131  void copy_from(const header_version & ref);
132  void move_from(header_version && ref) noexcept;
133  void detruit();
134 
135  // FLAG VALUES
136 
137  static constexpr U_I FLAG_SAVED_EA_ROOT = 0x80;
138  static constexpr U_I FLAG_SAVED_EA_USER = 0x40;
139  static constexpr U_I FLAG_SCRAMBLED = 0x20;
140  static constexpr U_I FLAG_SEQUENCE_MARK = 0x10;
141  static constexpr U_I FLAG_INITIAL_OFFSET = 0x08;
142  static constexpr U_I FLAG_HAS_CRYPTED_KEY = 0x04;
143  static constexpr U_I FLAG_HAS_REF_SLICING = 0x02;
144  static constexpr U_I FLAG_HAS_AN_EXTENDED_SIZE = 0x01;
145  static constexpr U_I FLAG_ARCHIVE_IS_SIGNED = 0x0200;
146  static constexpr U_I FLAG_HAS_KDF_PARAM = 0x0400;
147  static constexpr U_I FLAG_HAS_AN_SECOND_EXTENDED_SIZE = 0x0101;
148 
149  //
150 
151  static constexpr U_I PRE_FORMAT_10_ITERATION = 2000;
152  };
153 
154 } // end of namespace
155 
156 #endif
void read(generic_file &f, user_interaction &dialog, bool lax_mode)
read the header or trailer from the archive
bool ciphered
whether the archive is ciphered, even if we do not know its crypto algorithm (old archives) ...
static constexpr U_I FLAG_HAS_AN_SECOND_EXTENDED_SIZE
reserved for future use
archive_version edition
archive format
static constexpr U_I FLAG_ARCHIVE_IS_SIGNED
archive is signed
class generic_file is defined here as well as class fichierthe generic_file interface is widely used ...
bool arch_signed
whether the archive is signed
static constexpr U_I FLAG_SAVED_EA_ROOT
no more used since version "05"
void set_crypted_key(memory_file *key)
the object pointed to by key passes to the responsibility of this header_version object ...
std::string cmd_line
used long ago to store cmd_line, then abandonned, then recycled as a user comment field ...
static constexpr U_I FLAG_INITIAL_OFFSET
whether the header contains the initial offset (size of clear data before encrypted) NOTE : This valu...
This is a pure virtual class that is used by libdar when interaction with the user is required...
manages the archive header and trailer
std::string salt
used for key derivation
slice_layout * ref_layout
optional field used in isolated catalogues to record the slicing layout of their archive of reference...
the crypto algoritm definition
object describing the slicing of an archive
static constexpr U_I FLAG_SAVED_EA_USER
no more used since version "05"
generic_file stored in memory
Definition: memory_file.hpp:40
static constexpr U_I FLAG_HAS_KDF_PARAM
archive header contains salt and non default interaction count
crypto_algo
the different cypher available for encryption (strong or weak)
Definition: crypto.hpp:49
compression parameters for API
defines the interaction interface between libdar and users.
static constexpr U_I FLAG_SEQUENCE_MARK
escape sequence marks present for sequential reading
static constexpr U_I FLAG_HAS_REF_SLICING
the header contains the slicing information of the archive of reference (used for isolated catalogue)...
Memory_file is a generic_file class that only uses virtual memory.
bool has_tape_marks
whether the archive contains tape marks aka escape marks aka sequence marks
compression algo_zip
compression algorithm used
static constexpr U_I PRE_FORMAT_10_ITERATION
fixed value used for key derivation before archive format 10
static constexpr U_I FLAG_SCRAMBLED
scrambled or strong encryption used
hash_algo kdf_hash
used for key derivation
void write(generic_file &f) const
write down the object to the archive (as header if wrote at the beginning of the archive, as trailer is at the end)
memory_file * crypted_key
optional field containing the asymmetrically ciphered key used for strong encryption ciphering ...
infinint iteration_count
used for key derivation
switch module to limitint (32 ou 64 bits integers) or infinint
compression
the different compression algorithm available
Definition: compression.hpp:45
crypto_algo sym
strong encryption algorithm used for symmetrical encryption
this is the interface class from which all other data transfer classes inherit
infinint initial_offset
defines at which offset starts the archive (passed the archive header), this field is obiously only u...
class archive_version that rules which archive format to follow
hash_algo
hashing algorithm available
Definition: archive_aux.hpp:62
void set_slice_layout(slice_layout *layout)
the object pointed to by layout is passed under the responsibility of this header_version object ...
the arbitrary large positive integer class
class archive_version manages the version of the archive format
static constexpr U_I FLAG_HAS_AN_EXTENDED_SIZE
the flag is two bytes length
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:46
static constexpr U_I FLAG_HAS_CRYPTED_KEY
the header contains a symmetrical key encrypted with asymmetrical algorithm
set of datastructures used to interact with a catalogue object