Return to buffer.h CVS log

Up to [truecrypt] / truecrypt / platform

Annotation of truecrypt/platform/buffer.h, revision 1.1.1.5

1.1       root        1: /*
                      2:  Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
                      3: 
1.1.1.5 ! root        4:  Governed by the TrueCrypt License 2.8 the full text of which is contained
1.1       root        5:  in the file License.txt included in TrueCrypt binary and source code
                      6:  distribution packages.
                      7: */
                      8: 
                      9: #ifndef TC_HEADER_Platform_Buffer
                     10: #define TC_HEADER_Platform_Buffer
                     11: 
                     12: #include "PlatformBase.h"
                     13: #include "Memory.h"
                     14: 
                     15: namespace TrueCrypt
                     16: {
                     17: 
                     18:        class ConstBufferPtr
                     19:        {
                     20:        public:
                     21:                ConstBufferPtr ()
                     22:                        : DataPtr (nullptr), DataSize (0) { }
                     23:                ConstBufferPtr (const byte *data, size_t size)
                     24:                        : DataPtr (data), DataSize (size) { }
                     25:                virtual ~ConstBufferPtr () { }
                     26: 
                     27:                operator const byte * () const { return DataPtr; }
                     28: 
                     29:                bool IsDataEqual (const ConstBufferPtr &other) const { return Memory::Compare (DataPtr, DataSize, other.DataPtr, other.DataSize) == 0; }
                     30:                const byte *Get () const { return DataPtr; }
                     31:                ConstBufferPtr GetRange (size_t offset, size_t size) const;
                     32:                void Set (const byte *data, size_t size) { DataPtr = data; DataSize = size; }
                     33:                size_t Size () const { return DataSize; }
                     34: 
                     35:        protected:
                     36:                const byte *DataPtr;
                     37:                size_t DataSize;
                     38:        };
                     39: 
                     40: 
                     41:        class BufferPtr
                     42:        {
                     43:        public:
                     44:                BufferPtr ()
                     45:                        : DataPtr (nullptr), DataSize (0) { }
                     46:                BufferPtr (byte *data, size_t size)
                     47:                        : DataPtr (data), DataSize (size) { }
                     48:                virtual ~BufferPtr () { }
                     49: 
                     50:                operator byte * () const { return DataPtr; }
1.1.1.2   root       51:                void CopyFrom (const ConstBufferPtr &bufferPtr) const;
1.1       root       52:                void Erase () const { Zero(); }
                     53:                byte *Get () const { return DataPtr; }
                     54:                BufferPtr GetRange (size_t offset, size_t size) const;
                     55:                void Set (byte *data, size_t size) { DataPtr = data; DataSize = size; }
                     56:                size_t Size () const { return DataSize; }
                     57:                void Zero () const { Memory::Zero (DataPtr, DataSize); }
                     58: 
                     59:                operator ConstBufferPtr () const { return ConstBufferPtr (DataPtr, DataSize); }
                     60: 
                     61:        protected:
                     62:                byte *DataPtr;
                     63:                size_t DataSize;
                     64:        };
                     65: 
                     66:        class Buffer
                     67:        {
                     68:        public:
                     69:                Buffer ();
                     70:                Buffer (size_t size);
                     71:                Buffer (const ConstBufferPtr &bufferPtr) { CopyFrom (bufferPtr); }
                     72:                virtual ~Buffer ();
                     73: 
                     74:                virtual void Allocate (size_t size);
                     75:                virtual void CopyFrom (const ConstBufferPtr &bufferPtr);
                     76:                virtual byte *Ptr () const { return DataPtr; }
                     77:                virtual void Erase ();
                     78:                virtual void Free ();
                     79:                virtual BufferPtr GetRange (size_t offset, size_t size) const;
                     80:                virtual size_t Size () const { return DataSize; }
                     81:                virtual bool IsAllocated () const { return DataSize != 0; }
                     82:                virtual void Zero ();
                     83: 
                     84:                virtual operator byte * () const { return DataPtr; }
                     85:                virtual operator BufferPtr () const { return BufferPtr (DataPtr, DataSize); }
                     86:                virtual operator ConstBufferPtr () const { return ConstBufferPtr (DataPtr, DataSize); }
                     87: 
                     88:        protected:
                     89:                byte *DataPtr;
                     90:                size_t DataSize;
                     91: 
                     92:        private:
                     93:                Buffer (const Buffer &);
                     94:                Buffer &operator= (const Buffer &);
                     95:        };
                     96: 
                     97:        class SecureBuffer : public Buffer
                     98:        {
                     99:        public:
                    100:                SecureBuffer () { }
                    101:                SecureBuffer (size_t size);
                    102:                SecureBuffer (const ConstBufferPtr &bufferPtr) { CopyFrom (bufferPtr); }
                    103:                virtual ~SecureBuffer ();
                    104: 
                    105:                virtual void Allocate (size_t size);
                    106:                virtual void Free ();
                    107: 
                    108:        private:
                    109:                SecureBuffer (const SecureBuffer &);
                    110:                SecureBuffer &operator= (const SecureBuffer &);
                    111:        };
                    112: 
                    113: }
                    114: 
                    115: #endif // TC_HEADER_Platform_Buffer

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.