SharedMemoryServer.cpp [plain text]
#include "SharedMemoryServer.h"
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <machine/byte_order.h>
#include <string>
#include <sys/stat.h>
#include <security_utilities/crc.h>
#include <unistd.h>
static const char* kPrefix = "/private/var/db/mds/messages/se_";
SharedMemoryServer::SharedMemoryServer (const char* segmentName, SegmentOffsetType segmentSize) :
mSegmentName (segmentName), mSegmentSize (segmentSize)
{
mFileName = kPrefix;
mFileName += segmentName;
mkdir("/var/db/mds", 1777);
mkdir("/var/db/mds/messages", 0755);
unlink (mFileName.c_str ());
int segmentDescriptor = open (mFileName.c_str (), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (segmentDescriptor < 0)
{
return;
}
ftruncate (segmentDescriptor, segmentSize);
mSegment = (u_int8_t*) mmap (NULL, mSegmentSize, PROT_READ | PROT_WRITE, MAP_SHARED, segmentDescriptor, 0);
close (segmentDescriptor);
if (mSegment == (u_int8_t*) -1) {
mSegment = NULL;
unlink (mFileName.c_str());
}
mDataPtr = mDataArea = mSegment + sizeof(SegmentOffsetType);
mDataMax = mSegment + segmentSize;;
SetProducerOffset (0);
}
SharedMemoryServer::~SharedMemoryServer ()
{
if (mSegment == NULL)
{
return;
}
munmap (mSegment, mSegmentSize);
unlink (mFileName.c_str ());
}
const SegmentOffsetType
kSegmentLength = 0,
kCRCOffset = kSegmentLength + sizeof(SegmentOffsetType),
kDomainOffset = kCRCOffset + sizeof(SegmentOffsetType),
kEventTypeOffset = kDomainOffset + sizeof(SegmentOffsetType),
kHeaderLength = kEventTypeOffset + sizeof(SegmentOffsetType) - kCRCOffset;
void SharedMemoryServer::WriteMessage (SegmentOffsetType domain, SegmentOffsetType event, const void *message, SegmentOffsetType messageLength)
{
ssize_t messageSize = kHeaderLength + messageLength;
u_int8_t finalMessage[messageSize];
SegmentOffsetType *fm = (SegmentOffsetType*) finalMessage;
fm[0] = OSSwapHostToBigInt32(domain);
fm[1] = OSSwapHostToBigInt32(event);
memcpy(&fm[2], message, messageLength);
SegmentOffsetType crc = CalculateCRC(finalMessage, messageSize);
WriteOffset(messageSize);
WriteOffset(crc);
WriteData (finalMessage, messageSize);
SetProducerOffset(mDataPtr - mDataArea);
}
const char* SharedMemoryServer::GetSegmentName ()
{
return mSegmentName.c_str ();
}
size_t SharedMemoryServer::GetSegmentSize ()
{
return mSegmentSize;
}
SegmentOffsetType SharedMemoryServer::GetProducerOffset ()
{
u_int32_t pCount = OSSwapBigToHostInt32 (*(u_int32_t*) mSegment);
return OSSwapHostToBigInt32 (pCount);
}
void SharedMemoryServer::SetProducerOffset (SegmentOffsetType producerCount)
{
*((SegmentOffsetType*) mSegment) = OSSwapHostToBigInt32 (producerCount);
}
void SharedMemoryServer::WriteOffset(SegmentOffsetType offset)
{
u_int8_t buffer[4];
*((u_int32_t*) buffer) = OSSwapHostToBigInt32(offset);
WriteData(buffer, 4);
}
void SharedMemoryServer::WriteData(const void* data, SegmentOffsetType length)
{
const u_int8_t* dp = (const u_int8_t*) data;
SegmentOffsetType bytesToEnd = mDataMax - mDataPtr;
SegmentOffsetType bytesToWrite = (length <= bytesToEnd) ? length : bytesToEnd;
memcpy (mDataPtr, dp, bytesToWrite);
mDataPtr += bytesToWrite;
dp += bytesToWrite;
length -= bytesToWrite;
if (length != 0) {
mDataPtr = mDataArea;
memcpy (mDataPtr, dp, length);
mDataPtr += length;
}
}