colin
/
tripwire-open-source
mirror of https://github.com/Tripwire/tripwire-open-source.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
tripwire-open-source/src/core/archive.h

340 lines
12 KiB
C++
Raw Blame History

//
// The developer of the original code and/or files is Tripwire, Inc.
// Portions created by Tripwire, Inc. are copyright (C) 2000-2018 Tripwire,
// Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights
// reserved.
//
// This program is free software. The contents of this file are subject
// to 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. You may redistribute it and/or modify it
// only in compliance with the GNU General Public License.
//
// This program is distributed in the hope that it will be useful.
// However, this program is distributed AS-IS WITHOUT ANY
// WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS
// FOR A PARTICULAR PURPOSE. Please 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.
//
// Nothing in the GNU General Public License or any other license to use
// the code or files shall permit you to use Tripwire's trademarks,
// service marks, or other intellectual property without Tripwire's
// prior written consent.
//
// If you have any questions, please contact Tripwire, Inc. at either
// info@tripwire.org or www.tripwire.org.
//
///////////////////////////////////////////////////////////////////////////////
// archive.h -- classes that abstract a raw byte archive
//
// cArchive -- interface for single-direction (one pass) reads and writes
// cBidirArchive -- interface for a random-access archive
// cMemArchive -- implementation of a bidirectional archive in memory
// cFileArchive -- implementation of a bidirectional archive as a file
#ifndef __ARCHIVE_H
#define __ARCHIVE_H
#ifndef __DEBUG_H
#include "debug.h"
#endif
#ifndef __ERRORUTIL_H
#include "errorutil.h"
#endif
#ifndef __FILEERROR_H
#include "fileerror.h"
#endif
#ifndef __FILE_H
#include "file.h"
#endif
//=============================================================================
// eArchive exception classes
//=============================================================================
TSS_FILE_EXCEPTION(eArchive, eFileError);
TSS_FILE_EXCEPTION(eArchiveOpen, eArchive);
TSS_FILE_EXCEPTION(eArchiveWrite, eArchive);
TSS_FILE_EXCEPTION(eArchiveRead, eArchive);
TSS_FILE_EXCEPTION(eArchiveEOF, eArchive);
TSS_FILE_EXCEPTION(eArchiveSeek, eArchive);
TSS_FILE_EXCEPTION(eArchiveMemmap, eArchive);
TSS_FILE_EXCEPTION(eArchiveOutOfMem, eArchive);
TSS_FILE_EXCEPTION(eArchiveInvalidOp, eArchive);
TSS_FILE_EXCEPTION(eArchiveFormat, eArchive);
TSS_FILE_EXCEPTION(eArchiveNotRegularFile, eArchive);
TSS_BEGIN_EXCEPTION(eArchiveCrypto, eArchive)
virtual TSTRING GetMsg() const;
// eCryptoArchive appends a special string to the end of
// all exception messages
TSS_END_EXCEPTION()
TSS_EXCEPTION(eArchiveStringTooLong, eArchive);
// throw( eArchiveOpen( cErrorUtil::MakeFileError( fileError.GetMsg(), strTempFile ) ) );
//=============================================================================
// cArchive
//=============================================================================
class cArchive
{
public:
virtual ~cArchive()
{
}
// convenience methods
//
// Specific Read functions throw(eArchive) if EOF is reached because
// if the caller is requesting a certain amount of data to be present,
// reaching EOF is unexpected
//
// ReadBlob and WriteBlob return number of bytes read or written. Notice
// that ReadBlob does not throw an exception since eventually EOF is expected.
//
// ReadBlob can take NULL as a destination pointer
//
// All write functions throw exceptions for unexpected events like
// running out of memory or disk space.
//
void ReadInt16(int16_t& ret); // throw(eArchive)
void ReadInt32(int32_t& ret); // throw(eArchive)
void ReadInt64(int64_t& ret); // throw(eArchive)
void ReadString(TSTRING& ret); // throw(eArchive)
int ReadBlob(void* pBlob, int count);
void WriteInt16(int16_t i); // throw(eArchive)
void WriteInt32(int32_t i); // throw(eArchive)
void WriteInt64(int64_t i); // throw(eArchive)
void WriteString(const TSTRING& s); // throw(eArchive)
void WriteBlob(const void* pBlob, int count); // throw(eArchive)
static int32_t GetStorageSize(const TSTRING& str);
// this method calculates how many bytes the given string will take up in the archive and returns
// that value
// NOTE -- if the implementation of ReadString() or WriteString() ever changes, this method will also
// need to change.
int64_t Copy(cArchive* pFrom, int64_t amt); // throw(eArchive)
// this method copies amt bytes from pFrom to itself, throwing an eArchive if anything goes wrong.
// only makes sense to call for reading archives
virtual bool EndOfFile() = 0;
protected:
// overrides
virtual int Read(void* pDest, int count) = 0;
virtual int Write(const void* pDest, int count) = 0; // throw(eArchive);
};
///////////////////////////////////////////////////////////////////////////////
// class cBidirArchive --
///////////////////////////////////////////////////////////////////////////////
class cBidirArchive : public cArchive
{
public:
enum SeekFrom
{
BEGINNING = 0,
CURRENT = 1,
END = -1
};
virtual void Seek(int64_t offset, SeekFrom from) = 0; // throw(eArchive);
virtual int64_t CurrentPos() const = 0;
virtual int64_t Length() const = 0;
};
///////////////////////////////////////////////////////////////////////////////
// class cMemMappedArchive -- Archive that can be memory mapped.
///////////////////////////////////////////////////////////////////////////////
class cMemMappedArchive : public cBidirArchive
{
public:
enum
{
MAP_TO_EOF = -1
};
cMemMappedArchive();
virtual ~cMemMappedArchive();
virtual void MapArchive(int64_t offset, int64_t len) = 0; // throw(eArchive);
virtual void MapArchive(int64_t offset, int64_t len) const = 0; // throw(eArchive);
// the const version of MapArchive() does not allow the archive to grow in size
int64_t GetMappedOffset() const; // throw(eArchive)
int64_t GetMappedLength() const; // throw(eArchive)
void* GetMap(); // throw(eArchive)
const void* GetMap() const;
protected:
mutable void* mpMappedMem;
mutable int64_t mMappedOffset;
mutable int64_t mMappedLength;
// call in derived class to set above vars
void SetNewMap(void* pMap, int64_t offset, int64_t length) const;
};
///////////////////////////////////////////////////////////////////////////////
// class cMemoryArchive -- An archive that stores itself in a memory buffer.
// This buffer can grow as needed up until a pre-specified maximum
// size. The buffer can be read and written to and can be memory
// mapped.
///////////////////////////////////////////////////////////////////////////////
class cMemoryArchive : public cMemMappedArchive
{
public:
cMemoryArchive(int maxSize = 0x8000000); // default max size == 128MB
~cMemoryArchive();
virtual bool EndOfFile();
virtual void Seek(int64_t offset, SeekFrom from); // throw(eArchive)
virtual int64_t CurrentPos() const;
virtual int64_t Length() const;
virtual void MapArchive(int64_t offset, int64_t len); // throw(eArchive)
virtual void MapArchive(int64_t offset, int64_t len) const; // throw(eArchive)
void Truncate(); // set the length to the current pos
int8_t* GetMemory() const
{
return mpMemory;
}
protected:
int8_t* mpMemory;
int mAllocatedLen;
int mMaxAllocatedLen;
int mLogicalSize;
int mReadHead;
virtual int Read(void* pDest, int count);
virtual int Write(const void* pDest, int count); // throw(eArchive)
virtual void AllocateMemory(int len); // throw(eArchive)
};
///////////////////////////////////////////////////////////////////////////////
// cFixedMemArchive -- a memory archive that operates on a fixed-sized block of
// memory that has already been allocated
///////////////////////////////////////////////////////////////////////////////
class cFixedMemArchive : public cBidirArchive
{
public:
cFixedMemArchive();
cFixedMemArchive(int8_t* pMem, int32_t size);
virtual ~cFixedMemArchive();
void Attach(int8_t* pMem, int32_t size);
// this method associates the archive with pMem and sets the size of the
// archive. Unlike cMemoryArchive, this may never grow or shrink in size.
//-----------------------------------
// cBidirArchive interface
//-----------------------------------
virtual void Seek(int64_t offset, SeekFrom from); // throw(eArchive);
virtual int64_t CurrentPos() const;
virtual int64_t Length() const;
virtual bool EndOfFile();
protected:
//-----------------------------------
// cArchive interface
//-----------------------------------
virtual int Read(void* pDest, int count); // throw(eArchive)
virtual int Write(const void* pDest, int count); // throw(eArchive)
int8_t* mpMemory;
int32_t mSize;
int32_t mReadHead;
};
class cFileArchive : public cBidirArchive
{
public:
cFileArchive();
virtual ~cFileArchive();
enum OpenFlags
{
FA_OPEN_TEXT = 0x1,
FA_OPEN_TRUNCATE = 0x2,
FA_SCANNING = 0x4,
FA_DIRECT = 0x8
};
// TODO: Open should throw
virtual void OpenRead(const TCHAR* filename, uint32_t openFlags = 0);
virtual void OpenReadWrite(const TCHAR* filename, uint32_t openFlags = FA_OPEN_TRUNCATE);
// opens a file for reading or writing; the file is always created if it doesn't exist,
// and is truncated to zero length if truncateFile is set to true;
TSTRING GetCurrentFilename(void) const;
virtual void Close(void);
void Truncate(); // throw(eArchive) // set the length to the current pos
//-----------------------------------
// cBidirArchive interface
//-----------------------------------
virtual bool EndOfFile();
virtual void Seek(int64_t offset, SeekFrom from); // throw(eArchive)
virtual int64_t CurrentPos() const;
virtual int64_t Length() const;
protected:
int64_t mFileSize; //Size of FileArchive
int64_t mReadHead; //Current position of read/write head
//-----------------------------------
// cArchive interface
//-----------------------------------
virtual int Read(void* pDest, int count);
virtual int Write(const void* pDest, int count); //throw(eArchive)
bool isWritable;
cFile mCurrentFile;
TSTRING mCurrentFilename; //current file
uint32_t mOpenFlags;
};
///////////////////////////////////////////////////////////////
// cLockedTemporaryFileArchive -- this class uses as an archive a file
// that is not accessable to any other process besides the calling one.
// the file will be deleted from the filesystem on Close();
//
// implemented by using cFileArchive and overwriting open and close
// functions
//
class cLockedTemporaryFileArchive : public cFileArchive
{
public:
virtual void OpenReadWrite(const TCHAR* filename = NULL, uint32_t openFlags = FA_OPEN_TRUNCATE);
// creates the file. filename must not exist on the file system.
// if filename is NULL, the class will create and use a temporary file.
// truncateFile has no meaning
//virtual void OpenReadWriteThrow ( const TCHAR* filename = NULL, bool truncateFile = true ) throw (eArchive);
// this is the same as OpenReadWrite, except an exception is thrown on error (of type
// cArchive::ERR_OPEN_FAILED)
virtual void Close();
// close and delete the file
private:
// open for read only makes no sense if we're always creating the file,
// so disallow read only file opens
virtual void OpenRead(const TCHAR*, uint32_t openFlags = 0)
{
ASSERT(false);
THROW_INTERNAL("archive.h");
}
};
#endif
Reference in New Issue View Git Blame Copy Permalink