Low Fragmentation Heap and Function Interception

#include "stdafx.h"
#include "lfh.h"
#include "allocator.h"

LPLFHHEAP m_pHead = NULL;

bool SetLFH( HANDLE hHeap, bool bUseLFH )
{
	LPLFHHEAP pLFH = Find( hHeap );

	if(bUseLFH)
	{
		if(pLFH == NULL)
			Add( hHeap );
		else
			pLFH->bLFH = true;
	}
	else
	{
		if(pLFH != NULL)
			Delete (pLFH);
	}

	return true;
}

bool GetLFH ( HANDLE hHeap )
{
	LPLFHHEAP pHeap = Find( hHeap );

	if( pHeap == NULL)
		return false;

	return pHeap->bLFH;
}

LPLFHHEAP Find( HANDLE hHeap )
{
	LPLFHHEAP pCurrent = m_pHead;

	while(pCurrent != NULL)
	{
		if(pCurrent->hHeap == hHeap)
			return pCurrent;
		pCurrent = pCurrent->pNext;
	}
	return pCurrent;
}

void Add( HANDLE hHeap)
{
	LPLFHHEAP pNew	= new LFHHEAP;
	pNew->hHeap			= hHeap;
	pNew->pNext			= m_pHead;

	if(m_pHead != NULL)
		m_pHead->pPrev	= pNew;

	m_pHead					= pNew;
}

void Delete ( LPLFHHEAP pLFH )
{
	if(pLFH != NULL)
	{
		if(pLFH == m_pHead)
		{
			m_pHead = pLFH->pNext;
		}
		else
		{
			if(pLFH->pNext == NULL)			// Tail
			{
				pLFH->pPrev->pNext = NULL;
			}
			else
			{
				pLFH->pPrev->pNext = pLFH->pNext;
				pLFH->pNext->pPrev = pLFH->pPrev;
			}
		}
		delete pLFH;
	}
}

void DeleteAll()
{
	LPLFHHEAP pCurrent = m_pHead;

	while(pCurrent != NULL)
	{
		LPLFHHEAP pTemp = pCurrent->pNext;
		delete pCurrent;
		pCurrent = pTemp;
	}
}

// calculate our LFH allocation size
size_t GetAllocationSize( bool bLFH, size_t s )
{
	if(bLFH == false)
		return s;

	size_t nAlloc = 0;

	if( s <= 256 )
		nAlloc = (s + 7) & (-8);
	else if( s <= 512)
		nAlloc = (s + 15) & (-16);
	else if( s <= 1024)
		nAlloc = (s + 31) & (-32);
	else if( s <= 2048)
		nAlloc = (s + 63) & (-64);
	else if( s <= 4096)
		nAlloc = (s + 127) & (-128);
	else if( s <= 8196)
		nAlloc = (s + 255) & (-256);
	else if( s <= 16384 )
		nAlloc = (s + 511) & (-512);
	else 
		nAlloc = s;

	return nAlloc;
}