343 lines
11 KiB
C++
343 lines
11 KiB
C++
//------------------------------------------------------------------------------------
|
|
//
|
|
// File: REGUTILS.CPP
|
|
//
|
|
// Helper functions that handle reading and writing strings to the system registry.
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
|
|
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
|
|
#define MAX_VALUELEN 16
|
|
|
|
const TCHAR c_szSoftwareClassesFmt[] = TEXT("Software\\Classes\\%s");
|
|
|
|
// our own atoi function so we don't have to link to the C runtimes...
|
|
INT AtoI( LPTSTR pValue )
|
|
{
|
|
INT i = 0;
|
|
INT iSign = 1;
|
|
|
|
while( pValue && *pValue )
|
|
{
|
|
if (*pValue == TEXT('-'))
|
|
{
|
|
iSign = -1;
|
|
}
|
|
else
|
|
{
|
|
i = (i*10) + (*pValue - TEXT('0'));
|
|
}
|
|
pValue++;
|
|
}
|
|
|
|
return (i * iSign);
|
|
}
|
|
|
|
void ItoA ( INT val, LPTSTR buf, UINT radix )
|
|
{
|
|
LPTSTR p; /* pointer to traverse string */
|
|
LPTSTR firstdig; /* pointer to first digit */
|
|
TCHAR temp; /* temp char */
|
|
INT digval; /* value of digit */
|
|
|
|
p = buf;
|
|
|
|
if (val < 0) {
|
|
/* negative, so output '-' and negate */
|
|
*p++ = TEXT('-');
|
|
val = -val;
|
|
}
|
|
|
|
firstdig = p; /* save pointer to first digit */
|
|
|
|
do {
|
|
digval = (val % radix);
|
|
val /= radix; /* get next digit */
|
|
|
|
/* convert to ascii and store */
|
|
if (digval > 9)
|
|
*p++ = (TCHAR) (digval - 10 + TEXT('a')); /* a letter */
|
|
else
|
|
*p++ = (TCHAR) (digval + TEXT('0')); /* a digit */
|
|
} while (val > 0);
|
|
|
|
/* We now have the digit of the number in the buffer, but in reverse
|
|
order. Thus we reverse them now. */
|
|
|
|
*p-- = TEXT('\0'); /* terminate string; p points to last digit */
|
|
|
|
do {
|
|
temp = *p;
|
|
*p = *firstdig;
|
|
*firstdig = temp; /* swap *p and *firstdig */
|
|
--p;
|
|
++firstdig; /* advance to next two digits */
|
|
} while (firstdig < p); /* repeat until halfway */
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// IconSet/GetRegValueString()
|
|
//
|
|
// Versions of Get/SetRegValueString that go to the user classes section.
|
|
// This can be overridden by the bClasses flag, which will only write the
|
|
// value to the HKEY_CLASSES_ROOT section.
|
|
//
|
|
// Returns: success of string setting / retrieval
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
BOOL IconSetRegValueString(LPSTR lpszSubKey, LPSTR lpszValName, LPSTR lpszValue ) {
|
|
TCHAR szRegPath[MAX_PATH];
|
|
|
|
wsprintf( szRegPath, c_szSoftwareClassesFmt, lpszSubKey );
|
|
return SetRegValueString(HKEY_CURRENT_USER, szRegPath, lpszValName, lpszValue );
|
|
|
|
}
|
|
|
|
BOOL IconGetRegValueString(LPSTR lpszSubKey, LPSTR lpszValName, LPSTR lpszValue, int iMaxSize ) {
|
|
TCHAR szRegPath[MAX_PATH];
|
|
|
|
wsprintf( szRegPath, c_szSoftwareClassesFmt, lpszSubKey );
|
|
|
|
if (!GetRegValueString(HKEY_CURRENT_USER, szRegPath, lpszValName, lpszValue, iMaxSize ))
|
|
return GetRegValueString(HKEY_CLASSES_ROOT, lpszSubKey, lpszValName, lpszValue, iMaxSize );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// GetRegValueString()
|
|
//
|
|
// Just a little helper routine, gets an individual string value from the
|
|
// registry and returns it to the caller. Takes care of registry headaches,
|
|
// including a paranoid length check before getting the string.
|
|
//
|
|
// Returns: success of string retrieval
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
BOOL GetRegValueString( HKEY hMainKey, LPSTR lpszSubKey, LPSTR lpszValName, LPSTR lpszValue, int iMaxSize )
|
|
{
|
|
LONG lRet;
|
|
HKEY hKey; // cur open key
|
|
BOOL bOK = TRUE;
|
|
DWORD dwSize, dwType;
|
|
|
|
// get subkey
|
|
lRet = RegOpenKeyEx( hMainKey, lpszSubKey, (DWORD)0, KEY_QUERY_VALUE, (PHKEY)&hKey );
|
|
if( lRet != ERROR_SUCCESS )
|
|
{
|
|
// Assert(FALSE, "problem on RegOpenKeyEx in GetRegValue\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// now do our paranoid check of data size
|
|
lRet = RegQueryValueEx( hKey, lpszValName,(LPDWORD)NULL,(LPDWORD)&dwType, (LPBYTE)NULL,/* null for size info only */ (LPDWORD)&dwSize );
|
|
|
|
if( ERROR_SUCCESS == lRet )
|
|
{ // saw something there
|
|
// here's the size check before getting the data
|
|
if( dwSize > (DWORD)iMaxSize )
|
|
{ // if string too big
|
|
// Assert(FALSE, "Humongous registry string; can't GetRegValue...\n");
|
|
bOK = FALSE; // can't read, so very bad news
|
|
}
|
|
else
|
|
{ // size is OK to continue
|
|
// now really get the value
|
|
lRet = RegQueryValueEx( hKey, lpszValName, (LPDWORD)NULL,(LPDWORD)&dwType, (LPBYTE)lpszValue, /* getting actual value */ (LPDWORD)&dwSize );
|
|
// Assert(lret == ERROR_SUCCESS, "bad return GetRegValue query\n");
|
|
// Assert(dwType == (DWORD)REG_SZ, "non-string type in GetValue!\n");
|
|
|
|
if( ERROR_SUCCESS != lRet )
|
|
bOK = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bOK = FALSE;
|
|
}
|
|
|
|
// close subkey
|
|
RegCloseKey( hKey );
|
|
|
|
return (bOK);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// GetRegValueInt()
|
|
//
|
|
// Just a little helper routine, gets an individual string value from the
|
|
// registry and returns it to the caller as an int. Takes care of registry headaches,
|
|
// including a paranoid length check before getting the string.
|
|
//
|
|
// Returns: success of string retrieval
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
BOOL GetRegValueInt( HKEY hMainKey, LPSTR lpszSubKey, LPSTR lpszValName, int* piValue )
|
|
{
|
|
char lpszValue[16];
|
|
BOOL bOK = TRUE;
|
|
|
|
bOK = GetRegValueString( hMainKey, lpszSubKey, lpszValName, lpszValue, MAX_VALUELEN );
|
|
*piValue = AtoI( lpszValue );
|
|
|
|
return bOK;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// SetRegValueString()
|
|
//
|
|
// Just a little helper routine that takes string and writes it to the registry.
|
|
//
|
|
// Returns: success writing to Registry, should be always TRUE.
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
BOOL SetRegValueString( HKEY hMainKey, LPSTR lpszSubKey, LPSTR lpszValName, LPSTR lpszValue )
|
|
{
|
|
HKEY hKey; // cur open key
|
|
LONG lRet;
|
|
BOOL bOK = TRUE;
|
|
|
|
// open this subkey
|
|
lRet = RegOpenKeyEx( hMainKey, (LPSTR)lpszSubKey, (DWORD)0, KEY_SET_VALUE, (PHKEY)&hKey );
|
|
|
|
// check that you got a good key here
|
|
if( lRet != ERROR_SUCCESS )
|
|
{
|
|
DWORD dwDisposition;
|
|
|
|
// Assert(FALSE, "problem on RegOpenKeyEx (write) of subkey ");
|
|
// Assert(FALSE, szSubKey);
|
|
// Assert(FALSE, "\n");
|
|
|
|
// OK, you couldn't even open the key !!!
|
|
|
|
// **********************************************************************************
|
|
// based on the sketchy documentation we have for this Reg* and Error stuff, we're
|
|
// guessing that you've ended up here because this totally standard, Windows-defined
|
|
// subkey name just doesn't happen to be defined for the current user.
|
|
// **********************************************************************************
|
|
|
|
// SO: Just create this subkey for this user, and maybe it will get used after you create and set it.
|
|
// still successful so long as can create new subkey to write to
|
|
|
|
lRet = RegCreateKeyEx( hMainKey, (LPSTR)lpszSubKey, (DWORD)0, (LPSTR)NULL, REG_OPTION_NON_VOLATILE,
|
|
KEY_SET_VALUE, (LPSECURITY_ATTRIBUTES)NULL, (PHKEY)&hKey, (LPDWORD)&dwDisposition );
|
|
if( lRet != ERROR_SUCCESS )
|
|
{
|
|
// Assert(FALSE, "problem even with RegCreateKeyEx (write) of subkey ");
|
|
// Assert(FALSE, szSubKey);
|
|
// Assert(FALSE, "\n");
|
|
|
|
// oh, oh, couldn't create the key
|
|
bOK = FALSE;
|
|
}
|
|
}
|
|
lRet = RegSetValueEx( hKey, lpszValName, (DWORD)NULL,(DWORD)REG_SZ,(LPBYTE)lpszValue, (DWORD)( lstrlen( lpszValue) + 1 ) );
|
|
bOK = bOK && (lRet == ERROR_SUCCESS);
|
|
// Assert(bOK, "couldn't write a string value to registry!\n");
|
|
|
|
// close this key
|
|
RegCloseKey( hKey );
|
|
|
|
// Assert(bOK, "didn't SetRegValue well\n");
|
|
return (bOK);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// SetRegValueInt()
|
|
//
|
|
// Just a little helper routine that takes an int and writes it as a string to the
|
|
// registry.
|
|
//
|
|
// Returns: success writing to Registry, should be always TRUE.
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
BOOL SetRegValueInt( HKEY hMainKey, LPSTR lpszSubKey, LPSTR lpszValName, int iValue )
|
|
{
|
|
char lpszValue[16];
|
|
|
|
ItoA( iValue, lpszValue, 10 );
|
|
return SetRegValueString( hMainKey, lpszSubKey, lpszValName, lpszValue );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// SetRegValueDword()
|
|
//
|
|
// Just a little helper routine that takes an dword and writes it to the
|
|
// supplied location.
|
|
//
|
|
// Returns: success writing to Registry, should be always TRUE.
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
BOOL SetRegValueDword( HKEY hk, LPTSTR pSubKey, LPTSTR pValue, DWORD dwVal )
|
|
{
|
|
HKEY hkey = NULL;
|
|
BOOL bRet = FALSE;
|
|
|
|
if (ERROR_SUCCESS == RegOpenKey( hk, pSubKey, &hkey ))
|
|
{
|
|
if (ERROR_SUCCESS == RegSetValueEx( hkey, pValue, 0,
|
|
REG_DWORD, (LPBYTE)&dwVal,
|
|
sizeof(DWORD)
|
|
)
|
|
)
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
if (hkey)
|
|
{
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------------
|
|
//
|
|
// GetRegValueDword()
|
|
//
|
|
// Just a little helper routine that takes an dword and writes it to the
|
|
// supplied location.
|
|
//
|
|
// Returns: success writing to Registry, should be always TRUE.
|
|
//
|
|
//------------------------------------------------------------------------------------
|
|
DWORD GetRegValueDword( HKEY hk, LPTSTR pSubKey, LPTSTR pValue )
|
|
{
|
|
HKEY hkey = NULL;
|
|
DWORD dwVal = REG_BAD_DWORD;
|
|
|
|
if (ERROR_SUCCESS == RegOpenKey( hk, pSubKey, &hkey ))
|
|
{
|
|
DWORD dwType, dwSize = sizeof(DWORD);
|
|
|
|
RegQueryValueEx( hkey, pValue, NULL, &dwType, (LPBYTE)&dwVal, &dwSize );
|
|
}
|
|
|
|
|
|
if (hkey)
|
|
{
|
|
RegCloseKey( hkey );
|
|
}
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
|