www.pudn.com > mod_rssimLib.zip > dregkey.cpp
// dregkey.cpp
#include "stdafx.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// ---------------------------- RegDelete -------------------------
// Recursively deletes subkeys within a key.
// Basically a deltree for registries.
//
// Note. When you delete a Key all values in that key get deleted
// automatically. Do not use too much stack since this function
// does use recursion.
LONG RegDelete( HKEY hParentKey, // handle of open key
LPCTSTR lpSubKey // address of name of subkey to delete
)
{
LONG retValue; // return value stored
HKEY hKey; // currently open key for enumeration
CHAR regSubKeyName[4096]; // subkey obtained through enumeration
CString regKeyName; // key-subkenname concatenated
DWORD index =0; // enumerated key index#
// test the keys security
retValue = RegOpenKeyEx(hParentKey, lpSubKey, 0, KEY_WRITE | KEY_READ, &hKey);
if (ERROR_SUCCESS != retValue)
return(retValue);
// go into a loop until we run out of subkeys
while (ERROR_SUCCESS == RegEnumKey(hKey, index, regSubKeyName, sizeof(regSubKeyName)))
{
// delete the subkey by..
// building up its full name
regKeyName = lpSubKey;
regKeyName += "\\";
regKeyName += regSubKeyName;
// recursively delete any subkeys in it
retValue = RegDelete(hParentKey, regKeyName);
// bomb out of the loop if we encounter an error
if (ERROR_SUCCESS != retValue)
return(retValue);
//index++; // enumerate next key
}
// enumerate failed (none or no more subkeys)
RegCloseKey(hKey);
retValue = RegDeleteKey(hParentKey, lpSubKey);
return (retValue);
} // RegDelete
//////////////////////////////////////////////////////////////////////////////
// DRegKey class implementation follows:
//
//
// initialise some static variables
HKEY DRegKey::local_machine = HKEY_LOCAL_MACHINE;
HKEY DRegKey::current_user = HKEY_CURRENT_USER;
// implementation
// ------------------------------DRegKey::DRegKey --------------------------
// constructor
DRegKey::DRegKey(HKEY hKey, LPCTSTR keyName, REGSAM regSam)
{
m_hKey = NULL;
Open(hKey ,keyName, regSam);
}
// KEY_ENUMERATE_SUB_KEYS |KEY_EXECUTE | KEY_QUERY_VALUE
// ------------------------------------ Open -------------------------------
LONG DRegKey::Open(HKEY hKey, // can be "local_machine" or "current_user"
LPCTSTR keyName, // optional name
REGSAM regSam // optional access specifiers
)
{
HKEY openedKey;
DWORD dp;
if (NULL!= keyName)
{
m_KeyName = keyName;
m_baseKey = hKey;
result = RegCreateKeyEx(hKey, keyName, 0, NULL,
REG_OPTION_NON_VOLATILE,
regSam, NULL, &openedKey, &dp);
if (ERROR_SUCCESS == result)
m_hKey = openedKey;
return (result);
}
else
m_hKey = hKey;
return (ERROR_SUCCESS);
} // Open
// ----------------------------------- Close ---------------------------------
// closes the opened key (also called by the destructor)
LONG DRegKey::Close()
{
if (NULL == m_hKey)
return(FALSE);
result = RegCloseKey(m_hKey);
m_hKey = NULL;
return(result);
} // Close
// ------------------------------ operator HKEY() const ---------------------
DRegKey::operator HKEY() const
{
return m_hKey;
} // operator HKEY() const
// ----------------------------------- QueryValue ----------------------------
// DWORD
LONG DRegKey::QueryValue(LPCTSTR valueName , DWORD *dwValue)
{
DWORD size = sizeof(DWORD);
result = RegQueryValueEx(m_hKey,
valueName,
NULL, // reserved
NULL, // value type
(BYTE*)dwValue,
&size);
return(result);
} // QueryValue
// ------------------------------------ QueryValue ---------------------------
LONG DRegKey::QueryValue(LPCTSTR valueName , BYTE *bValue)
{
DWORD v = (DWORD)*bValue;
LONG ret=QueryValue(valueName,&v);
*bValue = (BYTE)v;
return(ret);
}
// ------------------------------------ QueryValue ---------------------------
LONG DRegKey::QueryValue(LPCTSTR valueName , LONG *lValue)
{
DWORD v= (DWORD)*lValue;
LONG ret=QueryValue(valueName,&v);
*lValue = (LONG)v;
return(ret);
}
// ----------------------------------- QueryValue ----------------------------
// strings
LONG DRegKey::QueryValue(LPCTSTR valueName , LPSTR szValue, DWORD *pLength)
{
result = RegQueryValueEx(m_hKey,
valueName,
NULL, // reserved
NULL, // value type
(BYTE*)szValue,
pLength);
return(result);
} // QueryValue
// ----------------------------------- QueryValue ----------------------------
// strings
LONG DRegKey::QueryValue(LPCTSTR valueName , CString &string)
{
CHAR buffer[1024];
DWORD len = sizeof(buffer);
result = RegQueryValueEx(m_hKey,
valueName,
NULL, // reserved
NULL, // value type
(BYTE*)buffer,
&len);
if (ERROR_SUCCESS == result)
{
string = buffer;
}
return(result);
} // QueryValue
// ----------------------------------- QueryBinValue ----------------------------
// binary data
LONG DRegKey::QueryBinValue(LPCTSTR valueName , BYTE* binData, DWORD *pLength)
{
result = RegQueryValueEx(m_hKey,
valueName,
NULL, // reserved
NULL, // value type
binData,
pLength);
return(result);
} // QueryBinValue
// ----------------------------------- SetBinValue ----------------------------
// binary data
LONG DRegKey::SetBinValue(LPCTSTR valueName , BYTE* binData, DWORD length)
{
result = RegSetValueEx(m_hKey,
valueName,
0, // reserved
REG_BINARY, // value type
binData,
length);
return(result);
} // SetBinValue
// ----------------------------------- SetValue ------------------------------
// DWORD
LONG DRegKey::SetValue(LPCTSTR valueName , DWORD dwValue)
{
result = RegSetValueEx(m_hKey, valueName, 0, REG_DWORD, (BYTE*)&dwValue, sizeof(DWORD));
return(result);
} // SetValue
// ----------------------------------- SetValue ------------------------------
// strings
LONG DRegKey::SetValue(LPCTSTR valueName , LPCTSTR szValue, DWORD length)
{
if (-1 == length)
length = strlen(szValue);
result = RegSetValueEx(m_hKey, valueName, 0, REG_SZ, (BYTE*)szValue, length+1);
return(result);
} // SetValue
// ----------------------------------- SetValue ------------------------------
// Binary data
LONG DRegKey::SetValue(LPCTSTR valueName , const BYTE* binData, DWORD length)
{
result = RegSetValueEx(m_hKey, valueName, 0, REG_BINARY, binData, length);
return(result);
} // SetValue
// ----------------------------------- DeleteValue ---------------------------
LONG DRegKey::DeleteValue(LPCTSTR valueName)
{
result = RegDeleteValue(m_hKey, valueName);
return(result);
} // DeleteValue
// ----------------------------------- DeleteKey -----------------------------
// delete a key and all values, will not work if the key has any sub-keys
LONG DRegKey::DeleteKey(LPCTSTR keyName)
{
if (NULL != keyName)
{
// delete a subkey of the already opened key
result = ::RegDeleteKey(m_hKey, keyName);
}
else
{
// delete a key off the root key
result = ::RegDeleteKey(m_baseKey, m_KeyName);
}
return(result);
} // DeleteKey
// ----------------------------------- DeleteKeyRecurse ----------------------
// uses the global driverlib function to delete a key and all of it's
// subkeys
LONG DRegKey::DeleteKeyRecurse(LPCTSTR keyName)
{
if (NULL != keyName)
{
// call the driverlib function
::RegDelete(m_hKey, keyName);
result = GetLastError();
}
else
{
// call the driverlib function
::RegDelete(m_baseKey, m_KeyName);
result = GetLastError();
}
return(result);
} // DeleteKeyRecurse
// ------------------------------ EnumKey ------------------------
// populate a CStringarray with key names
LONG DRegKey::EnumKey(CStringArray &csaKeyNames)
{
LONG ret = ERROR_SUCCESS;
DWORD index=0;
CString keyName;
csaKeyNames.RemoveAll();
while (ERROR_SUCCESS == ret)
{
ret = EnumKey(index, keyName);
csaKeyNames.Add(keyName);
index++;
}
return(csaKeyNames.GetSize());
}
// ------------------------------ EnumKey ------------------------
// Supply the key name at an index
LONG DRegKey::EnumKey(DWORD index, CString &valueName)
{
LONG ret;
DWORD keyLengthMax;
// LONG RegQueryInfoKey(HKEY hKey, // handle to key
// LPTSTR lpClass, // class buffer
// LPDWORD lpcClass, // size of class buffer
// LPDWORD lpReserved, // reserved
// LPDWORD lpcSubKeys, // number of subkeys
// LPDWORD lpcMaxSubKeyLen, // longest subkey name
// LPDWORD lpcMaxClassLen, // longest class string
// LPDWORD lpcValues, // number of value entries
// LPDWORD lpcMaxValueNameLen, // longest value name
// LPDWORD lpcMaxValueLen, // longest value data
// LPDWORD lpcbSecurityDescriptor, // descriptor length
// PFILETIME lpftLastWriteTime ); // last write time
ret = RegQueryInfoKey(m_hKey, NULL, NULL,
NULL,
NULL, // number of subkeys
&keyLengthMax,
NULL,NULL,NULL,NULL,NULL,NULL);
if (ret != ERROR_SUCCESS)
return(ret);
ret = EnumKey(index, valueName.GetBufferSetLength(keyLengthMax), keyLengthMax);
valueName.ReleaseBuffer();
return(ret);
}
// ------------------------------ EnumKey ------------------------
// return the key name at an index
LONG DRegKey::EnumKey(DWORD index, LPSTR string, DWORD maxSize)
{
LONG ret;
ret = RegEnumKey(m_hKey, index, string, maxSize);
return(ret);
}