archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/com/ole32/oleui/creg.cpp

549 lines
17 KiB
Raw Blame History

//+---------------------------------------------------------------------
//
// 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();
}