able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/gina/snapins/ade/msiclass.cpp

1493 lines
37 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 2001.
//
// File: msiclass.cpp
//
// Contents: msi class collection abstraction
//
// Classes:
//
//
// History: 4-14-2000 adamed Created
//
//---------------------------------------------------------------------------
#include "precomp.hxx"
WCHAR* CClassCollection::_wszQueries[ TYPE_COUNT ] =
{
QUERY_EXTENSIONS,
QUERY_CLSIDS,
QUERY_VERSION_INDEPENDENT_PROGIDS
};
CClassCollection::CClassCollection( PACKAGEDETAIL* pPackageDetail ) :
_pPackageDetail( pPackageDetail ),
_cMaxClsids( 0 ),
_cMaxExtensions( 0 ),
_InstallLevel( 0 )
{
//
// All memory referenced by the pPackageDetail must be
// freed by the caller after the GetClasses method is called,
// even if the call fails.
//
//
// We need to clear any existing class information in the
// PACKAGEDETAIL structure since we are going to overwrite
// it eventually anyway
//
//
// First clear the clsid's
//
DWORD iClass;
//
// Free each individual class
//
for ( iClass = 0; iClass < _pPackageDetail->pActInfo->cClasses; iClass++ )
{
FreeClassDetail( &(_pPackageDetail->pActInfo->pClasses[ iClass ]) );
}
//
// Now free the vector that held the classes
//
LocalFree( _pPackageDetail->pActInfo->pClasses );
//
// Set our vector reference to the initial state of none
//
_pPackageDetail->pActInfo->pClasses = NULL;
//
// Set the initial state of no clsid's since they have all been freed
//
_pPackageDetail->pActInfo->cClasses = 0;
//
// Now clear the extensions
//
DWORD iExtension;
//
// For each individual extension
//
for ( iExtension = 0; iExtension < _pPackageDetail->pActInfo->cShellFileExt; iExtension++ )
{
LocalFree( _pPackageDetail->pActInfo->prgShellFileExt[ iExtension ] );
}
//
// Free the vector that held the extensions
//
LocalFree( _pPackageDetail->pActInfo->prgShellFileExt );
//
// Also destroy the vector that held extension priorities
//
LocalFree( _pPackageDetail->pActInfo->prgPriority );
//
// Set our vector references to the initial state of none
//
_pPackageDetail->pActInfo->prgShellFileExt = NULL;
_pPackageDetail->pActInfo->prgPriority = NULL;
//
// Set the initial state of no file extensions since they have all been freed
//
_pPackageDetail->pActInfo->cShellFileExt = 0;
}
HRESULT
CClassCollection::GetClasses( BOOL bFileExtensionsOnly )
{
HRESULT hr;
LONG Status;
DWORD cTransforms;
//
// This method obtains the class metadata from an msi package + transforms.
// The goal is to approximate the set of class data that would be advertised
// on any system (regardless of system configuration) if the package were
// advertised.
//
//
// The classes will all be stored in the PACKAGEDETAIL structure. The caller
// must free this memory after finishing with the structure, even if this
// method fails
//
//
// First, we must create a database representation of the package + transforms
//
//
// The source list vector contains the package + transforms in application order --
// we must subtract one source since the original package is included in the list
//
cTransforms = _pPackageDetail->cSources - 1;
//
// Now we create a database out of the package plus transforms. Since the
// first item in the source list is the package, we pass that in as the package,
// and all other items after it in the vector are passed in as the transform vector
//
Status = _Database.Open(
_pPackageDetail->pszSourceList[0],
cTransforms,
cTransforms ? &(_pPackageDetail->pszSourceList[1]) : NULL );
if ( ERROR_SUCCESS == Status )
{
//
// We've successfully opened the package, now obtain its friendly name.
//
Status = GetFriendlyName();
if (ERROR_SUCCESS == Status)
{
//
// Now obtain its install level.
// The install level affects whether or not a class will get advertised
//
Status = GetInstallLevel();
}
if ( ERROR_SUCCESS == Status )
{
//
// Now that we know the install level of the package, we have
// enough information to flag each advertisable feature in the database.
// We need this because a class is only advertised if its associated
// feature is advertised.
//
Status = FlagAdvertisableFeatures();
}
//
// We may now retrieve the set of classes that will be advertised based
// on the set of advertised features we flagged earlier. We care only
// about 3 types of classes: Clsid's, ProgId's, and File Extenions.
//
if ( ! bFileExtensionsOnly )
{
if ( ERROR_SUCCESS == Status )
{
Status = GetClsids();
}
if ( ERROR_SUCCESS == Status )
{
Status = GetProgIds();
}
}
if ( ERROR_SUCCESS == Status )
{
Status = GetExtensions();
}
LONG StatusFree;
//
// We must remove the scratch flags we added to the database
//
StatusFree = RemoveAdvertisableFeatureFlags();
if ( ERROR_SUCCESS == Status )
{
//
// Take care to preserve the return value -- a failure
// before cleaning up the database takes precedence over
// a failure in cleaning up the database.
//
Status = StatusFree;
}
}
return HRESULT_FROM_WIN32(Status);
}
LONG
CClassCollection::GetExtensions()
{
LONG Status;
BOOL bTableExists;
//
// First check to see if we even have an extension table to query
//
Status = _Database.TableExists( TABLE_FILE_EXTENSIONS, &bTableExists );
if ( ( ERROR_SUCCESS == Status ) && bTableExists )
{
//
// Set up a destination in the user's PACKAGEDETAIL structure
// for the shell extension class data
//
DataDestination Destination(
TYPE_EXTENSION,
(void**)&(_pPackageDetail->pActInfo->prgShellFileExt),
&(_pPackageDetail->pActInfo->cShellFileExt),
(UINT*) &_cMaxExtensions);
//
// Now retrieve the shell extensions
//
Status = GetElements(
TYPE_EXTENSION,
&Destination );
if ( ERROR_SUCCESS == Status )
{
//
// We've successfully retrieved the shell extensions --
// the caller also expects a parallel array of priorities
// with each shell extension -- the values are unimportant
// since the caller will fill those in, but the memory must
// exist, so we will allocate it.
//
_pPackageDetail->pActInfo->prgPriority =
(UINT*) LocalAlloc(
0,
sizeof(UINT) *
_pPackageDetail->pActInfo->cShellFileExt );
if ( ! _pPackageDetail->pActInfo->prgPriority )
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
}
}
return Status;
}
LONG
CClassCollection::GetClsids()
{
LONG Status;
BOOL bTableExists;
//
// First check to see if we even have a clsid table to query
//
Status = _Database.TableExists( TABLE_CLSIDS, &bTableExists );
if ( ( ERROR_SUCCESS == Status ) && bTableExists )
{
//
// Set the destination for the clsid's to a location
// in the caller's PACKAGEDETAIL structure
//
DataDestination Destination(
TYPE_CLSID,
(void**)&(_pPackageDetail->pActInfo->pClasses),
&(_pPackageDetail->pActInfo->cClasses),
(UINT*) &_cMaxClsids);
//
// Now retrieve the clsid's for each package
//
Status = GetElements(
TYPE_CLSID,
&Destination );
}
return Status;
}
LONG
CClassCollection::GetProgIds()
{
LONG Status;
BOOL bTableExists;
//
// First check to see if we even have a ProgId table to query
//
Status = _Database.TableExists( TABLE_PROGIDS, &bTableExists );
if ( ( ERROR_SUCCESS == Status ) && bTableExists )
{
//
// This method MUST be called AFTER GetClsids -- progid's
// are stored within their associated clsid's, so we will
// not have a place to store the progid's unless we've
// already obtained the clsid's.
//
//
// At this point, we know only that we want to retrieve ProgId's --
// we do not know their destination because this differs for
// each progid depending on the associated clsid -- the NULL
// parameters indicate that some callee will need to determine
// the location for this data.
//
DataDestination Destination(
TYPE_PROGID,
NULL,
NULL,
NULL);
//
// Retrieve the progid's into the appropriate locations in the structure
//
Status = GetElements(
TYPE_PROGID,
&Destination );
}
return ERROR_SUCCESS;
}
LONG
CClassCollection::GetElements(
DWORD dwType,
DataDestination* pDestination )
{
LONG Status;
CMsiQuery ElementQuery;
//
// Perform the query for the class elements
//
Status = _Database.GetQueryResults(
_wszQueries[ dwType ],
&ElementQuery);
if ( ERROR_SUCCESS != Status )
{
return Status;
}
for (;;)
{
//
// We've obtained the results -- now we enumerate them so
// that we can persist them in the caller's PACKAGEDETAIL
// structure.
//
//
// Note that we start a new scope so that our record object
// will automatically free its resources
//
{
CMsiRecord CurrentRecord;
//
// Enumerate the next record in the query result set
//
Status = ElementQuery.GetNextRecord( &CurrentRecord );
if ( ERROR_SUCCESS != Status )
{
if ( ERROR_NO_MORE_ITEMS == Status )
{
Status = ERROR_SUCCESS;
}
break;
}
//
// Now attempt to add the class data from this record into
// the PACKAGEDETAIL structure
//
Status = ProcessElement(
dwType,
&CurrentRecord,
pDestination);
}
if ( ERROR_SUCCESS != Status )
{
break;
}
}
return Status;
}
LONG
CClassCollection::FlagAdvertisableFeatures()
{
LONG Status;
CMsiQuery FeatureQueryCreate;
//
// We will attempt to mark each feature in the database
// with a flag indicating whether or not it will be advertised
//
//
// First, add a column to the feature table of the database
// so that we can use the column to flag whether or not the
// feature is advertised.
//
Status = _Database.GetQueryResults(
QUERY_ADVERTISED_FEATURES_CREATE,
&FeatureQueryCreate);
CMsiQuery FeatureQueryInit;
//
// Now intialize the new column's flags to 0 which
// indicates that no features will be advertised (yet)
//
if ( ERROR_SUCCESS == Status )
{
Status = _Database.GetQueryResults(
QUERY_ADVERTISED_FEATURES_INIT,
&FeatureQueryInit);
}
CMsiQuery AllFeatures;
//
// Now we perform the query to retrieve all features --
// records in this query will contain the newly added
// flag column.
//
if ( ERROR_SUCCESS == Status )
{
Status = _Database.GetQueryResults(
QUERY_ADVERTISED_FEATURES_RESULT,
&AllFeatures);
}
CMsiQuery SetAdvertised;
//
// Create a query that will allow us to set the flag --
// this query is not yet computed, simply initialized
//
if ( ERROR_SUCCESS == Status )
{
Status = _Database.OpenQuery(
QUERY_FEATURES_SET,
&SetAdvertised);
}
//
// Now we enumerate through all the features and
// set the flag for each feature that passes the tests
// for advertisability.
//
for (; ERROR_SUCCESS == Status ;)
{
CMsiRecord CurrentRecord;
BOOL bAdvertised;
//
// Retrieve the current feature
//
Status = AllFeatures.GetNextRecord(
&CurrentRecord);
if ( ERROR_SUCCESS != Status )
{
if ( ERROR_NO_MORE_ITEMS == Status )
{
Status = ERROR_SUCCESS;
}
break;
}
//
// Determine whether or not this feature should be advertised
//
Status = GetFeatureAdvertiseState(
&CurrentRecord,
&bAdvertised );
if ( ( ERROR_SUCCESS == Status ) &&
bAdvertised )
{
//
// This feature is advertisable -- use our SetAdvertised query
// to set the advertisability flag to true.
//
Status = SetAdvertised.UpdateQueryFromFilter( &CurrentRecord );
}
}
return Status;
}
LONG
CClassCollection::RemoveAdvertisableFeatureFlags()
{
LONG Status;
CMsiQuery FreeQuery;
//
// Retrieving the results of this query will
// eliminate the extra flag column we added
// to the feature table to flag advertisable
// features.
//
Status = _Database.GetQueryResults(
QUERY_ADVERTISED_FEATURES_DESTROY,
&FreeQuery);
return Status;
}
LONG
CClassCollection::GetInstallLevel()
{
LONG Status;
CMsiQuery InstallLevelQuery;
//
// Perform a query which retrieves the install level
// property from the package's property table
//
Status = _Database.GetQueryResults(
QUERY_INSTALLLEVEL,
&InstallLevelQuery);
CMsiRecord InstallLevelRecord;
//
// This query should only have one record in it since
// it was targeted at the specific record for install level --
// we now read that record
//
if ( ERROR_SUCCESS == Status )
{
Status = InstallLevelQuery.GetNextRecord(
&InstallLevelRecord);
}
if ( ERROR_SUCCESS == Status )
{
CMsiValue InstallLevelProperty;
//
// We now attempt to obtain the installlevel property value
// from the retrieved record.
//
Status = InstallLevelRecord.GetValue(
CMsiValue::TYPE_DWORD,
PROPERTY_COLUMN_VALUE,
&InstallLevelProperty);
if ( ERROR_SUCCESS == Status )
{
//
// We've successfully obtained the value, so we set it
//
_InstallLevel = InstallLevelProperty.GetDWORDValue();
}
}
else if ( ERROR_NO_MORE_ITEMS == Status )
{
//
// This will only happen if the install level property
// is not present. As fundamental as this property is,
// some packages do not specify it. The Darwin engine
// treats this case as an implicit install level of 1, so
// we must do the same here
//
_InstallLevel = 1;
Status = ERROR_SUCCESS;
}
return Status;
}
LONG
CClassCollection::GetFriendlyName()
{
LONG Status;
CMsiQuery FriendlyNameQuery;
//
// Perform a query which retrieves the install level
// property from the package's property table
//
Status = _Database.GetQueryResults(
QUERY_FRIENDLYNAME,
&FriendlyNameQuery);
CMsiRecord FriendlyNameRecord;
//
// This query should only have one record in it since
// it was targeted at the specific record
// we now read that record
//
if ( ERROR_SUCCESS == Status )
{
Status = FriendlyNameQuery.GetNextRecord(
&FriendlyNameRecord);
}
if ( ERROR_SUCCESS == Status )
{
CMsiValue FriendlyNameProperty;
//
// We now attempt to obtain the property value
// from the retrieved record.
//
Status = FriendlyNameRecord.GetValue(
CMsiValue::TYPE_STRING,
PROPERTY_COLUMN_VALUE,
&FriendlyNameProperty);
if ( ERROR_SUCCESS == Status )
{
//
// We've successfully obtained the value, so we set it
//
CString szName = FriendlyNameProperty.GetStringValue();
OLESAFE_DELETE(_pPackageDetail->pszPackageName);
OLESAFE_COPYSTRING(_pPackageDetail->pszPackageName, szName);
}
}
return Status;
}
LONG
CClassCollection::GetFeatureAdvertiseState(
CMsiRecord* pFeatureRecord,
BOOL* pbAdvertised )
{
LONG Status;
CMsiValue Attributes;
CMsiValue InstallLevel;
//
// Set the out paramter's initial value to FALSE,
// indicating that the feature is not advertised
//
*pbAdvertised = FALSE;
//
// The Attributes column of the feature table
// contains a flag indicating that a feature
// should be not advertised
//
Status = pFeatureRecord->GetValue(
CMsiValue::TYPE_DWORD,
FEATURE_COLUMN_ATTRIBUTES,
&Attributes);
if ( ERROR_SUCCESS == Status )
{
//
// If the disable advertise flag is set, this feature
// cannot be advertised
//
if ( Attributes.GetDWORDValue() & MSI_DISABLEADVERTISE )
{
return ERROR_SUCCESS;
}
//
// The disable flag was not set -- that still does not mean that
// the feature is advertised -- we must check the install level.
// We retrieve the install level for this feature here
//
Status = pFeatureRecord->GetValue(
CMsiValue::TYPE_DWORD,
FEATURE_COLUMN_LEVEL,
&InstallLevel);
}
if ( ERROR_SUCCESS == Status )
{
DWORD dwInstallLevel;
//
// Obtain the value for the install level so
// we can compare against the package install level
//
dwInstallLevel = InstallLevel.GetDWORDValue();
//
// An install level of 0 indicates that the package will
// not be advertised. The install level of the feature
// must be no higher than the package's global install
// level
//
if ( ( 0 != dwInstallLevel ) &&
( dwInstallLevel <= _InstallLevel ) )
{
//
// This feature passes the tests -- set the out parameter
// to TRUE to indicate that the feature should be advertised
//
*pbAdvertised = TRUE;
}
}
return Status;
}
LONG
CClassCollection::AddElement(
void* pvDataSource,
DataDestination* pDataDestination)
{
DWORD* pcMax;
BYTE* pNewResults;
DWORD cCurrent;
//
// We attempt to add an element to a vector
//
//
// Set the count for how many elements are stored in the vector to
// that specified by the caller
//
cCurrent = *(pDataDestination->_pcCurrent);
//
// Set the element count for the maximum number of elements that
// will fit in the vector currently to that specified by the caller
//
pcMax = (DWORD*) pDataDestination->_pcMax;
//
// Set our results to point to the vector specified by the caller
//
pNewResults = (BYTE*) pDataDestination->_ppvData;
//
// If we already have the maximum number of elements in the vector,
// we will have to make room for more
//
if ( *pcMax >= cCurrent)
{
DWORD cbSize;
//
// Calculate the new size in bytes so that we can ask the system
// for memory. We take our current size in elements and add on a fixed
// allocation increment. The caller has specified the size
// of each individual element, so we use that to turn the number
// of elements to a memory size.
//
cbSize = ( *pcMax + CLASS_ALLOC_SIZE ) *
pDataDestination->_cbElementSize;
//
// Make the request for memory
//
pNewResults = (BYTE*) LocalAlloc( 0, cbSize );
if ( ! pNewResults )
{
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// Clear the memory -- any data structures embedded in the element
// will have NULL references and thus will be properly initialized
//
memset( pNewResults, 0, cbSize );
//
// If the original maximum size of the vector was nonzero, then we must
// copy to original contents of the vector to the newly allocated memory
// location.
//
if ( *pcMax )
{
memcpy(
pNewResults,
*(pDataDestination->_ppvData),
*pcMax * pDataDestination->_cbElementSize);
}
//
// Free the original vector as it is no longer needed
//
LocalFree( *(pDataDestination->_ppvData) );
//
// Change the caller's reference to point to the new vector
//
*(pDataDestination->_ppvData) = pNewResults;
//
// Set the new maximum size (in elements) to that of the newly allocated vector
//
*pcMax += CLASS_ALLOC_SIZE;
}
//
// At this point, we know we have a memory location in the vector into
// which we can safely copy the new element
//
memcpy(
pNewResults + ( cCurrent * pDataDestination->_cbElementSize ),
pvDataSource,
pDataDestination->_cbElementSize);
//
// Update the count of elements currently stored in the vector
//
*(pDataDestination->_pcCurrent) = cCurrent + 1;
return ERROR_SUCCESS;
}
LONG
CClassCollection::ProcessElement(
DWORD dwType,
CMsiRecord* pRecord,
DataDestination* pDataDestination)
{
LONG Status = ERROR_SUCCESS;
void* pvData;
WCHAR* wszData;
CLASSDETAIL ClassDetail;
pvData = NULL;
wszData = NULL;
//
// We attempt to create a new class element based
// on the record passed in by the caller, and then
// add that element to the caller's PACKAGEDETAIL structure
//
//
// The type of element to be added depends on the type
// of class requested by the caller. The pvData variable
// will point to the element to be added if we can successfully
// create a representation for it.
//
switch ( dwType )
{
case TYPE_EXTENSION:
//
// Get a file extension representation from the record --
// note that wszData points to memory allocated by the callee
// on success, so it must be freed by this function.
//
Status = ProcessExtension(
pRecord,
&wszData);
if ( ERROR_SUCCESS == Status )
{
pvData = &wszData;
}
break;
case TYPE_CLSID:
//
// Get a clsid representation from the record --
// in this case, the ClassDetail itself does not
// need to be freed since it does not contain any references
// to memory after this call
//
BOOL bIgnoreClsid;
Status = ProcessClsid(
pRecord,
&ClassDetail,
&bIgnoreClsid);
if ( ERROR_SUCCESS == Status )
{
//
// Check to see if we should add this clsid -- we may be prohibited from
// this because it is a duplicate of an exsting clsid, which would be
// redundant and furthermore the PACKAGEDETAIL format requires
// that all (clsid, clsctx) pairs be unique. Or the clsid itself
// may have an unsupported clsctx. This is not a failure
// case, so we return success here and simply avoid addding this
// class
//
if ( bIgnoreClsid )
{
return ERROR_SUCCESS;
}
pvData = &ClassDetail;
}
break;
case TYPE_PROGID:
//
// Get a progid representation from the record. In addition
// to retrieving the progid in the form of an allocated string
// which must be freed by this funciton, we also retrieve the
// location at which to add the progid to the caller's
// PACKAGEDETAIL structure. This is necessary since the
// ProgId must be part of the CLASSDETAIL structure with which
// it is associated.
//
Status = ProcessProgId(
pRecord,
pDataDestination,
&wszData);
if ( ( ERROR_SUCCESS == Status ) &&
wszData )
{
pvData = &wszData;
}
break;
default:
ASSERT(FALSE);
break;
}
//
// If we were successful in obtaining a representation of the record
// that can be stored in the caller's PACKAGEDETAIL structure, attempt
// to add it to the structure
//
if ( pvData )
{
Status = AddElement(
pvData,
pDataDestination);
}
//
// Be sure that in the failure case, we free any memory
// that may have been allocated.
//
if ( ERROR_SUCCESS != Status )
{
if (wszData )
{
LocalFree( wszData );
}
}
return Status;
}
LONG
CClassCollection::ProcessExtension(
CMsiRecord* pRecord,
WCHAR** ppwszExtension)
{
LONG Status;
CMsiValue FileExtension;
*ppwszExtension = NULL;
//
// We retrieve the actual file extension string
//
Status = pRecord->GetValue(
CMsiValue::TYPE_STRING,
EXTENSION_COLUMN_EXTENSION,
&FileExtension);
if ( ERROR_SUCCESS == Status )
{
//
// We have the value. Note that it does not contain
// an initial '.', but the usage of the PACKAGEDETAIL
// structure mandates that file extensions begin with the '.'
// char, so we will have to prepend the '.' here.
//
//
// First, get space for a copy of the string that includes
// the '.' as well as the zero terminator.
//
*ppwszExtension = (WCHAR*) LocalAlloc(
0,
(FileExtension.GetStringSize() + 1 + 1) * sizeof(WCHAR) );
if ( ! *ppwszExtension )
{
Status = ERROR_NOT_ENOUGH_MEMORY;
return Status;
}
//
// Set the first char to be '.'
//
**ppwszExtension = L'.';
//
// Now append the actual extension to the '.'
//
lstrcpy( *ppwszExtension + 1, FileExtension.GetStringValue() );
}
return Status;
}
LONG
CClassCollection::ProcessClsid(
CMsiRecord* pRecord,
CLASSDETAIL* pClsid,
BOOL* pbIgnoreClsid)
{
LONG Status;
DWORD dwClsCtx;
CMsiValue GuidString;
CMsiValue ClassContext;
//
// Clear the clsid to a safe state
//
memset( pClsid, 0, sizeof( *pClsid ) );
//
// Reset out parameters
//
*pbIgnoreClsid = FALSE;
dwClsCtx = 0;
//
// Retrieve the actual clsid
//
Status = pRecord->GetValue(
CMsiValue::TYPE_STRING,
CLSID_COLUMN_CLSID,
&GuidString);
if ( ERROR_SUCCESS == Status )
{
//
// Get the clsctx for this clsid
//
Status = pRecord->GetValue(
CMsiValue::TYPE_STRING,
CLSID_COLUMN_CONTEXT,
&ClassContext);
}
if ( ERROR_SUCCESS == Status )
{
CMsiValue Attribute;
WCHAR* wszClassContext;
DWORD dwInprocClsCtx;
dwInprocClsCtx = 0;
//
// Retrieve a string representation of the clsctx for this clsid
//
wszClassContext = ClassContext.GetStringValue();
//
// Now map the clsctx strings to COM CLSCTX_* values
//
if ( 0 == lstrcmpi( wszClassContext, COM_INPROC_CONTEXT) )
{
dwInprocClsCtx |= CLSCTX_INPROC_SERVER;
}
else if ( 0 == lstrcmpi( wszClassContext, COM_INPROCHANDLER_CONTEXT) )
{
dwInprocClsCtx |= CLSCTX_INPROC_HANDLER;
}
else if ( 0 == lstrcmpi( wszClassContext, COM_LOCALSERVER_CONTEXT) )
{
dwClsCtx |= CLSCTX_LOCAL_SERVER;
}
else if ( 0 == lstrcmpi( wszClassContext, COM_REMOTESERVER_CONTEXT) )
{
dwClsCtx |= CLSCTX_REMOTE_SERVER;
}
else
{
//
// If the clsctx is one we do not support, we will ignore it
//
*pbIgnoreClsid = TRUE;
return ERROR_SUCCESS;
}
BOOL b64Bit;
b64Bit = FALSE;
//
// We must disginguish between 32-bit and 64-bit in-process servers, since
// 64-bit Windows does not allows modules of different bitness to coexist in the
// same process. If this is an in-process component, we will also check to see
// whether it is 64-bit or not.
//
if ( ( dwInprocClsCtx & CLSCTX_INPROC_HANDLER ) ||
( dwInprocClsCtx & CLSCTX_INPROC_SERVER ) )
{
//
// The Attributes column of the record has a flag indicating bitness -- this
// will only fail if the property is NULL
//
Status = pRecord->GetValue(
CMsiValue::TYPE_DWORD,
CLSID_COLUMN_ATTRIBUTES,
&Attribute);
//
// Check the flag to see if this is 64-bit
//
if ( ERROR_SUCCESS == Status )
{
b64Bit = Attribute.GetDWORDValue() & MSI_64BIT_CLASS;
}
else
{
//
// This means the property is NULL, so we interpret that as
// meaning the application is not 64 bit
//
Status = ERROR_SUCCESS;
}
//
// Map this 64-bit clsctx to a custom (non-COM) CLSCTX that
// indicates that this is a 64-bit-only in-process class.
//
if ( ( ERROR_SUCCESS == Status ) && b64Bit )
{
if ( dwInprocClsCtx & CLSCTX_INPROC_SERVER )
{
dwClsCtx |= CLSCTX64_INPROC_SERVER;
}
if ( dwInprocClsCtx & CLSCTX_INPROC_HANDLER )
{
dwClsCtx |= CLSCTX64_INPROC_HANDLER;
}
}
}
//
// In the 32-bit case, just or in the values we already computed for
// inproc case
//
if ( ! b64Bit )
{
dwClsCtx |= dwInprocClsCtx;
}
}
//
// Check to see if this is a duplicate -- we do this because our query
// returned results distinct in (clsid, clsctx, attribute). Since we
// are mapping attribute to clsctx above and we only support 1 attribute
// flag (the 64-bit flag) out of several, we may end up with duplicate
// (clsid, clsctx) pairs, and the PACKAGEDETAIL format requires that
// we have unique (clsid, clsctx) pairs. Another way to get this would
// be if COM introduced new clsctx types which we did not support -- these
// would map to zero, and again we could have duplicates
//
if ( ERROR_SUCCESS == Status )
{
CLASSDETAIL* pClassDetail;
pClassDetail = NULL;
Status = FindClass(
GuidString.GetStringValue(),
&pClassDetail);
//
// If we already have an entry for this clsid, check to see if
// it has the same clsctx bits -- if so it is a duplicate entry
// and we will cease processing it
//
if ( ( ERROR_SUCCESS == Status ) && pClassDetail )
{
*pbIgnoreClsid = ( dwClsCtx & pClassDetail->dwComClassContext );
if ( *pbIgnoreClsid )
{
return ERROR_SUCCESS;
}
}
}
//
// Convert the clsid string to a guid as mandated by the
// CLASSDETAIL structure
//
if ( ERROR_SUCCESS == Status )
{
HRESULT hr;
hr = CLSIDFromString(
GuidString.GetStringValue(),
&(pClsid->Clsid));
if ( FAILED(hr) )
{
Status = ERROR_GEN_FAILURE;
}
}
//
// Set the clsctx we computed above.
//
if ( ERROR_SUCCESS == Status )
{
pClsid->dwComClassContext = dwClsCtx;
}
return Status;
}
LONG
CClassCollection::ProcessProgId(
CMsiRecord* pRecord,
DataDestination* pDataDestination,
WCHAR** ppwszProgId)
{
LONG Status;
CMsiValue ProgIdString;
CMsiValue ClsidString;
CLASSDETAIL* pClassDetail;
//
// We attempt to map a progid record to a
// clsid that we've already processed, since
// the progid will eventually need to go
// inside the clsid's structure.
//
*ppwszProgId = NULL;
pClassDetail = NULL;
//
// Retrieve the value for the progid itself
//
Status = pRecord->GetValue(
CMsiValue::TYPE_STRING,
PROGID_COLUMN_PROGID,
&ProgIdString);
//
// Retrieve the value of the clsid associated with
// the progid
//
if ( ERROR_SUCCESS == Status )
{
Status = pRecord->GetValue(
CMsiValue::TYPE_STRING,
PROGID_COLUMN_CLSID,
&ClsidString);
}
//
// We must find the existing CLASSDETAIL structure
// that we are maintaining for the progid since the
// progid must eventually be referenced in that structure.
//
if ( ERROR_SUCCESS == Status )
{
Status = FindClass(
ClsidString.GetStringValue(),
&pClassDetail);
}
if ( ERROR_SUCCESS == Status )
{
//
// If we have successfully found the class,
//
if ( pClassDetail )
{
//
// Give the caller the progid string since
// we know that we have a class in which
// to place it
//
*ppwszProgId = ProgIdString.DuplicateString();
if ( ! *ppwszProgId )
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
else
{
//
// Set the caller's data destination to that of the
// progid vector within the clsid associated with this progid
//
pDataDestination->_ppvData = (void**) &( pClassDetail->prgProgId );
pDataDestination->_pcCurrent = (UINT*) &( pClassDetail->cProgId );
pDataDestination->_pcMax = (UINT*) &( pClassDetail->cMaxProgId );
}
}
}
//
// On failure, free any resources we've allocated
//
if ( ( ERROR_SUCCESS != Status ) &&
*ppwszProgId )
{
LocalFree( *ppwszProgId );
}
return Status;
}
LONG
CClassCollection::FindClass(
WCHAR* wszClsid,
CLASSDETAIL** ppClass)
{
CLSID Clsid;
HRESULT hr;
//
// Attempt to find a CLASSDETAIL structure in the PACKAGEDETAIL structure
// for the clsid given in string form in wszClsid
//
*ppClass = NULL;
//
// The PACKAGEDETAIL structure stores the clsid in guid form,
// so we must convert the string to that form before searching
//
hr = CLSIDFromString(
wszClsid,
&Clsid);
if ( FAILED(hr) )
{
return ERROR_GEN_FAILURE;
}
UINT iClsid;
//
// We now perform a simple linear search for the clsid
//
for (
iClsid = 0;
iClsid < _pPackageDetail->pActInfo->cClasses;
iClsid++)
{
if ( IsEqualGUID(
_pPackageDetail->pActInfo->pClasses[iClsid].Clsid,
Clsid) )
{
*ppClass = &(_pPackageDetail->pActInfo->pClasses[iClsid]);
return ERROR_SUCCESS;
}
}
return ERROR_SUCCESS;
}
void
CClassCollection::FreeClassDetail( CLASSDETAIL* pClass )
{
DWORD iProgId;
//
// Free each individual progid string
//
for ( iProgId = 0; iProgId < pClass->cProgId; iProgId++ )
{
LocalFree( pClass->prgProgId[ iProgId ] );
}
//
// Free the array of progid strings
//
LocalFree( pClass->prgProgId );
}
DataDestination::DataDestination(
DWORD dwType,
void** prgpvDestination,
UINT* pcCurrent,
UINT* pcMax ) :
_pcCurrent( pcCurrent ),
_ppvData( prgpvDestination ),
_pcMax ( pcMax )
{
//
// The size of the elements stored by
// the vector referenced from this class
// depend on the type of element --
// clsid, file extension, or progid
//
switch ( dwType )
{
case TYPE_EXTENSION:
_cbElementSize = sizeof( WCHAR* );
break;
case TYPE_CLSID:
_cbElementSize = sizeof( CLASSDETAIL );
break;
case TYPE_PROGID:
_cbElementSize = sizeof( WCHAR* );
break;
default:
ASSERT(FALSE);
}
}
Reference in a new issue Copy permalink