CSimpleVector<T>& operator=(const CSimpleVector<T>& src)
{
if (GetAllocSize() != src.GetAllocSize())
{
RemoveAll();
m_Size = src.GetSize();
m_SizeAlloc = src.GetAllocSize();
::memcpy(
m_mem.Get(src.GetAllocSize() * sizeof(T)),
src.GetData(),
src.GetSize() * sizeof(T));
}
else
{
if (GetSize() != src.GetSize())
{
m_Size = src.GetSize();
}
::memcpy(
m_mem.Get(),
src.GetData(),
src.GetSize() * sizeof(T));
}
return (*this);
}
int32_t FixedMemPool::Init(void* mem, uint32_t max_node_num, size_t node_size, bool check_header) {
if (!mem) {
return -1;
}
m_header = (MemHeader*)mem;
if (!check_header) {
//init head
m_header->max_size = GetAllocSize(max_node_num, node_size);
m_header->max_node_num = max_node_num;
//we use the beginning of the memory pool to as head infomation
m_header->used_size = sizeof(MemHeader);
m_header->used_node_num = 0;
//block size is based on node size aligned by 8 bytes
m_header->block_size = GetBlockSize(node_size);
//no block is freed
m_header->free_list_offset = kInvalidPointer;
m_data = (char*)m_header + sizeof(MemHeader);
} else {
if (!CheckHeader(max_node_num, node_size, m_header)) {
snprintf(m_error_msg, sizeof(m_error_msg), "Memory pool head check error!");
return -1;
}
m_data = (char*)m_header + sizeof(MemHeader);
}
return 0;
}
MF_API void *MFHeap_AllocInternal(size_t bytes, MFHeap *pHeap)
{
MFCALLSTACK;
MFHeap *pAllocHeap = pOverrideHeap ? pOverrideHeap : (pHeap ? pHeap : pActiveHeap);
size_t extra;
size_t allocBytes = GetAllocSize(bytes, extra);
MFThread_LockMutex(gAllocMutex);
char *pMemory = (char*)pAllocHeap->pCallbacks->pMalloc(allocBytes, pAllocHeap->pHeapData);
if(pMemory)
{
#if defined(_USE_TRACKING_HASH_TABLE)
#if defined(USE_PRE_MUNGWALL)
int alignment = (int)(MFALIGN(pMemory + MFHeap_MungwallBytes, heapAlignment) - (uintp)pMemory);
#else
int alignment = (int)(MFALIGN(pMemory, heapAlignment) - (uintp)pMemory);
#endif
#else
int alignment = (int)(MFALIGN(pMemory + sizeof(MFAllocHeader), heapAlignment) - (uintp)pMemory);
#endif
pMemory += alignment;
#if defined(_USE_TRACKING_HASH_TABLE)
MFAllocHeader *pHeader = AddAlloc(pMemory, bytes, NULL);
#else
MFAllocHeader *pHeader = GetAllocHeader(pMemory);
#endif
pHeader->alignment = alignment;
pHeader->pHeap = pAllocHeap;
pHeader->size = bytes;
pHeader->pFile = gpMFHeap_TrackerFile;
pHeader->line = gMFHeap_TrackerLine;
#if defined(USE_PRE_MUNGWALL)
MFCopyMemory(pMemory - MFHeap_MungwallBytes, gLlawgnum, MFHeap_MungwallBytes);
#endif
#if !defined(_RETAIL)
MFCopyMemory(pMemory + bytes, gMungwall, MFHeap_MungwallBytes);
pAllocHeap->totalAllocated += allocBytes;
pAllocHeap->totalWaste += extra;
++pAllocHeap->allocCount;
// MFDebug_Log(2, MFStr("Alloc: %p(%p), %d bytes - %s:(%d)", pMemory, pMemory - pHeader->alignment, bytes, gpMFHeap_TrackerFile, gMFHeap_TrackerLine));
#endif
}
MFThread_ReleaseMutex(gAllocMutex);
return (void*)pMemory;
}
BOOL GetTokenInfo(
HANDLE Token,
TOKEN_INFORMATION_CLASS TokenInformationClass,
PPVOID pBuffer)
{
NTSTATUS Status;
ULONG BufferSize;
ULONG InfoLength;
PVOID Buffer;
*pBuffer = NULL; // Prepare for failure
Buffer = AllocTokenInfo(Token, TokenInformationClass);
if (Buffer == NULL) {
return(FALSE);
}
BufferSize = GetAllocSize(Buffer);
Status = NtQueryInformationToken(
Token, // Handle
TokenInformationClass, // TokenInformationClass
Buffer, // TokenInformation
BufferSize, // TokenInformationLength
&InfoLength // ReturnLength
);
if (!NT_SUCCESS(Status)) {
#ifdef NTBUILD
DbgPrint("SECEDIT: NtQueryInformationToken failed, status = 0x%lx\n", Status);
#endif
FreeTokenInfo(Buffer);
return(FALSE);
}
if (InfoLength > BufferSize) {
#ifdef NTBUILD
DbgPrint("SECEDIT: NtQueryInformationToken failed, DataSize > BufferSize");
#endif
FreeTokenInfo(Buffer);
return(FALSE);
}
*pBuffer = Buffer;
return(TRUE);
}
MF_API void MFHeap_Free(void *pMem)
{
MFCALLSTACK;
if(!pMem)
{
MFDebug_Warn(3, "Attemptd to Free 'NULL' pointer.");
return;
}
MFThread_LockMutex(gAllocMutex);
MFAllocHeader *pHeader = GetAllocHeader(pMem);
MFDebug_Assert(MFHeap_ValidateMemory(pMem), MFStr("Memory corruption detected!!\n%s(" MFFMT_SIZE_T ")", pHeader->pFile, pHeader->line));
MFHeap *pHeap = pHeader->pHeap;
#if !defined(_RETAIL)
size_t extra;
size_t allocBytes = GetAllocSize(pHeader->size, extra);
pHeap->totalAllocated -= allocBytes;
pHeap->totalWaste -= extra;
--pHeap->allocCount;
// MFDebug_Log(2, MFStr("Free: %p, %d bytes - %s:(%d)", pMem, pHeader->size, pHeader->pFile, (int)pHeader->line));
#endif
MFCopyMemory((char*)pMem + pHeader->size, "freefreefreefree", MFHeap_MungwallBytes);
#if defined(USE_PRE_MUNGWALL)
MFCopyMemory((char*)pMem - MFHeap_MungwallBytes, "eerfeerfeerfeerf", MFHeap_MungwallBytes);
#endif
MFMemSet(pMem, 0xFE, pHeader->size);
pHeap->pCallbacks->pFree((char*)pMem - pHeader->alignment, pHeap->pHeapData);
#if defined(_USE_TRACKING_HASH_TABLE)
FreeAlloc(pMem);
#endif
MFThread_ReleaseMutex(gAllocMutex);
}
BOOL SetTokenInfo(
HANDLE Token,
TOKEN_INFORMATION_CLASS TokenInformationClass,
PVOID Buffer)
{
NTSTATUS Status;
ULONG BufferSize;
BufferSize = GetAllocSize(Buffer);
switch (TokenInformationClass) {
case TokenOwner:
case TokenPrimaryGroup:
case TokenDefaultDacl:
Status = NtSetInformationToken(
Token, // Handle
TokenInformationClass, // TokenInformationClass
Buffer, // TokenInformation
BufferSize // TokenInformationLength
);
if (!NT_SUCCESS(Status)) {
DbgPrint("SECEDIT: NtSetInformationToken failed, info class = 0x%x, status = 0x%lx\n",
TokenInformationClass, Status);
return(FALSE);
}
break;
case TokenGroups:
Status = NtAdjustGroupsToken(
Token, // Handle
FALSE, // Reset to default
(PTOKEN_GROUPS)Buffer, // New State
BufferSize, // Buffer Length
NULL, // Previous State
NULL // Return Length
);
if (!NT_SUCCESS(Status)) {
DbgPrint("SECEDIT: NtAdjustGroupsToken failed, status = 0x%lx\n", Status);
return(FALSE);
}
break;
case TokenPrivileges:
Status = NtAdjustPrivilegesToken(
Token, // Handle
FALSE, // Disable all privileges
(PTOKEN_PRIVILEGES)Buffer, // New State
BufferSize, // Buffer Length
NULL, // Previous State
NULL // Return Length
);
if (!NT_SUCCESS(Status)) {
DbgPrint("SECEDIT: NtAdjustPrivilegesToken failed, status = 0x%lx\n", Status);
return(FALSE);
}
break;
default:
// Unrecognised information type
DbgPrint("SECEDIT: SetTokenInfo passed unrecognised infoclass, class = 0x%x\n", TokenInformationClass);
return(FALSE);
}
return(TRUE);
}
