1381 lines
36 KiB
C++
1381 lines
36 KiB
C++
/******************************************************************************
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
Utils_RegKey.cpp
|
|
|
|
Abstract:
|
|
This file contains the implementation of the Registry wrapper.
|
|
|
|
Revision History:
|
|
Davide Massarenti (Dmassare) 04/28/99
|
|
created
|
|
|
|
******************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static bool IsPredefinedRegistryHandle( HKEY h )
|
|
{
|
|
return (h == HKEY_CLASSES_ROOT ||
|
|
h == HKEY_CURRENT_USER ||
|
|
h == HKEY_LOCAL_MACHINE ||
|
|
h == HKEY_PERFORMANCE_DATA ||
|
|
h == HKEY_PERFORMANCE_TEXT ||
|
|
h == HKEY_PERFORMANCE_NLSTEXT ||
|
|
h == HKEY_USERS ||
|
|
h == HKEY_CURRENT_CONFIG ||
|
|
h == HKEY_DYN_DATA );
|
|
}
|
|
|
|
static LONG safe_RegOpenKeyExW( HKEY hKey ,
|
|
LPCWSTR lpSubKey ,
|
|
DWORD ulOptions ,
|
|
REGSAM samDesired ,
|
|
PHKEY phkResult )
|
|
{
|
|
if(!STRINGISPRESENT(lpSubKey) && IsPredefinedRegistryHandle( hKey ) && phkResult) // Reopening a predefined registry key is considered bad!! Go figure....
|
|
{
|
|
*phkResult = hKey; return ERROR_SUCCESS;
|
|
}
|
|
|
|
return ::RegOpenKeyExW( hKey ,
|
|
lpSubKey ,
|
|
ulOptions ,
|
|
samDesired ,
|
|
phkResult );
|
|
}
|
|
|
|
static LONG safe_RegCloseKey( HKEY hKey )
|
|
{
|
|
if(IsPredefinedRegistryHandle( hKey )) // Closing a predefined registry key is considered bad!! Go figure....
|
|
{
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
return ::RegCloseKey( hKey );
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
MPC::RegKey::RegKey()
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::RegKey" );
|
|
|
|
|
|
m_samDesired = KEY_READ; // REGSAM m_samDesired;
|
|
m_hRoot = NULL; // HKEY m_hRoot;
|
|
m_hKey = NULL; // HKEY m_hKey;
|
|
//
|
|
// MPC::wstring m_strKey;
|
|
// MPC::wstring m_strPath;
|
|
// MPC::wstring m_strName;
|
|
|
|
}
|
|
|
|
MPC::RegKey::~RegKey()
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::~RegKey" );
|
|
|
|
|
|
(void)Clean( true );
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Clean( /*[in]*/ bool fBoth )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Clean" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
|
|
|
|
if(m_hKey != NULL)
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, safe_RegCloseKey( m_hKey ));
|
|
|
|
m_hKey = NULL;
|
|
}
|
|
|
|
if(fBoth == true)
|
|
{
|
|
if(m_hRoot != NULL)
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, safe_RegCloseKey( m_hRoot ));
|
|
|
|
m_hRoot = NULL;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
MPC::RegKey::operator HKEY() const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::operator HKEY()" );
|
|
|
|
HKEY hKey = m_hKey;
|
|
|
|
__MPC_FUNC_EXIT(hKey);
|
|
}
|
|
|
|
MPC::RegKey& MPC::RegKey::operator=( /*[in]*/ const RegKey& rk )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::operator=" );
|
|
|
|
|
|
Clean( true );
|
|
|
|
|
|
m_samDesired = rk.m_samDesired; // REGSAM m_samDesired;
|
|
// HKEY m_hRoot;
|
|
// HKEY m_hKey;
|
|
//
|
|
m_strKey = rk.m_strKey; // MPC::wstring m_strKey;
|
|
m_strPath = rk.m_strPath; // MPC::wstring m_strPath;
|
|
m_strName = rk.m_strName; // MPC::wstring m_strName;
|
|
|
|
if(rk.m_hRoot) (void)safe_RegOpenKeyExW( rk.m_hRoot, NULL, 0, m_samDesired, &m_hRoot );
|
|
if(rk.m_hKey ) (void)safe_RegOpenKeyExW( rk.m_hKey , NULL, 0, m_samDesired, &m_hKey );
|
|
|
|
|
|
__MPC_FUNC_EXIT(*this);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::SetRoot( /*[in]*/ HKEY hKey ,
|
|
/*[in]*/ REGSAM samDesired ,
|
|
/*[in]*/ LPCWSTR lpszMachine )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::SetRoot" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Clean( true ));
|
|
|
|
|
|
m_samDesired = samDesired;
|
|
|
|
if(lpszMachine && lpszMachine[0] && _wcsicmp( lpszMachine, L"localhost" ) != 0)
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegConnectRegistryW( lpszMachine, hKey, &m_hRoot ));
|
|
}
|
|
else
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, safe_RegOpenKeyExW( hKey, NULL, 0, m_samDesired, &m_hRoot ));
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Attach( /*[in]*/ LPCWSTR lpszKeyName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Attach" );
|
|
|
|
HRESULT hr;
|
|
MPC::wstring::size_type iPos;
|
|
|
|
|
|
//
|
|
// Release previously opened key, if any.
|
|
//
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Clean( false ));
|
|
|
|
m_strKey = lpszKeyName;
|
|
|
|
//
|
|
// If the key has a parent, split into basename and path.
|
|
//
|
|
iPos = m_strKey.rfind( '\\' );
|
|
if(iPos != MPC::wstring::npos)
|
|
{
|
|
m_strPath = m_strKey.substr( 0, iPos );
|
|
m_strName = m_strKey.substr( iPos+1 );
|
|
}
|
|
else
|
|
{
|
|
m_strPath = L"";
|
|
m_strName = m_strKey;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::Exists( /*[out]*/ bool& fFound ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Exists" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
|
|
|
|
//
|
|
// Default to a negative result, in case of errors.
|
|
//
|
|
fFound = false;
|
|
|
|
if(m_hKey == NULL)
|
|
{
|
|
lRes = safe_RegOpenKeyExW( m_hRoot, (m_strKey.empty() ? NULL : m_strKey.c_str()), 0, m_samDesired, &m_hKey );
|
|
if(lRes != ERROR_SUCCESS)
|
|
{
|
|
if(lRes == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, S_OK);
|
|
}
|
|
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, lRes);
|
|
}
|
|
}
|
|
|
|
fFound = true;
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Create() const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Create" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == false)
|
|
{
|
|
MPC::RegKey rkParent;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Parent( rkParent ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkParent.Create());
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegCreateKeyExW( rkParent.m_hKey, m_strName.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, m_samDesired, NULL, &m_hKey, NULL ));
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Delete( /*[in]*/ bool fDeep )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Delete" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == true)
|
|
{
|
|
MPC::RegKey rkParent;
|
|
|
|
if(fDeep)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, DeleteSubKeys());
|
|
}
|
|
|
|
//
|
|
// Release the opened key.
|
|
//
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Clean( false ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Parent( rkParent ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkParent.Exists( fFound ));
|
|
if(fFound == true)
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegDeleteKeyW( rkParent.m_hKey, m_strName.c_str() ));
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
|
|
}
|
|
|
|
HRESULT MPC::RegKey::SubKey( /*[in]*/ LPCWSTR lpszKeyName ,
|
|
/*[out]*/ RegKey& rkSubKey ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::SubKey" );
|
|
|
|
HRESULT hr;
|
|
MPC::wstring strKey;
|
|
|
|
|
|
//
|
|
// First of all, make a copy of the key.
|
|
//
|
|
rkSubKey = *this;
|
|
|
|
//
|
|
// Then close its key handle, but not the one to the root of the hive.
|
|
//
|
|
rkSubKey.Clean( false );
|
|
|
|
//
|
|
// Finally construct the name of the subkey.
|
|
//
|
|
strKey = m_strKey;
|
|
strKey += L"\\";
|
|
strKey += lpszKeyName;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkSubKey.Attach( strKey.c_str() ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Parent( /*[out]*/ RegKey& rkParent ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Parent" );
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
//
|
|
// First of all, make a copy of the key.
|
|
//
|
|
rkParent = *this;
|
|
|
|
//
|
|
// Then close its key handle, but not the one to the root of the hive.
|
|
//
|
|
rkParent.Clean( false );
|
|
|
|
//
|
|
// Finally attach it to the pathname of our parent.
|
|
//
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkParent.Attach( m_strPath.c_str() ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::EnumerateSubKeys( /*[out]*/ MPC::WStringList& lstSubKeys ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::EnumerateSubKeys" );
|
|
|
|
HRESULT hr;
|
|
DWORD dwIndex = 0;
|
|
WCHAR rgBuf[MAX_PATH + 1];
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
lstSubKeys.clear();
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == true)
|
|
{
|
|
while((lRes = ::RegEnumKeyW( m_hKey, dwIndex++, rgBuf, MAX_PATH )) == ERROR_SUCCESS)
|
|
{
|
|
lstSubKeys.push_back( MPC::wstring( rgBuf ) );
|
|
}
|
|
|
|
if(lRes != ERROR_SUCCESS &&
|
|
lRes != ERROR_NO_MORE_ITEMS )
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, lRes);
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::EnumerateValues( /*[out]*/ MPC::WStringList& lstValues ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::EnumerateValues" );
|
|
|
|
HRESULT hr;
|
|
DWORD dwIndex = 0;
|
|
DWORD dwCount;
|
|
WCHAR rgBuf[MAX_PATH + 1];
|
|
WCHAR* rgBuffer = NULL;
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
lstValues.clear();
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == false)
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
|
|
while(1)
|
|
{
|
|
WCHAR* rgPtr;
|
|
|
|
dwCount = MAXSTRLEN(rgBuf);
|
|
|
|
lRes = ::RegEnumValueW( m_hKey, dwIndex, rgPtr = rgBuf, &dwCount, NULL, NULL, NULL, NULL );
|
|
if(lRes == ERROR_MORE_DATA)
|
|
{
|
|
delete [] rgBuffer;
|
|
|
|
__MPC_EXIT_IF_ALLOC_FAILS(hr, rgBuffer, new WCHAR[dwCount+1]);
|
|
|
|
lRes = ::RegEnumValueW( m_hKey, dwIndex, rgPtr = rgBuffer, &dwCount, NULL, NULL, NULL, NULL );
|
|
}
|
|
if(lRes != ERROR_SUCCESS) break;
|
|
|
|
|
|
lstValues.push_back( MPC::wstring( rgPtr ) ); dwIndex++;
|
|
}
|
|
|
|
if(lRes != ERROR_SUCCESS &&
|
|
lRes != ERROR_NO_MORE_ITEMS )
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, lRes);
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
delete [] rgBuffer;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::DeleteSubKeys() const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::DeleteSubKeys" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
MPC::WStringList lst;
|
|
MPC::WStringIter it;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, EnumerateSubKeys( lst ));
|
|
|
|
for(it=lst.begin(); it != lst.end(); it++)
|
|
{
|
|
RegKey rkSubKey;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, SubKey( it->c_str(), rkSubKey ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkSubKey.Delete( true ));
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::DeleteValues() const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::DeleteValues" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
MPC::WStringList lst;
|
|
MPC::WStringIter it;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, EnumerateValues( lst ));
|
|
|
|
for(it=lst.begin(); it != lst.end(); it++)
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegDeleteValueW( m_hKey, it->c_str() ));
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::ReadDirect( /*[in ]*/ LPCWSTR lpszValueName ,
|
|
/*[out]*/ CComHGLOBAL& chg ,
|
|
/*[out]*/ DWORD& dwSize ,
|
|
/*[out]*/ DWORD& dwType ,
|
|
/*[out]*/ bool& fFound ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::ReadDirect" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
bool fFoundKey;
|
|
|
|
|
|
dwSize = 0;
|
|
dwType = 0;
|
|
fFound = false;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFoundKey ));
|
|
if(fFoundKey == false)
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, S_OK);
|
|
}
|
|
|
|
|
|
lRes = ::RegQueryValueExW( m_hKey, (LPWSTR)lpszValueName, NULL, &dwType, NULL, &dwSize );
|
|
if(lRes != ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// If the result is ERROR_FILE_NOT_FOUND, the value doesn't exist, so return VT_EMPTY (done by calling VariantClear).
|
|
//
|
|
if(lRes == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, S_OK);
|
|
}
|
|
|
|
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, lRes);
|
|
}
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, chg.New( GMEM_FIXED, dwSize ));
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegQueryValueExW( m_hKey, lpszValueName, NULL, NULL, (LPBYTE)chg.Get(), &dwSize ));
|
|
|
|
fFound = true;
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::WriteDirect( /*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ void* pBuffer ,
|
|
/*[in]*/ DWORD dwSize ,
|
|
/*[in]*/ DWORD dwType ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::WriteDirect" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == false)
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegSetValueExW( m_hKey, lpszValueName, NULL, dwType, (LPBYTE)pBuffer, dwSize ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::get_Key( /*[out]*/ MPC::wstring& strKey ) const
|
|
{
|
|
strKey = m_strKey;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT MPC::RegKey::get_Name( /*[out]*/ MPC::wstring& strName ) const
|
|
{
|
|
strName = m_strName;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT MPC::RegKey::get_Path( /*[out]*/ MPC::wstring& strPath ) const
|
|
{
|
|
strPath = m_strPath;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT MPC::RegKey::get_Value( /*[out]*/ VARIANT& vValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszValueName ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::get_Value" );
|
|
|
|
HRESULT hr;
|
|
CComHGLOBAL chg;
|
|
LPVOID ptr;
|
|
DWORD dwSize = 0;
|
|
DWORD dwType = 0;
|
|
bool fFoundKey;
|
|
LONG lRes;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::VariantClear( &vValue ));
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ReadDirect( lpszValueName, chg, dwSize, dwType, fFoundKey ));
|
|
if(fFoundKey == false)
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, S_OK);
|
|
}
|
|
|
|
ptr = chg.Lock();
|
|
|
|
if(dwType == REG_DWORD)
|
|
{
|
|
vValue.vt = VT_I4;
|
|
vValue.lVal = *(DWORD*)ptr;
|
|
}
|
|
else if(dwType == REG_SZ ||
|
|
dwType == REG_EXPAND_SZ )
|
|
{
|
|
vValue.vt = VT_BSTR;
|
|
vValue.bstrVal = ::SysAllocString( (LPCWSTR)ptr );
|
|
if(vValue.bstrVal == NULL && ((LPCWSTR)ptr)[0])
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else if(dwType == REG_MULTI_SZ)
|
|
{
|
|
BSTR* rgArrayData;
|
|
LPCWSTR szStrings;
|
|
int iCount;
|
|
|
|
//
|
|
// Count the number of strings.
|
|
//
|
|
iCount = 0;
|
|
szStrings = (LPCWSTR)ptr;
|
|
while(szStrings[0]) // This doesn't cover the case of null strings, but who cares?
|
|
{
|
|
szStrings += wcslen( szStrings ) + 1; iCount++;
|
|
}
|
|
|
|
//
|
|
// Allocate SAFEARRAY.
|
|
//
|
|
__MPC_EXIT_IF_ALLOC_FAILS(hr, vValue.parray, ::SafeArrayCreateVector( VT_BSTR, 0, iCount ));
|
|
vValue.vt = VT_ARRAY | VT_BSTR;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::SafeArrayAccessData( vValue.parray, (LPVOID*)&rgArrayData ));
|
|
|
|
//
|
|
// Copy strings into the SAFEARRAY.
|
|
//
|
|
szStrings = (LPCWSTR)ptr;
|
|
while(szStrings[0]) // This doesn't cover the case of null strings, but who cares?
|
|
{
|
|
if((*rgArrayData++ = ::SysAllocString( szStrings )) == NULL) break;
|
|
|
|
szStrings += wcslen( szStrings ) + 1;
|
|
}
|
|
|
|
::SafeArrayUnaccessData( vValue.parray );
|
|
|
|
if(szStrings[0]) // TRUE means we break out of the loop for an allocation failure.
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
else if(dwType == REG_BINARY)
|
|
{
|
|
BYTE* rgArrayData;
|
|
|
|
vValue.vt = VT_ARRAY | VT_UI1;
|
|
|
|
__MPC_EXIT_IF_ALLOC_FAILS(hr, vValue.parray, ::SafeArrayCreateVector( VT_UI1, 0, dwSize ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::SafeArrayAccessData( vValue.parray, (LPVOID*)&rgArrayData ));
|
|
|
|
::CopyMemory( rgArrayData, ptr, dwSize );
|
|
|
|
::SafeArrayUnaccessData( vValue.parray );
|
|
}
|
|
else
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, E_INVALIDARG);
|
|
}
|
|
|
|
fFound = true;
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::put_Value( /*[in]*/ const VARIANT vValue ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ bool fExpand ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::put_Value" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == false)
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
if(vValue.vt == VT_EMPTY)
|
|
{
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, del_Value( lpszValueName ));
|
|
}
|
|
else if(vValue.vt == VT_I4)
|
|
{
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegSetValueExW( m_hKey, lpszValueName, NULL, REG_DWORD, (LPBYTE)&vValue.lVal, sizeof(DWORD) ));
|
|
}
|
|
else if(vValue.vt == VT_BOOL)
|
|
{
|
|
LPCWSTR rgBuffer = vValue.boolVal ? L"true" : L"false";
|
|
UINT iLen = (wcslen( rgBuffer ) + 1) * sizeof(WCHAR);
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegSetValueExW( m_hKey, lpszValueName, NULL, fExpand ? REG_EXPAND_SZ : REG_SZ, (LPBYTE)rgBuffer, iLen ));
|
|
}
|
|
else if(vValue.vt == VT_BSTR)
|
|
{
|
|
LPCWSTR rgBuffer = SAFEBSTR(vValue.bstrVal);
|
|
UINT iLen = (wcslen( rgBuffer ) + 1) * sizeof(WCHAR);
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegSetValueExW( m_hKey, lpszValueName, NULL, fExpand ? REG_EXPAND_SZ : REG_SZ, (LPBYTE)rgBuffer, iLen ));
|
|
}
|
|
else if(vValue.vt == (VT_ARRAY | VT_BSTR))
|
|
{
|
|
LPWSTR rgBuffer;
|
|
LPWSTR rgBufferPtr;
|
|
BSTR* rgArrayData;
|
|
BSTR* rgArrayDataPtr;
|
|
DWORD dwLen;
|
|
long lBound;
|
|
long uBound;
|
|
long l;
|
|
int iSize;
|
|
|
|
::SafeArrayGetLBound( vValue.parray, 1, &lBound );
|
|
::SafeArrayGetUBound( vValue.parray, 1, &uBound );
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::SafeArrayAccessData( vValue.parray, (LPVOID*)&rgArrayData ));
|
|
|
|
iSize = 1;
|
|
rgArrayDataPtr = rgArrayData;
|
|
for(l=lBound; l<=uBound; l++)
|
|
{
|
|
if((dwLen = ::SysStringLen( *rgArrayDataPtr++ )))
|
|
{
|
|
iSize += dwLen + 1;
|
|
}
|
|
}
|
|
|
|
|
|
__MPC_EXIT_IF_ALLOC_FAILS(hr, rgBuffer, new WCHAR[iSize]);
|
|
|
|
rgArrayDataPtr = rgArrayData;
|
|
rgBufferPtr = rgBuffer;
|
|
for(l=lBound; l<=uBound; l++, rgArrayDataPtr++)
|
|
{
|
|
if((dwLen = ::SysStringLen( *rgArrayDataPtr )))
|
|
{
|
|
wcscpy( rgBufferPtr, SAFEBSTR(*rgArrayDataPtr) );
|
|
|
|
rgBufferPtr += dwLen + 1;
|
|
}
|
|
}
|
|
rgBufferPtr[0] = 0;
|
|
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegSetValueExW( m_hKey, lpszValueName, NULL, REG_MULTI_SZ, (LPBYTE)rgBuffer, iSize*sizeof(WCHAR) ));
|
|
|
|
::SafeArrayUnaccessData( vValue.parray );
|
|
}
|
|
else if(vValue.vt == (VT_ARRAY | VT_UI1))
|
|
{
|
|
BYTE* rgArrayData;
|
|
long lBound;
|
|
long uBound;
|
|
|
|
::SafeArrayGetLBound( vValue.parray, 1, &lBound );
|
|
::SafeArrayGetUBound( vValue.parray, 1, &uBound );
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::SafeArrayAccessData( vValue.parray, (LPVOID*)&rgArrayData ));
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegSetValueExW( m_hKey, lpszValueName, NULL, REG_BINARY, rgArrayData, uBound-lBound+1 ));
|
|
|
|
::SafeArrayUnaccessData( vValue.parray );
|
|
}
|
|
else
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, E_INVALIDARG);
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::del_Value( /*[in]*/ LPCWSTR lpszValueName ) const
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::del_Value" );
|
|
|
|
HRESULT hr;
|
|
LONG lRes;
|
|
bool fFound;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, Exists( fFound ));
|
|
if(fFound == false)
|
|
{
|
|
__MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
__MPC_EXIT_IF_SYSCALL_FAILS(hr, lRes, ::RegDeleteValueW( m_hKey, lpszValueName ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::Read( /*[out]*/ MPC::string& strValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszValueName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Read" );
|
|
|
|
HRESULT hr;
|
|
CComVariant vValue;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, get_Value( vValue, fFound, lpszValueName ));
|
|
|
|
if(vValue.vt == VT_BSTR)
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
strValue = W2A( SAFEBSTR(vValue.bstrVal) );
|
|
}
|
|
else
|
|
{
|
|
fFound = false;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Read( /*[out]*/ MPC::wstring& strValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszValueName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Read" );
|
|
|
|
HRESULT hr;
|
|
CComVariant vValue;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, get_Value( vValue, fFound, lpszValueName ));
|
|
|
|
if(vValue.vt == VT_BSTR)
|
|
{
|
|
strValue = SAFEBSTR(vValue.bstrVal);
|
|
}
|
|
else
|
|
{
|
|
fFound = false;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Read( /*[out]*/ CComBSTR& bstrValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszValueName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Read" );
|
|
|
|
HRESULT hr;
|
|
CComVariant vValue;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, get_Value( vValue, fFound, lpszValueName ));
|
|
|
|
if(vValue.vt == VT_BSTR)
|
|
{
|
|
bstrValue = vValue.bstrVal;
|
|
}
|
|
else
|
|
{
|
|
fFound = false;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Read( /*[out]*/ DWORD& dwValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszValueName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Read" );
|
|
|
|
HRESULT hr;
|
|
CComVariant vValue;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, get_Value( vValue, fFound, lpszValueName ));
|
|
|
|
if(vValue.vt == VT_I4)
|
|
{
|
|
dwValue = vValue.lVal;
|
|
}
|
|
else
|
|
{
|
|
fFound = false;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Read( /*[out]*/ MPC::WStringList& lstValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszValueName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Read" );
|
|
|
|
HRESULT hr;
|
|
CComVariant vValue;
|
|
|
|
|
|
lstValue.clear();
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, get_Value( vValue, fFound, lpszValueName ));
|
|
|
|
if(vValue.vt == (VT_ARRAY | VT_BSTR))
|
|
{
|
|
BSTR* rgArrayData;
|
|
long lBound;
|
|
long uBound;
|
|
long l;
|
|
|
|
::SafeArrayGetLBound( vValue.parray, 1, &lBound );
|
|
::SafeArrayGetUBound( vValue.parray, 1, &uBound );
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::SafeArrayAccessData( vValue.parray, (LPVOID*)&rgArrayData ));
|
|
|
|
for(l=lBound; l<=uBound; l++, rgArrayData++)
|
|
{
|
|
lstValue.push_back( SAFEBSTR(*rgArrayData) );
|
|
}
|
|
|
|
::SafeArrayUnaccessData( vValue.parray );
|
|
}
|
|
else
|
|
{
|
|
fFound = false;
|
|
}
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::Write( /*[in]*/ const MPC::string& strValue ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ bool fExpand )
|
|
{
|
|
USES_CONVERSION;
|
|
|
|
return put_Value( CComVariant( A2W( strValue.c_str() ) ), lpszValueName, fExpand );
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Write( /*[in]*/ const MPC::wstring& strValue ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ bool fExpand )
|
|
{
|
|
return put_Value( CComVariant( strValue.c_str() ), lpszValueName, fExpand );
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Write( /*[in]*/ BSTR bstrValue ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ bool fExpand )
|
|
{
|
|
return put_Value( CComVariant( bstrValue ), lpszValueName, fExpand );
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Write( /*[in]*/ DWORD dwValue ,
|
|
/*[in]*/ LPCWSTR lpszValueName )
|
|
{
|
|
return put_Value( CComVariant( (long)dwValue ), lpszValueName );
|
|
}
|
|
|
|
HRESULT MPC::RegKey::Write( /*[in]*/ const MPC::WStringList& lstValue ,
|
|
/*[in]*/ LPCWSTR lpszValueName )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::Write" );
|
|
|
|
HRESULT hr;
|
|
CComVariant vValue;
|
|
BSTR* rgArrayData;
|
|
bool fLocked = false;
|
|
|
|
//
|
|
// Allocate SAFEARRAY.
|
|
//
|
|
__MPC_EXIT_IF_ALLOC_FAILS(hr, vValue.parray, ::SafeArrayCreateVector( VT_BSTR, 0, lstValue.size() ));
|
|
vValue.vt = VT_ARRAY | VT_BSTR;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, ::SafeArrayAccessData( vValue.parray, (LPVOID*)&rgArrayData )); fLocked = true;
|
|
|
|
for(MPC::WStringIterConst it = lstValue.begin(); it != lstValue.end(); it++)
|
|
{
|
|
if((*rgArrayData++ = ::SysAllocString( it->c_str() )) == NULL)
|
|
{
|
|
__MPC_SET_ERROR_AND_EXIT(hr, E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
|
|
::SafeArrayUnaccessData( vValue.parray ); fLocked = false;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, put_Value( vValue, lpszValueName, /*fExpand*/false ));
|
|
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
if(fLocked) ::SafeArrayUnaccessData( vValue.parray );
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey::ParsePath( /*[in ]*/ LPCWSTR szKey ,
|
|
/*[out]*/ HKEY& hKey ,
|
|
/*[out]*/ LPCWSTR& szPath ,
|
|
/*[in ]*/ HKEY hKeyDefault )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey::ParsePath" );
|
|
|
|
|
|
static const WCHAR s_HKEY_CLASSES_ROOT [] = L"HKEY_CLASSES_ROOT";
|
|
static const WCHAR s_HKEY_CLASSES_ROOT_s [] = L"HKCR";
|
|
static const WCHAR s_HKEY_CURRENT_CONFIG [] = L"HKEY_CURRENT_CONFIG";
|
|
static const WCHAR s_HKEY_CURRENT_USER [] = L"HKEY_CURRENT_USER";
|
|
static const WCHAR s_HKEY_CURRENT_USER_s [] = L"HKCU";
|
|
static const WCHAR s_HKEY_LOCAL_MACHINE [] = L"HKEY_LOCAL_MACHINE";
|
|
static const WCHAR s_HKEY_LOCAL_MACHINE_s [] = L"HKLM";
|
|
static const WCHAR s_HKEY_PERFORMANCE_DATA[] = L"HKEY_PERFORMANCE_DATA";
|
|
static const WCHAR s_HKEY_USERS [] = L"HKEY_USERS";
|
|
|
|
static struct
|
|
{
|
|
HKEY hKey;
|
|
LPCWSTR szName;
|
|
int iLen;
|
|
} s_Lookup[] =
|
|
{
|
|
{ HKEY_CLASSES_ROOT , s_HKEY_CLASSES_ROOT , MAXSTRLEN(s_HKEY_CLASSES_ROOT ) },
|
|
{ HKEY_CLASSES_ROOT , s_HKEY_CLASSES_ROOT_s , MAXSTRLEN(s_HKEY_CLASSES_ROOT_s ) },
|
|
{ HKEY_CURRENT_CONFIG , s_HKEY_CURRENT_CONFIG , MAXSTRLEN(s_HKEY_CURRENT_CONFIG ) },
|
|
{ HKEY_CURRENT_USER , s_HKEY_CURRENT_USER , MAXSTRLEN(s_HKEY_CURRENT_USER ) },
|
|
{ HKEY_CURRENT_USER , s_HKEY_CURRENT_USER_s , MAXSTRLEN(s_HKEY_CURRENT_USER_s ) },
|
|
{ HKEY_LOCAL_MACHINE , s_HKEY_LOCAL_MACHINE , MAXSTRLEN(s_HKEY_LOCAL_MACHINE ) },
|
|
{ HKEY_LOCAL_MACHINE , s_HKEY_LOCAL_MACHINE_s , MAXSTRLEN(s_HKEY_LOCAL_MACHINE_s ) },
|
|
{ HKEY_PERFORMANCE_DATA, s_HKEY_PERFORMANCE_DATA, MAXSTRLEN(s_HKEY_PERFORMANCE_DATA) },
|
|
{ HKEY_USERS , s_HKEY_USERS , MAXSTRLEN(s_HKEY_USERS ) },
|
|
};
|
|
|
|
|
|
//
|
|
// Setup results in case of a mismatch.
|
|
//
|
|
hKey = hKeyDefault;
|
|
szPath = szKey;
|
|
|
|
|
|
for(int i=0; i<ARRAYSIZE(s_Lookup); i++)
|
|
{
|
|
LPCWSTR szName = s_Lookup[i].szName;
|
|
int iLen = s_Lookup[i].iLen;
|
|
|
|
if(!_wcsnicmp( szName, szKey, iLen ) && szKey[iLen] == '\\')
|
|
{
|
|
hKey = s_Lookup[i].hKey;
|
|
szPath = &szKey[iLen+1];
|
|
break;
|
|
}
|
|
}
|
|
|
|
__MPC_FUNC_EXIT(S_OK);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
HRESULT MPC::RegKey_Value_Read( /*[out]*/ VARIANT& vValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszKeyName ,
|
|
/*[in] */ LPCWSTR lpszValueName ,
|
|
/*[in] */ HKEY hKey )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey_Value_Read" );
|
|
|
|
HRESULT hr;
|
|
MPC::RegKey rkRead;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.SetRoot( hKey, KEY_READ ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.Attach ( lpszKeyName ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.get_Value( vValue, fFound, lpszValueName ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey_Value_Read( /*[out]*/ MPC::wstring& strValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszKeyName ,
|
|
/*[in] */ LPCWSTR lpszValueName ,
|
|
/*[in] */ HKEY hKey )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey_Value_Read" );
|
|
|
|
HRESULT hr;
|
|
MPC::RegKey rkRead;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.SetRoot( hKey, KEY_READ ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.Attach ( lpszKeyName ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.Read( strValue, fFound, lpszValueName ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey_Value_Read( /*[out]*/ DWORD& dwValue ,
|
|
/*[out]*/ bool& fFound ,
|
|
/*[in] */ LPCWSTR lpszKeyName ,
|
|
/*[in] */ LPCWSTR lpszValueName ,
|
|
/*[in] */ HKEY hKey )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey_Value_Read" );
|
|
|
|
HRESULT hr;
|
|
MPC::RegKey rkRead;
|
|
|
|
|
|
fFound = false;
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.SetRoot( hKey, KEY_READ ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.Attach ( lpszKeyName ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkRead.Read( dwValue, fFound, lpszValueName ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
////////////////////
|
|
|
|
HRESULT MPC::RegKey_Value_Write( /*[in]*/ const VARIANT& vValue ,
|
|
/*[in]*/ LPCWSTR lpszKeyName ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ HKEY hKey ,
|
|
/*[in]*/ bool fExpand )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey_Value_Write" );
|
|
|
|
HRESULT hr;
|
|
MPC::RegKey rkWrite;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.SetRoot( hKey, KEY_ALL_ACCESS ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Attach ( lpszKeyName ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Create ( ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.put_Value( vValue, lpszValueName, fExpand ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey_Value_Write( /*[in]*/ const MPC::wstring& strValue ,
|
|
/*[in]*/ LPCWSTR lpszKeyName ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ HKEY hKey ,
|
|
/*[in]*/ bool fExpand )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey_Value_Write" );
|
|
|
|
HRESULT hr;
|
|
MPC::RegKey rkWrite;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.SetRoot( hKey, KEY_ALL_ACCESS ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Attach ( lpszKeyName ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Create ( ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Write( strValue, lpszValueName, fExpand ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|
|
|
|
HRESULT MPC::RegKey_Value_Write( /*[in]*/ DWORD dwValue ,
|
|
/*[in]*/ LPCWSTR lpszKeyName ,
|
|
/*[in]*/ LPCWSTR lpszValueName ,
|
|
/*[in]*/ HKEY hKey )
|
|
{
|
|
__MPC_FUNC_ENTRY( COMMONID, "MPC::RegKey_Value_Write" );
|
|
|
|
HRESULT hr;
|
|
MPC::RegKey rkWrite;
|
|
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.SetRoot( hKey, KEY_ALL_ACCESS ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Attach ( lpszKeyName ));
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Create ( ));
|
|
|
|
__MPC_EXIT_IF_METHOD_FAILS(hr, rkWrite.Write( dwValue, lpszValueName ));
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
__MPC_FUNC_CLEANUP;
|
|
|
|
__MPC_FUNC_EXIT(hr);
|
|
}
|