You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
549 lines
17 KiB
549 lines
17 KiB
//+---------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1993 - 1997.
|
|
//
|
|
// File: creg.cpp
|
|
//
|
|
// Contents: Implements class CRegistry to wrap registry access
|
|
//
|
|
// Classes:
|
|
//
|
|
// Methods: CRegistry::CRegistry
|
|
// CRegistry::~CRegistry
|
|
// CRegistry::Init
|
|
// CRegistry::InitGetItem
|
|
// CRegistry::GetNextItem
|
|
// CRegistry::GetItem
|
|
// CRegistry::FindItem
|
|
// CRegistry::FindAppid
|
|
// CRegistry::AppendIndex
|
|
// CRegistry::GetNumItems
|
|
//
|
|
// History: 23-Apr-96 BruceMa Created.
|
|
//
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "types.h"
|
|
#include "cstrings.h"
|
|
#include "creg.h"
|
|
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
CRegistry::CRegistry(void)
|
|
{
|
|
m_applications.RemoveAll();
|
|
}
|
|
|
|
|
|
CRegistry::~CRegistry(void)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
|
|
// Access and store all application names and associated appid's
|
|
BOOL CRegistry::Init(void)
|
|
{
|
|
int err;
|
|
HKEY hKey;
|
|
DWORD dwSubKey;
|
|
TCHAR szTitle[MAX_PATH];
|
|
TCHAR szAppid[MAX_PATH];
|
|
TCHAR szCLSID[MAX_PATH];
|
|
TCHAR szBuffer[MAX_PATH];
|
|
LONG lSize;
|
|
DWORD dwType;
|
|
DWORD dwDisposition;
|
|
|
|
// Cleanup any previous run
|
|
m_applications.RemoveAll();
|
|
|
|
|
|
// First enumerate HKEY_CLASSES_ROOT\CLSID picking up all .exe
|
|
|
|
// Open HKEY_CLASSES_ROOT\CLSID
|
|
if (RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("CLSID"), 0, KEY_READ | KEY_WRITE,
|
|
&hKey) != ERROR_SUCCESS)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Enumerate the CLSID subkeys
|
|
dwSubKey = 0;
|
|
while (RegEnumKey(hKey, dwSubKey, szCLSID, sizeof(szCLSID) / sizeof(TCHAR))
|
|
== ERROR_SUCCESS)
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
HKEY hKey2;
|
|
SRVTYPE srvType;
|
|
|
|
// Prepare for next key
|
|
dwSubKey++;
|
|
|
|
// Open this key
|
|
if (RegOpenKeyEx(hKey, szCLSID, 0, KEY_READ | KEY_WRITE,
|
|
&hKey2) == ERROR_SUCCESS)
|
|
{
|
|
// Check for subkeys "LocalServer32", "_LocalServer32",
|
|
// "LocalServer", and "_LocalServer"
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
err = RegQueryValue(hKey2, TEXT("LocalServer32"), szPath,
|
|
&lSize);
|
|
srvType = LOCALSERVER32;
|
|
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
err = RegQueryValue(hKey2, TEXT("_LocalServer32"), szPath,
|
|
&lSize);
|
|
srvType = _LOCALSERVER32;
|
|
}
|
|
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
err = RegQueryValue(hKey2, TEXT("LocalServer"), szPath,
|
|
&lSize);
|
|
srvType = LOCALSERVER;
|
|
}
|
|
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
err = RegQueryValue(hKey2, TEXT("_LocalServer"), szPath,
|
|
&lSize);
|
|
srvType = _LOCALSERVER;
|
|
}
|
|
|
|
if (err != ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hKey2);
|
|
continue;
|
|
}
|
|
|
|
// Strip off any command line parameters -
|
|
// it's the executale path that determines an item. Because
|
|
// of quotes, embedded spaces, etc. we scan for ".exe"
|
|
int k = 0;
|
|
|
|
// szPath is executable path
|
|
while (szPath[k])
|
|
{
|
|
if (szPath[k] == TEXT('.') &&
|
|
szPath[k + 1] && (szPath[k + 1] == TEXT('e') ||
|
|
szPath[k + 1] == TEXT('E')) &&
|
|
szPath[k + 2] && (szPath[k + 2] == TEXT('x') ||
|
|
szPath[k + 2] == TEXT('X')) &&
|
|
szPath[k + 3] && (szPath[k + 3] == TEXT('e') ||
|
|
szPath[k + 3] == TEXT('E')))
|
|
{
|
|
break;
|
|
}
|
|
|
|
k++;
|
|
}
|
|
|
|
// Just continue if we don't have an .exe path
|
|
if (!szPath[k])
|
|
{
|
|
RegCloseKey(hKey2);
|
|
continue;
|
|
}
|
|
|
|
// Increment to the nominal end of the path
|
|
k += 4;
|
|
|
|
// In case the entire path is surrounded by quotes
|
|
if (szPath[k] == TEXT('"'))
|
|
{
|
|
k++;
|
|
}
|
|
szPath[k] = TEXT('\0');
|
|
|
|
// Read the AppID for this clsid (if any)
|
|
BOOL fUseThisClsid = FALSE;
|
|
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
if (RegQueryValueEx(hKey2, TEXT("AppID"), NULL, &dwType,
|
|
(UCHAR *) szAppid, (ULONG *) &lSize)
|
|
!= ERROR_SUCCESS)
|
|
{
|
|
// Use this clsid as the appid
|
|
fUseThisClsid = TRUE;
|
|
}
|
|
|
|
// If this is a 16-bit server without an existing AppId
|
|
// named value then skip it
|
|
if ((srvType == LOCALSERVER || srvType == _LOCALSERVER) &&
|
|
fUseThisClsid == TRUE)
|
|
{
|
|
RegCloseKey(hKey2);
|
|
continue;
|
|
}
|
|
|
|
// Read the title for the item
|
|
BOOL fNoTitle = FALSE;
|
|
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
if (RegQueryValueEx(hKey2, NULL, NULL, &dwType,
|
|
(UCHAR *) szTitle, (ULONG *) &lSize)
|
|
!= ERROR_SUCCESS)
|
|
{
|
|
fNoTitle = TRUE;
|
|
}
|
|
else if (szTitle[0] == TEXT('\0'))
|
|
{
|
|
fNoTitle = TRUE;
|
|
}
|
|
|
|
// If both the item (the executable path) and the title
|
|
// (the unnamed value on the CLSID) are empty, then skip
|
|
// this entry
|
|
if (szPath[0] == TEXT('\0') &&
|
|
(fNoTitle || szTitle[0] == TEXT('\0')))
|
|
{
|
|
RegCloseKey(hKey2);
|
|
continue;
|
|
}
|
|
|
|
// Check whether we already have this item in the table - we
|
|
// search differently depending on whether this clsid already
|
|
// has an associated appid
|
|
SItem *pItem;
|
|
|
|
if (fUseThisClsid)
|
|
{
|
|
// check if application is in list
|
|
pItem = FindItem(szPath);
|
|
}
|
|
else
|
|
{
|
|
pItem = FindAppid(szAppid);
|
|
}
|
|
|
|
if (pItem == NULL)
|
|
{
|
|
// Create a new item
|
|
// szPath is path, szCLSID is CLSID
|
|
pItem = m_applications.PutItem(szPath[0] ? szPath : szCLSID,
|
|
fNoTitle ? szCLSID : szTitle,
|
|
fUseThisClsid ? szCLSID : szAppid);
|
|
if (pItem == NULL)
|
|
{
|
|
RegCloseKey(hKey2);
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
|
|
// Note whether the clsid had an appid named value
|
|
pItem->fHasAppid = !fUseThisClsid;
|
|
}
|
|
|
|
// Write the AppId for this class if it doesn't exist
|
|
lSize = MAX_PATH * sizeof(TCHAR);
|
|
if (RegQueryValueEx(hKey2, TEXT("AppID"), 0, &dwType,
|
|
(BYTE *) szBuffer, (ULONG *) &lSize)
|
|
!= ERROR_SUCCESS)
|
|
{
|
|
if (RegSetValueEx(hKey2, TEXT("AppID"), 0, REG_SZ,
|
|
(const BYTE *) (LPCTSTR)pItem->szAppid,
|
|
(pItem->szAppid.GetLength() + 1) * sizeof(TCHAR))
|
|
!= ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hKey2);
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Now add this clsid to the table of clsid's for this .exe
|
|
if (!m_applications.AddClsid(pItem, szCLSID))
|
|
{
|
|
RegCloseKey(hKey2);
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
|
|
// Close the key
|
|
RegCloseKey(hKey2);
|
|
}
|
|
} // End of the enumeration over HKEY_CLASSES_ROOT\CLSID
|
|
|
|
// Close the key on HKEY_CLASSES_ROOT\CLSID
|
|
RegCloseKey(hKey);
|
|
|
|
|
|
|
|
// Create or open the key "HKEY_CLASSES_ROOT\AppID"
|
|
if (RegCreateKeyEx(HKEY_CLASSES_ROOT, TEXT("AppID"), 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey,
|
|
&dwDisposition) != ERROR_SUCCESS)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Enumerate keys under HKEY_CLASSES_ROOT\AppID
|
|
dwSubKey = 0;
|
|
while (RegEnumKey(hKey, dwSubKey, szCLSID, sizeof(szCLSID) / sizeof(TCHAR)) == ERROR_SUCCESS)
|
|
{
|
|
// Prepare for next key
|
|
dwSubKey++;
|
|
|
|
// Only look at entries having an AppId format
|
|
if (!(szCLSID[0] == TEXT('{') &&
|
|
_tcslen(szCLSID) == GUIDSTR_MAX &&
|
|
szCLSID[37] == TEXT('}')))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Check if this appid is already in the table
|
|
SItem *pItem = FindAppid(szCLSID);
|
|
|
|
// read title
|
|
TCHAR szTitle[MAX_PATH];
|
|
long lSize = MAX_PATH * sizeof(TCHAR);
|
|
|
|
// Read its unnamed value as the title
|
|
szTitle[0] = TEXT('\0');
|
|
err = RegQueryValue(hKey, szCLSID, szTitle, &lSize);
|
|
|
|
// If not create an item entry so it can be displayed in the UI
|
|
if (pItem == NULL)
|
|
{
|
|
// Store this item
|
|
pItem = m_applications.PutItem(NULL,
|
|
szTitle[0] ? szTitle : szCLSID,
|
|
szCLSID);
|
|
if (pItem == NULL)
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
// ronans - bugfix for raided bug
|
|
// change existing item title to AppID title if there is one
|
|
if ((err == ERROR_SUCCESS) && szTitle[0])
|
|
{
|
|
pItem -> szTitle = (LPCTSTR)szTitle;
|
|
}
|
|
}
|
|
|
|
// Mark it so we don't rewrite it to HKEY_CLASSES_ROOT\AppID
|
|
pItem->fMarked = TRUE;
|
|
} // End enumeration of HKEY_CLASSES_ROOT\AppID
|
|
|
|
|
|
|
|
// Enumerate through the table of items, writing to HKEY_CLASSES_ROOT\AppID
|
|
// any items that are not marked
|
|
SItem *pItem;
|
|
|
|
m_applications.InitGetNext();
|
|
for (pItem = GetNextItem(); pItem; pItem = GetNextItem())
|
|
{
|
|
HKEY hKey2;
|
|
|
|
// If this item has an AppID but is unmarked, then ask the user
|
|
// whether he really wants to create the AppID
|
|
if (!pItem->fMarked && pItem->fHasAppid)
|
|
{
|
|
CString szMessage;
|
|
CString szDCOM_;
|
|
CString szNULL;
|
|
TCHAR szText[MAX_PATH*2];
|
|
TCHAR *szParms[3];
|
|
|
|
szMessage.LoadString(IDS_CLSID_);
|
|
szDCOM_.LoadString(IDS_DCOM_Configuration_Warning);
|
|
szNULL.LoadString(IDS_NULL);
|
|
|
|
szParms[0] = pItem->ppszClsids[0];
|
|
szParms[1] = !pItem->szItem.IsEmpty() ? (TCHAR *) ((LPCTSTR)pItem->szItem)
|
|
: (TCHAR *) ((LPCTSTR) szNULL);
|
|
szParms[2] = !pItem->szTitle.IsEmpty() ? (TCHAR *) ((LPCTSTR)pItem->szTitle)
|
|
: (TCHAR *) ((LPCTSTR) szNULL);
|
|
|
|
FormatMessage(FORMAT_MESSAGE_FROM_STRING |
|
|
FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
(TCHAR *) ((LPCTSTR) szMessage),
|
|
0,
|
|
0,
|
|
szText,
|
|
sizeof(szText)/sizeof(*szText),
|
|
(va_list *) szParms);
|
|
|
|
if (MessageBox(GetForegroundWindow(),
|
|
szText,
|
|
(TCHAR *) ((LPCTSTR) szDCOM_),
|
|
MB_YESNO) == IDNO)
|
|
{
|
|
pItem->fMarked = TRUE;
|
|
pItem->fDontDisplay = TRUE;
|
|
}
|
|
}
|
|
|
|
// If this item is not marked then, then create an appid key for
|
|
// it under HKEY_CLASSES_ROOT\AppID and, separately, write the
|
|
// .exe name under HKEY_CLASSES_ROOT\AppID
|
|
if (!pItem->fMarked)
|
|
{
|
|
if (RegCreateKeyEx(hKey, pItem->szAppid, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey2,
|
|
&dwDisposition) == ERROR_SUCCESS)
|
|
{
|
|
// Write the item title as the unnamed value
|
|
if (!pItem->szTitle.IsEmpty())
|
|
{
|
|
RegSetValueEx(hKey2, NULL, 0, REG_SZ,(BYTE *) (LPCTSTR) pItem->szTitle,
|
|
(pItem->szTitle.GetLength() + 1) * sizeof(TCHAR));
|
|
}
|
|
|
|
// Close it
|
|
RegCloseKey(hKey2);
|
|
|
|
|
|
// Write the .exe name if it's not empty
|
|
if (!(pItem->szItem.IsEmpty()))
|
|
{
|
|
// Extract the .exe name
|
|
int k = pItem->szItem.ReverseFind(TEXT('\\'));
|
|
CString szExe = pItem->szItem.Mid((k != -1) ? k+1 : 0);
|
|
|
|
// remove trailing quotes on executable name if necessary
|
|
k = szExe.GetLength();
|
|
if (k && (szExe.GetAt(k-1) == TEXT('\"')))
|
|
szExe = szExe.Left(k-1);
|
|
|
|
// Write the .exe name as a key
|
|
if (RegCreateKeyEx(hKey, (LPCTSTR)szExe, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &hKey2,
|
|
&dwDisposition) == ERROR_SUCCESS)
|
|
{
|
|
// Now write the associated AppId as a named value
|
|
RegSetValueEx(hKey2, TEXT("AppId"), 0, REG_SZ,
|
|
(BYTE *)(LPCTSTR) pItem->szAppid,
|
|
(pItem->szAppid.GetLength() + 1) * sizeof(TCHAR));
|
|
|
|
RegCloseKey(hKey2);
|
|
}
|
|
}
|
|
}
|
|
else // dont continue on failure
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Close the key on HKEY_CLASSES_ROOT\AppID
|
|
RegCloseKey(hKey);
|
|
|
|
|
|
// We display applications by their titles (e.g. "Microsoft Word 6.0")
|
|
// which have to be unique because we're going to uniquely associate
|
|
// an entry in the list box with the index of its associated SItem
|
|
// structure. So here we make sure all the titles are unique.
|
|
DWORD cbItems = m_applications.GetNumItems();
|
|
|
|
// Compare all non-empty titles of the same length. If they are
|
|
// not unique, then append "(<index>)" to make them unique
|
|
for (DWORD k = 0; k < cbItems; k++)
|
|
{
|
|
DWORD dwIndex = 1;
|
|
SItem *pItem = m_applications.GetItem(k);
|
|
|
|
if (!(pItem->szTitle.IsEmpty()) && !pItem->fChecked)
|
|
{
|
|
for (DWORD j = k + 1; j < cbItems; j++)
|
|
{
|
|
SItem *pItem2 = m_applications.GetItem(j);
|
|
|
|
if (!pItem2->fChecked &&
|
|
(pItem->szTitle == pItem2->szTitle))
|
|
{
|
|
if (dwIndex == 1)
|
|
{
|
|
AppendIndex(pItem, 1);
|
|
dwIndex++;
|
|
}
|
|
AppendIndex(pItem2, dwIndex++);
|
|
pItem2->fChecked = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Prepare for the UI enumerating item entries
|
|
m_applications.InitGetNext();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOL CRegistry::InitGetItem(void)
|
|
{
|
|
return m_applications.InitGetNext();
|
|
}
|
|
|
|
|
|
|
|
|
|
// Enumerate the next application name
|
|
SItem *CRegistry::GetNextItem(void)
|
|
{
|
|
return m_applications.GetNextItem();
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get a specific item
|
|
SItem *CRegistry::GetItem(DWORD dwItem)
|
|
{
|
|
return m_applications.GetItem(dwItem);
|
|
}
|
|
|
|
|
|
|
|
SItem *CRegistry::FindItem(TCHAR *szPath)
|
|
{
|
|
return m_applications.FindItem(szPath);
|
|
}
|
|
|
|
|
|
|
|
SItem *CRegistry::FindAppid(TCHAR *szAppid)
|
|
{
|
|
return m_applications.FindAppid(szAppid);
|
|
}
|
|
|
|
|
|
|
|
|
|
void CRegistry::AppendIndex(SItem *pItem, DWORD dwIndex)
|
|
{
|
|
CString szTmp;
|
|
szTmp.Format(TEXT(" (%d)"),dwIndex);
|
|
|
|
pItem->szTitle += szTmp;
|
|
}
|
|
|
|
|
|
|
|
DWORD CRegistry::GetNumItems(void)
|
|
{
|
|
return m_applications.GetNumItems();
|
|
}
|