ArgumentDecoder.cpp [plain text]
#include "config.h"
#include "ArgumentDecoder.h"
#include "DataReference.h"
#include <stdio.h>
namespace CoreIPC {
ArgumentDecoder::ArgumentDecoder(const uint8_t* buffer, size_t bufferSize)
{
initialize(buffer, bufferSize);
}
ArgumentDecoder::ArgumentDecoder(const uint8_t* buffer, size_t bufferSize, Deque<Attachment>& attachments)
{
initialize(buffer, bufferSize);
m_attachments.swap(attachments);
}
ArgumentDecoder::~ArgumentDecoder()
{
ASSERT(m_allocatedBase);
fastFree(m_allocatedBase);
#if !USE(UNIX_DOMAIN_SOCKETS)
#else
Deque<Attachment>::iterator end = m_attachments.end();
for (Deque<Attachment>::iterator it = m_attachments.begin(); it != end; ++it)
it->dispose();
#endif
}
static inline uint8_t* roundUpToAlignment(uint8_t* ptr, unsigned alignment)
{
ASSERT(alignment && !(alignment & (alignment - 1)));
uintptr_t alignmentMask = alignment - 1;
return reinterpret_cast<uint8_t*>((reinterpret_cast<uintptr_t>(ptr) + alignmentMask) & ~alignmentMask);
}
void ArgumentDecoder::initialize(const uint8_t* buffer, size_t bufferSize)
{
const size_t expectedAlignment = sizeof(uint64_t);
m_allocatedBase = static_cast<uint8_t*>(fastMalloc(bufferSize + expectedAlignment));
m_buffer = roundUpToAlignment(m_allocatedBase, expectedAlignment);
ASSERT(!(reinterpret_cast<uintptr_t>(m_buffer) % expectedAlignment));
m_bufferPos = m_buffer;
m_bufferEnd = m_buffer + bufferSize;
memcpy(m_buffer, buffer, bufferSize);
decodeUInt64(m_destinationID);
}
static inline bool alignedBufferIsLargeEnoughToContain(const uint8_t* alignedPosition, const uint8_t* bufferEnd, size_t size)
{
return bufferEnd >= alignedPosition && static_cast<size_t>(bufferEnd - alignedPosition) >= size;
}
bool ArgumentDecoder::alignBufferPosition(unsigned alignment, size_t size)
{
uint8_t* alignedPosition = roundUpToAlignment(m_bufferPos, alignment);
if (!alignedBufferIsLargeEnoughToContain(alignedPosition, m_bufferEnd, size)) {
markInvalid();
return false;
}
m_bufferPos = alignedPosition;
return true;
}
bool ArgumentDecoder::bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const
{
return alignedBufferIsLargeEnoughToContain(roundUpToAlignment(m_bufferPos, alignment), m_bufferEnd, size);
}
bool ArgumentDecoder::decodeFixedLengthData(uint8_t* data, size_t size, unsigned alignment)
{
if (!alignBufferPosition(alignment, size))
return false;
memcpy(data, m_bufferPos, size);
m_bufferPos += size;
return true;
}
bool ArgumentDecoder::decodeVariableLengthByteArray(DataReference& dataReference)
{
uint64_t size;
if (!decodeUInt64(size))
return false;
if (!alignBufferPosition(1, size))
return false;
uint8_t* data = m_bufferPos;
m_bufferPos += size;
dataReference = DataReference(data, size);
return true;
}
bool ArgumentDecoder::decodeBool(bool& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<bool*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeUInt16(uint16_t& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<uint16_t*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeUInt32(uint32_t& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<uint32_t*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeUInt64(uint64_t& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<uint64_t*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeInt32(int32_t& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<uint32_t*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeInt64(int64_t& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<uint64_t*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeFloat(float& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<float*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::decodeDouble(double& result)
{
if (!alignBufferPosition(sizeof(result), sizeof(result)))
return false;
result = *reinterpret_cast<double*>(m_bufferPos);
m_bufferPos += sizeof(result);
return true;
}
bool ArgumentDecoder::removeAttachment(Attachment& attachment)
{
if (m_attachments.isEmpty())
return false;
attachment = m_attachments.takeFirst();
return true;
}
#ifndef NDEBUG
void ArgumentDecoder::debug()
{
printf("ArgumentDecoder::debug()\n");
printf("Number of Attachments: %d\n", (int)m_attachments.size());
printf("Size of buffer: %d\n", (int)(m_bufferEnd - m_buffer));
}
#endif
}