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);
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);
}
bool ArgumentDecoder::alignBufferPosition(unsigned alignment, size_t size)
{
uint8_t* buffer = roundUpToAlignment(m_bufferPos, alignment);
if (static_cast<size_t>(m_bufferEnd - buffer) < size) {
markInvalid();
return false;
}
m_bufferPos = buffer;
return true;
}
bool ArgumentDecoder::bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const
{
return static_cast<size_t>(m_bufferEnd - roundUpToAlignment(m_bufferPos, alignment)) >= size;
}
bool ArgumentDecoder::decodeBytes(Vector<uint8_t>& buffer)
{
uint64_t size;
if (!decodeUInt64(size))
return false;
if (!alignBufferPosition(1, size))
return false;
buffer.resize(size);
if (size > 0)
memcpy(&buffer[0], m_bufferPos, size);
m_bufferPos += size;
return true;
}
bool ArgumentDecoder::decodeBytes(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::decodeBytes(uint8_t* buffer, size_t bufferSize)
{
uint64_t size;
if (!decodeUInt64(size))
return false;
ASSERT(size == bufferSize);
if (size != bufferSize)
return false;
if (!alignBufferPosition(1, size))
return false;
memcpy(buffer, m_bufferPos, size);
m_bufferPos += 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::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
}