//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializeUserDefinedType(ISerializable *pObj, TypeNode* pType, bool isPtr, fstream& pen)
{
int size = 0;
bool isNull = false;
if (isPtr)
{
// Access the pointer pointed by the pointer to pointer
pObj = (*(ISerializable**)pObj);
int length = 0;
string typeName;
char buffer[MaxTypeNameLength + 1];
isNull = (NULL == pObj);
pen.write(reinterpret_cast<char*>(&isNull), sizeof(bool));
if (!isNull)
{
auto objLayout = pObj->GetObjectLayout();
typeName = g_ObjectFactory.FromCName(objLayout.CName());
PerformLateBinding(pObj, pType);
length = typeName.size();
_ASSERTE(length <= MaxTypeNameLength);
strcpy_s(buffer, typeName.c_str());
buffer[length] = 0;
pen.write(buffer, MaxTypeNameLength + 1);
Iterator* addresses = objLayout.GetIterator();
unsigned* addr32;
for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < pType->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
SerializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, pen);
}
}
size = sizeof(unsigned);
}
else
{
auto objLayout = pObj->GetObjectLayout();
Iterator* addresses = objLayout.GetIterator();
unsigned* addr32;
for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < pType->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
SerializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, pen);
}
size = objLayout.TypeSize();
}
return size;
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializeArray(char* pMem, TypeNode* pType, fstream& pen)
{
// not supported for this time
_ASSERTE(false);
int size = 0;
int length = pType->Children[0].Val32;
TypeNode* type = pType->Children[1].Ptr32;
bool isNull = false;
_ASSERTE(pType->Children.size() == 2);
if (pType->Indirection)
{
unsigned* addr32 = reinterpret_cast<unsigned*>(pMem);
isNull = (*addr32 == NULL);
pen.write(reinterpret_cast<char*>(&isNull), sizeof(bool));
if (!isNull)
{
for (int i = 0; i < length; ++i)
{
pMem = reinterpret_cast<char*>(*addr32);
SerializeType(pMem, type, pen);
addr32++;
}
}
size = sizeof(unsigned)* length;
}
else
{
int s = 0;
for (int i = 0; i < length; ++i)
{
s = SerializeType(pMem, type, pen);
pMem += s;
size += s;
}
}
return size;
}
//----------------------------------------------------------------------------------------------
void ObjectSerializer::Serialize(const UserObject* p_object, string p_objectFileName)
{
fstream pen;
pen.open(p_objectFileName.c_str(), ios::binary | ios::out);
_ASSERTE(pen.is_open());
const string& typeName = g_ObjectFactory.FromCName(p_object->CName());
_ASSERTE(m_typeTable.find(typeName) != m_typeTable.end());
TypeData& typeData = m_typeTable[typeName];
SerializeType(reinterpret_cast<char*>(const_cast<UserObject*>(p_object)), typeData.TypeGraph, pen);
pen.close();
}
//----------------------------------------------------------------------------------------------
void ObjectSerializer::Serialize(const ISerializable* pObject, string objFilename)
{
fstream pen;
pen.open(objFilename.c_str(), ios::binary | ios::out);
_ASSERTE(pen.is_open());
auto objLayout = const_cast<ISerializable*>(pObject)->GetObjectLayout();
const string& typeName = g_ObjectFactory.FromCName(objLayout.CName());
_ASSERTE(m_typeTable.find(typeName) != m_typeTable.end());
TypeData& typeData = m_typeTable[typeName];
SerializeType(reinterpret_cast<char*>(const_cast<ISerializable*>(pObject)), typeData.TypeGraph, pen);
pen.close();
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializeContainerMap(char* p_fieldAddress, TypeNode* p_type, fstream& p_pen)
{
// Pointer to map is not supported
_ASSERTE(p_type->Indirection == false);
_ASSERTE(p_type->TemplateArguments.size() == 1);
Container* container = reinterpret_cast<Container*>(p_fieldAddress);
Iterator* itr = container->GetIterator();
int count = container->ContainerCount();
p_pen.write(reinterpret_cast<char*>(&count), sizeof(int));
while(itr->MoveNext())
{
SerializeType(itr->Current(), p_type->TemplateArguments[0], p_pen);
}
return container->TypeSize();
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializePair(ISerializable* pObj, TypeNode* pType, fstream& pen)
{
// Pointer to pair is not supported
_ASSERTE(pType->Indirection == false);
_ASSERTE(pType->TemplateArguments.size() == 2);
auto objLayout = pObj->GetObjectLayout();
Iterator* addresses = objLayout.GetIterator();
unsigned* addr32;
for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < pType->TemplateArguments.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
SerializeType(reinterpret_cast<char*>(*addr32), pType->TemplateArguments[memberIdx], pen);
}
return objLayout.TypeSize();
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializeContainerSet(ISerializable* pObj, TypeNode* pType, fstream& pen)
{
// Pointer to set is not supported
_ASSERTE(pType->Indirection == false);
_ASSERTE(pType->TemplateArguments.size() == 1);
auto objLayout = pObj->GetObjectLayout();
IContainer* pContainer = dynamic_cast<IContainer*>(pObj);
_ASSERTE(pContainer);
Iterator* itr = objLayout.GetIterator();
int count = pContainer->ContainerCount();
pen.write(reinterpret_cast<char*>(&count), sizeof(int));
while (itr->MoveNext())
{
SerializeType(itr->Current(), pType->TemplateArguments[0], pen);
}
return objLayout.TypeSize();
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializePair(char* p_fieldAddress, TypeNode* p_type, fstream& p_pen)
{
// Pointer to pair is not supported
_ASSERTE(p_type->Indirection == false);
_ASSERTE(p_type->TemplateArguments.size() == 2);
UserObject* object = reinterpret_cast<UserObject*>(p_fieldAddress);
object->InitializeAddresses();
Iterator* addresses = object->GetIterator();
unsigned* addr32;
for(int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < p_type->TemplateArguments.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
SerializeType(reinterpret_cast<char*>(*addr32), p_type->TemplateArguments[memberIdx], p_pen);
}
return object->TypeSize();
}
BOOLEAN WINAPI RtlFreeHeapHook(PVOID heapHandle, ULONG flags, PVOID heapBase)
{
if (!gPipe || (gHeap == heapHandle) || gStopSendThread)
return gRtlFreeHeapOrig(heapHandle, flags, heapBase);
PerThreadData threadDataEmergency = { true, true };
PerThreadData *threadData = GetPerThreadData(&threadDataEmergency);
bool inFree = threadData->inFree;
// prevent infinite recursion
threadData->inFree = true;
BOOLEAN res = gRtlFreeHeapOrig(heapHandle, flags, heapBase);
if (inFree)
return res;
FreeData d = { (uint32)heapBase };
Vec<byte> msg;
SerializeType((byte*)&d, &freeDataTypeInfo, msg);
QueueMessageForSending(msg);
threadData->inFree = false;
return res;
}
PVOID WINAPI RtlAllocateHeapHook(PVOID heapHandle, ULONG flags, SIZE_T size)
{
if (!gPipe || (gHeap == heapHandle) || gStopSendThread)
return gRtlAllocateHeapOrig(heapHandle, flags, size);
PerThreadData threadDataEmergency = { true, true };
PerThreadData *threadData = GetPerThreadData(&threadDataEmergency);
bool inAlloc = threadData->inAlloc;
// prevent infinite recursion
threadData->inAlloc = true;
PVOID res = gRtlAllocateHeapOrig(heapHandle, flags, size);
if (inAlloc)
return res;
AllocData d = { (uint32)size, (uint32)res };
Vec<byte> msg;
SerializeType((byte*)&d, &allocDataTypeInfo, msg);
QueueMessageForSending(msg);
threadData->inAlloc = false;
return res;
}
//----------------------------------------------------------------------------------------------
int ObjectSerializer::SerializeUserDefinedType(char* p_fieldAddress, TypeNode* p_type, bool p_isPtr, fstream& p_pen)
{
int size = 0;
UserObject* object = NULL;
bool isNull = false;
if(p_isPtr)
{
int length = 0;
string typeName;
char buffer[MaxTypeNameLength + 1];
unsigned* addr32 = reinterpret_cast<unsigned*>(p_fieldAddress);
isNull = (NULL == *addr32);
p_pen.write(reinterpret_cast<char*>(&isNull), sizeof(bool));
if(!isNull)
{
object = reinterpret_cast<UserObject*>(*addr32);
typeName = g_ObjectFactory.FromCName(object->CName());
PerformLateBinding(object, p_type);
length = typeName.size();
_ASSERTE(length <= MaxTypeNameLength);
strcpy(buffer, typeName.c_str());
buffer[length] = 0;
p_pen.write(buffer, MaxTypeNameLength + 1);
object->InitializeAddresses();
Iterator* addresses = object->GetIterator();
unsigned* addr32;
for(int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < p_type->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
SerializeType(reinterpret_cast<char*>(*addr32), p_type->Children[memberIdx].Ptr32, p_pen);
}
}
size = sizeof(unsigned);
}
else
{
object = reinterpret_cast<UserObject*>(p_fieldAddress);
object->InitializeAddresses();
Iterator* addresses = object->GetIterator();
unsigned* addr32;
for(int memberIdx = 0; addresses->MoveNext(); ++memberIdx)
{
_ASSERTE(memberIdx < p_type->Children.size());
addr32 = reinterpret_cast<unsigned*>(addresses->Current());
SerializeType(reinterpret_cast<char*>(*addr32), p_type->Children[memberIdx].Ptr32, p_pen);
}
size = object->TypeSize();
}
return size;
}
