tronconneuse.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2052 Denis Corbin
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// to contact the author : http://dar.linux.free.fr/email.html
/*********************************************************************/


#ifndef TRONCONNEUSE_HPP
#define TRONCONNEUSE_HPP

#include "../my_config.h"
#include <string>

#include "infinint.hpp"
#include "generic_file.hpp"
#include "header_version.hpp"

namespace libdar
{




    class tronconneuse : public generic_file
    {
    public:

        tronconneuse(U_32 block_size, generic_file & encrypted_side, bool no_initial_shift, const archive_version & reading_ver);

        tronconneuse(const tronconneuse & ref) : generic_file(ref) { copy_from(ref); };

        const tronconneuse & operator = (const tronconneuse & ref);

        virtual ~tronconneuse() { detruit(); }; // must not write pure virtual method from here, directly or not

        bool skip(const infinint & pos);
        bool skip_to_eof();
        bool skip_relative(S_I x);
        infinint get_position() { if(is_terminated()) throw SRC_BUG; return current_position; };


        void write_end_of_file() { if(is_terminated()) throw SRC_BUG; flush(); weof = true; };



        void set_initial_shift(const infinint & x) { initial_shift = x; };


        void set_callback_trailing_clear_data(infinint (*call_back)(generic_file & below, const archive_version & reading_ver)) { trailing_clear_data = call_back; };

    private:


        U_I inherited_read(char *a, U_I size);


        void inherited_write(const char *a, U_I size);

        void inherited_sync_write() { flush(); };

        void inherited_terminate() {};

    protected:

        virtual U_32 encrypted_block_size_for(U_32 clear_block_size) = 0;


        virtual U_32 clear_block_allocated_size_for(U_32 clear_block_size) = 0;


        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;


        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;


    private:
        infinint initial_shift;    //< the initial_shift first bytes of the underlying file are not encrypted
        infinint buf_offset;       //< offset of the first byte in buf
        U_32 buf_byte_data;        //< number of byte of information in buf (buf_byte_data <= buf_size)
        U_32 buf_size;             //< size of allocated memory for clear data in buf
        char *buf;                 //< decrypted data (or data to encrypt)
        U_32 clear_block_size;     //< max amount of data that will be encrypted at once (must stay less than buf_size)
        infinint current_position; //< position of the next character to read or write
        infinint block_num;        //< block number we next read or write
        generic_file *encrypted;   //< generic_file where is put / get the encrypted data
        char *encrypted_buf;       //< buffer of encrypted data (read or to write)
        U_32 encrypted_buf_size;   //< allocated size of encrypted_buf
        bool weof;                 //< whether write_end_of_file() has been called
        bool reof;                 //< whether we reached eof while reading
        archive_version reading_ver;//< archive format we currently read
        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


        void detruit();
        void copy_from(const tronconneuse & ref);
        U_32 fill_buf();       // returns the position (of the next read op) inside the buffer and fill the buffer with clear data
        void flush();          // flush any pending data (write mode only) to encrypted device
        void init_buf();       // initialize if necessary the various buffers that relies on inherited method values



        void position_clear2crypt(const infinint & pos,
                                  infinint & file_buf_start,
                                  infinint & clear_buf_start,
                                  infinint & pos_in_buf,
                                  infinint & block_num);

        void position_crypt2clear(const infinint & pos, infinint & clear_pos);
            // gives the position of the next character
            // of clear data that corresponds to the encrypted data which index is pos

        bool check_current_position() { reof = false; return fill_buf() < buf_byte_data; };
            // return true if a there is a byte of information at the given offset

        infinint check_trailing_clear_data();
            // returns the offset of the first byte of cleared data found after all cyphered data
    };


} // end of namespace

#endif