# libdar::tronconneuse Class Reference
[Private]

this is a partial implementation of the generic_file interface to encrypt/decrypt data block by block. More...

`#include <tronconneuse.hpp>`

Inherits libdar::generic_file.

Inherited by libdar::blowfish.

List of all members.

## Public Member Functions
| tronconneuse (user_interaction &dialog, U_32 block_size, generic_file &encrypted_side)
| This is the constructor.
| tronconneuse (const tronconneuse &ref)
| copy constructor
tronconneuse & | operator= (const tronconneuse &ref)
| assignment operator
virtual | ~tronconneuse ()
| destructor
bool | skip (const infinint &pos)
| inherited from generic_file
bool | skip_to_eof ()
| inherited from generic_file
bool | skip_relative (S_I x)
| inherited from generic_file
infinint | get_position ()
| inherited from generic_file
void | write_end_of_file ()
| in write_only mode indicate that end of file is reached
## Protected Member Functions
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 | 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 for encryption
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
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 is for decrypts data

## Detailed Description

this is a partial implementation of the generic_file interface to encrypt/decrypt data block by block.

This class is a pure virtual one, as several calls have to be defined by inherited classes

- encrypted_block_size_for
- clear_block_allocated_size_for
- encrypt_data
- decrypt_data

tronconneuse is either read_only or write_only, read_write is not allowed. The openning mode his mode is defined by encrupted_side's mode. In write_only no skip() is allowed, writing is sequential from the beginning of the file to the end (like writing to a pipe). In read_only all skip() functions are available.

Definition at line 58 of file tronconneuse.hpp.

## Constructor & Destructor Documentation

libdar::tronconneuse::tronconneuse | ( | user_interaction & | dialog,
|  | U_32 | block_size,
|  | generic_file & | encrypted_side |
| ) |  |  |

This is the constructor.

Parameters:

  `[in]` | dialog | for user interaction.
  `[in]` | block_size | is the size of block encryption (the size of clear data encrypted toghether).
  `[in]` | encrypted_side | where encrypted data are read from or written to.

Note:
  that encrypted_side is not owned and destroyed by tronconneuse, it must exist during all the life of the tronconneuse object, and is not destroyed by the tronconneuse's destructor

## Member Function Documentation

virtual U_32 libdar::tronconneuse::clear_block_allocated_size_for | ( | U_32 | clear_block_size | ) | `[protected, pure virtual]`

it may be necessary by the inherited class have few more bytes allocated after the clear data given for encryption

Parameters:

  `[in]` | clear_block_size | is the size in byte of the clear data that will be asked to encrypt.

Returns:
  the requested allocated buffer size (at least the size of the clear data).

Note:
  when giving clear buffer of data of size "clear_block_size" some inherited class may requested that a bit more of data must be allocated. this is to avoid copying data when the algorithm needs to add some data after the clear data before encryption.

Implemented in libdar::blowfish.

virtual U_32 libdar::tronconneuse::decrypt_data | ( | const infinint & | block_num,
|  | const char * | crypt_buf,
|  | const U_32 | crypt_size,
|  | char * | clear_buf,
|  | U_32 | clear_size |
| ) |  |  | `[protected, pure virtual]`

this method is for decrypts data

Parameters:

  `[in]` | block_num | block number of the data to decrypt.
  `[in]` | crypt_buf | pointer to the first byte of encrypted data.
  `[in]` | crypt_size | size of encrypted data to decrypt.
  `[in,out]` | clear_buf | pointer where to put clear data.
  `[in]` | clear_size | allocated size of clear_buf.

Returns:
  is the amount of data put in clear_buf (<= clear_size)

Implemented in libdar::blowfish.

virtual U_32 libdar::tronconneuse::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 |
| ) |  |  | `[protected, pure virtual]`

this method encrypts the clear data given

Parameters:

  | block_num | is the number of the block to which correspond the given data, This is an informational field for inherited classes.
  `[in]` | clear_buf | points to the first byte of clear data to encrypt.
  `[in]` | clear_size | is the length in byte of data to encrypt.
  `[in]` | clear_allocated | is the size of the allocated memory (modifiable bytes) in clear_buf.
  `[in,out]` | crypt_buf | is the area where to put corresponding encrypted data.
  `[in]` | crypt_size | is the allocated memory size for crypt_buf.

Returns:
  is the amount of data put in crypt_buf (<= crypt_size).

Note:
  it must respect that : returned value = encrypted_block_size_for(clear_size argument)

Implemented in libdar::blowfish.

virtual U_32 libdar::tronconneuse::encrypted_block_size_for | ( | U_32 | clear_block_size | ) | `[protected, pure virtual]`

defines the size necessary to encrypt a given amount of clear data

Parameters:

  `[in]` | clear_block_size | is the size of the clear block to encrypt.

Returns:
  the size of the memory to allocate to receive corresponding encrypted data.

Note:
  this implies that encryption algorithm must always generate a fixed size encrypted block of data for a given fixed size block of data. However, the size of the encrypted block of data may differ from the size of the clear block of data

Implemented in libdar::blowfish.

void libdar::tronconneuse::write_end_of_file | ( |  | ) | `[inline]`

in write_only mode indicate that end of file is reached

this call must be called in write mode to purge the internal cache before deleting the object (else some data may be lost) no further write call is allowed

Definition at line 93 of file tronconneuse.hpp.

The documentation for this class was generated from the following file:

- tronconneuse.hpp