411 lines
13 KiB
C++
411 lines
13 KiB
C++
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Microsoft Windows
|
||
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1993.
|
||
|
|
//
|
||
|
|
// File: olescm.cxx
|
||
|
|
//
|
||
|
|
// Contents: Functions shared between OLE32 and the SCM
|
||
|
|
//
|
||
|
|
// Classes:
|
||
|
|
//
|
||
|
|
// Functions:
|
||
|
|
//
|
||
|
|
// History: 10-03-95 kevinro Created
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#include <windows.h>
|
||
|
|
#include <ole2sp.h>
|
||
|
|
#include <ole2com.h>
|
||
|
|
|
||
|
|
static const WCHAR wszOle32Dll[] = L"OLE32.DLL";
|
||
|
|
|
||
|
|
#define OLE32_DLL wszOle32Dll
|
||
|
|
#define OLE32_BYTE_LEN sizeof(OLE32_DLL)
|
||
|
|
#define OLE32_CHAR_LEN (sizeof(OLE32_DLL) / sizeof(WCHAR) - 1)
|
||
|
|
|
||
|
|
//
|
||
|
|
// Threading Model Registry Constants
|
||
|
|
//
|
||
|
|
|
||
|
|
const WCHAR wszDllThreadModel[] = L"ThreadingModel";
|
||
|
|
|
||
|
|
const WCHAR wszAptModel[] = L"Apartment";
|
||
|
|
const WCHAR wszBothModel[] = L"Both";
|
||
|
|
const WCHAR wszFreeModel[] = L"Free";
|
||
|
|
const WCHAR wszNeutralModel[] = L"Neutral";
|
||
|
|
|
||
|
|
// Thread model match table. The table's first index is the threading
|
||
|
|
// model of the process and can be either APT_THREADED or
|
||
|
|
// FREE_THREADED. The second index is any one of the types of threading
|
||
|
|
// model's for DLLs.
|
||
|
|
BOOL afThreadModelMatch[2][4] =
|
||
|
|
{{TRUE, FALSE, TRUE, TRUE},
|
||
|
|
{FALSE, TRUE, FALSE, TRUE}};
|
||
|
|
|
||
|
|
//+---------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: CompareDllName
|
||
|
|
//
|
||
|
|
// Synopsis: Give a DLL path, this sees if the path is equal to a given
|
||
|
|
// DLL name or the last component of the is the same as the
|
||
|
|
// DLL name.
|
||
|
|
//
|
||
|
|
// Arguments: [pwszPath] -- DLL path
|
||
|
|
// [pwszDllName] -- name of DLL to compare with
|
||
|
|
//
|
||
|
|
// Returns: TRUE - The input path is equal or its last component is equal
|
||
|
|
// to the input Dll name.
|
||
|
|
// FALSE - Not equal at all.
|
||
|
|
//
|
||
|
|
// History: 6-15-95 ricksa Created
|
||
|
|
//
|
||
|
|
// Notes: This is a helper function used by the routines that convert
|
||
|
|
// ole2.dll to ole32.dll and to convert paths that end in ole32.dll
|
||
|
|
// into ole32.dll.
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------------
|
||
|
|
BOOL
|
||
|
|
wCompareDllName(LPCWSTR pwszPath, LPCWSTR pwszDllName, DWORD dwDllNameLen)
|
||
|
|
{
|
||
|
|
BOOL fResult = TRUE;
|
||
|
|
|
||
|
|
if (lstrcmpiW(pwszDllName, pwszPath) != 0)
|
||
|
|
{
|
||
|
|
// Check if the last component is the same path
|
||
|
|
DWORD dwPathLen = lstrlenW(pwszPath);
|
||
|
|
|
||
|
|
if (dwPathLen > dwDllNameLen)
|
||
|
|
{
|
||
|
|
// Point to the last where the slash would be if the substitute
|
||
|
|
// path is the last component
|
||
|
|
LPCWSTR pwszLastComponent = pwszPath + dwPathLen - (dwDllNameLen + 1);
|
||
|
|
|
||
|
|
// Is there a slash in that position
|
||
|
|
if ((*pwszLastComponent == '\\') || (*pwszLastComponent == '/'))
|
||
|
|
{
|
||
|
|
// Point to where the last component should be
|
||
|
|
pwszLastComponent++;
|
||
|
|
|
||
|
|
// Does the last component match?
|
||
|
|
if (lstrcmpiW(pwszLastComponent, pwszDllName) == 0)
|
||
|
|
{
|
||
|
|
goto CompareDllName_Exit;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fResult = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
CompareDllName_Exit:
|
||
|
|
|
||
|
|
return fResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+-------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: wThreadModelMatch
|
||
|
|
//
|
||
|
|
// Synopsis: Determines whether caller and DLL thread models match
|
||
|
|
//
|
||
|
|
// Arguments: [dwCallerThreadModel] - Caller thread model
|
||
|
|
// [dwDllThreadModel] - DLL thread model
|
||
|
|
//
|
||
|
|
// Returns: TRUE - DLL can be loaded caller
|
||
|
|
// FALSE - DLL cannot be loaded into caller.
|
||
|
|
//
|
||
|
|
// Algorithm: If the caller's thread model is apartment, then check
|
||
|
|
// whether the DLL is one of apartment, single threaded or
|
||
|
|
// both threaded. If it is, then return TRUE. Otherwise,
|
||
|
|
// for free threading return TRUE if the DLL model is either
|
||
|
|
// both or free threaded. If neither of the above is TRUE
|
||
|
|
// then return FALSE.
|
||
|
|
//
|
||
|
|
// History: 10-Nov-94 Ricksa Created
|
||
|
|
//
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
BOOL wThreadModelMatch(
|
||
|
|
DWORD dwCallerThreadModel,
|
||
|
|
DWORD dwDllThreadModel,
|
||
|
|
DWORD dwContext)
|
||
|
|
{
|
||
|
|
BOOL fResult = afThreadModelMatch[dwCallerThreadModel] [dwDllThreadModel];
|
||
|
|
|
||
|
|
if (dwContext & CLSCTX_PS_DLL)
|
||
|
|
{
|
||
|
|
fResult = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return fResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+-------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: wQueryStripRegValue
|
||
|
|
//
|
||
|
|
// Synopsis: Get the DLL information for a 32 bit DLL and
|
||
|
|
// strip off any leading and trailing "
|
||
|
|
//
|
||
|
|
// Arguments: [hkey] - class handle
|
||
|
|
// [pwszSubKey] - key to open
|
||
|
|
// [pwszValue] - where to return data
|
||
|
|
// [pcbValue] - length of above buffer in bytes
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS - read DLL path information
|
||
|
|
// Other - registry entries could not be found
|
||
|
|
//
|
||
|
|
// Algorithm: Read the value requested.
|
||
|
|
// If first character is not ", exit
|
||
|
|
// Otherwise, copy data after quote to beginning of buffer.
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// History: 05-Jan-94 BillMo Created
|
||
|
|
// 26-Sep-95 BruceMa Support environment variable expansion
|
||
|
|
// for shell viewers
|
||
|
|
//
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
|
||
|
|
LONG
|
||
|
|
wQueryStripRegValue(HKEY hKey, // handle of key to query
|
||
|
|
LPCWSTR pwszSubKey, // address of name of subkey to query
|
||
|
|
LPWSTR pwszValue, // address of buffer for returned string
|
||
|
|
PLONG pcbValue) // address of buffer for size of returned string
|
||
|
|
{
|
||
|
|
HKEY hSubKey;
|
||
|
|
DWORD dwType;
|
||
|
|
LONG lErr ;
|
||
|
|
|
||
|
|
Win4Assert(pwszValue != NULL);
|
||
|
|
Win4Assert(pcbValue != NULL);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Open the subkey if there is a string
|
||
|
|
//
|
||
|
|
if (pwszSubKey != NULL)
|
||
|
|
{
|
||
|
|
lErr = RegOpenKeyExW(hKey, pwszSubKey, NULL, KEY_READ, &hSubKey);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hSubKey = hKey;
|
||
|
|
lErr = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Read the value into the user's buffer
|
||
|
|
if (lErr == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
lErr = RegQueryValueExW(hSubKey, NULL , NULL, &dwType,
|
||
|
|
(BYTE *) pwszValue, (ULONG *) pcbValue);
|
||
|
|
if (lErr == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
WCHAR *pwszScan = pwszValue; // used to scan along string
|
||
|
|
WCHAR *pwszDest = pwszValue; // used as destination when copying
|
||
|
|
|
||
|
|
// if the name is quoted then ...
|
||
|
|
if (*pwszScan == '\"')
|
||
|
|
{
|
||
|
|
pwszScan++;
|
||
|
|
|
||
|
|
// copy all non-quote characters down to base of buffer
|
||
|
|
// until end of quoted string
|
||
|
|
while (*pwszScan != '\0' && *pwszScan != '\"')
|
||
|
|
{
|
||
|
|
*pwszDest++ = *pwszScan++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// terminate string and get length in bytes including nul
|
||
|
|
*pwszDest++ = '\0';
|
||
|
|
*pcbValue = (int)(pwszDest - pwszValue) * sizeof(WCHAR);
|
||
|
|
}
|
||
|
|
|
||
|
|
// find first non-white space character
|
||
|
|
pwszScan = pwszValue;
|
||
|
|
while (_istspace(*pwszScan))
|
||
|
|
pwszScan++;
|
||
|
|
|
||
|
|
// if there are no non-white space characters this will be true
|
||
|
|
if (*pwszScan == L'\0')
|
||
|
|
{
|
||
|
|
lErr = ERROR_FILE_NOT_FOUND;
|
||
|
|
*pcbValue = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Chicago does not support ExpandEnvironmentStrings
|
||
|
|
#ifndef _CHICAGO_
|
||
|
|
// If the value type is REG_EXPAND_SZ then do environment variable
|
||
|
|
// expansion
|
||
|
|
if (dwType == REG_EXPAND_SZ)
|
||
|
|
{
|
||
|
|
// Expand any embedded environemnt variable expressions
|
||
|
|
WCHAR wszTemp[MAX_PATH];
|
||
|
|
|
||
|
|
lstrcpyW(wszTemp, pwszValue);
|
||
|
|
*pcbValue = ExpandEnvironmentStrings(wszTemp, pwszValue,MAX_PATH);
|
||
|
|
}
|
||
|
|
#endif // !_CHICAGO_
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Only close the sub key if we actually opened it.
|
||
|
|
//
|
||
|
|
if (hSubKey != hKey)
|
||
|
|
{
|
||
|
|
RegCloseKey(hSubKey);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
return lErr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+-------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetDllInfo
|
||
|
|
//
|
||
|
|
// Synopsis: Get the DLL information for a 32 bit DLL
|
||
|
|
//
|
||
|
|
// Arguments: [hClsRegEntry] - class handle
|
||
|
|
// [pwszKey] - key to open
|
||
|
|
// [pwszDllName] - where to return DLL path
|
||
|
|
// [pclDllName] - length of above buffer
|
||
|
|
// [pulDllThreadType] - where to return DLL threading information
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS - read DLL path information
|
||
|
|
// Other - registry entries could not be found
|
||
|
|
//
|
||
|
|
// Algorithm: Open the DLL key. Then read the DLL path name. Finally read
|
||
|
|
// the threading model information if it is specified.
|
||
|
|
//
|
||
|
|
// History: 09-Nov-94 Ricksa Created
|
||
|
|
//
|
||
|
|
//--------------------------------------------------------------------------
|
||
|
|
LONG wGetDllInfo(
|
||
|
|
HKEY hClsRegEntry,
|
||
|
|
LPCWSTR pwszKey,
|
||
|
|
LPWSTR pwszDllName,
|
||
|
|
LONG* pclDllName,
|
||
|
|
ULONG* pulDllThreadType)
|
||
|
|
{
|
||
|
|
HKEY hDllEntry = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Attempt to open the specified registry key.
|
||
|
|
//
|
||
|
|
|
||
|
|
LONG lerr = RegOpenKeyW(hClsRegEntry, pwszKey, &hDllEntry);
|
||
|
|
if (ERROR_SUCCESS == lerr)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Try to read the DLL name.
|
||
|
|
//
|
||
|
|
|
||
|
|
lerr = wQueryStripRegValue(hDllEntry, NULL, pwszDllName, pclDllName);
|
||
|
|
if (ERROR_SUCCESS == lerr)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// A DLL name is registered. If the DLL is OLE32.DLL, then we
|
||
|
|
// know all about and don't have to dig more info from the
|
||
|
|
// the registry. Otherwise, we do need to keep digging.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (wCompareDllName(pwszDllName, OLE32_DLL, OLE32_CHAR_LEN))
|
||
|
|
{
|
||
|
|
memcpy(pwszDllName, OLE32_DLL, OLE32_BYTE_LEN);
|
||
|
|
*pclDllName = OLE32_CHAR_LEN;
|
||
|
|
*pulDllThreadType = BOTH_THREADED;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Assume there is no registry entry.
|
||
|
|
//
|
||
|
|
|
||
|
|
*pulDllThreadType = SINGLE_THREADED;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Buffer to hold entry for the registry data.
|
||
|
|
//
|
||
|
|
|
||
|
|
WCHAR wszModelBuf[MAX_PATH];
|
||
|
|
DWORD cdwModelBuf = sizeof(wszModelBuf);
|
||
|
|
DWORD dwRegEntType;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read the DLL threading model from the registry.
|
||
|
|
//
|
||
|
|
|
||
|
|
lerr = RegQueryValueExW(hDllEntry,
|
||
|
|
wszDllThreadModel,
|
||
|
|
NULL,
|
||
|
|
&dwRegEntType,
|
||
|
|
(LPBYTE) &wszModelBuf[0],
|
||
|
|
&cdwModelBuf);
|
||
|
|
|
||
|
|
//
|
||
|
|
// If there is a thread model descriptor, set the thread
|
||
|
|
// type accordingly.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (ERROR_SUCCESS == lerr)
|
||
|
|
{
|
||
|
|
if (REG_SZ != dwRegEntType)
|
||
|
|
{
|
||
|
|
Win4Assert(L"ThreadingModel Key Type incorrect");
|
||
|
|
}
|
||
|
|
else if (0 == lstrcmpiW(wszAptModel, wszModelBuf))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// An APARTMENT model object.
|
||
|
|
//
|
||
|
|
|
||
|
|
*pulDllThreadType = APT_THREADED;
|
||
|
|
}
|
||
|
|
else if (0 == lstrcmpiW(wszBothModel, wszModelBuf))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// A BOTH model object.
|
||
|
|
//
|
||
|
|
|
||
|
|
*pulDllThreadType = BOTH_THREADED;
|
||
|
|
}
|
||
|
|
else if (lstrcmpiW(wszFreeModel, wszModelBuf) == 0)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// A FREE_THREADED model object.
|
||
|
|
//
|
||
|
|
|
||
|
|
*pulDllThreadType = FREE_THREADED;
|
||
|
|
}
|
||
|
|
else if (0 == lstrcmpiW(wszNeutralModel, wszModelBuf))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// A NEUTRAL_THREADED object.
|
||
|
|
//
|
||
|
|
|
||
|
|
*pulDllThreadType = NEUTRAL_THREADED;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Win4Assert(L"ThreadingModel Value incorrect");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// When we get to this point, we got a DLL entry so we remap
|
||
|
|
// any errors to success because they only mean that we could
|
||
|
|
// not get a model from the registry.
|
||
|
|
//
|
||
|
|
|
||
|
|
lerr = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
RegCloseKey(hDllEntry);
|
||
|
|
}
|
||
|
|
|
||
|
|
return lerr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|