windows-server-2003/net/mmc/wins/memmngr.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
	memmngr.cpp	
		memory manager for the WINS db object

	FILE HISTORY:
    Oct 13  1997    EricDav     Modifed

*/

#include "stdafx.h"
#include "wins.h"
#include "memmngr.h"

CMemoryManager::CMemoryManager()
{
    m_hHeap = NULL;
}

CMemoryManager::~CMemoryManager()
{
    Reset();
}
	
/*!--------------------------------------------------------------------------
	CMemoryManager::Initialize
		Initializes the memory manager to free up and existing blocks
        and pre-allocate one block
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
HRESULT
CMemoryManager::Initialize()
{
    HRESULT hr = hrOK;

    CORg (Reset());
    CORg (Allocate());

    // create a heap for allocation of the multiple IP address blocks
    m_hHeap = HeapCreate(0, 4096, 0);
    if (m_hHeap == NULL)
    {
        Trace1("CMemoryManager::Initialize - HeapCreate failed! %d\n", GetLastError());
        return E_FAIL;
    }

Error:
    return hr;
}

/*!--------------------------------------------------------------------------
	CMemoryManager::Reset
		Free's up all memory
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
HRESULT
CMemoryManager::Reset()
{
	// free the memory allocated
	for (int i = 0; i< m_BlockArray.GetSize(); i++)
	{
		::GlobalFree(m_BlockArray.GetAt(i));
	}
	
	m_BlockArray.RemoveAll();

    if (m_hHeap)
    {
        HeapDestroy(m_hHeap);
        m_hHeap = NULL;
    }

    return hrOK;
}

/*!--------------------------------------------------------------------------
	CMemoryManager::Allocate
		Allocates one memory block
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
HRESULT
CMemoryManager::Allocate()
{
    HGLOBAL hMem = GlobalAlloc(GMEM_FIXED, BLOCK_SIZE);
	
	if (hMem != NULL)
	{
		m_hrowCurrent = (LPWINSDBRECORD) hMem;
		m_BlockArray.Add(hMem);

        return hrOK;
	}

	return E_FAIL;
}

/*!--------------------------------------------------------------------------
	CMemoryManager::IsvalidHRow
		Verifies that the given HROW is valid
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
BOOL 
CMemoryManager::IsValidHRow(HROW hrow)
{
	// check to see thet this HROW lies between the 
	// limits, i.e b/n hMem and hMem + INIT_SIZE
	for (int i = 0; i < m_BlockArray.GetSize(); i++)
	{
		if (hrow >= (HROW)(m_BlockArray.GetAt(i)) && (hrow < (HROW)(m_BlockArray.GetAt(i)) + BLOCK_SIZE))
		    return TRUE;
	}

	return FALSE;
}

/*!--------------------------------------------------------------------------
	CMemoryManager::AddData
		Copies a record into our internal store
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
HRESULT
CMemoryManager::AddData(const WinsRecord & wRecord, LPHROW phrow)
{
    HRESULT hr = hrOK;

	CSingleLock     cLock(&m_cs);
	cLock.Lock();

    Assert((BYTE) wRecord.szRecordName[15] == (BYTE) wRecord.dwType);

    // check if for the validity fo the current 
	// m_hrowCurrent
	if (!IsValidHRow((HROW) m_hrowCurrent))
	{
		Allocate();
		m_hrowCurrent = (LPWINSDBRECORD) (m_BlockArray.GetAt(m_BlockArray.GetSize() - 1));
	}

    WinsRecordToWinsDbRecord(m_hHeap, wRecord, m_hrowCurrent);

    if (phrow)
        *phrow = (HROW) m_hrowCurrent;	
	
    // move our pointer to the next record
    m_hrowCurrent++;

	return hr;
}

/*!--------------------------------------------------------------------------
	CMemoryManager::GetData
		Copies a record into our internal store
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
HRESULT
CMemoryManager::GetData(HROW hrow, LPWINSRECORD pWinsRecord)
{
    HRESULT hr = hrOK;
    LPWINSDBRECORD pDbRec = (LPWINSDBRECORD) hrow;

	CSingleLock     cLock(&m_cs);
	cLock.Lock();

    // check if for the validity fo the current 
	// m_hrowCurrent
	if (!IsValidHRow(hrow))
	{
        return E_FAIL;
    }

    WinsDbRecordToWinsRecord(pDbRec, pWinsRecord);

	return hr;
}

/*!--------------------------------------------------------------------------
	CMemoryManager::Delete
		Marks a record as deleted
	Author: EricDav, v-shubk
 ---------------------------------------------------------------------------*/
HRESULT 
CMemoryManager::Delete(HROW hrow)
{
    HRESULT hr = hrOK;

	CSingleLock     cLock(&m_cs);
	cLock.Lock();

    LPWINSDBRECORD pRec = (LPWINSDBRECORD) hrow;

    pRec->szRecordName[17] |= WINSDB_INTERNAL_DELETED;

    return hr;
}

void
WinsRecordToWinsDbRecord(HANDLE hHeap, const WinsRecord & wRecord, const LPWINSDBRECORD pRec)
{
    ZeroMemory(pRec, sizeof(WinsDBRecord));

    // fill in our internal struct, first the name
    if (IS_WINREC_LONGNAME(&wRecord))
    {
        // name is too long for our internal struct, allocate space off of our heap
        // this shouldn't happen very often.  Only for scoped names.
        pRec->szRecordName[17] |= WINSDB_INTERNAL_LONG_NAME;
        char * pName = (char *) ::HeapAlloc(hHeap, HEAP_ZERO_MEMORY, (wRecord.dwNameLen + 1));
        if (pName)
        {
            memcpy(pName, &wRecord.szRecordName[0], wRecord.dwNameLen);
            memcpy(&pRec->szRecordName[0], &pName, sizeof(char *));
        }
    }
    else
    {
        memcpy(&pRec->szRecordName[0], &wRecord.szRecordName[0], 16);
    }

    pRec->dwExpiration = (DWORD) wRecord.dwExpiration;
    pRec->liVersion.QuadPart = wRecord.liVersion.QuadPart;
    pRec->dwOwner = wRecord.dwOwner;

    // max length is 255, so this is OK
    pRec->szRecordName[19] = LOBYTE(LOWORD(wRecord.dwNameLen));

	BYTE bTest = HIBYTE(LOWORD(wRecord.dwState));

	pRec->szRecordName[20] = HIBYTE(LOWORD(wRecord.dwState));

    // only the low byte of the dwState field is used
    pRec->szRecordName[18] = (BYTE) wRecord.dwState;
    pRec->szRecordName[17] |= HIWORD (wRecord.dwType);

    // now figure out how many IP addrs there are
    if (wRecord.dwNoOfAddrs > 1)
    {
        Assert(hHeap);
        LPDWORD pdwIpAddrs = (LPDWORD) ::HeapAlloc(hHeap, HEAP_ZERO_MEMORY, (wRecord.dwNoOfAddrs + 1) * sizeof(DWORD));

        if (pdwIpAddrs)
        {
            // first DWORD contains the # of addrs
            pdwIpAddrs[0] = wRecord.dwNoOfAddrs;
            for (UINT i = 0; i < wRecord.dwNoOfAddrs; i++)
                pdwIpAddrs[i+1] = wRecord.dwIpAdd[i];

            // now store our pointer off
            pRec->dwIpAdd = (DWORD_PTR) pdwIpAddrs;
        }
    }
    else
    {
        pRec->dwIpAdd = wRecord.dwIpAdd[0];
    }

    Assert((BYTE) pRec->szRecordName[16] == NULL);
}

void 
WinsDbRecordToWinsRecord(const LPWINSDBRECORD pDbRec, LPWINSRECORD pWRec)
{
    Assert((BYTE) pDbRec->szRecordName[16] == NULL);

    ZeroMemory(pWRec, sizeof(WinsRecord));
    DWORD dwType = 0;

	size_t length = pDbRec->szRecordName[19] & 0x000000FF;

    // fill in our internal struct, name first
    if (IS_DBREC_LONGNAME(pDbRec))
    {
        char * pName = *((char **) pDbRec->szRecordName);

        memcpy(&pWRec->szRecordName[0], pName, length);
        dwType = (DWORD) pName[15];
    }
    else
    {
        memcpy(&pWRec->szRecordName[0], &pDbRec->szRecordName[0], 16);
        dwType = (DWORD) pWRec->szRecordName[15];
    }

    pWRec->dwExpiration = pDbRec->dwExpiration;
    pWRec->liVersion.QuadPart = pDbRec->liVersion.QuadPart;
    pWRec->dwOwner = pDbRec->dwOwner;
    pWRec->dwNameLen = length;
    
	WORD wState = MAKEWORD(pDbRec->szRecordName[18], pDbRec->szRecordName[20]);
	pWRec->dwState = wState;

	//pWRec->dwState = pDbRec->szRecordName[18];

    pWRec->dwType = pDbRec->szRecordName[17] & 0x03;
    pWRec->dwType = pWRec->dwType << 16;

    pWRec->dwType |= dwType;

    // now the ip address(es)
    if (pWRec->dwState & (BYTE) WINSDB_REC_MULT_ADDRS)
    {
        LPDWORD pdwIpAddrs = (LPDWORD) pDbRec->dwIpAdd;
        
        // the first DWORD is the count
        int nCount = pdwIpAddrs[0];
        for (int i = 0; i < nCount; i++)
            pWRec->dwIpAdd[i] = pdwIpAddrs[i+1];

        pWRec->dwNoOfAddrs = (DWORD) nCount;
    }
    else
    {
        pWRec->dwIpAdd[0] = (DWORD) pDbRec->dwIpAdd;
        pWRec->dwNoOfAddrs = 1;
    }
 
}