secu_string.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 SECU_STRING_HPP
#define SECU_STRING_HPP

#include "../my_config.h"

#include <string>
#include "integers.hpp"
#include "special_alloc.hpp"

namespace libdar
{




    class secu_string
    {
    public:

        static bool is_string_secured();


        secu_string(U_I size = 0) { init(size); };


        secu_string(const char *ptr, U_I size) { init(size); append(ptr, size); };

        secu_string(const secu_string & ref) { copy_from(ref); };


        secu_string & operator = (const secu_string & ref) { clean_and_destroy(); copy_from(ref); return *this; };

        bool operator != (const std::string & ref) const { return ! (*this == ref); };
        bool operator != (const secu_string & ref) const { return ! (*this == ref); };
        bool operator == (const std::string &ref) const { return compare_with(ref.c_str(),(U_I)(ref.size())); };
        bool operator == (const secu_string &ref) const { return compare_with(ref.mem, *ref.string_size); };

        ~secu_string() { clean_and_destroy(); };


        void read(int fd, U_I size);


        void append(const char *ptr, U_I size);

        void append(int fd, U_I size);

        void reduce_string_size_to(U_I pos);

        void clear() { clean_and_destroy(); init(0); };


        void clear_and_resize(U_I size) { clean_and_destroy(); init(size); };

        void clear_and_not_resize() {  string_size = 0; };


        const char*c_str() const { return mem == NULL ? throw SRC_BUG : mem; };


        U_I size() const { return *string_size; }; // returns the size of the string

#ifdef LIBDAR_SPECIAL_ALLOC
        USE_SPECIAL_ALLOC(secu_string);
#endif
    private:
        U_I *allocated_size;
        char *mem;
        U_I *string_size;

        void init(U_I size);
        void copy_from(const secu_string & ref);
        bool compare_with(const char *ptr, U_I size) const;
        void clean_and_destroy();
    };


} // end of namespace

#endif