| Disk ARchive 2.8.4 Full featured and portable backup and archiving tool

Loading...
Searching...
No Matches
header_version.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2026 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
47 class header_version
48 {
49 public:
50 header_version();
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:
117 archive_version edition;
118 compression algo_zip;
119 std::string cmd_line;
120 infinint initial_offset;
121 // has to be set to zero when it is unknown, in that case this field is not dump to archive
122 crypto_algo sym;
123 memory_file *crypted_key;
124 slice_layout *ref_layout;
125 bool has_tape_marks;
126
127 bool ciphered;
128 bool arch_signed;
129 bool has_kdf_params;
130 std::string salt;
131 infinint iteration_count;
132 hash_algo kdf_hash;
133 infinint compr_bs;
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
archive_aux.hpp
set of datastructures used to interact with a catalogue object
archive_version.hpp
class archive_version that rules which archive format to follow
libdar::archive_version
class archive_version manages the version of the archive format
Definition archive_version.hpp:47
libdar::generic_file
this is the interface class from which all other data transfer classes inherit
Definition generic_file.hpp:77
libdar::header_version
manages the archive header and trailer
Definition header_version.hpp:48
libdar::infinint
the arbitrary large positive integer class
Definition real_infinint.hpp:62
libdar::memory_file
generic_file stored in memory
Definition memory_file.hpp:41
libdar::user_interaction
This is a pure virtual class that is used by libdar when interaction with the user is required.
Definition user_interaction.hpp:58
compression.hpp
compression parameters for API
crypto.hpp
the crypto algoritm definition
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::compression
compression
the different compression algorithm available
Definition compression.hpp:46
libdar::crypto_algo
crypto_algo
the different cypher available for encryption (strong or weak)
Definition crypto.hpp:50
libdar::crypto_algo::none
@ none
no encryption
Definition crypto.hpp:51
libdar::header_version::edition
archive_version edition
archive format
Definition header_version.hpp:117
libdar::header_version::set_slice_layout
void set_slice_layout(slice_layout *layout)
the object pointed to by layout is passed under the responsibility of this header_version object
Definition header_version.hpp:76
libdar::header_version::set_crypted_key
void set_crypted_key(memory_file *key)
the object pointed to by key passes to the responsibility of this header_version object
Definition header_version.hpp:72
libdar::header_version::salt
std::string salt
used for key derivation
Definition header_version.hpp:130
libdar::header_version::has_tape_marks
bool has_tape_marks
whether the archive contains tape marks aka escape marks aka sequence marks
Definition header_version.hpp:125
libdar::header_version::kdf_hash
hash_algo kdf_hash
used for key derivation
Definition header_version.hpp:132
libdar::header_version::crypted_key
memory_file * crypted_key
optional field containing the asymmetrically ciphered key used for strong encryption ciphering
Definition header_version.hpp:123
libdar::header_version::has_kdf_params
bool has_kdf_params
has salt/ineration/kdf_hash fields valid
Definition header_version.hpp:129
libdar::header_version::read
void read(generic_file &f, user_interaction &dialog, bool lax_mode)
read the header or trailer from the archive
libdar::header_version::write
void write(generic_file &f) const
write down the object to the archive (as header if wrote at the beginning of the archive,...
libdar::header_version::algo_zip
compression algo_zip
compression algorithm used
Definition header_version.hpp:118
libdar::header_version::ref_layout
slice_layout * ref_layout
optional field used in isolated catalogues to record the slicing layout of their archive of reference
Definition header_version.hpp:124
libdar::header_version::iteration_count
infinint iteration_count
used for key derivation
Definition header_version.hpp:131
libdar::header_version::arch_signed
bool arch_signed
whether the archive is signed
Definition header_version.hpp:128
libdar::header_version::cmd_line
std::string cmd_line
used long ago to store cmd_line, then abandonned, then recycled as a user comment field
Definition header_version.hpp:119
libdar::header_version::PRE_FORMAT_10_ITERATION
static constexpr U_I PRE_FORMAT_10_ITERATION
fixed value used for key derivation before archive format 10
Definition header_version.hpp:141
libdar::header_version::ciphered
bool ciphered
whether the archive is ciphered, even if we do not know its crypto algorithm (old archives)
Definition header_version.hpp:127
libdar::header_version::compr_bs
infinint compr_bs
the compression block size (0 for legacy compression mode)
Definition header_version.hpp:133
libdar::header_version::initial_offset
infinint initial_offset
defines at which offset starts the archive (passed the archive header), this field is obiously only u...
Definition header_version.hpp:120
libdar::header_version::sym
crypto_algo sym
strong encryption algorithm used for symmetrical encryption
Definition header_version.hpp:122
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
memory_file.hpp
Memory_file is a generic_file class that only uses virtual memory.
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
user_interaction.hpp
defines the interaction interface between libdar and users.