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.
962 lines
22 KiB
962 lines
22 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1995 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <memory.h>
|
|
#include <ctype.h>
|
|
|
|
#include "tfschar.h"
|
|
#include "tregkey.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
// Convert a CStringList to the REG_MULTI_SZ format
|
|
DWORD StrList2MULTI_SZ(CStringList & strList, DWORD * pcbSize, BYTE ** ppbData)
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
|
|
POSITION pos ;
|
|
CString * pstr ;
|
|
int cbTotal = 0 ;
|
|
|
|
// Walk the list accumulating sizes
|
|
for ( pos = strList.GetHeadPosition() ;
|
|
pos != NULL && (pstr = & strList.GetNext( pos )) ; )
|
|
{
|
|
cbTotal += pstr->GetLength() + 1 ;
|
|
}
|
|
|
|
// Add on space for two NULL characters
|
|
cbTotal += 2;
|
|
|
|
// Allocate and fill a temporary buffer
|
|
if (*pcbSize = (cbTotal * sizeof(TCHAR) ) )
|
|
{
|
|
TRY
|
|
{
|
|
*ppbData = new BYTE[ *pcbSize] ;
|
|
|
|
// NULL out the data buffer
|
|
::ZeroMemory(*ppbData, *pcbSize);
|
|
|
|
BYTE * pbData = *ppbData ;
|
|
|
|
// Populate the buffer with the strings.
|
|
for ( pos = strList.GetHeadPosition() ;
|
|
pos != NULL && (pstr = & strList.GetNext( pos )) ; )
|
|
{
|
|
int cb = (pstr->GetLength() + 1) * sizeof(TCHAR) ;
|
|
::memcpy( pbData, (LPCTSTR) *pstr, cb ) ;
|
|
pbData += cb ;
|
|
}
|
|
|
|
// Assert that we have not passed the end of the buffer
|
|
Assert((pbData - *ppbData) < (int) *pcbSize);
|
|
|
|
// Assert that we have an extra NULL character
|
|
Assert(*((TCHAR *)pbData) == 0);
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY ;
|
|
}
|
|
END_CATCH_ALL
|
|
}
|
|
else
|
|
{
|
|
*ppbData = NULL;
|
|
}
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
// Convert a REG_MULTI_SZ format to the CStringList
|
|
DWORD MULTI_SZ2StrList(LPCTSTR pstrMulti_Sz, CStringList& strList)
|
|
{
|
|
DWORD dwErr = NOERROR;
|
|
|
|
strList.RemoveAll();
|
|
|
|
// Catch exceptions trying to build the list
|
|
TRY
|
|
{
|
|
if (pstrMulti_Sz)
|
|
{
|
|
while ( StrLen(pstrMulti_Sz) )
|
|
{
|
|
strList.AddTail( pstrMulti_Sz ) ;
|
|
pstrMulti_Sz += StrLen( pstrMulti_Sz ) + 1 ;
|
|
}
|
|
}
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY ;
|
|
}
|
|
END_CATCH_ALL
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::RegKey
|
|
Constructor
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
RegKey::RegKey()
|
|
: m_hKey(0)
|
|
{
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::~RegKey
|
|
Destructor
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
RegKey::~RegKey ()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::Open
|
|
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::Open( HKEY hKeyParent,
|
|
LPCTSTR pszSubKey,
|
|
REGSAM regSam,
|
|
LPCTSTR pszServerName)
|
|
{
|
|
HKEY hkBase = NULL ;
|
|
DWORD dwErr = 0;
|
|
|
|
Close();
|
|
|
|
// If we have a server name, try to open a remote connection
|
|
if ( pszServerName )
|
|
dwErr = ::RegConnectRegistry((LPTSTR) pszServerName, hKeyParent, &hkBase);
|
|
else
|
|
hkBase = hKeyParent ;
|
|
|
|
if ( dwErr == 0 )
|
|
{
|
|
if ( pszSubKey )
|
|
{
|
|
dwErr = ::RegOpenKeyEx( hkBase, pszSubKey, 0, regSam, & m_hKey ) ;
|
|
}
|
|
else
|
|
{
|
|
m_hKey = hkBase ;
|
|
hkBase = NULL ; // set to NULL so that the key doesn't get closed
|
|
}
|
|
|
|
if ( hkBase && (hkBase != hKeyParent) )
|
|
::RegCloseKey( hkBase ) ;
|
|
}
|
|
|
|
if ( dwErr )
|
|
m_hKey = NULL ;
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::Create
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::Create(
|
|
HKEY hKeyBase,
|
|
LPCTSTR pszSubKey,
|
|
DWORD dwOptions,
|
|
REGSAM regSam,
|
|
LPSECURITY_ATTRIBUTES pSecAttr,
|
|
LPCTSTR pszServerName )
|
|
{
|
|
HKEY hkBase = NULL ;
|
|
LONG dwErr = 0;
|
|
DWORD dwDisposition;
|
|
|
|
Close();
|
|
|
|
if ( pszServerName )
|
|
{
|
|
// This is a remote connection.
|
|
dwErr = ::RegConnectRegistry( (LPTSTR) pszServerName, hKeyBase, &hkBase );
|
|
}
|
|
else
|
|
hkBase = hKeyBase ;
|
|
|
|
if (dwErr == 0)
|
|
{
|
|
LPTSTR szEmpty = _T("");
|
|
|
|
dwErr = ::RegCreateKeyEx( hkBase, pszSubKey,
|
|
0, szEmpty,
|
|
dwOptions, regSam, pSecAttr,
|
|
& m_hKey,
|
|
& dwDisposition ) ;
|
|
|
|
if ( hkBase && (hkBase != hKeyBase) )
|
|
::RegCloseKey( hkBase ) ;
|
|
}
|
|
|
|
if ( dwErr )
|
|
m_hKey = NULL ;
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::Close
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::Close()
|
|
{
|
|
DWORD dwErr = 0;
|
|
if (m_hKey)
|
|
dwErr = ::RegCloseKey(m_hKey);
|
|
m_hKey = 0;
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::Detach
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HKEY RegKey::Detach()
|
|
{
|
|
HKEY hKey = m_hKey;
|
|
m_hKey = NULL;
|
|
return hKey;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::Attach
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
void RegKey::Attach(HKEY hKey)
|
|
{
|
|
Assert(m_hKey == NULL);
|
|
m_hKey = hKey;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::DeleteSubKey
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::DeleteSubKey(LPCTSTR lpszSubKey)
|
|
{
|
|
Assert(m_hKey != NULL);
|
|
return RegDeleteKey(m_hKey, lpszSubKey);
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::DeleteValue
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::DeleteValue(LPCTSTR lpszValue)
|
|
{
|
|
Assert(m_hKey != NULL);
|
|
return RegDeleteValue(m_hKey, (LPTSTR)lpszValue);
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::RecurseDeleteKey
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::RecurseDeleteKey(LPCTSTR lpszKey)
|
|
{
|
|
RegKey key;
|
|
DWORD dwRes = key.Open(m_hKey, lpszKey, KEY_READ | KEY_WRITE);
|
|
if (dwRes != ERROR_SUCCESS)
|
|
return dwRes;
|
|
|
|
FILETIME time;
|
|
TCHAR szBuffer[256];
|
|
DWORD dwSize = 256;
|
|
|
|
while (RegEnumKeyEx(key, 0, szBuffer, &dwSize, NULL, NULL, NULL,
|
|
&time)==ERROR_SUCCESS)
|
|
{
|
|
dwRes = key.RecurseDeleteKey(szBuffer);
|
|
if (dwRes != ERROR_SUCCESS)
|
|
return dwRes;
|
|
dwSize = 256;
|
|
}
|
|
key.Close();
|
|
return DeleteSubKey(lpszKey);
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::RecurseDeleteSubKeys
|
|
Deletes the subkeys of the current key.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::RecurseDeleteSubKeys()
|
|
{
|
|
FILETIME time;
|
|
TCHAR szBuffer[256];
|
|
DWORD dwSize = 256;
|
|
DWORD dwRes;
|
|
|
|
while (RegEnumKeyEx(m_hKey, 0, szBuffer, &dwSize, NULL, NULL, NULL,
|
|
&time)==ERROR_SUCCESS)
|
|
{
|
|
dwRes = RecurseDeleteKey(szBuffer);
|
|
if (dwRes != ERROR_SUCCESS)
|
|
return dwRes;
|
|
dwSize = 256;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::PrepareValue
|
|
Prepare to read a value by finding the value's size. This will
|
|
allocate space for the data. The data needs to be freed separately
|
|
by 'delete'.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::PrepareValue( LPCTSTR pszValueName,
|
|
DWORD * pdwType,
|
|
DWORD * pcbSize,
|
|
BYTE ** ppbData )
|
|
{
|
|
DWORD dwErr = 0;
|
|
|
|
BYTE chDummy[2] ;
|
|
DWORD cbData = 0 ;
|
|
|
|
do
|
|
{
|
|
// Set the resulting buffer size to 0.
|
|
*pcbSize = 0 ;
|
|
*ppbData = NULL ;
|
|
|
|
dwErr = ::RegQueryValueEx( m_hKey,
|
|
pszValueName,
|
|
0, pdwType,
|
|
chDummy, & cbData ) ;
|
|
|
|
// The only error we should get here is ERROR_MORE_DATA, but
|
|
// we may get no error if the value has no data.
|
|
if ( dwErr == 0 )
|
|
{
|
|
cbData = sizeof (LONG) ; // Just a fudgy number
|
|
}
|
|
else
|
|
if ( dwErr != ERROR_MORE_DATA )
|
|
break ;
|
|
|
|
// Allocate a buffer large enough for the data.
|
|
|
|
*ppbData = new BYTE [ (*pcbSize = cbData) + sizeof (LONG) ] ;
|
|
Assert(*ppbData);
|
|
|
|
// Now that have a buffer, re-fetch the value.
|
|
|
|
dwErr = ::RegQueryValueEx( m_hKey,
|
|
pszValueName,
|
|
0, pdwType,
|
|
*ppbData, &cbData ) ;
|
|
|
|
} while ( FALSE ) ;
|
|
|
|
if ( dwErr )
|
|
{
|
|
delete [] *ppbData ;
|
|
*ppbData = NULL;
|
|
*pcbSize = 0;
|
|
}
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
|
|
DWORD RegKey::QueryTypeAndSize(LPCTSTR pszValueName, DWORD *pdwType, DWORD *pdwSize)
|
|
{
|
|
return ::RegQueryValueEx(m_hKey, pszValueName, NULL, pdwType,
|
|
NULL, pdwSize);
|
|
}
|
|
|
|
DWORD RegKey::QueryValueExplicit(LPCTSTR pszValueName,
|
|
DWORD *pdwType,
|
|
DWORD *pdwSize,
|
|
LPBYTE *ppbData)
|
|
{
|
|
DWORD dwErr = 0;
|
|
DWORD dwType;
|
|
DWORD cbData;
|
|
BYTE * pbData = NULL;
|
|
|
|
Assert(pdwType);
|
|
Assert(pdwSize);
|
|
Assert(ppbData);
|
|
|
|
dwErr = PrepareValue( pszValueName, &dwType, &cbData, &pbData );
|
|
if (dwErr == ERROR_SUCCESS)
|
|
{
|
|
if (dwType != REG_MULTI_SZ)
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
}
|
|
else
|
|
{
|
|
*pdwType = dwType;
|
|
*pdwSize = cbData;
|
|
*ppbData = pbData;
|
|
pbData = NULL;
|
|
}
|
|
}
|
|
delete pbData;
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
// Overloaded value query members; each returns ERROR_INVALID_PARAMETER
|
|
// if data exists but not in correct form to deliver into result object.
|
|
|
|
DWORD RegKey::QueryValue( LPCTSTR pszValueName, CString& strResult )
|
|
{
|
|
DWORD dwErr = 0;
|
|
|
|
DWORD dwType ;
|
|
DWORD cbData ;
|
|
BYTE * pabData = NULL ;
|
|
|
|
do
|
|
{
|
|
if ( dwErr = PrepareValue( pszValueName, &dwType, &cbData, &pabData ) )
|
|
break ;
|
|
|
|
if (( dwType != REG_SZ ) && (dwType != REG_EXPAND_SZ))
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER ;
|
|
break ;
|
|
}
|
|
|
|
// Guarantee that the data looks like a string
|
|
pabData[cbData] = 0 ;
|
|
|
|
// Catch exceptions trying to assign to the caller's string
|
|
TRY
|
|
{
|
|
strResult = (LPCTSTR) pabData ;
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY ;
|
|
}
|
|
END_CATCH_ALL
|
|
}
|
|
while ( FALSE ) ;
|
|
|
|
delete [] pabData ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
|
|
DWORD RegKey::QueryValue ( LPCTSTR pchValueName, CStringList & strList )
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
|
|
DWORD dwType ;
|
|
DWORD cbData ;
|
|
BYTE * pabData = NULL ;
|
|
LPTSTR pbTemp, pbTempLimit;
|
|
|
|
do
|
|
{
|
|
if ( dwErr = PrepareValue( pchValueName, & dwType, & cbData, & pabData ) )
|
|
break ;
|
|
|
|
if ( dwType != REG_MULTI_SZ )
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER ;
|
|
break ;
|
|
}
|
|
|
|
// Guarantee that the trailing data looks like a string
|
|
pabData[cbData] = 0 ;
|
|
pbTemp = (LPTSTR) pabData ;
|
|
pbTempLimit = & pbTemp[MaxCchFromCb(cbData)-1] ;
|
|
|
|
dwErr = MULTI_SZ2StrList(pbTemp, strList);
|
|
|
|
}
|
|
while ( FALSE ) ;
|
|
|
|
delete [] pabData ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKey::QueryValue
|
|
Gets the DWORD value for this key. Returns ERROR_INVALID_PARAMETER
|
|
if the value is not a REG_DWORD.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
DWORD RegKey::QueryValue( LPCTSTR pszValueName, DWORD& dwResult )
|
|
{
|
|
DWORD dwErr;
|
|
DWORD cbData = sizeof(DWORD);
|
|
DWORD dwType = REG_DWORD;
|
|
|
|
dwErr = ::RegQueryValueEx( m_hKey,
|
|
pszValueName,
|
|
0, &dwType,
|
|
(LPBYTE) &dwResult, &cbData ) ;
|
|
|
|
if ((dwErr == ERROR_SUCCESS) && (dwType != REG_DWORD))
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
|
|
if ( dwErr )
|
|
dwResult = 0;
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD RegKey::QueryValue ( LPCTSTR pchValueName, LPTSTR pszDestBuffer, DWORD cchSize, BOOL fExpandSz)
|
|
{
|
|
DWORD dwErr;
|
|
DWORD cbData = MinCbNeededForCch(cchSize);
|
|
DWORD dwType = REG_SZ;
|
|
TCHAR * pszBuffer = (TCHAR *) _alloca(MinCbNeededForCch(cchSize));
|
|
|
|
dwErr = ::RegQueryValueEx( m_hKey,
|
|
pchValueName,
|
|
0, &dwType,
|
|
(LPBYTE) pszBuffer, &cbData ) ;
|
|
|
|
if ((dwErr == ERROR_SUCCESS) &&
|
|
(dwType != REG_SZ) &&
|
|
(dwType != REG_EXPAND_SZ) &&
|
|
(dwType != REG_MULTI_SZ))
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
|
|
|
|
if (dwErr == ERROR_SUCCESS)
|
|
{
|
|
if ((dwType == REG_EXPAND_SZ) && fExpandSz)
|
|
ExpandEnvironmentStrings(pszBuffer, pszDestBuffer, cchSize);
|
|
else
|
|
::CopyMemory(pszDestBuffer, pszBuffer, cbData);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
|
|
DWORD RegKey::QueryValue ( LPCTSTR pszValueName, CByteArray & abResult )
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
|
|
DWORD dwType ;
|
|
DWORD cbData ;
|
|
BYTE * pabData = NULL ;
|
|
|
|
do
|
|
{
|
|
if ( dwErr = PrepareValue( pszValueName, & dwType, & cbData, & pabData ) )
|
|
break ;
|
|
|
|
if ( dwType != REG_BINARY )
|
|
{
|
|
dwErr = ERROR_INVALID_PARAMETER ;
|
|
break ;
|
|
}
|
|
|
|
// Catch exceptions trying to grow the result array
|
|
TRY
|
|
{
|
|
abResult.SetSize( cbData ) ;
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY ;
|
|
}
|
|
END_CATCH_ALL
|
|
|
|
if ( dwErr )
|
|
break ;
|
|
|
|
// Move the data to the result array.
|
|
for ( DWORD i = 0 ; i < cbData ; i++ )
|
|
{
|
|
abResult[i] = pabData[i] ;
|
|
}
|
|
}
|
|
while ( FALSE ) ;
|
|
|
|
// Memory leak....
|
|
//if ( dwErr )
|
|
//{
|
|
delete [] pabData ;
|
|
//}
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
DWORD RegKey::QueryValue ( LPCTSTR pszValueName, void * pvResult, DWORD cbSize )
|
|
{
|
|
DWORD dwErr;
|
|
DWORD dwType = REG_BINARY;
|
|
|
|
dwErr = ::RegQueryValueEx( m_hKey,
|
|
pszValueName,
|
|
0, &dwType,
|
|
(LPBYTE) pvResult, &cbSize ) ;
|
|
|
|
if ((dwErr == ERROR_SUCCESS) && (dwType != REG_BINARY))
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD RegKey::SetValueExplicit(LPCTSTR pszValueName,
|
|
DWORD dwType,
|
|
DWORD dwSize,
|
|
LPBYTE pbData)
|
|
{
|
|
return ::RegSetValueEx( *this,
|
|
pszValueName,
|
|
0,
|
|
dwType,
|
|
pbData,
|
|
dwSize);
|
|
}
|
|
|
|
// Overloaded value setting members.
|
|
DWORD RegKey::SetValue ( LPCTSTR pszValueName, LPCTSTR pszValue,
|
|
BOOL fRegExpand)
|
|
{
|
|
DWORD dwErr = 0;
|
|
DWORD dwType = fRegExpand ? REG_EXPAND_SZ : REG_SZ;
|
|
|
|
dwErr = ::RegSetValueEx( *this,
|
|
pszValueName,
|
|
0,
|
|
dwType,
|
|
(const BYTE *) pszValue,
|
|
// This is not the correct string length
|
|
// for DBCS strings
|
|
pszValue ? CbStrLen(pszValue) : 0);
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
DWORD RegKey::SetValue ( LPCTSTR pszValueName, CStringList & strList )
|
|
{
|
|
|
|
DWORD dwErr = 0;
|
|
|
|
DWORD cbSize ;
|
|
BYTE * pbData = NULL ;
|
|
|
|
dwErr = FlattenValue( strList, & cbSize, & pbData ) ;
|
|
|
|
if ( dwErr == 0 )
|
|
{
|
|
dwErr = ::RegSetValueEx( *this,
|
|
pszValueName,
|
|
0,
|
|
REG_MULTI_SZ,
|
|
pbData,
|
|
cbSize ) ;
|
|
}
|
|
|
|
delete pbData ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
DWORD RegKey::SetValue ( LPCTSTR pszValueName, DWORD & dwResult )
|
|
{
|
|
DWORD dwErr = 0;
|
|
|
|
dwErr = ::RegSetValueEx( *this,
|
|
pszValueName,
|
|
0,
|
|
REG_DWORD,
|
|
(const BYTE *) & dwResult,
|
|
sizeof dwResult ) ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
DWORD RegKey::SetValue ( LPCTSTR pszValueName, CByteArray & abResult )
|
|
{
|
|
|
|
DWORD dwErr = 0;
|
|
|
|
DWORD cbSize ;
|
|
BYTE * pbData = NULL ;
|
|
|
|
dwErr = FlattenValue( abResult, & cbSize, & pbData ) ;
|
|
|
|
if ( dwErr == 0 )
|
|
{
|
|
dwErr = ::RegSetValueEx( *this,
|
|
pszValueName,
|
|
0,
|
|
REG_BINARY,
|
|
pbData,
|
|
cbSize ) ;
|
|
}
|
|
|
|
delete pbData ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
DWORD RegKey::SetValue ( LPCTSTR pszValueName, void * pvResult, DWORD cbSize )
|
|
{
|
|
|
|
DWORD dwErr = 0;
|
|
|
|
dwErr = ::RegSetValueEx( *this,
|
|
pszValueName,
|
|
0,
|
|
REG_BINARY,
|
|
(const BYTE *)pvResult,
|
|
cbSize ) ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
DWORD RegKey::FlattenValue (
|
|
CStringList & strList,
|
|
DWORD * pcbSize,
|
|
BYTE ** ppbData )
|
|
{
|
|
return StrList2MULTI_SZ(strList, pcbSize, ppbData);
|
|
}
|
|
|
|
DWORD RegKey::FlattenValue (
|
|
CByteArray & abData,
|
|
DWORD * pcbSize,
|
|
BYTE ** ppbData )
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
|
|
DWORD i ;
|
|
|
|
// Allocate and fill a temporary buffer
|
|
if (*pcbSize = (DWORD)abData.GetSize())
|
|
{
|
|
TRY
|
|
{
|
|
*ppbData = new BYTE[*pcbSize] ;
|
|
|
|
for ( i = 0 ; i < *pcbSize ; i++ )
|
|
{
|
|
(*ppbData)[i] = abData[i] ;
|
|
}
|
|
|
|
}
|
|
CATCH_ALL(e)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY ;
|
|
}
|
|
END_CATCH_ALL
|
|
}
|
|
else
|
|
{
|
|
*ppbData = NULL;
|
|
}
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
|
|
DWORD RegKey::QueryKeyInfo ( CREGKEY_KEY_INFO * pRegKeyInfo )
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
|
|
pRegKeyInfo->dwClassNameSize = sizeof pRegKeyInfo->chBuff - 1 ;
|
|
|
|
dwErr = ::RegQueryInfoKey( *this,
|
|
pRegKeyInfo->chBuff,
|
|
& pRegKeyInfo->dwClassNameSize,
|
|
NULL,
|
|
& pRegKeyInfo->dwNumSubKeys,
|
|
& pRegKeyInfo->dwMaxSubKey,
|
|
& pRegKeyInfo->dwMaxClass,
|
|
& pRegKeyInfo->dwMaxValues,
|
|
& pRegKeyInfo->dwMaxValueName,
|
|
& pRegKeyInfo->dwMaxValueData,
|
|
& pRegKeyInfo->dwSecDesc,
|
|
& pRegKeyInfo->ftKey ) ;
|
|
|
|
return dwErr ;
|
|
}
|
|
|
|
|
|
RegValueIterator::RegValueIterator()
|
|
: m_pRegKey( NULL ),
|
|
m_pszBuffer( NULL ),
|
|
m_cbBuffer( 0 )
|
|
{
|
|
}
|
|
|
|
HRESULT RegValueIterator::Init(RegKey *pRegKey)
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
RegKey::CREGKEY_KEY_INFO regKeyInfo ;
|
|
|
|
Reset() ;
|
|
|
|
m_pRegKey= pRegKey;
|
|
|
|
dwErr = pRegKey->QueryKeyInfo( & regKeyInfo ) ;
|
|
|
|
if ( dwErr == 0 )
|
|
{
|
|
m_cbBuffer = regKeyInfo.dwMaxValueName + sizeof (DWORD) ;
|
|
delete [] m_pszBuffer;
|
|
m_pszBuffer = new TCHAR [ m_cbBuffer ] ;
|
|
Assert(m_pszBuffer);
|
|
}
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
|
|
RegValueIterator::~RegValueIterator()
|
|
{
|
|
delete [] m_pszBuffer ;
|
|
}
|
|
|
|
HRESULT RegValueIterator::Next( CString * pstrName, DWORD * pdwType )
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
|
|
DWORD dwNameLength = m_cbBuffer ;
|
|
|
|
dwErr = ::RegEnumValue( *m_pRegKey,
|
|
m_dwIndex,
|
|
m_pszBuffer,
|
|
& dwNameLength,
|
|
NULL,
|
|
pdwType,
|
|
NULL,
|
|
NULL ) ;
|
|
|
|
if ( dwErr == 0 )
|
|
{
|
|
m_dwIndex++ ;
|
|
|
|
*pstrName = m_pszBuffer ;
|
|
}
|
|
|
|
return HRESULT_FROM_WIN32(dwErr) ;
|
|
}
|
|
|
|
|
|
RegKeyIterator::RegKeyIterator()
|
|
: m_pregkey(NULL),
|
|
m_pszBuffer(NULL),
|
|
m_cbBuffer( 0 )
|
|
{
|
|
}
|
|
|
|
HRESULT RegKeyIterator::Init(RegKey *pregkey)
|
|
{
|
|
DWORD dwErr = 0 ;
|
|
RegKey::CREGKEY_KEY_INFO regKeyInfo ;
|
|
|
|
Reset() ;
|
|
|
|
m_pregkey= pregkey;
|
|
|
|
dwErr = pregkey->QueryKeyInfo( & regKeyInfo ) ;
|
|
|
|
if ( dwErr == 0 )
|
|
{
|
|
m_cbBuffer = regKeyInfo.dwMaxSubKey + sizeof(DWORD);
|
|
delete [] m_pszBuffer;
|
|
m_pszBuffer = new TCHAR[m_cbBuffer];
|
|
}
|
|
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
|
|
RegKeyIterator::~RegKeyIterator ()
|
|
{
|
|
delete [] m_pszBuffer ;
|
|
}
|
|
|
|
HRESULT RegKeyIterator::Reset()
|
|
{
|
|
m_dwIndex = 0;
|
|
return hrOK;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RegKeyIterator::Next
|
|
Returns the name (and optional last write time) of the next key.
|
|
Return S_FALSE if there are no other items to be returned.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT RegKeyIterator::Next ( CString * pstrName, CTime * pTime )
|
|
{
|
|
DWORD dwErr = 0;
|
|
|
|
FILETIME ftDummy ;
|
|
DWORD dwNameSize = m_cbBuffer;
|
|
|
|
dwErr = ::RegEnumKeyEx( *m_pregkey,
|
|
m_dwIndex,
|
|
m_pszBuffer,
|
|
& dwNameSize,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
& ftDummy ) ;
|
|
if ( dwErr == 0 )
|
|
{
|
|
m_dwIndex++ ;
|
|
|
|
if ( pTime )
|
|
{
|
|
*pTime = ftDummy ;
|
|
}
|
|
|
|
if (pstrName)
|
|
{
|
|
*pstrName = m_pszBuffer ;
|
|
}
|
|
}
|
|
|
|
return (dwErr == ERROR_NO_MORE_ITEMS) ? S_FALSE : HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
|