crypt/file.h

Go to the documentation of this file.

// -*- c++ -*-
//
// $Id: file.h 3342 2010-09-17 18:32:00Z java $
//
// Copyright (C) 2008-2010  Rafael Ostertag
//
// This file is part of YAPET.
//
// YAPET 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 3 of the License, or (at your option) any later
// version.
//
// YAPET 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
// YAPET.  If not, see <http://www.gnu.org/licenses/>.
//
// Additional permission under GNU GPL version 3 section 7
//
// If you modify this program, or any covered work, by linking or combining it
// with the OpenSSL project's OpenSSL library (or a modified version of that
// library), containing parts covered by the terms of the OpenSSL or SSLeay
// licenses, Rafael Ostertag grants you additional permission to convey the
// resulting work.  Corresponding Source for a non-source form of such a
// combination shall include the source code for the parts of OpenSSL used as
// well as that of the covered work.
//

#ifndef _FILE_H
#define _FILE_H

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifdef HAVE_ASSERT_H
# include <assert.h>
#endif

#ifdef HAVE_STRING
# include <string>
#endif

#ifdef HAVE_LIST
# include <list>
#endif

#include "yapetexception.h"

#include "bdbuffer.h"
#include "structs.h"
#include "key.h"
#include "partdec.h"

namespace YAPET {
    class File {
        private:
            int fd;
            std::string filename;
        int64_t mtime;

            bool usefsecurity;

            void checkFileSecurity() throw (YAPETException);
            void setFileSecurity() throw (YAPETException);

            void openCreate() throw (YAPETException);
            void openNoCreate() throw (YAPETException);
            int64_t lastModified() const throw (YAPETException);
            void seekCurr (off_t offset) const throw (YAPETException);
            void seekAbs (off_t offset) const throw (YAPETException);
            void preparePWSave() throw (YAPETException);

        protected:
        template <class t>
            union ENDIAN {
            t value;
            uint8_t fields[sizeof(t)];
            };

#ifndef WORDS_BIGENDIAN

        template<class t>
            t int_to_disk (t le) const {
        ENDIAN<t> in;
        ENDIAN<t> out;
        in.value = le;
        out.value = 0;
        for (register unsigned int i=0; i < sizeof(t); i++)
            out.fields[(sizeof(t)-1)-i] = in.fields[i];
        return out.value;
        }
        template<class t>
        t int_from_disk (t i) const {
        return int_to_disk<t>(i);
        }
#else

        template<class t>
            t int_to_disk (t i) const {
                return i;
            }
        template<class t>
            t int_from_disk (t i) const {
                return i;
            }
#endif // WORDS_BIGENDIAN

            void seekDataSection() const throw (YAPETException);

            BDBuffer* read() const throw (YAPETException);
            void write (const BDBuffer& buff,
                        bool forceappend = false,
                        bool forcewrite = false)
            throw (YAPETException, YAPETRetryException);
            bool isempty() const throw (YAPETException);
            void initFile (const Key& key) throw (YAPETException);
            void writeHeader (const Record<FileHeader_64>& header,
                              const Key& key)
            throw (YAPETException);
            void writeHeader (const BDBuffer& enc_header) throw (YAPETException);
            BDBuffer* readHeader() const throw (YAPETException);
        void readHeader(const Key& key, Record<FileHeader_32>** ptr32, Record<FileHeader_64>** ptr64) const throw(YAPETException);
            void validateKey (const Key& key)
            throw (YAPETException, YAPETInvalidPasswordException);

        public:
            File (const std::string& fn,
                  const Key& key,
                  bool create = false,
                  bool secure = true)
            throw (YAPETException);
            File (const File& f) throw (YAPETException);
            ~File();

            void save (std::list<PartDec>& records) throw (YAPETException);
            std::list<PartDec> read (const Key& key) const throw (YAPETException);
            std::string getFilename() const {
                return filename;
            }
            void setNewKey (const Key& oldkey, const Key& newkey) throw (YAPETException);
            int64_t getMasterPWSet (const Key& key) const throw (YAPETException, YAPETInvalidPasswordException);
        FILE_VERSION getFileVersion(const Key& key) const throw (YAPETException, YAPETInvalidPasswordException);
            const File& operator= (const File& f) throw (YAPETException);

            bool filesecurityEnabled() const {
                return usefsecurity;
            }
            void setFilesecurity (bool secure) {
                usefsecurity = secure;
            }
    };
}
#endif // _FILE_H