try

{

DataSize = size;

DataAlignment = alignment;

}

void Buffer::Erase ()

{

if (DataSize > 0)

}

void Buffer::Free ()

public:

ConstBufferPtr ()

: DataPtr (nullptr), DataSize (0) { }

: DataPtr (data), DataSize (size) { }

virtual ~ConstBufferPtr () { }

bool IsDataEqual (const ConstBufferPtr &other) const { return Memory::Compare (DataPtr, DataSize, other.DataPtr, other.DataSize) == 0; }

ConstBufferPtr GetRange (size_t offset, size_t size) const;

size_t Size () const { return DataSize; }

protected:

size_t DataSize;

};

public:

BufferPtr ()

: DataPtr (nullptr), DataSize (0) { }

: DataPtr (data), DataSize (size) { }

virtual ~BufferPtr () { }

void CopyFrom (const ConstBufferPtr &bufferPtr) const;

void Erase () const { Zero(); }

BufferPtr GetRange (size_t offset, size_t size) const;

size_t Size () const { return DataSize; }

void Zero () const { Memory::Zero (DataPtr, DataSize); }

operator ConstBufferPtr () const { return ConstBufferPtr (DataPtr, DataSize); }

protected:

size_t DataSize;

};

virtual void Allocate (size_t size, size_t alignment = 0);

virtual void CopyFrom (const ConstBufferPtr &bufferPtr, size_t alignment = 0);

virtual void Erase ();

virtual void Free ();

virtual BufferPtr GetRange (size_t offset, size_t size) const;

virtual bool IsAllocated () const { return DataSize != 0; }

virtual void Zero ();

virtual operator BufferPtr () const { return BufferPtr (DataPtr, DataSize); }

virtual operator ConstBufferPtr () const { return ConstBufferPtr (DataPtr, DataSize); }

protected:

size_t DataSize;

size_t DataAlignment;

TC_EXCEPTION_NODECL (ExecutedProcessFailed); \

TC_EXCEPTION (AlreadyInitialized); \

TC_EXCEPTION (AssertionFailed); \

TC_EXCEPTION (ExternalException); \

TC_EXCEPTION (InsufficientData); \

TC_EXCEPTION (NotApplicable); \

TC_EXCEPTION (ParameterTooLarge); \

TC_EXCEPTION (PartitionDeviceRequired); \

TC_EXCEPTION (StringConversionFailed); \

TC_EXCEPTION (TestFailed); \

TC_EXCEPTION (TimeOut); \

TC_EXCEPTION (UnknownException); \

TC_EXCEPTION (UserAbort)

TC_EXCEPTION_SET;

typedef int SystemFileHandleType;

#endif

virtual ~File ();

void AssignSystemHandle (SystemFileHandleType openFileHandle, bool sharedHandle = true)

vector <char> buffer (4096);

uint64 len;

str.insert (str.end(), buffer.begin(), buffer.begin() + static_cast <int> (len));

return str;

code distribution packages.

*/

#include "Memory.h"

#include "Exception.h"

#include <stdlib.h>

memcpy (memoryDestination, memorySource, size);

}

void Memory::Zero (void *memory, size_t size)

{

memset (memory, 0, size);

#include <new>

#include <memory.h>

#include "PlatformBase.h"

#ifdef TC_WINDOWS

static void *AllocateAligned (size_t size, size_t alignment);

static int Compare (const void *memory1, size_t size1, const void *memory2, size_t size2);

static void Copy (void *memoryDestination, const void *memorySource, size_t size);

static void Free (void *memory);

static void FreeAligned (void *memory);

static void Zero (void *memory, size_t size);

class Endian

{

public:

{

return x;

}

#endif

}

{

return x;

}

static uint32 MirrorBytes (const uint32 &x)

{

}

static uint64 MirrorBytes (const uint64 &x)

{

}

};

}

MemoryStream::MemoryStream (const ConstBufferPtr &data) :

ReadPosition (0)

{

BufferPtr (&Data[0], Data.size()).CopyFrom (data);

}

virtual void Write (const ConstBufferPtr &data);

protected:

size_t ReadPosition;

};

}

typedef __int16 int16;

typedef __int32 int32;

typedef __int64 int64;

typedef unsigned __int16 uint16;

typedef unsigned __int32 uint32;

typedef unsigned __int64 uint64;

typedef int16_t int16;

typedef int32_t int32;

typedef int64_t int64;

typedef uint16_t uint16;

typedef uint32_t uint32;

typedef uint64_t uint64;

Buffer buffer (10);

for (size_t i = 0; i < buffer.Size(); i++)

ser.Serialize ("int32", i32);

ser.Serialize ("int64", i64);

Buffer dbuffer (10);

ser.Deserialize ("buffer", buffer);

for (size_t i = 0; i < buffer.Size(); i++)

throw TestFailed (SRC_POS);

shared_ptr <ExecutedProcessFailed> dex = Serializable::DeserializeNew <ExecutedProcessFailed> (stream);

bool PlatformTest::TestAll ()

{

// Integer types

if (sizeof (uint16) != 2 || sizeof (int16) != 2 || sizeof (__int16) != 2) throw TestFailed (SRC_POS);

if (sizeof (uint32) != 4 || sizeof (int32) != 4 || sizeof (__int32) != 4) throw TestFailed (SRC_POS);

if (sizeof (uint64) != 8 || sizeof (int64) != 8) throw TestFailed (SRC_POS);

T Serializer::Deserialize ()

{

uint64 size;

if (Endian::Big (size) != sizeof (T))

throw ParameterIncorrect (SRC_POS);

T data;

return Endian::Big (data);

}

void Serializer::Deserialize (const string &name, bool &data)

{

ValidateName (name);

}

{

ValidateName (name);

}

void Serializer::Deserialize (const string &name, int32 &data)

uint64 size = Deserialize <uint64> ();

vector <char> data ((size_t) size);

return string (&data[0]);

}

uint64 size = Deserialize <uint64> ();

vector <wchar_t> data ((size_t) size / sizeof (wchar_t));

return wstring (&data[0]);

}

void Serializer::Serialize (T data)

{

uint64 size = Endian::Big (uint64 (sizeof (data)));

data = Endian::Big (data);

}

void Serializer::Serialize (const string &name, bool data)

{

SerializeString (name);

Serialize (d);

}

{

SerializeString (name);

Serialize (data);

void Serializer::SerializeString (const string &data)

{

Serialize ((uint64) data.size() + 1);

}

void Serializer::SerializeWString (const wstring &data)

{

uint64 size = (data.size() + 1) * sizeof (wchar_t);

Serialize (size);

}

void Serializer::ValidateName (const string &name)

virtual ~Serializer () { }

void Deserialize (const string &name, bool &data);

void Deserialize (const string &name, int32 &data);

void Deserialize (const string &name, int64 &data);

void Deserialize (const string &name, uint32 &data);

wstring DeserializeWString (const string &name);

list <wstring> DeserializeWStringList (const string &name);

void Serialize (const string &name, bool data);

void Serialize (const string &name, const char *data);

void Serialize (const string &name, int32 data);

void Serialize (const string &name, int64 data);

#define TC_HEADER_Platform_SharedPtr

#include <stdexcept>

#include "SharedVal.h"

#ifdef nullptr

namespace VeraCrypt

{

template <class T>

class SharedPtr

{

#define make_shared VeraCrypt::make_shared

}

#endif // nullptr

str.clear();

str.insert (0, &buf.front(), size);

}

catch (...)

{

}

BufferPtr (

bufferSize).CopyFrom (

(str.length() + 1) * sizeof (wchar_t)

)

);

outputString.erase();

char c;

{

if (c == '\r')

continue;

#include <sys/disk.h>

#endif

#ifdef TC_SOLARIS

#include <stropts.h>

#include <sys/dkio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "Platform/File.h"

#include "Platform/TextReader.h"

throw_sys_sub_if (ioctl (FileHandle, DIOCGSECTORSIZE, &sectorSize) == -1, wstring (Path));

return (uint32) sectorSize;

#elif defined (TC_SOLARIS)

struct dk_minfo mediaInfo;

throw_sys_sub_if (ioctl (FileHandle, DKIOCGMEDIAINFO, &mediaInfo) == -1, wstring (Path));

throw_sys_sub_if (ioctl (FileHandle, DKIOCGETBASE, &offset) == -1, wstring (Path));

return offset;

#elif defined (TC_SOLARIS)

struct extpart_info partInfo;

throw_sys_sub_if (ioctl (FileHandle, DKIOCGETBLOCKSIZE, &blockSize) == -1, wstring (Path));

throw_sys_sub_if (ioctl (FileHandle, DKIOCGETBLOCKCOUNT, &blockCount) == -1, wstring (Path));

return blockCount * blockSize;

# else

uint64 mediaSize;

throw_sys_sub_if (ioctl (FileHandle, DIOCGMEDIASIZE, &mediaSize) == -1, wstring (Path));

# endif

}

#endif

off_t current = lseek (FileHandle, 0, SEEK_CUR);

throw_sys_sub_if (current == -1, wstring (Path));

SeekEnd (0);

#include "Platform/StringConverter.h"

#include <stdio.h>

#include <sys/stat.h>

namespace VeraCrypt

{

string pathStr = StringConverter::ToSingle (Path);

size_t p = pathStr.rfind ("s");

path = pathStr.substr (0, p);

#elif defined (TC_SOLARIS)

string Process::Execute (const string &processName, const list <string> &arguments, int timeOut, ProcessExecFunctor *execFunctor, const Buffer *inputData)

{

char *args[32];

throw ParameterTooLarge (SRC_POS);

#if 0

try

{

int argIndex = 0;

if (!execFunctor)

{

}

args[argIndex] = nullptr;

if (inputData)

throw_sys_if (fcntl (exceptionPipe.GetReadFD(), F_SETFL, O_NONBLOCK) == -1);

vector <char> buffer (4096), stdOutput (4096), errOutput (4096), exOutput (4096);

stdOutput.clear ();

errOutput.clear ();

exOutput.clear ();

if (!exOutput.empty())

{

Exception *deserializedException = nullptr;

try

{

deserializedObject.reset (Serializable::DeserializeNew (stream));

deserializedException = dynamic_cast <Exception*> (deserializedObject.get());

}

return L"Mac OS X";

#elif defined (TC_FREEBSD)

return L"FreeBSD";

#elif defined (TC_SOLARIS)

return L"Solaris";

#else