1798 lines
58 KiB
C++
1798 lines
58 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1995.
|
|
//
|
|
// File: psctbl2.cxx
|
|
//
|
|
// Contents: Trie-based IID to CLSID map
|
|
//
|
|
// Classes: CMapGuidToGuidBase
|
|
// CPSClsidTbl (DLL)
|
|
// CScmPSClsidTbl (SCM/EXE)
|
|
//
|
|
// Functions: bmemcmp
|
|
// bmemcpy
|
|
// CMapGuidToGuidBase::Initialize
|
|
// CMapGuidToGuidBase::CGUIDBlock -> internal functions
|
|
// CMapGuidToGuidBase::TrieNode -> internal functions
|
|
// CPSClsidTbl::Initialize
|
|
// CPSClsidTbl::Find
|
|
// CScmPSClsidTbl::Initialize
|
|
// CScmPSClsidTbl::InitTbl
|
|
// CScmPSClsidTbl::AddLocal
|
|
// CScmPSClsidTbl::CopyToSharedMem
|
|
//
|
|
// History: 06-Jun-95 t-stevan Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#include <ole2int.h>
|
|
#pragma hdrstop
|
|
#include <psctbl2.hxx>
|
|
|
|
|
|
// *** Defines and Constants ***
|
|
// The number of bits used to store the number of key bytes in a TrieNode
|
|
const int KEYBYTE_BITS = 5;
|
|
|
|
// # of bits used to store # of links
|
|
const int LINKS_BITS = 9;
|
|
|
|
// The mask for number of key bytes stored in a TrieNode
|
|
const WORD KEYBYTE_MASK = 0x1f;
|
|
|
|
// The mask for the number of links stored in a TrieNode
|
|
const WORD LINKS_MASK = (0x1ff<<KEYBYTE_BITS);
|
|
|
|
// Mask for leaf bit in TrieNode
|
|
const WORD ISLEAF_MASK = 0x4000;
|
|
|
|
// Mask for deleted flag bit in TrieNode
|
|
const WORD DELETED_MASK = 0x8000;
|
|
|
|
// *** These definitions control the amount of memory that the cache uses/can use ***
|
|
// The default number of links per TrieNode
|
|
const int NODE_LINKS = 4;
|
|
|
|
// The initial amount to grow by
|
|
const int NODE_INIT_GROWBY =4;
|
|
|
|
// The amount to growby afterwards
|
|
// Note: must be a factor of 256, so therefore must be power of 2
|
|
// also, NODE_LINKS+NODE_INIT_GROWBY = multiple of NODE_GROWBY
|
|
const int NODE_GROWBY = 8;
|
|
|
|
// Mod mask for NODE_GROWBY so we can just and it instead of using %
|
|
const int NODE_GROWBY_MOD_MASK = NODE_GROWBY-1;
|
|
|
|
// Constants for our initial/maximum map size
|
|
const ULONG MAP_INITIAL_SIZE = 4096; // initial size of map = 4K
|
|
const ULONG MAP_MAX_SIZE = 65536; // maximum size of map = 64K
|
|
|
|
// Key text of registry
|
|
TCHAR tszInterface[] = TEXT("Interface");
|
|
|
|
// the following string is used in compapi.cxx
|
|
WCHAR wszProxyStubClsid[] = L"\\ProxyStubClsid32";
|
|
WCHAR wszProxyStubClsid16[] = L"\\ProxyStubClsid";
|
|
|
|
// macros for setting up a pointer to base off of in member funcs
|
|
#ifdef SETUP_BASE_POINTER
|
|
#undef SETUP_BASE_POINTER
|
|
#endif
|
|
|
|
#define SETUP_BASE_POINTER() void *pBase = m_pMemBase
|
|
|
|
#ifdef SYNC_BASE_POINTER
|
|
#undef SYNC_BASE_POINTER
|
|
#endif
|
|
|
|
#define SYNC_BASE_POINTER() pBase = m_pMemBase
|
|
|
|
// a based pointer for TrieNode, using passed bases
|
|
#define PASSBASED __based(pBase)
|
|
#define OLDBASED __based(pOldBase)
|
|
#define NEWBASED __based(pNewBase)
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: bmemcmp
|
|
//
|
|
// Synopsis: compares two memory strings, the first of which runs forward in memory
|
|
// the second of which runs backwards in memory
|
|
//
|
|
// Arguments: [pFBuf] - the forward-running string in memory
|
|
// [pBBuf] - the backward-running string in memory
|
|
// [count] - the number of bytes to compare
|
|
//
|
|
// Returns: 0 if the two memory strings are equal. Example: pFBuf = "abcd", pBBuf-3 = "dcba" would be equal
|
|
// else it returns the number of bytes left to compare.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline int bmemcmp(const BYTE *pFBuf, const BYTE *pBBuf, size_t count)
|
|
{
|
|
// pFBuf goes forward, pBBuf goes backward
|
|
while((count > 0) && (*pFBuf++ == *pBBuf--))
|
|
{
|
|
count--;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: bmemcpy
|
|
//
|
|
// Synopsis: copies a backward-running memory string into a forward running one,
|
|
//
|
|
// Arguments: [pFDest] - the forward-running destination
|
|
// [pBSrc] - the backward-running string in memory
|
|
// [count] - the number of bytes to copy
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void bmemcpy(BYTE *pFDest, const BYTE *pBSrc, size_t count)
|
|
{
|
|
while(count-- > 0)
|
|
{
|
|
*pFDest++ = *pBSrc--;
|
|
}
|
|
}
|
|
|
|
// *** CMapGuidToGuidBase ***
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::Initialize
|
|
//
|
|
// Synopsis: Initializes base (client or server) guid -> guid map
|
|
//
|
|
// Arguments: [pBase] - the base address of our shared memory region
|
|
//
|
|
// Returns: appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CMapGuidToGuidBase::Initialize(void *pBase)
|
|
{
|
|
CairoleDebugOut((DEB_ITRACE, "CMapGuidToGuidBase::Initialize(pBase = %p)\n", pBase));
|
|
|
|
m_pMemBase = pBase;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// *** CMapGuidToGuidBase::CGUIDBlock ***
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::CGUIDBlock::Initialize, public
|
|
//
|
|
// Synopsis: Initializes the GUID list, we store the mapped-to GUIDs in this
|
|
// list because there aren't that many different ones, so storing one per
|
|
// leaf would be wasteful
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::CGUIDBlock::Initialize()
|
|
{
|
|
m_nGuids = 0;
|
|
m_bpNext = NULL;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::CGUIDBlock::GetGuid, public
|
|
//
|
|
// Synopsis: Returns a GUID associated with a given GUIDIndex
|
|
//
|
|
// Arguments: [pBase] - the base address of the memory region
|
|
// [guidIndex] - the index of the GUID to retreive
|
|
// [guidOut] - a reference to a GUID to store the retreive guid in
|
|
//
|
|
// Returns: TRUE if found, FALSE if didn't
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline BOOL CMapGuidToGuidBase::CGUIDBlock::GetGuid(void *pBase, GUIDIndex guidIndex, GUID &guidOut) const
|
|
{
|
|
const CGUIDBlock * pBlock = this;
|
|
|
|
if(guidIndex == INVALID_GUID_INDEX)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
while(guidIndex > cGuids)
|
|
{
|
|
guidIndex -= cGuids;
|
|
pBlock = BP_TO_P(CGUIDBlock *, (CGUIDBlock PASSBASED *) pBlock->m_bpNext);
|
|
if(pBlock == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
guidOut = pBlock->m_guidArray[guidIndex];
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::CGUIDBlock::AddGuid, public
|
|
//
|
|
// Synopsis: Adds a GUID to the list, or if the GUID is already there, just returns the proper
|
|
// reference to it.
|
|
//
|
|
// Arguments: [pBase] - base address of memory region (NULL if using local memory)
|
|
// [guid] - the guid to insert into the list
|
|
// [alloc] - the functor to use to allocate memory
|
|
//
|
|
// Returns: a based pointer to the GUID in the table
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
GUIDIndex CMapGuidToGuidBase::CGUIDBlock::AddGuid(void *pBase, REFGUID guid, CAllocFunctor &alloc)
|
|
{
|
|
CGUIDBlock *pBlock;
|
|
int iRetVal; // use an int so we can detect if our table of GUIDs is full
|
|
|
|
// First check to see if this GUID is already in the table
|
|
iRetVal = GuidInTable(pBase, this, guid);
|
|
|
|
if(iRetVal == INVALID_GUID_INDEX)
|
|
{
|
|
// Nope, add it
|
|
// avoid recursion
|
|
pBlock = this;
|
|
iRetVal = 0;
|
|
|
|
while(pBlock != NULL && (iRetVal < INVALID_GUID_INDEX))
|
|
{
|
|
Win4Assert(pBlock->m_nGuids <= cGuids && "More than cGuids in CGUIDBlock");
|
|
|
|
if(pBlock->m_nGuids == cGuids)
|
|
{
|
|
// we've outgrown this table, add a new block to the end
|
|
if(BP_TO_P(CGUIDBlock *, (CGUIDBlock PASSBASED *) pBlock->m_bpNext) == NULL)
|
|
{
|
|
CGUIDBlock *pNewBlock;
|
|
|
|
// allocate a new one
|
|
pNewBlock = (CGUIDBlock *) alloc.Alloc(sizeof(CGUIDBlock));
|
|
|
|
if(pNewBlock == NULL)
|
|
{
|
|
// we're out of memory
|
|
return INVALID_GUID_INDEX;
|
|
}
|
|
|
|
// initialize it
|
|
pNewBlock->Initialize();
|
|
|
|
// add the guid to it
|
|
pNewBlock->m_guidArray[0] = guid;
|
|
pNewBlock->m_nGuids++;
|
|
|
|
// chain it on the list
|
|
pBlock->m_bpNext = (CGUIDBlockBasedPtr) P_TO_BP(CGUIDBlock PASSBASED *, pNewBlock);
|
|
|
|
// set the return value
|
|
iRetVal += cGuids; // we're the first guid on this link in the chain
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// keep on looking for empty space
|
|
pBlock = BP_TO_P(CGUIDBlock *, (CGUIDBlock PASSBASED *) pBlock->m_bpNext);
|
|
iRetVal += cGuids;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// insert this GUID (in no particular order) into the block's array
|
|
pBlock->m_guidArray[pBlock->m_nGuids] = guid;
|
|
iRetVal += pBlock->m_nGuids;
|
|
pBlock->m_nGuids++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(iRetVal >= INVALID_GUID_INDEX)
|
|
{
|
|
iRetVal = INVALID_GUID_INDEX;
|
|
}
|
|
|
|
return (GUIDIndex) iRetVal;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::CGUIDBlock::GuidInTable, private (implementation)
|
|
//
|
|
// Synopsis: Looks down the chained block list for a particular GUID, if it finds it return a
|
|
// reference to it.
|
|
//
|
|
// Arguments: [pBase] - pointer to the base of the shared memory region
|
|
// [pBlock] - the block to start at
|
|
// [guid] - the guid to find
|
|
//
|
|
// Returns: a based pointer to the GUID in the table, NULL if it was not found
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
GUIDIndex CMapGuidToGuidBase::CGUIDBlock::GuidInTable(void *pBase, CGUIDBlock *pBlock, REFGUID guid)
|
|
{
|
|
GUIDIndex iRet = 0;
|
|
GUID *pIndex;
|
|
BOOL fFound = FALSE;
|
|
int i;
|
|
|
|
// avoid recursion!
|
|
while(pBlock != NULL)
|
|
{
|
|
// Check this block
|
|
for(i =0, pIndex = &(pBlock->m_guidArray[0]); i < pBlock->m_nGuids; i++, pIndex++)
|
|
{
|
|
if(*pIndex == guid)
|
|
{
|
|
// found it, break outta here
|
|
iRet += i;
|
|
fFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!fFound)
|
|
{
|
|
// not in this block ,try next one
|
|
pBlock = BP_TO_P(CGUIDBlock *, (CGUIDBlock PASSBASED *) pBlock->m_bpNext);
|
|
iRet += cGuids;
|
|
}
|
|
else
|
|
{
|
|
// we found it, break outta here
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!fFound)
|
|
{
|
|
return INVALID_GUID_INDEX;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::CGUIDBlock::CopyToSharedMem
|
|
//
|
|
// Synopsis: Copies an entire list of CGUIDBlocks allocated in local memory
|
|
// to shared memory, making sure the original blocks now have
|
|
// based pointers to where the new (copied) data lies
|
|
//
|
|
// Arguments: [pNewBase] - the base pointer of the destination shared memory block
|
|
// [pOldBase] - the base pointer of the source memory block (usually NULL)
|
|
// [pCopyBlock] - the block to copy the first CGUIDBlock to
|
|
// [alloc] - the allocator to use to allocate shared memory
|
|
//
|
|
// Returns: appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CMapGuidToGuidBase::CGUIDBlock::CopyToSharedMem(void *pNewBase, void *pOldBase, CGUIDBlock *pCopyBlock, CAllocFunctor &alloc)
|
|
{
|
|
CGUIDBlock *pBlock = this;
|
|
int i;
|
|
|
|
while(pBlock != NULL)
|
|
{
|
|
pCopyBlock->m_nGuids = pBlock->m_nGuids;
|
|
|
|
for(i = 0; i < m_nGuids; i++)
|
|
{
|
|
pCopyBlock->m_guidArray[i] = pBlock->m_guidArray[i];
|
|
}
|
|
|
|
pBlock = BP_TO_P(CGUIDBlock *, (CGUIDBlock OLDBASED *) pBlock->m_bpNext);
|
|
|
|
if(pBlock != NULL)
|
|
{
|
|
CGUIDBlock *pNewBlock;
|
|
|
|
pNewBlock = (CGUIDBlock *) alloc.Alloc(sizeof(CGUIDBlock));
|
|
|
|
if(pNewBlock == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pCopyBlock->m_bpNext = (CGUIDBlockBasedPtr) P_TO_BP(CGUIDBlock NEWBASED *, pNewBlock);
|
|
pCopyBlock = pNewBlock;
|
|
}
|
|
else
|
|
{
|
|
pCopyBlock->m_bpNext = (CGUIDBlockBasedPtr) P_TO_BP(CGUIDBlock NEWBASED *, NULL);
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// *** CMapGuidToGuidBase::TrieNode ***
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::NumLinks
|
|
//
|
|
// Synopsis: Return the number of links used in a node
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: see synopsis
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline int CMapGuidToGuidBase::TrieNode::NumLinks() const
|
|
{
|
|
return (m_wInfo & LINKS_MASK)>>KEYBYTE_BITS;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::NumKeyBytes
|
|
//
|
|
// Synopsis: Return the number of bytes of the key stored in this node
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: see synopsis
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline int CMapGuidToGuidBase::TrieNode::NumKeyBytes() const
|
|
{
|
|
return (m_wInfo & KEYBYTE_MASK);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPSClsidTbl::TrieNode::IsLeaf
|
|
//
|
|
// Synopsis: Return whether a node is a Node or a Leaf
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: TRUE if the node is a Leaf (is has no links)
|
|
// FALSE if it is a Node (it has links)
|
|
//--------------------------------------------------------------------------
|
|
inline BOOL CMapGuidToGuidBase::TrieNode::IsLeaf() const
|
|
{
|
|
if(m_wInfo & ISLEAF_MASK)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPSClsidTbl::TrieNode::IsDeleted
|
|
//
|
|
// Synopsis: Return whether a given node is deleted
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: TRUE if the node is marked as deleted
|
|
// FALSE otherwise
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline BOOL CMapGuidToGuidBase::TrieNode::IsDeleted() const
|
|
{
|
|
if(m_wInfo & DELETED_MASK)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::SetLeaf
|
|
//
|
|
// Synopsis: sets the leaf bit of a node
|
|
//
|
|
// Arguments: [fLeaf] - should be TRUE to set this node to a Leaf
|
|
// FALSE if this node should be a Node
|
|
// Returns: nothing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::TrieNode::SetLeaf(BOOL fLeaf)
|
|
{
|
|
if(fLeaf)
|
|
{
|
|
m_wInfo = m_wInfo | ISLEAF_MASK;
|
|
}
|
|
else
|
|
{
|
|
m_wInfo = m_wInfo & (~ISLEAF_MASK);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::SetDeleted
|
|
//
|
|
// Synopsis: sets the deleted bit of a node
|
|
//
|
|
// Arguments: [fDeleted] - should be TRUE to mark this node as deleted
|
|
// FALSE to not mark it (equivalent to un-marking it)
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::TrieNode::SetDeleted(BOOL fDeleted)
|
|
{
|
|
Win4Assert(IsLeaf() && "Tried to delete a non-Leaf TrieNode!");
|
|
|
|
if (fDeleted)
|
|
{
|
|
m_wInfo = m_wInfo | DELETED_MASK;
|
|
}
|
|
else
|
|
{
|
|
m_wInfo = m_wInfo & (~DELETED_MASK);
|
|
}
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::SetKeyBytes
|
|
//
|
|
// Synopsis: Sets the number of bytes of a key stored in this node
|
|
//
|
|
// Arguments: [nKeyBytes] - the number of bytes
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::TrieNode::SetKeyBytes(int nKeyBytes)
|
|
{
|
|
Win4Assert(nKeyBytes <= GUID_BYTES && "Tried to add more than GUID_BYTES to a TrieNode!");
|
|
|
|
m_wInfo = (m_wInfo & (~KEYBYTE_MASK)) |
|
|
(nKeyBytes&KEYBYTE_MASK);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::SetLinks
|
|
//
|
|
// Synopsis: Sets the number of links used in a node
|
|
//
|
|
// Arguments: [nLinks] - the number of links used
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::TrieNode::SetLinks(int nLinks)
|
|
{
|
|
Win4Assert(nLinks <= 256 && "Tried to have more than 256 links in a node");
|
|
|
|
m_wInfo = (m_wInfo & (~LINKS_MASK)) |
|
|
((nLinks<<KEYBYTE_BITS)&LINKS_MASK);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CPSClsidTbl::TrieNode::IncrementLinks
|
|
//
|
|
// Synopsis: Increments the number of links used in a node by 1
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: (nothing)
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::TrieNode::IncrementLinks()
|
|
{
|
|
Win4Assert(((m_wInfo & LINKS_MASK)>>KEYBYTE_BITS) <= 255
|
|
&& "Tried to insert past 256 links in a node");
|
|
|
|
m_wInfo += (1<<KEYBYTE_BITS);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::GetKey
|
|
//
|
|
// Synopsis: Return a pointer to a node's key data
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: see synopsis
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline BYTE *CMapGuidToGuidBase::TrieNode::GetKey()
|
|
{
|
|
#if !defined(_M_IX86)
|
|
// we need to worry about alignment
|
|
// so we put the 2-byte GUIDIndex before the n-byte key
|
|
if(IsLeaf())
|
|
{
|
|
return m_bData + sizeof(GUIDIndex);
|
|
}
|
|
else
|
|
{
|
|
return m_bData;
|
|
}
|
|
#else
|
|
// On the x86, we don't need to worry about alignment
|
|
return m_bData; // remember, this pointer not based!!
|
|
#endif // !defined(_M_IX86)
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::GetData
|
|
//
|
|
// Synopsis: Return a pointer to a Leaf's data (the data mapped to the key)
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: pointer to a Leaf's data
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline GUIDIndex *CMapGuidToGuidBase::TrieNode::GetData()
|
|
{
|
|
Win4Assert(IsLeaf() && "Tried to get data from a non-Leaf node!");
|
|
|
|
#if !defined(_M_IX86)
|
|
// we need to worry about alignment
|
|
// so we put the 2-byte GUIDIndex before the n-byte key
|
|
return (GUIDIndex *) m_bData;
|
|
#else
|
|
// On the x86, we don't need to worry about alignment
|
|
return (GUIDIndex *) &m_bData[NumKeyBytes()];
|
|
#endif // !defined(_M_IX86)
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::GetNodeSize
|
|
//
|
|
// Synopsis: Calculates the amount of bytes a node will take with the given parameters
|
|
//
|
|
// Arguments: [bKeyBytes] - the number of bytes of the key stored in this node
|
|
// [fLeaf] - TRUE = Leaf node, FALSE = Node node
|
|
// [bLinks] - the number of links to *allocate* (not the number of links used!!!!!)
|
|
//
|
|
// Returns: the computed size of the node
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline DWORD CMapGuidToGuidBase::TrieNode::GetNodeSize(BYTE bKeyBytes, BOOL fLeaf, int bLinks)
|
|
{
|
|
return sizeof(WORD)+bKeyBytes+sizeof(GUIDIndex)*(fLeaf?1:0)+bLinks*sizeof(TrieNodeBasedPtr);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CMapGuidToGuidBase::TrieNode::GetLinkStart
|
|
//
|
|
// Synopsis: Return the beginning of the link array of a node
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: a pointer to the beginning of the link array
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline TrieNodeBasedPtr UNALIGNED *CMapGuidToGuidBase::TrieNode::GetLinkStart() const
|
|
{
|
|
return (TrieNodeBasedPtr UNALIGNED *) &m_bData[NumKeyBytes()];
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::InsertIntoLinkArray (static)
|
|
//
|
|
// Synopsis: insert a based pointer into the array of links to other nodes
|
|
//
|
|
// Arguments: [pArray] - pointer to the place in the array we wish to insert
|
|
// [pInsert] - based pointer to insert
|
|
// [nAfter] - number of nodes we need to "tumble" down the rest of the array
|
|
//
|
|
// Returns: void
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline void CMapGuidToGuidBase::TrieNode::InsertIntoLinkArray(TrieNodeBasedPtr UNALIGNED *pbpArray, TrieNodeBasedPtr bpInsert,int nAfter)
|
|
{
|
|
Win4Assert(pbpArray != NULL && "Tried to insert into a NULL link array");
|
|
Win4Assert(bpInsert != 0 && "Tried to insert a NULL based pointer into link array");
|
|
|
|
// must use memmove, because memory regions overlap
|
|
memmove((pbpArray+1), pbpArray, nAfter*sizeof(TrieNodeBasedPtr));
|
|
*pbpArray = bpInsert;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CMapGuidToGuidBase::TrieNode::FindLinkSize, static
|
|
//
|
|
// Synopsis: Finds the number of allocated links to hold a given number of used links
|
|
//
|
|
// Arguments: [num] number of used links
|
|
//
|
|
// Returns: number of allocated links
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
inline int CMapGuidToGuidBase::TrieNode::FindLinkSize(int nLinks)
|
|
{
|
|
if(nLinks <= NODE_LINKS)
|
|
{
|
|
return NODE_LINKS;
|
|
}
|
|
|
|
if(nLinks <= (NODE_LINKS+NODE_INIT_GROWBY))
|
|
{
|
|
return NODE_LINKS+NODE_INIT_GROWBY;
|
|
}
|
|
|
|
return NODE_GROWBY*((nLinks+(NODE_GROWBY-1))/NODE_GROWBY);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::GetLink
|
|
//
|
|
// Synopsis: Given the next byte of a key, return the link to the next node in the trie
|
|
//
|
|
// Arguments: [pBase] - pointer to base of shared memory
|
|
// [bComp] - the next byte of the key to look for a link on
|
|
// [pbpLink]- a reference to a TrieNodeBasedPtr *, which on exit will hold
|
|
// the address of the link pointer so it can be changed
|
|
// in the future.
|
|
// Returns: the pointer to the node correspoding to bComp, or NULL if no such
|
|
// node exists
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CMapGuidToGuidBase::TrieNode *CMapGuidToGuidBase::TrieNode::GetLink(void *pBase, BYTE bComp, TrieNodeBasedPtr UNALIGNED *&pbpLink)
|
|
{
|
|
TrieNodeBasedPtr UNALIGNED *pbpLower;
|
|
TrieNodeBasedPtr UNALIGNED *pbpUpper;
|
|
TrieNodeBasedPtr UNALIGNED *pbpIndex;
|
|
BYTE bIndex;
|
|
|
|
Win4Assert(!IsLeaf() && "Tried to get a link from a leaf!\n");
|
|
|
|
pbpLower = GetLinkStart();
|
|
pbpUpper = pbpLower+(NumLinks() - 1);
|
|
|
|
// Use binary search
|
|
while(pbpLower < pbpUpper)
|
|
{
|
|
pbpIndex = pbpLower + ((pbpUpper - pbpLower)>>1);
|
|
bIndex = *(((TrieNode PASSBASED *) (*pbpIndex))->GetKey());
|
|
if(bComp < bIndex)
|
|
{
|
|
pbpUpper = pbpIndex - 1;
|
|
}
|
|
else
|
|
if(bComp > bIndex)
|
|
{
|
|
pbpLower = pbpIndex + 1;
|
|
}
|
|
else
|
|
{
|
|
// found it
|
|
pbpLink = pbpIndex;
|
|
return BP_TO_P(TrieNode *, (TrieNode PASSBASED *)(*pbpIndex));
|
|
}
|
|
}
|
|
|
|
if((pbpLower != pbpUpper) ||
|
|
(bComp != *(((TrieNode PASSBASED *) (*pbpLower))->GetKey())))
|
|
{
|
|
return NULL; // didn't find anything
|
|
}
|
|
|
|
pbpLink = pbpLower;
|
|
return BP_TO_P(TrieNode *, (TrieNode PASSBASED *) (*pbpLower));
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::AddLink (static)
|
|
//
|
|
// Synopsis: Adds a link to a node to the link array
|
|
//
|
|
// Arguments: [pBase] - pointer to the base of the block of memory the trie is in
|
|
// [pRoot] - pointer of node to add to
|
|
// pretty much an explicit "this" pointer so we can
|
|
// avoid a recursive step if we need to allocated more
|
|
// links (and therefore a new node)
|
|
// [pNode] - pointer of node to add
|
|
// [pbpNewNode]- handle to stick a new node in if we need to increase
|
|
// the number of links allocated to this node. If this is
|
|
// done, the original node will be deleted, so we need to
|
|
// change references to it.
|
|
// [alloc] - The allocator to use to allocate new memory
|
|
//
|
|
// Returns: S_OK if link was added without allocating more links,
|
|
// S_FALSE if more links were allocated, and there for *pbpNewNode is the
|
|
// pointer of the node that should be used to replace this one.
|
|
// Otherwise appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CMapGuidToGuidBase::TrieNode::AddLink(void *pBase, TrieNode *pRoot, TrieNode *pNode,
|
|
TrieNodeBasedPtr UNALIGNED*pbpNewNode, CAllocFunctor &alloc)
|
|
{
|
|
Win4Assert(pNode != NULL && "Tried to add link to NULL TrieNode");
|
|
Win4Assert(!pRoot->IsLeaf() && "Tried to add link to leaf TrieNode"); // can't add links to leafs!
|
|
HRESULT retVal = S_OK;
|
|
int newLinks = NODE_LINKS;
|
|
|
|
if(pRoot->NumLinks() == NODE_LINKS) // Check to see if we need more links
|
|
{
|
|
newLinks += NODE_INIT_GROWBY; // we need to grow by NODE_INIT_GROWBY
|
|
}
|
|
else if (((pRoot->NumLinks()&NODE_GROWBY_MOD_MASK) == 0) && (pRoot->NumLinks() != 0))
|
|
{
|
|
// we need to grow by NODE_GROWBY
|
|
// this computes the size of the node
|
|
newLinks = pRoot->NumLinks()+NODE_GROWBY;
|
|
}
|
|
else
|
|
{
|
|
newLinks = 0; // we don't need to grow
|
|
}
|
|
|
|
if((newLinks != 0) && (newLinks <= 256)) // we don't grow over 256
|
|
{
|
|
TrieNode *pTemp;
|
|
|
|
// we have to allocate another TrieNode, we've used all our links
|
|
Win4Assert(pRoot->NumLinks() <= 255);
|
|
|
|
// Create new trienode with more links
|
|
pTemp = (TrieNode *) alloc.Alloc(GetNodeSize(pRoot->NumKeyBytes(), FALSE, newLinks));
|
|
|
|
if(pTemp == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
*pbpNewNode = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pTemp);
|
|
|
|
// Copy over current data
|
|
memcpy(pTemp, pRoot, GetNodeSize(pRoot->NumKeyBytes(), FALSE, pRoot->NumLinks()));
|
|
|
|
// we don't delete the current node
|
|
alloc.Free(pRoot, GetNodeSize(pRoot->NumKeyBytes(), FALSE, pRoot->NumLinks()));
|
|
|
|
pRoot = pTemp;
|
|
|
|
retVal = S_FALSE;
|
|
}
|
|
|
|
if(pRoot->NumLinks() == 0) // Now that that's taken care of, let's add the link
|
|
{
|
|
// just pluck it right in the beginning
|
|
*(pRoot->GetLinkStart()) = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pNode);
|
|
}
|
|
else
|
|
{
|
|
// Insert using binary insertion
|
|
// This gives us an array in sorted order
|
|
TrieNodeBasedPtr UNALIGNED *pbpLower;
|
|
TrieNodeBasedPtr UNALIGNED *pbpUpper;
|
|
TrieNodeBasedPtr UNALIGNED *pbpIndex;
|
|
BYTE bIndex;
|
|
|
|
pbpLower = pRoot->GetLinkStart();
|
|
pbpUpper = pbpLower + (pRoot->NumLinks() - 1);
|
|
|
|
while(pbpLower < pbpUpper)
|
|
{
|
|
pbpIndex = pbpLower + (pbpUpper - pbpLower)/2;
|
|
bIndex = *(((TrieNode PASSBASED *) (*pbpIndex))->GetKey());
|
|
if(*(pNode->GetKey()) < bIndex)
|
|
{
|
|
pbpUpper = pbpIndex - 1;
|
|
}
|
|
else
|
|
if(*(pNode->GetKey()) > bIndex)
|
|
{
|
|
pbpLower = pbpIndex + 1;
|
|
}
|
|
else
|
|
{
|
|
// we shouldn't have duplicates in the table
|
|
Win4Assert(0 && "Duplicate Entries in IID->CLSID table!\n");
|
|
}
|
|
}
|
|
TrieNodeBasedPtr UNALIGNED *pStart = pRoot->GetLinkStart();
|
|
int iNumLinks = pRoot->NumLinks();
|
|
|
|
if(*(((TrieNode PASSBASED *) (*pbpLower))->GetKey()) > *(pNode->GetKey()))
|
|
{
|
|
// insert before
|
|
InsertIntoLinkArray(pbpLower,
|
|
(TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pNode),
|
|
iNumLinks - (pbpLower - pStart));
|
|
}
|
|
else
|
|
{
|
|
// insert after
|
|
InsertIntoLinkArray(pbpLower+1,
|
|
(TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pNode),
|
|
iNumLinks - (pbpLower+ 1 - pStart));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// Keep track of how many links
|
|
pRoot->IncrementLinks();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::CreateSuffixNode
|
|
//
|
|
// Synopsis: Creates a suffix node from the current node. A suffix node is
|
|
// the same node except with the bytes that are the same chopped off the beginning
|
|
// of the key
|
|
//
|
|
// Arguments: [bBytesDifferent] - the number of bytes which make up the suffix
|
|
// [alloc] - a memory allocator to use
|
|
//
|
|
// Returns: pointer to a TrieNode, which is the suffix node
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CMapGuidToGuidBase::TrieNode *CMapGuidToGuidBase::TrieNode::CreateSuffixNode(BYTE bBytesDifferent,
|
|
CAllocFunctor &alloc)
|
|
{
|
|
TrieNode *pNewNode;
|
|
|
|
if(IsLeaf())
|
|
{
|
|
// Create a Suffix leaf
|
|
pNewNode = (TrieNode *) alloc.Alloc(GetNodeSize(bBytesDifferent, TRUE, 0));
|
|
|
|
if(pNewNode == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
pNewNode->SetLeaf(TRUE);
|
|
pNewNode->SetKeyBytes(bBytesDifferent);
|
|
pNewNode->SetLinks(0);
|
|
memcpy(pNewNode->GetKey(), GetKey()+(NumKeyBytes() - bBytesDifferent), bBytesDifferent);
|
|
*(pNewNode->GetData()) = *(GetData());
|
|
}
|
|
else
|
|
{
|
|
// Create a Suffix Node
|
|
pNewNode = (TrieNode *) alloc.Alloc(GetNodeSize(bBytesDifferent, FALSE, FindLinkSize(NumLinks())));
|
|
|
|
if(pNewNode == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
pNewNode->SetKeyBytes(bBytesDifferent);
|
|
pNewNode->SetLeaf(FALSE);
|
|
pNewNode->SetLinks(NumLinks());
|
|
memcpy(pNewNode->GetKey(), GetKey()+(NumKeyBytes() - bBytesDifferent), bBytesDifferent);
|
|
memcpy(pNewNode->GetLinkStart(), GetLinkStart(), NumLinks()*sizeof(TrieNodeBasedPtr));
|
|
|
|
}
|
|
|
|
return pNewNode;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::CreateTrieNode (static)
|
|
//
|
|
// Synopsis: creates a trie Node with the passed data
|
|
//
|
|
// Arguments: [pbKey] - a pointer to key data (goes forward)
|
|
// [bKeyBytes] - how many bytes are in the key
|
|
// [bLinks] - how many links to allocated (must be power of 2)
|
|
// [alloc] - a memory allocator to use
|
|
//
|
|
// Returns: a pointer to a TrieNode filled with the above data
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CMapGuidToGuidBase::TrieNode *CMapGuidToGuidBase::TrieNode::CreateTrieNode(const BYTE *pbKey,
|
|
BYTE bKeyBytes,
|
|
BYTE bLinks,
|
|
CAllocFunctor &alloc)
|
|
{
|
|
TrieNode *pNode;
|
|
|
|
// if pbKey == NULL, bKeyBytes must = 0
|
|
Win4Assert(pbKey != NULL || (bKeyBytes == 0));
|
|
Win4Assert(bKeyBytes >= 0);
|
|
|
|
pNode = (TrieNode *) alloc.Alloc(GetNodeSize(bKeyBytes, FALSE, bLinks));
|
|
|
|
if(pNode == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
pNode->SetLeaf(FALSE);
|
|
pNode->SetKeyBytes(bKeyBytes);
|
|
pNode->SetLinks(0);
|
|
memcpy(pNode->GetKey(), pbKey, bKeyBytes);
|
|
|
|
return pNode;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::CreateTrieLeaf (static)
|
|
//
|
|
// Synopsis: creates a Leaf node with the passed data
|
|
//
|
|
// Arguments: [pbKey] - a pointer to the key data (goes backwards)
|
|
// [bKeyBytes] - how many bytes are in the key
|
|
// [data] - a GUIDIndex this key maps to.
|
|
// [alloc] - a memory allocator to use
|
|
//
|
|
// Returns: a pointer to a TrieNode structure filled with above data
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
CMapGuidToGuidBase::TrieNode *CMapGuidToGuidBase::TrieNode::CreateTrieLeaf(const BYTE *pbKey,
|
|
BYTE bKeyBytes,
|
|
GUIDIndex data,
|
|
CAllocFunctor &alloc)
|
|
{
|
|
Win4Assert(pbKey != NULL);
|
|
Win4Assert(bKeyBytes > 0);
|
|
|
|
TrieNode *pNode;
|
|
|
|
pNode = (TrieNode *) alloc.Alloc(GetNodeSize(bKeyBytes, TRUE, 0));
|
|
|
|
if(pNode == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
pNode->SetLeaf(TRUE);
|
|
pNode->SetKeyBytes(bKeyBytes);
|
|
pNode->SetLinks(0);
|
|
bmemcpy(pNode->GetKey(), pbKey, bKeyBytes);
|
|
*(pNode->GetData()) = data;
|
|
|
|
return pNode;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::AddKey (static)
|
|
//
|
|
// Synopsis: This function adds a key/GUIDBasedPtr pair to the passed trie.
|
|
//
|
|
// Arguments: [pBase] - the base of our shared memory block
|
|
// [pRoot] - the root node of the trie (explicit "this" pointer)
|
|
// [pbpPrev] - a handle to the previous reference to the root node,
|
|
// so that if AddLink requires us to update it, we can.
|
|
// [pbKey] - a pointer to the END of the key data, we add the key reversed!!!
|
|
// [data] - the GUIDIndex to map this key to
|
|
// [fReplace] - whether or not we should replace an existing entry
|
|
// [alloc] - a memory allocator to use
|
|
//
|
|
// Returns: S_OK if successful, S_FALSE if the key was already in the trie and fReplace == FALSE,
|
|
// appropriate error code otherwise
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CMapGuidToGuidBase::TrieNode::AddKey(void *pBase, TrieNode *pRoot, TrieNodeBasedPtr UNALIGNED *pbpPrev,
|
|
const BYTE *pbKey, GUIDIndex data, BOOL fReplace,
|
|
CAllocFunctor &alloc)
|
|
{
|
|
Win4Assert(pRoot != NULL && "Tried to add key to NULL trie");
|
|
Win4Assert(pbpPrev != NULL && "Backlink to Trie NULL");
|
|
Win4Assert(pbKey != NULL && "Pointer to key data NULL");
|
|
|
|
int numDifferent, nNodeKeyBytes, nKeyBytes;
|
|
BYTE *pbNodeKey;
|
|
TrieNode *pNextLevel, *pNewNode, *pPrefixNode, *pSuffixNode;
|
|
TrieNodeBasedPtr UNALIGNED *pbpLinkPointer;
|
|
TrieNodeBasedPtr bpDummy;
|
|
|
|
nKeyBytes = GUID_BYTES; // Every Key is a full GUID
|
|
pbNodeKey = pRoot->GetKey();
|
|
nNodeKeyBytes = pRoot->NumKeyBytes();
|
|
|
|
// while both keys are the same, traverse the trie
|
|
while((numDifferent = bmemcmp(pbNodeKey, pbKey, nNodeKeyBytes)) == 0)
|
|
{
|
|
Win4Assert(nKeyBytes >= nNodeKeyBytes);
|
|
|
|
// Key prefix is the same
|
|
if(nKeyBytes == nNodeKeyBytes) // that means these keys are *exactly* the same!!!
|
|
{ // so we might have to replace the key/data mapping
|
|
if(pRoot->IsDeleted() || fReplace)
|
|
{
|
|
Win4Assert(pRoot->IsLeaf());
|
|
// the leaf node is deleted, or the replace flag is set, we can write over the data map
|
|
*(pRoot->GetData()) = data;
|
|
pRoot->SetDeleted(FALSE); // this doesn't hurt if the node wasn't deleted in the first place
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return S_FALSE; // else we don't do anything
|
|
}
|
|
|
|
pbKey-= nNodeKeyBytes; // Chop off this part of the key, continue down the trie
|
|
nKeyBytes -= nNodeKeyBytes;
|
|
pNextLevel = BP_TO_P(TrieNode *, (TrieNode PASSBASED *) pRoot->GetLink(pBase, *pbKey, pbpLinkPointer));
|
|
|
|
if(pNextLevel == NULL) // no next level, create new leaf here
|
|
{
|
|
HRESULT hr;
|
|
|
|
pNewNode = CreateTrieLeaf(pbKey, nKeyBytes, data, alloc);
|
|
|
|
if(pNewNode == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = AddLink(pBase, pRoot, pNewNode, &bpDummy, alloc);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
if(hr == S_FALSE)
|
|
{
|
|
// had to allocate a new node (ran out of links), reattatch to previous link
|
|
*pbpPrev = bpDummy;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
pRoot = pNextLevel;
|
|
pbpPrev = pbpLinkPointer;
|
|
pbNodeKey = pRoot->GetKey();
|
|
nNodeKeyBytes = pRoot->NumKeyBytes();
|
|
}
|
|
|
|
// we have to split the tree up
|
|
Win4Assert(*pbNodeKey == *pbKey && "Took wrong path in Trie"); // if this isn't true, something's really screwed up
|
|
|
|
// We create three nodes : a prefix node, containing the part of the key similar both to the existing
|
|
// GUIDs in the trie and the new GUID we are adding
|
|
// a new node, containing the part of the new GUID that's DIFFERENT from the rest
|
|
// a suffix node, containg the part of the old GUID subtrie that's different from the new GUID
|
|
pSuffixNode = pRoot->CreateSuffixNode(numDifferent, alloc);
|
|
|
|
if(pSuffixNode == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pNewNode = CreateTrieLeaf(pbKey-(nNodeKeyBytes - numDifferent), nKeyBytes - (nNodeKeyBytes - numDifferent),
|
|
data, alloc);
|
|
|
|
if(pNewNode == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pPrefixNode = CreateTrieNode(pbNodeKey, (nNodeKeyBytes - numDifferent), NODE_LINKS, alloc);
|
|
|
|
if(pPrefixNode == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// Delete original node
|
|
alloc.Free(pRoot, GetNodeSize(pRoot->NumKeyBytes(), pRoot->IsLeaf(), FindLinkSize(pRoot->NumLinks())));
|
|
|
|
*pbpPrev = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pPrefixNode);
|
|
|
|
// This is the assumption we make, that each new node has at least 2 links pre-allocated
|
|
Win4Assert(NODE_LINKS >= 2);
|
|
|
|
// We add the link here without calling AddLink because we know that our newly created node
|
|
// has no existing links, and we can just stick the two in order
|
|
if(*(pSuffixNode->GetKey()) < *(pNewNode->GetKey()))
|
|
{
|
|
// suffix node goes before new node
|
|
*(pPrefixNode->GetLinkStart()) = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pSuffixNode);
|
|
pPrefixNode->IncrementLinks();
|
|
|
|
*(pPrefixNode->GetLinkStart()+1) = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pNewNode);
|
|
pPrefixNode->IncrementLinks();
|
|
}
|
|
else
|
|
{
|
|
// new node goes before suffix node
|
|
*(pPrefixNode->GetLinkStart()+1) = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pNewNode);
|
|
pPrefixNode->IncrementLinks();
|
|
|
|
*(pPrefixNode->GetLinkStart()) = (TrieNodeBasedPtr) P_TO_BP(TrieNode PASSBASED *, pSuffixNode);
|
|
pPrefixNode->IncrementLinks();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::RemoveKey (static)
|
|
//
|
|
// Synopsis: Given a key and a trie, removes the key from the trie
|
|
//
|
|
//
|
|
// Arguments: [pRoot] - the trie (explicit "this" pointer)
|
|
// [ppPrev] - a handle to the previous reference to the root node,
|
|
// so that if we need to update it, we can.
|
|
// [pbKey] - the key
|
|
//
|
|
// Returns: TRUE if we succeeded
|
|
// FALSE if we failed to find the key
|
|
//--------------------------------------------------------------------------
|
|
/*BOOL CMapGuidToGuidBase::TrieNode::RemoveKey(void *pBase, TrieNode *pRoot, const BYTE *pbKey)
|
|
{
|
|
int nKeyBytes = GUID_BYTES;
|
|
TrieNodeBasedPtr *ppDummy;
|
|
Win4Assert(pRoot != NULL);
|
|
Win4Assert(pbKey != NULL);
|
|
|
|
while(pRoot != NULL)
|
|
{
|
|
if(bmemcmp(pRoot->GetKey(), pbKey, pRoot->NumKeyBytes()))
|
|
{
|
|
return FALSE; // if the prefix of this node ain't the same as the prefix of the key
|
|
// then the key is not in the table
|
|
}
|
|
|
|
pbKey -= pRoot->NumKeyBytes();
|
|
nKeyBytes -= pRoot->NumKeyBytes();
|
|
|
|
Win4Assert(nKeyBytes >= 0);
|
|
|
|
if(nKeyBytes == 0) // then this should be a leaf node
|
|
{
|
|
Win4Assert(pRoot->IsLeaf());
|
|
|
|
if(!pRoot->IsDeleted())
|
|
{
|
|
pRoot->SetDeleted(TRUE); // set the flag on the node to deleted
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE; // node is already deleted
|
|
}
|
|
|
|
pRoot = pRoot->GetLink(pBase, *pbKey, ppDummy);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
*/
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::TraverseKey (static)
|
|
//
|
|
// Synopsis: Given a key, a trie, and a place to store data, find the data mapped to the key
|
|
//
|
|
// Arguments: [pBase] - the base pointer of our memory block
|
|
// [pRoot] - the trie to traverse (explicit "this" pointer)
|
|
// [pbKey] - a pointer to the key data
|
|
// [data] - a GUIDIndex ref to stick the data in if we succeed
|
|
//
|
|
// Returns: TRUE if we succeeded, then dwData has the GUIDIndex mapped to the passed key
|
|
// FALSE if we failed to find the key
|
|
//--------------------------------------------------------------------------
|
|
BOOL CMapGuidToGuidBase::TrieNode::TraverseKey(void *pBase, TrieNode *pRoot, const BYTE *pbKey,
|
|
GUIDIndex &data)
|
|
{
|
|
Win4Assert(pRoot != NULL && "Tried to traverse a NULL Trie");
|
|
Win4Assert(pbKey != NULL && "Pointer to key data is NULL");
|
|
int bKeyBytes = GUID_BYTES;
|
|
TrieNodeBasedPtr UNALIGNED *pbpDummy;
|
|
|
|
while(pRoot != NULL)
|
|
{
|
|
if(bmemcmp(pRoot->GetKey(), pbKey, pRoot->NumKeyBytes()))
|
|
{
|
|
return FALSE; // if the prefix of this node ain't the same as the prefix of the key
|
|
// then the key is not in the table
|
|
}
|
|
|
|
pbKey -= pRoot->NumKeyBytes();
|
|
bKeyBytes -= pRoot->NumKeyBytes();
|
|
|
|
Win4Assert(bKeyBytes >= 0 && "Too many key bytes in this Trie path");
|
|
|
|
if(bKeyBytes == 0) // then this should be a leaf node
|
|
{
|
|
Win4Assert(pRoot->IsLeaf() && "Ran out of key bytes before got to leaf");
|
|
|
|
if(pRoot->IsDeleted()) // is this node deleted
|
|
{
|
|
return FALSE; // if so, this map is not valid
|
|
}
|
|
|
|
data = *(pRoot->GetData());
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
pRoot = pRoot->GetLink(pBase, *pbKey, pbpDummy);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: TrieNode::CopyToSharedMem
|
|
//
|
|
// Synopsis: Copy a given trie from one memory block to another
|
|
//
|
|
// Arguments: [pNewBase] - the base of the destination memory block
|
|
// [pOldBase] - the base of the source memory block
|
|
// [pRoot] - the trie to copy
|
|
// [alloc] - the allocation functor to use to allocate memory
|
|
//
|
|
// Returns: a based pointer (off of pNewBase) to the newly copied trie
|
|
// NULL if we failed to copy the trie
|
|
//--------------------------------------------------------------------------
|
|
|
|
TrieNodeBasedPtr CMapGuidToGuidBase::TrieNode::CopyToSharedMem(void *pNewBase, void *pOldBase, TrieNode *pRoot,
|
|
CAllocFunctor &alloc)
|
|
{
|
|
// we use recursion here because it is more complex than simple tail recursion
|
|
// and a non-recursive implementation would be very confusing
|
|
// considering that there is a recursive depth of at most 16, this means this function
|
|
// could take a maximum of 7*4*16=448 bytes on the stack
|
|
TrieNode *pCopy;
|
|
|
|
Win4Assert(pRoot != NULL && "Tried to copy a NULL Trie to shared memory");
|
|
|
|
if(pRoot->IsLeaf())
|
|
{
|
|
// allocate shared memory
|
|
pCopy = (TrieNode *) alloc.Alloc(GetNodeSize(pRoot->NumKeyBytes(), TRUE, 0));
|
|
|
|
if(pCopy == NULL)
|
|
{
|
|
return (TrieNodeBasedPtr) BP_TO_P(TrieNode NEWBASED *, NULL);
|
|
}
|
|
|
|
// copy over data
|
|
memcpy(pCopy, pRoot, GetNodeSize(pRoot->NumKeyBytes(), TRUE, 0));
|
|
|
|
return (TrieNodeBasedPtr) P_TO_BP(TrieNode NEWBASED *, pCopy);
|
|
}
|
|
else
|
|
{
|
|
// allocate shared memory
|
|
pCopy = (TrieNode *) alloc.Alloc(GetNodeSize(pRoot->NumKeyBytes(), FALSE,
|
|
FindLinkSize(pRoot->NumLinks())));
|
|
|
|
if(pCopy == NULL)
|
|
{
|
|
return (TrieNodeBasedPtr) BP_TO_P(TrieNode NEWBASED *, NULL);
|
|
}
|
|
|
|
// copy over data
|
|
memcpy(pCopy, pRoot, sizeof(WORD)+pRoot->NumKeyBytes());
|
|
|
|
// recursively set links
|
|
for(int i = 0; i < pRoot->NumLinks(); i++)
|
|
{
|
|
(pCopy->GetLinkStart())[i] = CopyToSharedMem(pNewBase, pOldBase, BP_TO_P(TrieNode *,
|
|
(TrieNode OLDBASED *)(pRoot->GetLinkStart()[i])),
|
|
alloc);
|
|
if(BP_TO_P(TrieNode *, (TrieNode NEWBASED *) (pCopy->GetLinkStart())[i]) == NULL)
|
|
{
|
|
return (TrieNodeBasedPtr) BP_TO_P(TrieNode NEWBASED *, NULL);
|
|
}
|
|
}
|
|
|
|
return (TrieNodeBasedPtr) P_TO_BP(TrieNode NEWBASED *, pCopy);
|
|
}
|
|
}
|
|
|
|
|
|
// *** CPSClsidTbl *** (DLL)
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CPSClsidTbl::Initialize
|
|
//
|
|
// Synopsis: Initializes the client side of the guid->guid map
|
|
//
|
|
// Arguments: [pscMapName] - name of this stack, used to create a shared stack
|
|
//
|
|
// Returns: appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CPSClsidTbl::Initialize(void *pBase)
|
|
{
|
|
HRESULT hr;
|
|
|
|
CairoleDebugOut((DEB_ITRACE, "CPSClsidTbl::Initialize(pBase = %p)\n", pBase));
|
|
|
|
hr = CMapGuidToGuidBase::Initialize(pBase);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
// Get a pointer to our shared memory header
|
|
m_pHeader = (SharedMemHeader *) m_pMemBase;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CPSClsidTbl::Find
|
|
//
|
|
// Synopsis: Given a GUID key, looks for the data mapped to it
|
|
//
|
|
// Arguments: [refguid] - a C++ reference to a GUID structure
|
|
// [pGuidOut] - a GUID * to store the data in
|
|
//
|
|
// Returns: a pointer to the data (really pGuidOut)
|
|
// NULL if guid was not found
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CPSClsidTbl::Find(REFGUID srcguid, GUID *pGuidOut) const
|
|
{
|
|
GUIDIndex iGuid;
|
|
HRESULT hr;
|
|
|
|
SETUP_BASE_POINTER();
|
|
|
|
if(IsFull()) // initialize hr to error value
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hr = REGDB_E_IIDNOTREG;
|
|
}
|
|
|
|
if(TrieNode::TraverseKey(m_pMemBase, BP_TO_P(TrieNode *, (TrieNode PASSBASED *)m_pHeader->m_bpTrie),
|
|
((const BYTE *)&srcguid)+GUID_BYTES-1, iGuid))
|
|
{
|
|
if(m_pHeader->m_GUIDs.GetGuid(m_pMemBase, iGuid, *pGuidOut))
|
|
{
|
|
hr = S_OK; // set hr to OK
|
|
}
|
|
else
|
|
{
|
|
CairoleDebugOut((DEB_IWARN, "CPSClsidTbl: Found GUID %I in table, but couldn't find CLSID at %d\n",
|
|
srcguid, iGuid));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CairoleDebugOut((DEB_IWARN, "CPSClsidTbl: Couldn't find GUID - %I\n", &srcguid));
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// *** CScmPSClsidTbl *** (SCM)
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CScmPSClsidTbl::Initialize
|
|
//
|
|
// Synopsis: Initializes the server side of the guid->guid map
|
|
//
|
|
// Arguments: [pscMapName] - name of this stack, used to create a shared stack
|
|
//
|
|
// Returns: appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CScmPSClsidTbl::Initialize()
|
|
{
|
|
HRESULT hr;
|
|
|
|
CairoleDebugOut((DEB_ITRACE, "CScmPSClsidTbl::Initialize()\n"));
|
|
|
|
hr = CMapGuidToGuidBase::Initialize(NULL);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CScmPSClsidTbl::AddLocal
|
|
//
|
|
// Synopsis: Adds a key/data (GUID/GUIDBasedPtr) pair to internal dictionary
|
|
//
|
|
// Arguments: [guid] - a C++ reference to a GUID structure
|
|
// [dataGuid] - a GUID to map the GUID to
|
|
// [fReplace] - if TRUE, if the guid is already a key
|
|
// replace what it is mapped to with dataGuid
|
|
//
|
|
// Returns: TRUE if key/data pair was added to the dictionary
|
|
// FALSE if key was already in dictionary
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CScmPSClsidTbl::AddLocal(REFGUID keyGuid, REFGUID dataGuid, BOOL fReplace)
|
|
{
|
|
GUIDIndex iGuid;
|
|
CHeapAlloc heap(m_hHeap); // create allocation functor
|
|
void *pBase = NULL; // the base of our locally-created table
|
|
// we use this so we can support adding GUIDs to the table later, when it is in shared memory
|
|
|
|
CairoleDebugOut((DEB_ITRACE, "CScmPSClsidTbl::AddLocal called with keyGuid = %I, dataGuid = %I, fReplace =%d.\n"
|
|
, &keyGuid, &dataGuid, (DWORD) fReplace));
|
|
|
|
// Add guid to array of GUIDs
|
|
iGuid = m_pLocalHeader->m_GUIDs.AddGuid(pBase, dataGuid, heap);
|
|
|
|
if(iGuid == INVALID_GUID_INDEX)
|
|
{
|
|
m_pLocalHeader->m_fFull = TRUE; // we are out of memory
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
return TrieNode::AddKey(pBase, BP_TO_P(TrieNode *, (TrieNode PASSBASED *) m_pLocalHeader->m_bpTrie),
|
|
&m_pLocalHeader->m_bpTrie, ((const BYTE *)&keyGuid)+GUID_BYTES - 1,
|
|
iGuid, fReplace, heap);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: CScmPSClsidTbl::Delete
|
|
//
|
|
// Synopsis: Given a GUID key, removes it from the trie
|
|
//
|
|
// Arguments: [guid] - a C++ reference to a GUID structure
|
|
//
|
|
// Returns: TRUE if key/data pair was found and deleted
|
|
// FALSE if key was not found
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
/*BOOL CScmPSClsidTbl::Delete(REFGUID srcguid)
|
|
{
|
|
TrieNode *pRoot;
|
|
BYTE index;
|
|
|
|
SETUP_BASE_POINTER();
|
|
|
|
index = *(((const BYTE *)&srcguid)+GUID_BYTES - 1);
|
|
|
|
pRoot = BP_TO_P(TrieNode *, (TrieNode PASSBASED *) m_pHeader->m_pTries[index]);
|
|
|
|
if(pRoot == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TrieNode::RemoveKey(m_pMemBase, pRoot, ((const BYTE *)&srcguid)+GUID_BYTES-1);
|
|
}
|
|
*/
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CScmPSClsidTbl::CopytoSharedMem
|
|
//
|
|
// Synopsis: Copies a locally created GUID->GUID map into shared memory
|
|
//
|
|
// Arguments: [pBase] - base pointer of shared memory
|
|
// [alloc] - stack-based allocator of shared memory
|
|
//
|
|
// Returns: appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CScmPSClsidTbl::CopyToSharedMem(void *pBase, CSmStackAllocator &alloc)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
Win4Assert(m_hHeap != NULL);
|
|
CStackAlloc stack(alloc);
|
|
void *pOldBase = NULL;
|
|
|
|
// Allocate our shared memory header
|
|
m_pHeader = (SharedMemHeader *) alloc.Alloc(sizeof(SharedMemHeader));
|
|
|
|
if(m_pHeader == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
m_pMemBase = pBase;
|
|
m_pHeader->m_fFull = m_pLocalHeader->m_fFull;
|
|
|
|
// first copy over guids
|
|
hr = m_pLocalHeader->m_GUIDs.CopyToSharedMem(m_pMemBase, pOldBase, &(m_pHeader->m_GUIDs), stack);
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
// now copy over our trie
|
|
if( BP_TO_P(TrieNode *, (TrieNode OLDBASED *) m_pLocalHeader->m_bpTrie) != NULL)
|
|
{
|
|
m_pHeader->m_bpTrie = TrieNode::CopyToSharedMem(m_pMemBase, pOldBase,
|
|
BP_TO_P(TrieNode *, (TrieNode OLDBASED *) m_pLocalHeader->m_bpTrie), stack);
|
|
|
|
if(BP_TO_P(TrieNode *, (TrieNode PASSBASED *) m_pHeader->m_bpTrie) == NULL)
|
|
{
|
|
m_pHeader->m_fFull = TRUE;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pHeader->m_fFull = TRUE;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
// we are done
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CScmPSClsidTbl::InitTbl
|
|
//
|
|
// Synopsis: intializes the table
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns : appropriate status code
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CScmPSClsidTbl::InitTbl()
|
|
{
|
|
HKEY hKey;
|
|
FILETIME ftLastWrite;
|
|
WCHAR awName[MAX_PATH], awcsPSClsid[80];
|
|
WCHAR *pwcEndOfName;
|
|
GUID guidIID, guidCLSID;
|
|
DWORD cName = sizeof(awName);
|
|
DWORD iSubKey = 0;
|
|
LONG cbPSClsid = sizeof(awcsPSClsid);
|
|
void *pOldBase = NULL;
|
|
|
|
// Create a local heap to build the trie in
|
|
m_hHeap = HeapCreate(0, MAP_INITIAL_SIZE, MAP_MAX_SIZE);
|
|
|
|
if(m_hHeap == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// allocate our local header
|
|
m_pLocalHeader = (LocalMemHeader *) HeapAlloc(m_hHeap, 0, sizeof(LocalMemHeader));
|
|
|
|
if(m_pLocalHeader == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
m_pLocalHeader->m_fFull = FALSE;
|
|
|
|
m_pLocalHeader->m_GUIDs.Initialize();
|
|
TrieNode *pNode = TrieNode::CreateTrieNode(NULL, 0, NODE_LINKS, CHeapAlloc(m_hHeap));
|
|
m_pLocalHeader->m_bpTrie = (TrieNodeBasedPtr) P_TO_BP(TrieNode OLDBASED *, pNode);
|
|
|
|
if(BP_TO_P(TrieNode *, (TrieNode OLDBASED *) m_pLocalHeader->m_bpTrie) == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// enumerate the interface keys in the registry and create a table
|
|
// entry for each interface that has a ProxyStubClsid32 entry.
|
|
|
|
#ifdef _CHICAGO_
|
|
if (RegOpenKeyExA(HKEY_CLASSES_ROOT, tszInterface, NULL, KEY_READ, &hKey)
|
|
== ERROR_SUCCESS)
|
|
#else //_CHICAGO_
|
|
if (RegOpenKeyEx(HKEY_CLASSES_ROOT, tszInterface, NULL, KEY_READ, &hKey)
|
|
== ERROR_SUCCESS)
|
|
#endif //_CHICAGO_
|
|
|
|
{
|
|
while (RegEnumKeyEx(hKey, iSubKey, awName, &cName,
|
|
NULL, NULL, NULL, &ftLastWrite) == ERROR_SUCCESS)
|
|
{
|
|
// Get data from registry for this interface
|
|
|
|
// This variable is used below to overwrite the ProxyStubClsid32
|
|
pwcEndOfName = awName + lstrlenW(awName);
|
|
|
|
lstrcatW(awName, wszProxyStubClsid);
|
|
|
|
if (RegQueryValue(hKey, awName, awcsPSClsid, &cbPSClsid)
|
|
== ERROR_SUCCESS)
|
|
{
|
|
// Convert registry string formats to GUID formats
|
|
*pwcEndOfName = 0;
|
|
|
|
if (GUIDFromString(awName, &guidIID))
|
|
{
|
|
if (GUIDFromString(awcsPSClsid, &guidCLSID))
|
|
{
|
|
|
|
if (FAILED(AddLocal(guidIID, guidCLSID, TRUE)))
|
|
{
|
|
// we ran out of space in the cache table, exit
|
|
// now to avoid doing anymore work
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// There wasn't a ProxyStubClsid32 for this interface.
|
|
// Because many applications install with interfaces
|
|
// that are variations on IDispatch, we are going to check
|
|
// to see if there is a ProxyStubClsid. If there is, and its
|
|
// class is that of IDispatch, then the OLE Automation DLL is
|
|
// the correct one to use. In that particular case, we will
|
|
// pretend that ProxyStubClsid32 existed, and that it is
|
|
// for IDispatch.
|
|
//
|
|
|
|
// Copy over ProxyStubClsid
|
|
|
|
lstrcpyW(pwcEndOfName,wszProxyStubClsid16);
|
|
|
|
if (RegQueryValue(hKey, awName, awcsPSClsid, &cbPSClsid)
|
|
== ERROR_SUCCESS)
|
|
{
|
|
// Convert registry string formats to GUID formats
|
|
if (GUIDFromString(awcsPSClsid, &guidCLSID))
|
|
{
|
|
//
|
|
// If the clsid for the proxy stub is that of
|
|
// IDispatch, then register it.
|
|
//
|
|
*pwcEndOfName = 0;
|
|
if (!memcmp(&guidCLSID,&CLSID_PSDispatch, sizeof(GUID)) &&
|
|
GUIDFromString(awName, &guidIID))
|
|
{
|
|
|
|
if (FAILED(AddLocal(guidIID, guidCLSID, TRUE)))
|
|
{
|
|
// we ran out of space in the cache table, exit
|
|
// now to avoid doing anymore work
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
iSubKey++;
|
|
cName = sizeof(awName);
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|