Disk ARchive  2.4.15
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
tronconneuse.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2052 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 //
19 // to contact the author : http://dar.linux.free.fr/email.html
20 /*********************************************************************/
21 
27 
28 #ifndef TRONCONNEUSE_HPP
29 #define TRONCONNEUSE_HPP
30 
31 #include "../my_config.h"
32 #include <string>
33 
34 #include "infinint.hpp"
35 #include "generic_file.hpp"
36 #include "header_version.hpp"
37 
38 namespace libdar
39 {
40 
43 
44 
46 
59  class tronconneuse : public generic_file
60  {
61  public:
63 
71  tronconneuse(U_32 block_size, generic_file & encrypted_side, bool no_initial_shift, const archive_version & reading_ver);
72 
74  tronconneuse(const tronconneuse & ref) : generic_file(ref) { copy_from(ref); };
75 
77  const tronconneuse & operator = (const tronconneuse & ref);
78 
80  virtual ~tronconneuse() { detruit(); }; // must not write pure virtual method from here, directly or not
81 
83  bool skip(const infinint & pos);
85  bool skip_to_eof();
87  bool skip_relative(S_I x);
89  infinint get_position() { if(is_terminated()) throw SRC_BUG; return current_position; };
90 
92 
97  void write_end_of_file() { if(is_terminated()) throw SRC_BUG; flush(); weof = true; };
98 
99 
101 
102  void set_initial_shift(const infinint & x) { initial_shift = x; };
103 
104 
108  void set_callback_trailing_clear_data(infinint (*call_back)(generic_file & below, const archive_version & reading_ver)) { trailing_clear_data = call_back; };
109 
110  private:
111 
113 
115  U_I inherited_read(char *a, U_I size);
116 
118 
120  void inherited_write(const char *a, U_I size);
121 
123  void inherited_sync_write() { flush(); };
124 
126  void inherited_terminate() {};
127 
128  protected:
130 
136  virtual U_32 encrypted_block_size_for(U_32 clear_block_size) = 0;
137 
139 
146  virtual U_32 clear_block_allocated_size_for(U_32 clear_block_size) = 0;
147 
149 
158  virtual U_32 encrypt_data(const infinint & block_num,
159  const char *clear_buf, const U_32 clear_size, const U_32 clear_allocated,
160  char *crypt_buf, U_32 crypt_size) = 0;
161 
163 
170  virtual U_32 decrypt_data(const infinint & block_num,
171  const char *crypt_buf, const U_32 crypt_size,
172  char *clear_buf, U_32 clear_size) = 0;
173 
174 
175  private:
176  infinint initial_shift; //< the initial_shift first bytes of the underlying file are not encrypted
177  //
178  infinint buf_offset; //< offset of the first byte in buf
179  U_32 buf_byte_data; //< number of byte of information in buf (buf_byte_data <= buf_size)
180  U_32 buf_size; //< size of allocated memory for clear data in buf
181  char *buf; //< decrypted data (or data to encrypt)
182  //
183  U_32 clear_block_size; //< max amount of data that will be encrypted at once (must stay less than buf_size)
184  infinint current_position; //< position of the next character to read or write from the upper layer perspective
185  infinint block_num; //< block number we next read or write
186  generic_file *encrypted; //< generic_file where is put / get the encrypted data
187  //
188  U_32 encrypted_buf_size; //< allocated size of encrypted_buf
189  U_32 encrypted_buf_data; //< amount of byte of information in encrypted_buf
190  char *encrypted_buf; //< buffer of encrypted data (read or to write)
191  //
192  infinint extra_buf_offset; //< offset of the first byte of extra_buf
193  U_32 extra_buf_size; //< allocated size of extra_buf
194  U_32 extra_buf_data; //< amount of byte of information in extra_buf
195  char *extra_buf; //< additional read encrypted that follow what is in encrypted_buf used to check for clear data after encrypted data
196  //
197  bool weof; //< whether write_end_of_file() has been called
198  bool reof; //< whether we reached eof while reading
199  archive_version reading_ver;//< archive format we currently read
200  infinint (*trailing_clear_data)(generic_file & below, const archive_version & reading_ver); //< callback function that gives the amount of clear data found at the end of the given file
201 
202 
203  void detruit();
204  void copy_from(const tronconneuse & ref);
205  U_32 fill_buf(); // returns the position (of the next read op) inside the buffer and fill the buffer with clear data
206  void flush(); // flush any pending data (write mode only) to encrypted device
207  void init_buf(); // initialize if necessary the various buffers that relies on inherited method values
208 
209 
211 
217  void position_clear2crypt(const infinint & pos,
218  infinint & file_buf_start,
219  infinint & clear_buf_start,
220  infinint & pos_in_buf,
221  infinint & block_num);
222 
223  void position_crypt2clear(const infinint & pos, infinint & clear_pos);
224  // gives the position of the next character
225  // of clear data that corresponds to the encrypted data which index is pos
226 
227  bool check_current_position() { return fill_buf() < buf_byte_data; };
228  // return true if a there is a byte of information at the given offset
229 
233  void remove_trailing_clear_data_from_encrypted_buf(const infinint & crypt_offset);
234 
235  };
236 
238 
239 } // end of namespace
240 
241 #endif
bool skip_relative(S_I x)
inherited from generic_file
bool skip_to_eof()
inherited from generic_file
infinint get_position()
inherited from generic_file
virtual ~tronconneuse()
destructor
void set_initial_shift(const infinint &x)
this method to modify the initial shift. This overrides the constructor "no_initial_shift" of the con...
void set_callback_trailing_clear_data(infinint(*call_back)(generic_file &below, const archive_version &reading_ver))
this is a partial implementation of the generic_file interface to cypher/decypher data block by block...
virtual U_32 encrypt_data(const infinint &block_num, const char *clear_buf, const U_32 clear_size, const U_32 clear_allocated, char *crypt_buf, U_32 crypt_size)=0
this method encrypts the clear data given
class generic_file is defined here as well as class fichierthe generic_file interface is widely used ...
the deleted file entry
Definition: catalogue.hpp:906
const tronconneuse & operator=(const tronconneuse &ref)
assignment operator
bool skip(const infinint &pos)
inherited from generic_file
void write_end_of_file()
in write_only mode indicate that end of file is reached
bool is_terminated() const
archive global header structure is defined here
virtual U_32 clear_block_allocated_size_for(U_32 clear_block_size)=0
it may be necessary by the inherited class have few more bytes allocated after the clear data given f...
virtual U_32 encrypted_block_size_for(U_32 clear_block_size)=0
defines the size necessary to encrypt a given amount of clear data
virtual U_32 decrypt_data(const infinint &block_num, const char *crypt_buf, const U_32 crypt_size, char *clear_buf, U_32 clear_size)=0
this method decyphers data
generic_file(gf_mode m)
main constructor
tronconneuse(U_32 block_size, generic_file &encrypted_side, bool no_initial_shift, const archive_version &reading_ver)
This is the constructor.
switch module to limitint (32 ou 64 bits integers) or infinint
this is the interface class from which all other data transfer classes inherit
the arbitrary large positive integer class
class archive_version manages the version of the archive format
tronconneuse(const tronconneuse &ref)
copy constructor