//+---------------------------------------------------------------------------
//
// 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 TCHAR tszOle32Dll[] = TEXT("OLE32.DLL");
#define OLE32_DLL tszOle32Dll
#define OLE32_BYTE_LEN sizeof(OLE32_DLL)
#define OLE32_CHAR_LEN (sizeof(OLE32_DLL) / sizeof(TCHAR) - 1)
//
// Threading Model Registry Constants
//
const TCHAR tszDllThreadModel[] = TEXT("ThreadingModel");
const TCHAR tszAptModel[] = TEXT("Apartment");
const TCHAR tszBothModel[] = TEXT("Both");
const TCHAR wszFreeModel[] = TEXT("Free");
// 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(LPCTSTR ptszPath, LPCTSTR ptszDllName, DWORD dwDllNameLen)
{
BOOL fResult = TRUE;
if (lstrcmpi(ptszDllName, ptszPath) != 0)
{
// Check if the last component is the same path
DWORD dwPathLen = lstrlen(ptszPath);
if (dwPathLen > dwDllNameLen)
{
// Point to the last where the slash would be if the substitute
// path is the last component
LPCTSTR ptszLastComponent = ptszPath + dwPathLen - (dwDllNameLen + 1);
// Is there a slash in that position
if ((*ptszLastComponent == '\\') || (*ptszLastComponent == '/'))
{
// Point to where the last component should be
ptszLastComponent++;
// Does the last component match?
if (lstrcmpi(ptszLastComponent, ptszDllName) == 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
LPCTSTR ptszSubKey, // address of name of subkey to query
LPTSTR ptszValue, // address of buffer for returned string
PLONG pcbValue) // address of buffer for size of returned string
{
HKEY hSubKey;
DWORD dwType;
LONG lErr ;
Win4Assert(ptszValue != NULL);
Win4Assert(pcbValue != NULL);
//
// Open the subkey if there is a string
//
if (ptszSubKey != NULL)
{
lErr = RegOpenKeyExT(hKey, ptszSubKey, NULL, KEY_READ, &hSubKey);
}
else
{
hSubKey = hKey;
lErr = ERROR_SUCCESS;
}
// Read the value into the user's buffer
if (lErr == ERROR_SUCCESS)
{
lErr = RegQueryValueExT(hSubKey, NULL , NULL, &dwType,
(BYTE *) ptszValue, (ULONG *) pcbValue);
if (lErr == ERROR_SUCCESS)
{
TCHAR *ptszScan = ptszValue; // used to scan along string
TCHAR *ptszDest = ptszValue; // used as destination when copying
// if the name is quoted then ...
if (*ptszScan == '\"')
{
ptszScan++;
// copy all non-quote characters down to base of buffer
// until end of quoted string
while (*ptszScan != '\0' && *ptszScan != '\"')
{
*ptszDest++ = *ptszScan++;
}
// terminate string and get length in bytes including nul
*ptszDest++ = '\0';
*pcbValue = (ptszDest - ptszValue) * sizeof(TCHAR);
}
// find first non-white space character
ptszScan = ptszValue;
while (_istspace(*ptszScan))
ptszScan++;
// if there are no non-white space characters this will be true
if (*ptszScan == 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
TCHAR tszTemp[MAX_PATH];
lstrcpy(tszTemp, ptszValue);
*pcbValue = ExpandEnvironmentStrings(tszTemp, ptszValue,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,
LPCTSTR ptszKey,
LPTSTR ptszDllName,
LONG *pclDllName,
ULONG *pulDllThreadType)
{
HKEY hDllEntry = NULL;
// Open the registry key
LONG lerr = RegOpenKeyT(hClsRegEntry, ptszKey, &hDllEntry);
if (ERROR_SUCCESS == lerr)
{
// Read the DLL name
lerr = wQueryStripRegValue(hDllEntry, NULL, ptszDllName, pclDllName);
// Is there a DLL path?
if (ERROR_SUCCESS == lerr)
{
if (wCompareDllName(ptszDllName,OLE32_DLL,OLE32_CHAR_LEN))
{
memcpy(ptszDllName,OLE32_DLL,OLE32_BYTE_LEN);
*pclDllName = OLE32_CHAR_LEN;
// Ole32 DLL will work anywhere
*pulDllThreadType = BOTH_THREADED;
}
else
{
// Assume there is no registry entry
*pulDllThreadType = SINGLE_THREADED;
// Buffer to hold entry for the registry data.
TCHAR tszModelBuf[MAX_PATH];
DWORD cdwModelBuf = sizeof(tszModelBuf);
DWORD dwRegEntType;
// Read the DLL threading model from the registry
lerr = RegQueryValueExT(hDllEntry, tszDllThreadModel, NULL,
&dwRegEntType, (LPBYTE) &tszModelBuf[0], &cdwModelBuf);
// Is there an thread model descriptor
if (ERROR_SUCCESS == lerr)
{
if ( REG_SZ != dwRegEntType)
{
// If it wasn't a string, bail
}
// Is it apartment model?
else if (lstrcmpi(tszAptModel, tszModelBuf) == 0)
{
*pulDllThreadType = APT_THREADED;
}
// Is is both threaded?
else if (lstrcmpi(tszBothModel, tszModelBuf) == 0)
{
*pulDllThreadType = BOTH_THREADED;
}
else if (lstrcmpi(wszFreeModel, tszModelBuf) == 0)
{
*pulDllThreadType = FREE_THREADED;
}
else
{
// BUGBUG: Should print a warning here
}
// If neither then we fall back to single threaded
// since this is guaranteed to be safe for the DLL.
}
// 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;
}
