opentxs::OTData Class Reference

#include <OTData.hpp>

Inheritance diagram for opentxs::OTData:

Public Member Functions
EXPORT	OTData ()
EXPORT	OTData (const void *data, uint32_t size)
EXPORT	OTData (const OTData &source)
EXPORT	OTData (const OTASCIIArmor &source)
virtual EXPORT	~OTData ()
virtual EXPORT void	Release ()
EXPORT void	Release_Data ()
void	SetSize (uint32_t size)
const void *	GetPointer () const
EXPORT OTData &	operator= (OTData rhs)
EXPORT void	swap (OTData &rhs)
EXPORT bool	operator== (const OTData &rhs) const
EXPORT bool	operator!= (const OTData &rhs) const
EXPORT OTData &	operator+= (const OTData &rhs)
EXPORT bool	IsEmpty () const
uint32_t	GetSize () const
EXPORT void	Assign (const OTData &source)
EXPORT void	Assign (const void *data, uint32_t size)
EXPORT void	Concatenate (const void *data, uint32_t size)
EXPORT bool	Randomize (uint32_t size)
EXPORT void	zeroMemory () const
EXPORT uint32_t	OTfread (uint8_t *data, uint32_t size)
void	reset ()

Protected Member Functions
void	Initialize ()

Friends
class	OTASCIIArmor
class	OTIdentifier
class	OTEnvelope
class	OTCrypto

Detailed Description

Definition at line 143 of file OTData.hpp.

Constructor & Destructor Documentation

opentxs::OTData::OTData

(

)

Definition at line 145 of file OTData.cpp.

    : data_(nullptr)
    , position_(0)
    , size_(0)
{
}

opentxs::OTData::OTData	(	const void *	data,
		uint32_t	size
	)

Definition at line 170 of file OTData.cpp.

    : data_(nullptr)
    , position_(0)
    , size_(0)
{
    Assign(data, size);
}

opentxs::OTData::OTData

(

const OTData &

source

)

Definition at line 152 of file OTData.cpp.

    : data_(nullptr)
    , position_(0)
    , size_(0)
{
    Assign(source);
}

opentxs::OTData::OTData

(

const OTASCIIArmor &

source

)

Definition at line 160 of file OTData.cpp.

    : data_(nullptr)
    , position_(0)
    , size_(0)
{
    if (source.Exists()) {
        source.GetData(*this);
    }
}

opentxs::OTData::~OTData ( )

virtual

Definition at line 178 of file OTData.cpp.

{
    Release_Data();
}

Member Function Documentation

void opentxs::OTData::Assign

(

const OTData &

source

)

Definition at line 275 of file OTData.cpp.

{
    // can't assign to self.
    if (&source == this) {
        return;
    }

    if (!source.IsEmpty()) {
        Assign(source.data_, source.size_);
    }
    else {
        // Otherwise if it's empty, then empty this also.
        Release();
    }
}

void opentxs::OTData::Assign	(	const void *	data,
		uint32_t	size
	)

Definition at line 296 of file OTData.cpp.

{
    // This releases all memory and zeros out all members.
    Release();

    if (data != nullptr && size > 0) {
        data_ = static_cast<void*>(new uint8_t[size]);
        OT_ASSERT(data_ != nullptr);
        OTPassword::safe_memcpy(data_, size, data, size);
        size_ = size;
    }
    // TODO: else error condition.  Could just ASSERT() this.
}

void opentxs::OTData::Concatenate	(	const void *	data,
		uint32_t	size
	)

Definition at line 333 of file OTData.cpp.

{
    OT_ASSERT(data != nullptr);
    OT_ASSERT(size > 0);

    if (size == 0) {
        return;
    }

    if (size_ == 0) {
        Assign(data, size);
        return;
    }

    void* newData = nullptr;
    uint32_t newSize = GetSize() + size;

    if (newSize > 0) {
        newData = static_cast<void*>(new uint8_t[newSize]);
        OT_ASSERT(newData != nullptr);
        OTPassword::zeroMemory(newData, newSize);
    }
    // If there's a new memory buffer (for the combined..)
    if (newData != nullptr) {
        // if THIS object has data inside of it...
        if (!IsEmpty()) {
            // Copy THIS object into the new
            // buffer, starting at the
            // beginning.
            OTPassword::safe_memcpy(newData, newSize, data_, GetSize());
        }

        // Next we copy the data being appended...
        OTPassword::safe_memcpy(static_cast<uint8_t*>(newData) + GetSize(),
                                newSize - GetSize(), data, size);
    }

    if (data_ != nullptr) {
        delete[] static_cast<uint8_t*>(data_);
    }

    data_ = newData;
    size_ = newSize;
}

const void* opentxs::OTData::GetPointer ( ) const

inline

Definition at line 162 of file OTData.hpp.

    {
        return data_;
    }

uint32_t opentxs::OTData::GetSize ( ) const

inline

Definition at line 174 of file OTData.hpp.

    {
        return size_;
    }

void opentxs::OTData::Initialize ( )

inlineprotected

Definition at line 192 of file OTData.hpp.

    {
        data_ = nullptr;
        size_ = 0;
        position_ = 0;
    }

bool opentxs::OTData::IsEmpty

(

)

const

Definition at line 291 of file OTData.cpp.

{
    return size_ < 1;
}

bool opentxs::OTData::operator!=

(

const OTData &

rhs

)

const

Definition at line 202 of file OTData.cpp.

{
    return !operator==(rhs);
}

OTData & opentxs::OTData::operator+=

(

const OTData &

rhs

)

Definition at line 378 of file OTData.cpp.

{
    if (rhs.GetSize() > 0) {
        Concatenate(rhs.data_, rhs.GetSize());
    }
    return *this;
}

OTData & opentxs::OTData::operator=

(

OTData

rhs

)

Definition at line 262 of file OTData.cpp.

{
    swap(rhs);
    return *this;
}

bool opentxs::OTData::operator==

(

const OTData &

rhs

)

const

Definition at line 183 of file OTData.cpp.

{
    if (size_ != rhs.size_) {
        return false;
    }

    if (size_ == 0 && rhs.size_ == 0) {
        return true;
    }
    // TODO security: replace memcmp with a more secure
    // version. Still, though, I am managing it internal to
    // the class.
    if (std::memcmp(data_, rhs.data_, size_) == 0) {
        return true;
    }

    return false;
}

uint32_t opentxs::OTData::OTfread	(	uint8_t *	data,
		uint32_t	size
	)

Definition at line 214 of file OTData.cpp.

{
    OT_ASSERT(data != nullptr && size > 0);

    uint32_t sizeToRead = 0;

    if (data_ != nullptr && position_ < GetSize()) {
        // If the size is 20, and position is 5 (I've already read the first 5
        // bytes) then the size remaining to read is 15. That is, GetSize()
        // minus position_.
        sizeToRead = GetSize() - position_;

        if (size < sizeToRead) {
            sizeToRead = size;
        }
        OTPassword::safe_memcpy(data, size,
                                static_cast<uint8_t*>(data_) + position_,
                                static_cast<uint32_t>(sizeToRead));
        position_ += sizeToRead;
    }

    return sizeToRead;
}

bool opentxs::OTData::Randomize

(

uint32_t

size

)

Definition at line 310 of file OTData.cpp.

{
    Release(); // This releases all memory and zeros out all members.
    if (size > 0) {
        data_ = static_cast<void*>(new uint8_t[size]);
        OT_ASSERT(data_ != nullptr);

        if (!OTPassword::randomizeMemory_uint8(static_cast<uint8_t*>(data_),
                                               size)) {
            // randomizeMemory already logs, so I'm not logging again twice
            // here.
            delete[] static_cast<uint8_t*>(data_);
            data_ = nullptr;
            return false;
        }

        size_ = size;
        return true;
    }
    // else error condition.  Could just ASSERT() this.
    return false;
}

void opentxs::OTData::Release ( )

virtual

Definition at line 257 of file OTData.cpp.

{
    Release_Data();
}

void opentxs::OTData::Release_Data

(

)

Definition at line 245 of file OTData.cpp.

{
    if (data_ != nullptr) {
        // For security reasons, we clear the memory to 0 when deleting the
        // object. (Seems smart.)
        OTPassword::zeroMemory(data_, size_);
        delete[] static_cast<uint8_t*>(data_);
        // If data_ was already nullptr, no need to re-Initialize().
        Initialize();
    }
}

void opentxs::OTData::reset ( )

inline

Definition at line 186 of file OTData.hpp.

    {
        position_ = 0;
    }

void opentxs::OTData::SetSize

(

uint32_t

size

)

Definition at line 386 of file OTData.cpp.

{
    Release();

    if (size > 0) {
        data_ = static_cast<void*>(new uint8_t[size]);
        OT_ASSERT(data_ != nullptr);
        OTPassword::zeroMemory(data_, size);
        size_ = size;
    }
}

void opentxs::OTData::swap

(

OTData &

rhs

)

Definition at line 268 of file OTData.cpp.

{
    std::swap(data_, rhs.data_);
    std::swap(position_, rhs.position_);
    std::swap(size_, rhs.size_);
}

void opentxs::OTData::zeroMemory

(

)

const

Definition at line 238 of file OTData.cpp.

{
    if (data_ != nullptr) {
        OTPassword::zeroMemory(data_, size_);
    }
}

Friends And Related Function Documentation

friend class OTASCIIArmor

friend

Definition at line 145 of file OTData.hpp.

friend class OTCrypto

friend

Definition at line 148 of file OTData.hpp.

friend class OTEnvelope

friend

Definition at line 147 of file OTData.hpp.

friend class OTIdentifier

friend

Definition at line 146 of file OTData.hpp.

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/core/OTData.hpp
• /usr/local/src/opentxs/src/core/OTData.cpp