windows-server-2003/net/mmc/mprsnap/infobase.cpp

//============================================================================
// Copyright (C) Microsoft Corporation, 1996 - 1999 
//
// File:    infobase.cpp
//
// History:
//  Abolade Gbadegesin      Feb. 10, 1996   Created.
//
//  V. Raman                Nov. 1, 1996
//                          Fixed alignment code in
//                          CInfoBase::BlockListToArray
//
//	Kenn Takara				June 3, 1997
//							Wrapped code with a COM object wrapper.
//
// This file contains code for the CInfoBase class as well as
// the Router registry-parsing classes.
//============================================================================

#include "stdafx.h"
#include "globals.h"		// holds the various string constants

extern "C" {
#include <rtinfo.h>
}

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif



//----------------------------------------------------------------------------
// Class:   CInfoBase
//
// This function handles loading and saving of multi-block structures
// stored in the registry by the router managers.
//
// The data are saved as REG_BINARY values, and are manipulated using
// the RTR_INFO_BLOCK_HEADER structure as a template.
//----------------------------------------------------------------------------

class CInfoBase : public CObject {

    protected:

        IfDebug(DECLARE_DYNAMIC(CInfoBase))

    public:

        CInfoBase();
        ~CInfoBase();

        //--------------------------------------------------------------------
        // Registry-access methods
        //
        //--------------------------------------------------------------------

        //--------------------------------------------------------------------
        // Function:    Load
        //
        // Loads value named 'pszValue' from subkey 'pszKey' of 'hkey'
        //--------------------------------------------------------------------

        HRESULT
        Load(
            IN      HKEY    hkey,
            IN      LPCTSTR pszKey,
            IN      LPCTSTR pszValue );


        //--------------------------------------------------------------------
        // Function:    Save
        //
        // saves value named 'pszValue' to subkey 'pszKey' of 'hkey';
        // 'pszKey' cannot be a path
        //--------------------------------------------------------------------

        HRESULT
        Save(
            IN      HKEY    hkey,
            IN      LPCTSTR pszKey,
            IN      LPCTSTR pszValue );


        //--------------------------------------------------------------------
        // Function:    Unload
        //
        // unloads current infobase contents
        //--------------------------------------------------------------------

        HRESULT
        Unload( );



        //--------------------------------------------------------------------
        // Function:    CopyFrom
        //
        // copies contents of infobase 'src'
        //--------------------------------------------------------------------

        HRESULT
        CopyFrom(
                 IN IInfoBase *pSrc);


        //--------------------------------------------------------------------
        // Function:    LoadFrom
        //
        // loads from byte-array 'pBase'
        //--------------------------------------------------------------------

        HRESULT
        LoadFrom(
            IN      PBYTE   pBase,
            IN      DWORD   dwSize = 0 )
            { Unload(); return ArrayToBlockList(pBase, dwSize); }


        //--------------------------------------------------------------------
        // Function:    WriteTo
        //
        // sets 'pBase' to point to allocated memory into which
        // opaque info is written; saves size of '*pBase' in 'dwSize'
        //--------------------------------------------------------------------

        HRESULT
        WriteTo(
            OUT     PBYTE&  pBase,
            OUT     DWORD&  dwSize )
            {
			return BlockListToArray(pBase, dwSize);
			}


        //--------------------------------------------------------------------
        // Structure manipulation methods
        //
        //--------------------------------------------------------------------

        //--------------------------------------------------------------------
        // Function:    GetBlock
        //
        // retrieves 'dwNth' block of type 'dwType' from the list of blocks
        //--------------------------------------------------------------------

        HRESULT
        GetBlock(
            IN      DWORD           dwType,
            OUT     InfoBlock*&    pBlock,
            IN      DWORD           dwNth = 0 );


        //--------------------------------------------------------------------
        // Function:    SetBlock
        //
        // Replaces 'dwNth' block of type 'dwType' with a copy of 'pBlock'.
        // Note that this copies the data for the block from 'pBlock->pData'.
        //--------------------------------------------------------------------

        HRESULT
        SetBlock(
            IN      DWORD       dwType,
            IN      InfoBlock* pBlock,
            IN      DWORD       dwNth = 0 );


        //--------------------------------------------------------------------
        // Function:    AddBlock
        //
        // Add's a new block of type 'dwType' to the list of blocks
        //--------------------------------------------------------------------

        HRESULT
        AddBlock(
            IN      DWORD       dwType,
            IN      DWORD       dwSize,
            IN      PBYTE       pData,
            IN      DWORD       dwCount = 1,
            IN      BOOL        bRemoveFirst    = FALSE );


        //--------------------------------------------------------------------
        // Function:    GetData
        //
        // Retrieves the data for the 'dwNth' block of type 'dwType'.
        //--------------------------------------------------------------------

        PBYTE
        GetData(
            IN      DWORD       dwType,
            IN      DWORD       dwNth = 0 );


        //--------------------------------------------------------------------
        // Function:    SetData
        //
        // Replaces the data for the 'dwNth' block of type 'dwType'.
        // Note that this does not copy 'pData'; the block is changed
        // to point to 'pData', and thus 'pData' should not be a pointer
        // to data on the stack, and it should not be deleted.
        // Furthermore, it must have been allocated using 'new'.
        //--------------------------------------------------------------------

        HRESULT
        SetData(
            IN      DWORD       dwType,
            IN      DWORD       dwSize,
            IN      PBYTE       pData,
            IN      DWORD       dwCount = 1,
            IN      DWORD       dwNth = 0 );


        //--------------------------------------------------------------------
        // Function:    RemoveBlock
        //
        // Removes the 'dwNth' block of type 'dwType' from the list of blocks.
        //--------------------------------------------------------------------

        HRESULT
        RemoveBlock(
            IN      DWORD       dwType,
            IN      DWORD       dwNth = 0 );


        //--------------------------------------------------------------------
        // Function:    BlockExists
        //
        // Returns TRUE is a block of the specified type is in the block-list,
        // FALSE otherwise
        //--------------------------------------------------------------------

        BOOL
        BlockExists(
            IN      DWORD       dwType
            ) {

            InfoBlock *pblock;

            return (GetBlock(dwType, pblock) == NO_ERROR);
        }



        //--------------------------------------------------------------------
        // Function:    ProtocolExists
        //
        // Returns TRUE if the given routing-protocol exists in the info-base;
        // this is so if the block is present and non-empty.
        //--------------------------------------------------------------------

        BOOL
        ProtocolExists(
            IN      DWORD       dwProtocol
            ) {

            InfoBlock *pblock;

            return (!GetBlock(dwProtocol, pblock) && pblock->dwSize);
        }



        //--------------------------------------------------------------------
        // Function:    RemoveAllBlocks
        //
        // Removes all blocks from the list of blocks.
        //--------------------------------------------------------------------

        HRESULT
        RemoveAllBlocks( ) { return Unload(); }


        //--------------------------------------------------------------------
        // Function:    QueryBlockList
        //
        // Returns a reference to the list of blocks;
        // the returned list contains items of type 'InfoBlock',
        // and the list must not be modified.
        //--------------------------------------------------------------------

        CPtrList&
        QueryBlockList( ) { return m_lBlocks; }


        //--------------------------------------------------------------------
        // Function:    GetInfo
        //
		// Returns information about the infobase.  This is useful for
		// determining if this is a new infobase or not.
		//
		// Returns the size (in bytes) of the InfoBase as well as the
		// number of blocks.
        //--------------------------------------------------------------------
		HRESULT
		GetInfo(DWORD *pcSize, int *pcBlocks);

    protected:

        PBYTE           m_pBase;        // opaque block of bytes loaded
        DWORD           m_dwSize;       // size of m_pBase
        CPtrList        m_lBlocks;      // list of blocks of type InfoBlock


        //--------------------------------------------------------------------
        // Functions:   BlockListToArray
        //              ArrayToBlockList
        //
        // These functions handle parsing opaque data into block-lists
        // and combining blocks into opaque data.
        //--------------------------------------------------------------------

        HRESULT
        BlockListToArray(
            IN      PBYTE&  pBase,
            IN      DWORD&  dwSize );

        HRESULT
        ArrayToBlockList(
            IN      PBYTE   pBase,
            IN      DWORD   dwSize );

#ifdef _DEBUG
		BOOL			m_fLoaded;	// TRUE if data was loaded
#endif
};



//---------------------------------------------------------------------------
// Class:       CInfoBase
//---------------------------------------------------------------------------

IfDebug(IMPLEMENT_DYNAMIC(CInfoBase, CObject));


//---------------------------------------------------------------------------
// Function:    CInfoBase::CInfoBase
//
// minimal contructor
//---------------------------------------------------------------------------

CInfoBase::CInfoBase()
: m_pBase(NULL), m_dwSize(0)
#ifdef _DEBUG
	, m_fLoaded(FALSE)
#endif
{ }



//---------------------------------------------------------------------------
// Function:    CInfoBase::CInfoBase
//
// destructor.
//---------------------------------------------------------------------------

CInfoBase::~CInfoBase() { Unload(); }



//---------------------------------------------------------------------------
// Function:    CInfoBase::CopyFrom
//
// Copies the contents of the given CInfoBase
//---------------------------------------------------------------------------

HRESULT
CInfoBase::CopyFrom(
                    IN IInfoBase *pSrc
    ) {
    SPIEnumInfoBlock    spEnumInfoBlock;
    InfoBlock * pbsrc = NULL;
    InfoBlock * pbdst = NULL;
	HRESULT		hr = hrOK;

	COM_PROTECT_TRY
	{
		// Unload the current information, if any
		Unload();

		// go through the source's blocks copying each one
        pSrc->QueryBlockList(&spEnumInfoBlock);
        if (spEnumInfoBlock == NULL)
            goto Error;

        spEnumInfoBlock->Reset();

        while (hrOK == spEnumInfoBlock->Next(1, &pbsrc, NULL))
        {
			// allocate space for the copy
			pbdst = new InfoBlock;
			Assert(pbdst);
			
			// copy the fields from the source
			pbdst->dwType = pbsrc->dwType;
			pbdst->dwSize = pbsrc->dwSize;
			pbdst->dwCount = pbsrc->dwCount;
			
			// allocate space for a copy of the data
			pbdst->pData = NULL;
			pbdst->pData = new BYTE[pbsrc->dwSize * pbsrc->dwCount];
			Assert(pbdst->pData);
			
			// copy the data
			::CopyMemory(pbdst->pData, pbsrc->pData,
						 pbsrc->dwSize * pbsrc->dwCount);
			
			// add the copy to our list of blocks
			m_lBlocks.AddTail(pbdst);
			pbdst = NULL;
		}

        COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
		
	// if something went wrong, make certain we're unloaded
	if (!FHrSucceeded(hr))
	{
		if (pbdst)
			delete pbdst->pData;
		delete pbdst;
		Unload();
	}

#ifdef _DEBUG
	if (FHrSucceeded(hr))
		m_fLoaded = TRUE;
#endif

    return hr;
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::Load
//
// Loads the infobase from the specified registry path.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::Load(
    IN  HKEY    hkey,
    IN  LPCTSTR pszSubKey,
    IN  LPCTSTR pszValue
    ) {

    PBYTE pBase = NULL;
    DWORD dwErr, dwSize, dwType;
	RegKey	regsubkey;			// hold subkey that has to be freed
	RegKey	regkey;				// holds key, must NOT be closed
	HRESULT		hr = hrOK;

    if (pszSubKey && StrLen(pszSubKey))
	{
        HKEY hkTemp = hkey;

		dwErr = regsubkey.Open(hkTemp, pszSubKey, KEY_READ);
        if (dwErr != ERROR_SUCCESS)
			return HRESULT_FROM_WIN32(dwErr);

		// We use this as THE key.  However, since this key is attached
		// to a RegKey, it will get cleaned up on exit/thrown exception.
		hkey = (HKEY) regsubkey;
    }

	COM_PROTECT_TRY
	{
		do {
			// This regkey is used to utilize the class. Do NOT
			// close this regkey (it may be the key that was passed into us).
			regkey.Attach(hkey);
			
			// query the value specified for its size and type
			dwSize = 0;
			dwType = 0;
			dwErr = regkey.QueryTypeAndSize(pszValue, &dwType, &dwSize);
			if (dwErr != ERROR_SUCCESS)
				break;
			
			//$ Review: kennt, if the key is not the correct type
			// what error code do we want to return?
			if (dwErr != ERROR_SUCCESS || dwType != REG_BINARY)
				break;
			
			pBase = new BYTE[dwSize];
			Assert(pBase);

			// get the actual data
			dwErr = regkey.QueryValue(pszValue, (LPVOID) pBase, dwSize);
			if (dwErr != ERROR_SUCCESS)
				break;
			
			// convert the infobase into a list of blocks
			dwErr = ArrayToBlockList(pBase, dwSize);
			
		} while(FALSE);

		hr = HRESULT_FROM_WIN32(dwErr);
		
	}
	COM_PROTECT_CATCH;

	// free the memory allocated for the block
	delete [] pBase;

	// we do NOT want this key closed
	regkey.Detach();
		
    return hr;
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::Unload
//
// frees resources used by infoblocks.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::Unload(
    ) {


    //
    // go through the list of blocks, deleting each one
    //

    while (!m_lBlocks.IsEmpty()) {

        InfoBlock *pBlock = (InfoBlock *)m_lBlocks.RemoveHead();
        if (pBlock->pData) { delete [] pBlock->pData; }
        delete pBlock;
    }


    //
    // if we have a copy of the opaque data, free that too
    //

    if (m_pBase) { delete [] m_pBase; m_pBase = NULL; m_dwSize = 0; }

    return HRESULT_FROM_WIN32(NO_ERROR);
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::Save
//
// Saves the list of blocks as an infobase in the registry.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::Save(
    IN  HKEY    hkey,
    IN  LPCTSTR pszSubKey,
    IN  LPCTSTR pszValue
    ) {
    PBYTE pBase = NULL;
    DWORD dwErr, dwSize;
	RegKey	regsubkey;			// hold subkey that has to be freed
	RegKey	regkey;				// holds key, must NOT be closed
	HRESULT	hr = hrOK;

    // create/open the key specified
    if (pszSubKey && lstrlen(pszSubKey))
	{
		dwErr = regsubkey.Create(hkey, pszSubKey,
								 REG_OPTION_NON_VOLATILE, KEY_WRITE);
        if (dwErr != ERROR_SUCCESS)
			return HRESULT_FROM_WIN32(dwErr);

		// This subkey will get closed by the regsubkey destructor
		hkey = (HKEY) regsubkey;
    }


	COM_PROTECT_TRY
	{
		do {

			regkey.Attach(hkey);

			// convert our list of blocks into one block of data
			dwErr = BlockListToArray(pBase, dwSize);
			if (dwErr != NO_ERROR) { pBase = NULL; break; }

			if (!pBase || !dwSize) { break; }
			
			// attempt to set the value
			dwErr = regkey.SetValue(pszValue, (LPVOID) pBase, dwSize);
			if (dwErr != ERROR_SUCCESS) { break; }
						
		} while(FALSE);

		hr = HRESULT_FROM_WIN32(dwErr);
	}
	COM_PROTECT_CATCH;

	regkey.Detach();
		
	delete [] pBase;

    return hr;
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::GetBlock
//
// Retrieves a block of data of the specified type
// from the currently loaded infobase.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::GetBlock(
    IN  DWORD           dwType,
    OUT InfoBlock*&    pBlock,
    IN  DWORD           dwNth
    ) {

    POSITION pos;
    InfoBlock *pib;

    // start at the head of the list, and look for the block requested
    pos = m_lBlocks.GetHeadPosition();

    while (pos)
	{
        // retrieve the next block
        pib = (InfoBlock *)m_lBlocks.GetNext(pos);

        if (pib->dwType != dwType) { continue; }

        if (dwNth-- != 0) { continue; }

        // this is the block requested
        pBlock = pib;

        return HRESULT_FROM_WIN32(NO_ERROR);
    }

	pBlock = NULL;
    return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::SetBlock
//
// Sets a block of data of the specified type to a copy of the given data
// in the currently loaded infobase.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::SetBlock(
    IN  DWORD       dwType,
    IN  InfoBlock* pBlock,
    IN  DWORD       dwNth
    ) {

    DWORD dwErr;
	HRESULT	hr;
    PBYTE pData;
    InfoBlock *pib;

    // retrieve the block to be modified
    hr = GetBlock(dwType, pib, dwNth);
	if (!FHrSucceeded(hr))
		return hr;

    // modify the contents
    if (pBlock->dwSize == 0) { pData = NULL; }
    else
	{
        // allocate space for the new data
        pData = new BYTE[pBlock->dwSize * pBlock->dwCount];
		Assert(pData);

        ::CopyMemory(pData, pBlock->pData, pBlock->dwSize * pBlock->dwCount);
    }


    // if any space was allocated before, free it now
    if (pib->pData) { delete [] pib->pData; }

    // set the blocks new contents
    *pib = *pBlock;
    pib->pData = pData;

    return HRESULT_FROM_WIN32(NO_ERROR);
}


//--------------------------------------------------------------------
// Function:    GetData
//
// Retrieves the data for the 'dwNth' block of type 'dwType'.
//--------------------------------------------------------------------

PBYTE
CInfoBase::GetData(
    IN  DWORD   dwType,
    IN  DWORD   dwNth
    ) {

    InfoBlock* pblock;

	if (!FHrSucceeded(GetBlock(dwType, pblock, dwNth)))
		return NULL;

    return pblock->pData;
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::SetData
//
// Sets the data for an existing block.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::SetData(
    IN  DWORD   dwType,
    IN  DWORD   dwSize,
    IN  PBYTE   pData,
    IN  DWORD   dwCount,
    IN  DWORD   dwNth
    ) {

    DWORD dwErr;
    InfoBlock *pib;
	HRESULT	hr;

    //
    // retrieve the block to be modified
    //

    hr = GetBlock(dwType, pib, dwNth);
	
	if (!FHrSucceeded(hr)) { return hr; }


    //
    // modify the data
    //

    if (pib->pData) { delete [] pib->pData; }

    pib->dwSize = dwSize;
    pib->dwCount = dwCount;
    pib->pData = pData;

    return HRESULT_FROM_WIN32(NO_ERROR);
}


//---------------------------------------------------------------------------
// Function:    CInfoBase::AddBlock
//
// Adds a block with the given values to the end of the block list.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::AddBlock(
    IN  DWORD   dwType,
    IN  DWORD   dwSize,
    IN  PBYTE   pData,
    IN  DWORD   dwCount,
    IN  BOOL    bRemoveFirst
    ) {

    InfoBlock *pBlock = NULL;
	HRESULT		hr = hrOK;

    if (bRemoveFirst) { RemoveBlock(dwType); }

	COM_PROTECT_TRY
	{
		// allocate space for the block
		pBlock = new InfoBlock;
		Assert(pBlock);

		// initialize member fields with values passed in
		pBlock->dwType = dwType;
		pBlock->dwSize = dwSize;
		pBlock->dwCount = dwCount;

		// initialize the data field, copying the data passed in
	
		if (dwSize == 0 || dwCount == 0)
			pBlock->pData = NULL;
		else
		{
			pBlock->pData = NULL;
			pBlock->pData = new BYTE[dwSize * dwCount];
			Assert(pBlock->pData);
						
			::CopyMemory(pBlock->pData, pData, dwSize * dwCount);
		}

		// add the new block to the end of the list
		m_lBlocks.AddTail(pBlock);
	}
	COM_PROTECT_CATCH;

	if (!FHrSucceeded(hr))
	{
		if (pBlock)
			delete pBlock->pData;
		delete pBlock;
	}

    return hr;
}



//---------------------------------------------------------------------------
// Function:    CInfoBase::RemoveBlock
//
// Removes a block of the gievn type from the list
//---------------------------------------------------------------------------

HRESULT
CInfoBase::RemoveBlock(
    IN  DWORD   dwType,
    IN  DWORD   dwNth
    ) {

    POSITION pos;
    InfoBlock *pBlock;


    //
    // find the block
    //

    pos = m_lBlocks.GetHeadPosition();

    while (pos) {

        POSITION postemp = pos;

        pBlock = (InfoBlock *)m_lBlocks.GetNext(pos);

        if (pBlock->dwType != dwType) { continue; }

        if (dwNth-- != 0) { continue; }


        //
        // this is the block, remove it from the list
        //

        m_lBlocks.RemoveAt(postemp);


        //
        // free the block's memory as well
        //

        if (pBlock->pData) { delete [] pBlock->pData; }

        delete pBlock;

        return HRESULT_FROM_WIN32(NO_ERROR);
    }


    //
    // the block wasn't found
    //

    return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
}

HRESULT CInfoBase::GetInfo(DWORD *pdwSize, int *pcBlocks)
{
	if (pdwSize)
		*pdwSize = m_dwSize;
	if (pcBlocks)
		*pcBlocks = (int) m_lBlocks.GetCount();
	return hrOK;
}


//---------------------------------------------------------------------------
// Function:    CInfoBase::BlockListToArray
//
// Converts a list of blocks into an array.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::BlockListToArray(
    OUT PBYTE&  pBase,
    OUT DWORD&  dwSize
    ) {

    PBYTE pdata;
    DWORD dwCount;
    POSITION pos;
    RTR_INFO_BLOCK_HEADER *prtrbase;
    RTR_TOC_ENTRY *prtrblock;
    InfoBlock *pblock;
	HRESULT	hr = hrOK;


	COM_PROTECT_TRY
	{
		// Compute the total size occupied by the infobase's blocks

		// base structure
		dwCount = 0;
		dwSize = FIELD_OFFSET(RTR_INFO_BLOCK_HEADER, TocEntry);

		// Table Of Contents Entries
		pos = m_lBlocks.GetHeadPosition();
		while (pos) {
			
			pblock = (InfoBlock *)m_lBlocks.GetNext(pos);
			
			dwSize += sizeof(RTR_TOC_ENTRY);
			++dwCount;
		}
		

		// information blocks
		pos = m_lBlocks.GetHeadPosition();
		while (pos) {
			
			pblock = (InfoBlock *)m_lBlocks.GetNext(pos);

			dwSize += ALIGN_SHIFT;
			dwSize &= ALIGN_MASK;

			dwSize += pblock->dwSize * pblock->dwCount;
		}


		//
		// Allocate enough memory to hold the converted infobase
		//
		
		pBase = new BYTE[dwSize];
		Assert(pBase);
		
		ZeroMemory(pBase, dwSize);
		
		
		//
		// Initialize the header
		//
		
		prtrbase = (RTR_INFO_BLOCK_HEADER *)pBase;
		prtrbase->Size = dwSize;
		prtrbase->Version = RTR_INFO_BLOCK_VERSION;
		prtrbase->TocEntriesCount = dwCount;
		

		//
		// Now walk the list again, this time copying blocks over
		// along with their data
		//
		
		prtrblock = prtrbase->TocEntry;
		pdata = pBase + FIELD_OFFSET(RTR_INFO_BLOCK_HEADER, TocEntry) +
				dwCount * sizeof(RTR_TOC_ENTRY);
		
		
		pos = m_lBlocks.GetHeadPosition();
		while (pos) {
			
			pdata += ALIGN_SHIFT;
			pdata = (PBYTE)((LONG_PTR)pdata & ALIGN_MASK);
			
			pblock = (InfoBlock *)m_lBlocks.GetNext(pos);
			
			prtrblock->InfoType = pblock->dwType;
			prtrblock->Count = pblock->dwCount;
			prtrblock->InfoSize = pblock->dwSize;
			prtrblock->Offset = (ULONG)(pdata - pBase);
			
			
			if (pblock->pData) {
				::CopyMemory(pdata, pblock->pData, pblock->dwSize * pblock->dwCount);
			}
			
			pdata += pblock->dwSize * pblock->dwCount;
			
			++prtrblock;
		}
	}
	COM_PROTECT_CATCH;
				
	return hr;
}
	
	

//---------------------------------------------------------------------------
// Function:    CInfoBase::ArrayToBlockList
//
// This functions converts an array to a list of InfoBlock structures.
//---------------------------------------------------------------------------

HRESULT
CInfoBase::ArrayToBlockList(
    IN  PBYTE   pBase,
    IN  DWORD   dwSize
    ) {

    PBYTE pdata;
    DWORD dwCount, dwErr;
    RTR_TOC_ENTRY *prtrblock;
    RTR_INFO_BLOCK_HEADER *prtrbase;
	HRESULT	hr = hrOK;

    if (!pBase) { return HRESULT_FROM_WIN32(NO_ERROR); }


    //
    // Walk the infobase converting each block to an InfoBlock
    //

    prtrbase = (RTR_INFO_BLOCK_HEADER *)pBase;
    dwCount = prtrbase->TocEntriesCount;
    prtrblock = prtrbase->TocEntry;

    for ( ; dwCount > 0; dwCount--) {

        //
        // Get the next entry in the array
        //

        pdata = pBase + prtrblock->Offset;


        //
        // Add the array-entry to the list of blocks
        //

        hr = AddBlock(
					  prtrblock->InfoType, prtrblock->InfoSize,
					  pdata, prtrblock->Count
					 );
		if (!FHrSucceeded(hr))
		{
			Unload();
			return hr;
		}

        ++prtrblock;
    }

    return HRESULT_FROM_WIN32(NO_ERROR);
}




//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// 
// This section is for the actual implementation of the various
// COM objects, which wrap the previous C++ implementation.
// 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------



/*---------------------------------------------------------------------------
	Class:	InfoBase

	This is an interface wrapper around the CInfoBase class.
 ---------------------------------------------------------------------------*/
class InfoBase :
   public IInfoBase
{
public:
	DeclareIUnknownMembers(IMPL)
	DeclareIInfoBaseMembers(IMPL)

	InfoBase();
	~InfoBase();

protected:
	CInfoBase	m_cinfobase;
	LONG		m_cRef;
};

/*---------------------------------------------------------------------------
	Class:	InfoBlockEnumerator
 ---------------------------------------------------------------------------*/
class InfoBlockEnumerator :
   public IEnumInfoBlock
{
public:
	DeclareIUnknownMembers(IMPL)
	DeclareIEnumInfoBlockMembers(IMPL)

	InfoBlockEnumerator(IInfoBase *pInfoBase, CPtrList* pPtrList);
	~InfoBlockEnumerator();

protected:
	SPIInfoBase	m_spInfoBase;
	CPtrList *	m_pPtrList;
	POSITION	m_pos;
	LONG		m_cRef;
};




/*---------------------------------------------------------------------------
	InfoBase implementation
 ---------------------------------------------------------------------------*/

DEBUG_DECLARE_INSTANCE_COUNTER(InfoBase)

InfoBase::InfoBase()
	: m_cRef(1)
{
	DEBUG_INCREMENT_INSTANCE_COUNTER(InfoBase);
}

InfoBase::~InfoBase()
{
	Unload();
	DEBUG_DECREMENT_INSTANCE_COUNTER(InfoBase);
}

IMPLEMENT_ADDREF_RELEASE(InfoBase);

HRESULT InfoBase::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // Is the pointer bad?
    if (ppv == NULL)
		return E_INVALIDARG;

    //  Place NULL in *ppv in case of failure
    *ppv = NULL;

    //  This is the non-delegating IUnknown implementation
    if (riid == IID_IUnknown)
		*ppv = (LPVOID) this;
	else if (riid == IID_IInfoBase)
		*ppv = (IInfoBase *) this;

    //  If we're going to return an interface, AddRef it first
    if (*ppv)
	{
	((LPUNKNOWN) *ppv)->AddRef();
		return hrOK;
	}
    else
		return E_NOINTERFACE;	
}

/*!--------------------------------------------------------------------------
	InfoBase::Load
		Implementation of IInfoBase::Load
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::Load(HKEY hKey, 
							LPCOLESTR pszKey, 
							LPCOLESTR pszValue)
{
	HRESULT	hr;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.Load(hKey, OLE2CT(pszKey), OLE2CT(pszValue));
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::Save
		Implementation of IInfoBase::Save
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::Save(HKEY hKey, 
						 LPCOLESTR pszKey, 
						 LPCOLESTR pszValue)  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.Save(hKey,	OLE2CT(pszKey), OLE2CT(pszValue));
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::Unload
		Implementation of IInfoBase::Unload
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::Unload()  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.Unload();
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::CopyFrom
		Implementation of IInfoBase::CopyFrom
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::CopyFrom(IInfoBase * pSrc)  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.CopyFrom(pSrc);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::LoadFrom
		Implementation of IInfoBase::LoadFrom
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::LoadFrom(DWORD dwSize, PBYTE pBase)
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.LoadFrom(pBase, dwSize);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::WriteTo
		Implementation of IInfoBase::WriteTo
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::WriteTo(PBYTE *ppBase, 
							DWORD *pdwSize)  
{
	HRESULT	hr = hrOK;
	PBYTE	pBaseT = NULL;
	DWORD	dwSizeT;

	Assert(ppBase);
	Assert(pdwSize);
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.WriteTo(pBaseT, dwSizeT);

		if (FHrSucceeded(hr))
		{
			*ppBase = (PBYTE) CoTaskMemAlloc(dwSizeT);
			if (*ppBase == NULL)
				hr = E_OUTOFMEMORY;
			else
			{
				::CopyMemory(*ppBase, pBaseT, dwSizeT);
				*pdwSize = dwSizeT;
				delete pBaseT;
			}
		}
	}
	COM_PROTECT_CATCH;

	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::GetBlock		
		Implementation of IInfoBase::GetBlock
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::GetBlock(DWORD dwType, 
							 InfoBlock **ppBlock, 
							 DWORD dwNth)  
{
	HRESULT	hr = hrOK;
	Assert(ppBlock);
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.GetBlock(dwType, *ppBlock, dwNth);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::SetBlock
		Implementation of IInfoBase::SetBlock
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::SetBlock(DWORD dwType, 
							 InfoBlock *pBlock, 
							 DWORD dwNth)  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.SetBlock(dwType, pBlock, dwNth);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::AddBlock
		Implementation of IInfoBase::AddBlock
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::AddBlock(DWORD	dwType, 
							 DWORD	dwSize, 
							 PBYTE	pData, 
							 DWORD	dwCount, 
							 BOOL	bRemoveFirst)  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.AddBlock(dwType, dwSize, pData, dwCount, bRemoveFirst);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::GetData
		Implementation of IInfoBase::GetData
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::GetData(DWORD	dwType, 
							DWORD	dwNth, 
							PBYTE *	ppData)  
{
	HRESULT	hr = hrOK;
	PBYTE	pb = NULL;

	Assert(ppData);
	
	COM_PROTECT_TRY
	{
		pb = m_cinfobase.GetData(dwType, dwNth);
		*ppData = pb;
	}
	COM_PROTECT_CATCH;
	
	return *ppData ? hr : E_INVALIDARG;
}

/*!--------------------------------------------------------------------------
	InfoBase::SetData
		Implementation of IInfoBase::SetData
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::SetData(DWORD	dwType, 
							DWORD	dwSize, 
							PBYTE	pData, 
							DWORD	dwCount, 
							DWORD	dwNth)  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.SetData(dwType, dwSize, pData, dwCount, dwNth);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::RemoveBlock
		Implementation of IInfoBase::RemoveBlock
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::RemoveBlock(DWORD	dwType, 
								DWORD	dwNth)  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.RemoveBlock(dwType, dwNth);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::BlockExists
		Implementation of IInfoBase::BlockExists
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::BlockExists(DWORD	dwType )  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.BlockExists(dwType) ? hrOK : hrFalse;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::ProtocolExists
		Implementation of IInfoBase::ProtocolExists
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::ProtocolExists(DWORD dwProtocol )  
{
	HRESULT	hr = hrOK;
	BOOL	bResult;
	
	COM_PROTECT_TRY
	{
		bResult = m_cinfobase.ProtocolExists(dwProtocol);
		hr = (bResult ? S_OK : S_FALSE);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::RemoveAllBlocks
		Implementation of IInfoBase::RemoveAllBlocks
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::RemoveAllBlocks()  
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		hr = m_cinfobase.RemoveAllBlocks();
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InfoBase::QueryBlockList
		Implementation of IInfoBase::QueryBlockList
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBase::QueryBlockList(IEnumInfoBlock **ppBlockEnum)  
{
	HRESULT	hr = hrOK;
	InfoBlockEnumerator	*pIBEnum = NULL;
	
	COM_PROTECT_TRY
	{
		pIBEnum = new InfoBlockEnumerator(this, &m_cinfobase.QueryBlockList());
		Assert(pIBEnum);
	}
	COM_PROTECT_CATCH;

	*ppBlockEnum = static_cast<IEnumInfoBlock *>(pIBEnum);
	
	return hr;
}


STDMETHODIMP InfoBase::GetInfo(DWORD *pdwSize, int *pcBlocks)
{
	return m_cinfobase.GetInfo(pdwSize, pcBlocks);
	return hrOK;
}

/*!--------------------------------------------------------------------------
	CreateInfoBase
		Creates an IInfoBase object.
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) CreateInfoBase(IInfoBase **ppInfoBase)
{
	HRESULT	hr = hrOK;
	InfoBase *	pinfobase = NULL;

	Assert(ppInfoBase);

	COM_PROTECT_TRY
	{
		pinfobase = new InfoBase;
		*ppInfoBase = static_cast<IInfoBase *>(pinfobase);
	}
	COM_PROTECT_CATCH;

	return hr;
}


/*---------------------------------------------------------------------------
	InfoBlockEnumerator implementation
 ---------------------------------------------------------------------------*/

DEBUG_DECLARE_INSTANCE_COUNTER(InfoBlockEnumerator);

InfoBlockEnumerator::InfoBlockEnumerator(IInfoBase *pInfoBase, CPtrList *pPtrList)
	: m_cRef(1)
{
	m_spInfoBase.Set(pInfoBase);
	m_pPtrList = pPtrList;

	DEBUG_INCREMENT_INSTANCE_COUNTER(InfoBlockEnumerator);
}

InfoBlockEnumerator::~InfoBlockEnumerator()
{
	DEBUG_DECREMENT_INSTANCE_COUNTER(InfoBlockEnumerator);
}

IMPLEMENT_ADDREF_RELEASE(InfoBlockEnumerator);

HRESULT InfoBlockEnumerator::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // Is the pointer bad?
    if (ppv == NULL)
		return E_INVALIDARG;

    //  Place NULL in *ppv in case of failure
    *ppv = NULL;

    //  This is the non-delegating IUnknown implementation
    if (riid == IID_IUnknown)
		*ppv = (LPVOID) this;
	else if (riid == IID_IEnumInfoBlock)
		*ppv = (IEnumInfoBlock *) this;

    //  If we're going to return an interface, AddRef it first
    if (*ppv)
	{
	((LPUNKNOWN) *ppv)->AddRef();
		return hrOK;
	}
    else
		return E_NOINTERFACE;	
}

/*!--------------------------------------------------------------------------
	InfoBlockEnumerator::Next
		Implementation of IEnumInfoBlock::Next
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBlockEnumerator::Next(ULONG uNum, InfoBlock **ppBlock,
									ULONG *pNumReturned)
{
	Assert(uNum == 1);
	Assert(m_pPtrList);
	Assert(ppBlock);

	if (ppBlock)
		*ppBlock = NULL;
	
	if (!m_pos)
	{
		if (pNumReturned)
			*pNumReturned = 0;
		return S_FALSE;
	}
	
	*ppBlock = (InfoBlock *) m_pPtrList->GetNext(m_pos);
	if (pNumReturned)
		*pNumReturned = 1;
	return hrOK;
}

/*!--------------------------------------------------------------------------
	InfoBlockEnumerator::Skip
		Implementation of IEnumInfoBlock::Skip
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBlockEnumerator::Skip(ULONG uNum)
{
	Assert(uNum == 1);
	Assert(m_pPtrList);

	if (!m_pos)
		return S_FALSE;
	
	m_pPtrList->GetNext(m_pos);
	return hrOK;
}

/*!--------------------------------------------------------------------------
	InfoBlockEnumerator::Reset
		Implementation of IEnumInfoBlock::Reset
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBlockEnumerator::Reset()
{
	Assert(m_pPtrList);
	m_pos = m_pPtrList->GetHeadPosition();
	return hrOK;
}

/*!--------------------------------------------------------------------------
	InfoBlockEnumerator::Clone
		Implementation of IEnumInfoBlock::Clone
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InfoBlockEnumerator::Clone(IEnumInfoBlock **ppBlockEnum)
{
	return E_NOTIMPL;
}