mirror of https://github.com/tongzx/nt5src
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.
1564 lines
34 KiB
1564 lines
34 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
© 1998 Seagate Software, Inc. All rights reserved
|
|
|
|
Module Name:
|
|
|
|
wsbregty.cpp
|
|
|
|
Abstract:
|
|
|
|
This is the implementation of registry access helper functions
|
|
and is a part of RsCommon.dll.
|
|
|
|
Author:
|
|
|
|
Rohde Wakefield [rohde] 05-Nov-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
|
|
HRESULT
|
|
WsbOpenRegistryKey (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN REGSAM sam,
|
|
OUT HKEY * phKeyMachine,
|
|
OUT HKEY * phKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given a machine name and path, connect to obtain an HKEY
|
|
that can be used to do registry work.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
sam - permission desired to registry key.
|
|
|
|
phKeyMachine - return of HKEY to machine.
|
|
|
|
phKey - return of HKEY to path.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbOpenRegistryKey",
|
|
L"szMachine = '%ls', szPath = '%ls', sam = 0x%p, phKeyMachine = 0x%p, phKey = 0x%p",
|
|
szMachine, szPath, sam, phKeyMachine, phKey );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != phKey, E_POINTER );
|
|
WsbAssert ( 0 != phKeyMachine, E_POINTER );
|
|
|
|
*phKey = *phKeyMachine = 0;
|
|
|
|
WsbAffirmWin32 ( RegConnectRegistry ( (WCHAR*) szMachine, HKEY_LOCAL_MACHINE, phKeyMachine ) );
|
|
|
|
WsbAffirmWin32 ( RegOpenKeyEx ( *phKeyMachine, szPath, 0, sam, phKey ) );
|
|
|
|
|
|
} WsbCatchAndDo ( hr,
|
|
|
|
//
|
|
// Clean up from error
|
|
//
|
|
|
|
if ( phKeyMachine && *phKeyMachine ) {
|
|
|
|
RegCloseKey ( *phKeyMachine );
|
|
*phKeyMachine = 0;
|
|
|
|
}
|
|
|
|
) // WsbCatchAndDo
|
|
|
|
WsbTraceOut ( L"WsbOpenRegistryKey",
|
|
L"HRESULT = %ls, *phKeyMachine = %ls, *phKey = %ls",
|
|
WsbHrAsString ( hr ),
|
|
WsbStringCopy ( WsbPtrToPtrAsString ( (void**)phKeyMachine ) ),
|
|
WsbStringCopy ( WsbPtrToPtrAsString ( (void**)phKey ) ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbCloseRegistryKey (
|
|
IN OUT HKEY * phKeyMachine,
|
|
IN OUT HKEY * phKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
As a companion to WsbOpenRegistryKey, close the given keys and zero
|
|
their results.
|
|
|
|
Arguments:
|
|
|
|
phKeyMachine - HKEY to machine.
|
|
|
|
phKey - HKEY to path.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success.
|
|
|
|
E_POINTER - Invalid pointer passed in.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbCloseRegistryKey",
|
|
L"phKeyMachine = 0x%p, phKey = 0x%p", phKeyMachine, phKey );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != phKey, E_POINTER );
|
|
WsbAssert ( 0 != phKeyMachine, E_POINTER );
|
|
|
|
//
|
|
// Clean up the keys
|
|
//
|
|
|
|
if ( *phKey ) {
|
|
|
|
RegCloseKey ( *phKey );
|
|
*phKey = 0;
|
|
|
|
}
|
|
|
|
if ( *phKeyMachine ) {
|
|
|
|
RegCloseKey ( *phKeyMachine );
|
|
*phKeyMachine = 0;
|
|
|
|
}
|
|
} WsbCatch ( hr )
|
|
|
|
WsbTraceOut ( L"WsbCloseRegistryKey",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbRemoveRegistryKey (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine removes the value of a key as specified.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
E_POINTER - invalid pointer passed in as parameter.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbRemoveRegistryKey",
|
|
L"szMachine = '%ls', szPath = '%ls', szKey = '%ls'",
|
|
szMachine, szPath, szKey );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
|
|
//
|
|
// Open and delete the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_SET_VALUE | DELETE, &hKeyMachine, &hKey ) );
|
|
WsbAffirmWin32 ( RegDeleteKey ( hKey, szKey ) );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbRemoveRegistryKey",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbRemoveRegistryValue (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine removes the value of a key as specified.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to remove.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
E_POINTER - invalid pointer passed in as parameter.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbRemoveRegistryValue",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls'",
|
|
szMachine, szPath, szValue );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != szValue, E_POINTER );
|
|
|
|
//
|
|
// Open and write the value in the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_SET_VALUE, &hKeyMachine, &hKey ) );
|
|
WsbAffirmWin32 ( RegDeleteValue ( hKey, szValue ) );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbRemoveRegistryValue",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSetRegistryValueData (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
IN const BYTE *pData,
|
|
IN DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine set the value of a key as specified to the data
|
|
given. Type of the value is REG_BINARY.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to set.
|
|
|
|
pData - Pointer to the data buffer to copy into value.
|
|
|
|
cbData - Number of bytes to copy from pData.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
E_POINTER - invalid pointer passed in as parameter.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbSetRegistryValueData",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', pData = 0x%p, cbData = %ld",
|
|
szMachine, szPath, szValue, pData, cbData );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != szValue, E_POINTER );
|
|
|
|
//
|
|
// Open and write the value in the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_SET_VALUE, &hKeyMachine, &hKey ) );
|
|
WsbAffirmWin32 ( RegSetValueEx ( hKey, szValue, 0, REG_BINARY, pData, cbData ) );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbSetRegistryValueData",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbGetRegistryValueData (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
OUT BYTE *pData,
|
|
IN DWORD cbData,
|
|
OUT DWORD * pcbData OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the value of a key as specified. Type of
|
|
the value must be REG_BINARY.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
pData - Pointer to the data buffer to copy into value.
|
|
|
|
cbData - Size in bytes of pData.
|
|
|
|
pcbData - number of bytes filled in pData.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured getting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbGetRegistryValueData",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', pData = 0x%p, cbData = %ld, pcbData = 0x%p",
|
|
szMachine, szPath, szValue, pData, cbData, pcbData );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != szValue, E_POINTER );
|
|
WsbAssert ( 0 != pData, E_POINTER );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_QUERY_VALUE, &hKeyMachine, &hKey ) );
|
|
|
|
//
|
|
// Set up temporary vars in case NULL passed for pcbData
|
|
//
|
|
DWORD dwType, cbData2;
|
|
if ( !pcbData ) {
|
|
|
|
pcbData = &cbData2;
|
|
|
|
}
|
|
|
|
//
|
|
// Query for the REG_BINARY value
|
|
//
|
|
|
|
*pcbData = cbData;
|
|
WsbAffirmWin32 ( RegQueryValueEx ( hKey, szValue, 0, &dwType, pData, pcbData ) );
|
|
|
|
WsbAffirm ( REG_BINARY == dwType, E_FAIL );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbGetRegistryValueData",
|
|
L"HRESULT = %ls, *pcbData = %ls", WsbHrAsString ( hr ), WsbPtrToUlongAsString ( pcbData ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSetRegistryValueString (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
IN const OLECHAR * szString,
|
|
IN DWORD dwType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine set the value of a key as specified to the data
|
|
given. Type of the value is dwType (defaults to REG_SZ)
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to set.
|
|
|
|
szString - The string to place in the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbSetRegistryValueString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', szString = '%ls'",
|
|
szMachine, szPath, szValue, szString );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != szValue, E_POINTER );
|
|
WsbAssert ( 0 != szString, E_POINTER );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_SET_VALUE, &hKeyMachine, &hKey ) );
|
|
|
|
WsbAffirmWin32 ( RegSetValueEx ( hKey, szValue, 0, dwType, (BYTE*)szString, ( wcslen ( szString ) + 1 ) * sizeof ( OLECHAR ) ) );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbSetRegistryValueString",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbGetRegistryValueString (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
OUT OLECHAR * szString,
|
|
IN DWORD cSize,
|
|
OUT DWORD *pcLength OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine get the value specified
|
|
Type of the value must be REG_SZ or REG_EXPAND_SZ
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
szString - The string buffer to fill with the value.
|
|
|
|
cSize - Size of szString in OLECAHR's.
|
|
|
|
pcLength - Number of OLECHAR actually written (without L'\0').
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbGetRegistryValueString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', szString = 0x%p, cSize = '%ld', pcLength = 0x%p",
|
|
szMachine, szPath, szValue, szString, cSize, pcLength );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != szValue, E_POINTER );
|
|
WsbAssert ( 0 != szString, E_POINTER );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_QUERY_VALUE, &hKeyMachine, &hKey ) );
|
|
|
|
|
|
//
|
|
// Temporary size vars in case pcLength is NULL
|
|
//
|
|
|
|
DWORD dwType, cbData2;
|
|
if ( !pcLength ) {
|
|
|
|
pcLength = &cbData2;
|
|
|
|
}
|
|
|
|
//
|
|
// And do the query
|
|
//
|
|
|
|
*pcLength = cSize * sizeof ( OLECHAR );
|
|
WsbAffirmWin32 ( RegQueryValueEx ( hKey, szValue, 0, &dwType, (BYTE*)szString, pcLength ) ) ;
|
|
|
|
WsbAffirm ( (REG_SZ == dwType) || (REG_EXPAND_SZ == dwType), E_FAIL );
|
|
|
|
//
|
|
// return characters, not bytes
|
|
//
|
|
|
|
*pcLength = ( *pcLength / sizeof ( OLECHAR ) ) - 1;
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbGetRegistryValueString",
|
|
L"HRESULT = %ls, szString = '%ls', *pcbLength = %ls",
|
|
WsbHrAsString ( hr ), szString, WsbPtrToUlongAsString ( pcLength ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
HRESULT
|
|
WsbGetRegistryValueMultiString (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
OUT OLECHAR * szMultiString,
|
|
IN DWORD cSize,
|
|
OUT DWORD *pcLength OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine get the value specified
|
|
Type of the value must be REG_MULTI_SZ
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
szMultiString - The string buffer to fill with the value.
|
|
|
|
cSize - Size of szString in OLECAHR's.
|
|
|
|
pcLength - Number of OLECHAR actually written (without L'\0').
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbGetRegistryValueMultiString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', szMultiString = 0x%p, cSize = '%ld', pcLength = 0x%p",
|
|
szMachine, szPath, szValue, szMultiString, cSize, pcLength );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
WsbAssert ( 0 != szValue, E_POINTER );
|
|
WsbAssert ( 0 != szMultiString, E_POINTER );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_QUERY_VALUE, &hKeyMachine, &hKey ) );
|
|
|
|
|
|
//
|
|
// Temporary size vars in case pcLength is NULL
|
|
//
|
|
|
|
DWORD dwType, cbData2;
|
|
if ( !pcLength ) {
|
|
|
|
pcLength = &cbData2;
|
|
|
|
}
|
|
|
|
//
|
|
// And do the query
|
|
//
|
|
|
|
*pcLength = cSize * sizeof ( OLECHAR );
|
|
WsbAffirmWin32 ( RegQueryValueEx ( hKey, szValue, 0, &dwType, (BYTE*)szMultiString, pcLength ) ) ;
|
|
|
|
WsbAffirm ( REG_MULTI_SZ == dwType, E_FAIL );
|
|
|
|
//
|
|
// return characters, not bytes
|
|
//
|
|
|
|
*pcLength = ( *pcLength / sizeof ( OLECHAR ) ) - 1;
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbGetRegistryValueMultiString",
|
|
L"HRESULT = %ls, *pcbLength = %ls",
|
|
WsbHrAsString ( hr ), WsbPtrToUlongAsString ( pcLength ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSetRegistryValueDWORD (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
IN DWORD dw
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine set the value of a key as specified to the data
|
|
given. Type of the value is REG_DWORD
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to set.
|
|
|
|
dw - DWORD value to store.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbSetRegistryValueDWORD",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', dw = %lu [0x%p]",
|
|
szMachine, szPath, szValue, dw, dw );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssertPointer( szPath );
|
|
WsbAssertPointer( szValue );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_SET_VALUE, &hKeyMachine, &hKey ) );
|
|
|
|
WsbAffirmWin32 ( RegSetValueEx ( hKey, szValue, 0, REG_DWORD, (BYTE*)&dw, sizeof( DWORD ) ) );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbSetRegistryValueDWORD",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbGetRegistryValueDWORD(
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
OUT DWORD * pdw
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine set the value of a key as specified to the data
|
|
given. Type of the value is REG_SZ or REG_EXPAND_SZ
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
pdw - pointer to a DWORD to store value in.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbGetRegistryValueDWORD",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', pdw = 0x%p",
|
|
szMachine, szPath, szValue, pdw );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssertPointer( szPath );
|
|
WsbAssertPointer( szValue );
|
|
WsbAssertPointer( pdw );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, szPath, KEY_QUERY_VALUE, &hKeyMachine, &hKey ) );
|
|
|
|
|
|
//
|
|
// And do the query
|
|
//
|
|
|
|
DWORD dwType, cbData = sizeof( DWORD );
|
|
WsbAffirmWin32 ( RegQueryValueEx ( hKey, szValue, 0, &dwType, (BYTE*)pdw, &cbData ) ) ;
|
|
|
|
WsbAffirm( REG_DWORD == dwType, E_FAIL );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbGetRegistryValueDWORD",
|
|
L"HRESULT = %ls, *pdw = %ls",
|
|
WsbHrAsString ( hr ), WsbPtrToUlongAsString ( pdw ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbAddRegistryValueDWORD (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
IN DWORD adw
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine adds an amount to a registry value.
|
|
Type of the value must be REG_DWORD
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to increment
|
|
|
|
adw - DWORD value to add.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbAddRegistryValueDWORD",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', adw = %lu",
|
|
szMachine, szPath, szValue, adw);
|
|
|
|
HRESULT hr = S_OK;
|
|
DWORD value = 0;
|
|
|
|
// Get the old value
|
|
hr = WsbGetRegistryValueDWORD(szMachine, szPath, szValue, &value);
|
|
|
|
// Add to value and replace
|
|
if (S_OK == hr) {
|
|
value += adw;
|
|
} else {
|
|
value = adw;
|
|
}
|
|
hr = WsbSetRegistryValueDWORD(szMachine, szPath, szValue, value);
|
|
|
|
WsbTraceOut ( L"WsbAddRegistryValueDWORD",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbIncRegistryValueDWORD (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine increments a registry value by one.
|
|
Type of the value must be REG_DWORD
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to increment
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbIncRegistryValueDWORD",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls'",
|
|
szMachine, szPath, szValue);
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = WsbAddRegistryValueDWORD(szMachine, szPath, szValue, 1);
|
|
|
|
WsbTraceOut ( L"WsbIncRegistryValueDWORD",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbCheckIfRegistryKeyExists(
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine check if the supplied key exists
|
|
If the key already exists, S_OK is returned.
|
|
If it needed to be created, S_FALSE is returned.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Key already exists.
|
|
|
|
S_FALSE - Connection made, key did not exist but was created
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured creating the key.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbCheckIfRegistryKeyExists",
|
|
L"szMachine = '%ls', szPath = '%ls'", szMachine, szPath );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
HRESULT resultOpen = WsbOpenRegistryKey ( szMachine, szPath, KEY_QUERY_VALUE, &hKeyMachine, &hKey );
|
|
|
|
//
|
|
// If key could be opened, everything is fine - return S_OK
|
|
//
|
|
|
|
if ( SUCCEEDED ( resultOpen ) ) {
|
|
hr = S_OK;
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
} else {
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
|
|
WsbTraceOut ( L"WsbCheckIfRegistryKeyExists",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbEnsureRegistryKeyExists (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine creates the key specified by szPath. Multiple
|
|
levels in the path can be missing and thus created. If the
|
|
key already exists, S_OK is returned. If it needed to be
|
|
created, S_FALSE is returned.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Key already exists.
|
|
|
|
S_FALSE - Connection made, key did not exist but was created
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured creating the key.
|
|
|
|
--*/
|
|
|
|
{
|
|
WsbTraceIn ( L"WsbEnsureRegistryKeyExists",
|
|
L"szMachine = '%ls', szPath = '%ls'", szMachine, szPath );
|
|
|
|
HKEY hKeyMachine = 0,
|
|
hKey = 0;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
//
|
|
// Ensure parameters are valid
|
|
//
|
|
|
|
WsbAssert ( 0 != szPath, E_POINTER );
|
|
|
|
//
|
|
// Open the key
|
|
//
|
|
|
|
HRESULT resultOpen = WsbOpenRegistryKey ( szMachine, szPath, KEY_QUERY_VALUE, &hKeyMachine, &hKey );
|
|
|
|
//
|
|
// If key could be opened, everything is fine - return S_OK
|
|
//
|
|
|
|
if ( SUCCEEDED ( resultOpen ) ) {
|
|
|
|
hr = S_OK;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Otherwise, we need to start at root and create missing portion
|
|
//
|
|
|
|
//
|
|
// Create a copy of the string. Using WsbQuickString so we have
|
|
// automatic freeing of memory
|
|
//
|
|
|
|
WsbQuickString copyString ( szPath );
|
|
WCHAR * pSubKey = copyString;
|
|
|
|
WsbAffirm ( 0 != pSubKey, E_OUTOFMEMORY );
|
|
|
|
DWORD result, createResult;
|
|
HKEY hSubKey;
|
|
|
|
WsbAffirmHr ( WsbOpenRegistryKey ( szMachine, L"", KEY_CREATE_SUB_KEY, &hKeyMachine, &hKey ) );
|
|
|
|
pSubKey = wcstok ( pSubKey, L"\\" );
|
|
|
|
while ( 0 != pSubKey ) {
|
|
|
|
//
|
|
// Create the key. If it exists, RegCreateKeyEx returns
|
|
// REG_OPENED_EXISTING_KEY which is ok here.
|
|
//
|
|
|
|
createResult = 0;
|
|
|
|
result = RegCreateKeyEx ( hKey, pSubKey, 0, L"",
|
|
REG_OPTION_NON_VOLATILE, KEY_CREATE_SUB_KEY, 0, &hSubKey, &createResult );
|
|
|
|
WsbAffirm ( ERROR_SUCCESS == result, E_FAIL );
|
|
|
|
WsbAffirm (
|
|
( REG_CREATED_NEW_KEY == createResult ) ||
|
|
( REG_OPENED_EXISTING_KEY == createResult), E_FAIL );
|
|
|
|
//
|
|
// And move this hkey to be the next parent
|
|
//
|
|
|
|
RegCloseKey ( hKey );
|
|
hKey = hSubKey;
|
|
hSubKey = 0;
|
|
|
|
//
|
|
// And finally, find next token
|
|
//
|
|
|
|
pSubKey = wcstok ( 0, L"\\" );
|
|
|
|
};
|
|
|
|
//
|
|
// If we succeeded to this point, return S_FALSE
|
|
// for successfull creation of path
|
|
//
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbCloseRegistryKey ( &hKeyMachine, &hKey );
|
|
|
|
WsbTraceOut ( L"WsbEnsureRegistryKeyExists",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSetRegistryValueUlongAsString (
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
IN ULONG value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine puts a ULONG value in the registry as a string value.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to set.
|
|
|
|
value - ULONG value to store.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn ( L"WsbSetRegistryValueUlongAsString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', value = %lu",
|
|
szMachine, szPath, szValue, value );
|
|
|
|
try {
|
|
OLECHAR dataString[100];
|
|
|
|
WsbAffirmHr(WsbEnsureRegistryKeyExists(szMachine, szPath));
|
|
wsprintf(dataString, OLESTR("%lu"), value);
|
|
WsbAffirmHr(WsbSetRegistryValueString (szMachine, szPath, szValue,
|
|
dataString, REG_SZ));
|
|
} WsbCatch ( hr )
|
|
|
|
WsbTraceOut ( L"WsbSetRegistryValueUlongAsString",
|
|
L"HRESULT = %ls", WsbHrAsString ( hr ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbGetRegistryValueUlongAsString(
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
OUT ULONG * pvalue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine gets a string value from the registry and converts
|
|
it to a ULONG value.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
pvalue - pointer to a ULONG to store value in.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn ( L"WsbGetRegistryValueUlongAsString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', pvalue = 0x%p",
|
|
szMachine, szPath, szValue, pvalue );
|
|
|
|
try {
|
|
OLECHAR dataString[100];
|
|
DWORD sizeGot;
|
|
OLECHAR * stopString;
|
|
|
|
WsbAssertPointer( pvalue );
|
|
|
|
WsbAffirmHr(WsbGetRegistryValueString(szMachine, szPath, szValue,
|
|
dataString, 100, &sizeGot));
|
|
*pvalue = wcstoul( dataString, &stopString, 10 );
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbTraceOut ( L"WsbGetRegistryValueUlongAsString",
|
|
L"HRESULT = %ls, *pvalue = %ls",
|
|
WsbHrAsString ( hr ), WsbPtrToUlongAsString ( pvalue ) );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
HRESULT
|
|
WsbGetRegistryValueUlongAsMultiString(
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
OUT ULONG ** ppValues,
|
|
OUT ULONG * pNumValues
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine gets a multi-string value from the registry and converts
|
|
it to a vector of ULONG values.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
ppvalues - pointer to a ULONG * to alloacte and store the output vector in
|
|
|
|
pNumValues - Number of items returned
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured getting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn ( L"WsbGetRegistryValueUlongAsString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls'",
|
|
szMachine, szPath, szValue );
|
|
|
|
try {
|
|
OLECHAR dataString[256];
|
|
DWORD sizeGot;
|
|
OLECHAR * stopString;
|
|
|
|
WsbAssertPointer(ppValues);
|
|
WsbAssertPointer(pNumValues);
|
|
|
|
*pNumValues = 0;
|
|
*ppValues = NULL;
|
|
|
|
WsbAffirmHr(WsbGetRegistryValueMultiString(szMachine, szPath, szValue,
|
|
dataString, 256, &sizeGot));
|
|
|
|
// Build the output vector
|
|
OLECHAR *currentString = dataString;
|
|
int size = 10;
|
|
if ((*currentString) != NULL) {
|
|
// first alocation
|
|
*ppValues = (ULONG *)WsbAlloc(size*sizeof(ULONG));
|
|
WsbAffirm(*ppValues != 0, E_OUTOFMEMORY);
|
|
} else {
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
while ((*currentString) != NULL) {
|
|
(*ppValues)[*pNumValues] = wcstoul( currentString, &stopString, 10 );
|
|
(*pNumValues)++;
|
|
|
|
if (*pNumValues == size) {
|
|
size += 10;
|
|
ULONG* pTmp = (ULONG *)WsbRealloc(*ppValues, size*sizeof(ULONG));
|
|
WsbAffirm(0 != pTmp, E_OUTOFMEMORY);
|
|
*ppValues = pTmp;
|
|
}
|
|
|
|
currentString += wcslen(currentString);
|
|
currentString ++;
|
|
}
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbTraceOut ( L"WsbGetRegistryValueUlongAsString",
|
|
L"HRESULT = %ls, num values = %lu",
|
|
WsbHrAsString ( hr ), *pNumValues );
|
|
|
|
return ( hr );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbRegistryValueUlongAsString(
|
|
IN const OLECHAR * szMachine OPTIONAL,
|
|
IN const OLECHAR * szPath,
|
|
IN const OLECHAR * szValue,
|
|
IN OUT ULONG * pvalue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
If a registry string value is present, this routine gets it and converts
|
|
it to a ULONG value. If it is not present, this routine sets it to the
|
|
supplied default value.
|
|
|
|
Arguments:
|
|
|
|
szMachine - Name of computer to connect to.
|
|
|
|
szPath - Path inside registry to connect to.
|
|
|
|
szValue - Name of the value to get.
|
|
|
|
pvalue - In: default value , Out: pointer to a ULONG to store value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Connection made, Success.
|
|
|
|
CO_E_OBJNOTCONNECTED - could not connect to registry or key.
|
|
|
|
E_POINTER - invalid pointer in parameters.
|
|
|
|
E_FAIL - Failure occured setting the value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn ( L"WsbRegistryValueUlongAsString",
|
|
L"szMachine = '%ls', szPath = '%ls', szValue = '%ls', pvalue = 0x%p",
|
|
szMachine, szPath, szValue, pvalue );
|
|
|
|
try {
|
|
ULONG l_value;
|
|
|
|
WsbAssertPointer( pvalue );
|
|
|
|
if (S_OK == WsbGetRegistryValueUlongAsString(szMachine, szPath, szValue,
|
|
&l_value)) {
|
|
*pvalue = l_value;
|
|
} else {
|
|
WsbAffirmHr(WsbSetRegistryValueUlongAsString(szMachine, szPath,
|
|
szValue, *pvalue));
|
|
}
|
|
|
|
} WsbCatch ( hr )
|
|
|
|
WsbTraceOut ( L"WsbRegistryValueUlongAsString",
|
|
L"HRESULT = %ls, *pvalue = %ls",
|
|
WsbHrAsString ( hr ), WsbPtrToUlongAsString ( pvalue ) );
|
|
|
|
return ( hr );
|
|
}
|