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.
652 lines
15 KiB
652 lines
15 KiB
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Regsval.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the client side wrappers for the Win32 Registry
|
|
set value APIs. That is:
|
|
|
|
- RegSetValueA
|
|
- RegSetValueW
|
|
- RegSetValueExA
|
|
- RegSetValueExW
|
|
|
|
Author:
|
|
|
|
David J. Gilman (davegi) 18-Mar-1992
|
|
|
|
Notes:
|
|
|
|
See the notes in server\regsval.c.
|
|
|
|
--*/
|
|
|
|
#include <rpc.h>
|
|
#include "regrpc.h"
|
|
#include "client.h"
|
|
#include <string.h>
|
|
#include <wow64reg.h>
|
|
|
|
|
|
LONG
|
|
RegSetValueA (
|
|
HKEY hKey,
|
|
LPCSTR lpSubKey,
|
|
DWORD dwType,
|
|
LPCSTR lpData,
|
|
DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Win 3.1 ANSI RPC wrapper for setting a value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY ChildKey;
|
|
LONG Error;
|
|
HKEY TempHandle = NULL;
|
|
|
|
#if DBG
|
|
if ( BreakPointOnEntry ) {
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// Limit the capabilities associated with HKEY_PERFORMANCE_DATA.
|
|
//
|
|
|
|
if( hKey == HKEY_PERFORMANCE_DATA ) {
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Check the value type for compatability w/Win 3.1
|
|
//
|
|
|
|
if( dwType != REG_SZ ) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
hKey = MapPredefinedHandle( hKey, &TempHandle );
|
|
if( hKey == NULL ) {
|
|
Error = ERROR_INVALID_HANDLE;
|
|
goto ExitCleanup;
|
|
}
|
|
|
|
//
|
|
// Win3.1ism - Win 3.1 ignores the cbData parameter so it is computed
|
|
// here instead as the length of the string plus the NUL character.
|
|
//
|
|
|
|
cbData = strlen( lpData ) + 1;
|
|
|
|
|
|
//
|
|
// If the sub-key is NULL or points to an empty string then the value is
|
|
// set in this key (i.e. hKey) otherwise the sub-key needs to be
|
|
// opened/created.
|
|
//
|
|
|
|
if(( lpSubKey == NULL ) || ( *lpSubKey == '\0' )) {
|
|
|
|
ChildKey = hKey;
|
|
|
|
} else {
|
|
|
|
//
|
|
// The sub-key was supplied so attempt to open/create it.
|
|
//
|
|
|
|
Error = RegCreateKeyExA(
|
|
hKey,
|
|
lpSubKey,
|
|
0,
|
|
WIN31_CLASS,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
NULL,
|
|
&ChildKey,
|
|
NULL
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto ExitCleanup;
|
|
}
|
|
}
|
|
|
|
//
|
|
// ChildKey contains an HKEY which may be the one supplied (hKey) or
|
|
// returned from RegCreateKeyA. Set the value using the special value
|
|
// name NULL.
|
|
//
|
|
|
|
Error = RegSetValueExA(
|
|
ChildKey,
|
|
NULL,
|
|
0,
|
|
dwType,
|
|
lpData,
|
|
cbData
|
|
);
|
|
|
|
//
|
|
// If the sub key was opened, close it.
|
|
//
|
|
|
|
if( ChildKey != hKey ) {
|
|
|
|
Error = RegCloseKey( ChildKey );
|
|
ASSERT( Error == ERROR_SUCCESS );
|
|
}
|
|
|
|
//
|
|
// Return the results of setting the value.
|
|
//
|
|
|
|
ExitCleanup:
|
|
CLOSE_LOCAL_HANDLE(TempHandle);
|
|
return Error;
|
|
}
|
|
|
|
LONG
|
|
RegSetValueW (
|
|
HKEY hKey,
|
|
LPCWSTR lpSubKey,
|
|
DWORD dwType,
|
|
LPCWSTR lpData,
|
|
DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Win 3.1 Unicode RPC wrapper for setting a value.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY ChildKey;
|
|
LONG Error;
|
|
HKEY TempHandle = NULL;
|
|
|
|
#if DBG
|
|
if ( BreakPointOnEntry ) {
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// Limit the capabilities associated with HKEY_PERFORMANCE_DATA.
|
|
//
|
|
|
|
if( hKey == HKEY_PERFORMANCE_DATA ) {
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Check the value type for compatability w/Win 3.1
|
|
//
|
|
|
|
if( dwType != REG_SZ ) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
hKey = MapPredefinedHandle( hKey, &TempHandle);
|
|
if( hKey == NULL ) {
|
|
Error = ERROR_INVALID_HANDLE;
|
|
goto ExitCleanup;
|
|
}
|
|
|
|
//
|
|
// Win3.1ism - Win 3.1 ignores the cbData parameter so it is computed
|
|
// here instead as the length of the string plus the UNICODE_NUL
|
|
// character.
|
|
//
|
|
|
|
cbData = wcslen( lpData ) * sizeof( WCHAR ) + sizeof( UNICODE_NULL );;
|
|
|
|
//
|
|
// If the sub-key is NULL or points to an empty string then the value is
|
|
// set in this key (i.e. hKey) otherwise the sub-key needs to be
|
|
// opened/created.
|
|
//
|
|
|
|
if(( lpSubKey == NULL ) || ( *lpSubKey == '\0' )) {
|
|
|
|
ChildKey = hKey;
|
|
|
|
} else {
|
|
|
|
//
|
|
// The sub-key was supplied attempt to open/create it.
|
|
//
|
|
|
|
Error = RegCreateKeyExW(
|
|
hKey,
|
|
lpSubKey,
|
|
0,
|
|
WIN31_CLASS,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
NULL,
|
|
&ChildKey,
|
|
NULL
|
|
);
|
|
|
|
if( Error != ERROR_SUCCESS ) {
|
|
goto ExitCleanup;
|
|
}
|
|
}
|
|
|
|
//
|
|
// ChildKey contains an HKEY which may be the one supplied (hKey) or
|
|
// returned from RegCreateKeyW. Set the value using the special value
|
|
// name NULL.
|
|
//
|
|
|
|
Error = RegSetValueExW(
|
|
ChildKey,
|
|
NULL,
|
|
0,
|
|
dwType,
|
|
( LPBYTE ) lpData,
|
|
cbData
|
|
);
|
|
|
|
//
|
|
// If the sub key was opened/created, close it.
|
|
//
|
|
|
|
if( ChildKey != hKey ) {
|
|
|
|
RegCloseKey( ChildKey );
|
|
}
|
|
|
|
//
|
|
// Return the results of querying the value.
|
|
//
|
|
|
|
ExitCleanup:
|
|
CLOSE_LOCAL_HANDLE(TempHandle);
|
|
return Error;
|
|
}
|
|
|
|
LONG
|
|
APIENTRY
|
|
RegSetValueExA (
|
|
HKEY hKey,
|
|
LPCSTR lpValueName,
|
|
DWORD Reserved,
|
|
DWORD dwType,
|
|
CONST BYTE* lpData,
|
|
DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Win32 ANSI RPC wrapper for setting a value.
|
|
|
|
RegSetValueExA converts the lpValueName argument to a counted Unicode
|
|
string and then calls BaseRegSetValue.
|
|
|
|
--*/
|
|
|
|
{
|
|
PUNICODE_STRING ValueName;
|
|
UNICODE_STRING TempValueName;
|
|
UNICODE_STRING UnicodeString;
|
|
NTSTATUS Status;
|
|
LPBYTE ValueData;
|
|
|
|
PSTR AnsiValueBuffer;
|
|
ULONG AnsiValueLength;
|
|
PWSTR UnicodeValueBuffer;
|
|
ULONG UnicodeValueLength;
|
|
ULONG Index;
|
|
|
|
LONG Error;
|
|
HKEY TempHandle = NULL;
|
|
|
|
#if DBG
|
|
if ( BreakPointOnEntry ) {
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Limit the capabilities associated with HKEY_PERFORMANCE_DATA.
|
|
//
|
|
|
|
if( hKey == HKEY_PERFORMANCE_DATA ) {
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Ensure Reserved is zero to avoid future compatability problems.
|
|
//
|
|
|
|
if( Reserved != 0 ) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
hKey = MapPredefinedHandle( hKey, &TempHandle );
|
|
if( hKey == NULL ) {
|
|
Error = ERROR_INVALID_HANDLE;
|
|
goto ExitCleanup;
|
|
}
|
|
|
|
//
|
|
// Convert the value name to a counted Unicode string
|
|
//
|
|
if ( lpValueName ) {
|
|
|
|
//
|
|
// Convert the SubKey name to a counted Unicode
|
|
//
|
|
if( !RtlCreateUnicodeStringFromAsciiz(&TempValueName,lpValueName) ) {
|
|
Status = STATUS_NO_MEMORY;
|
|
Error = RtlNtStatusToDosError( Status );
|
|
goto ExitCleanup;
|
|
}
|
|
|
|
ValueName = &TempValueName;
|
|
|
|
//
|
|
// Add the NULL to the Length, so that RPC will transmit it
|
|
//
|
|
ValueName->Length += sizeof( UNICODE_NULL );
|
|
|
|
if( ValueName->Length == 0 ) {
|
|
//
|
|
// overflow in RtlCreateUnicodeStringFromAsciiz
|
|
//
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
goto ExitCleanup;
|
|
}
|
|
} else {
|
|
|
|
//
|
|
// No name was passed. Use our internal UNICODE string
|
|
// and set its fields to NULL. We don't use the static
|
|
// unicode string in the TEB in this case because we
|
|
// can't mess with its Buffer and MaximumLength fields.
|
|
//
|
|
ValueName = &UnicodeString;
|
|
ValueName->Length = 0;
|
|
ValueName->MaximumLength = 0;
|
|
ValueName->Buffer = NULL;
|
|
}
|
|
|
|
//
|
|
// If type is one of the null terminated string types, then do the ANSI to
|
|
// UNICODE translation into an allocated buffer.
|
|
//
|
|
ValueData = ( LPBYTE )lpData;
|
|
if (dwType == REG_SZ || dwType == REG_EXPAND_SZ || dwType == REG_MULTI_SZ) {
|
|
|
|
//
|
|
// Special hack to help out all the people who
|
|
// believe the length of a NULL terminated string is
|
|
// strlen(foo) instead of strlen(foo) + 1.
|
|
//
|
|
if ((cbData > 0) &&
|
|
(lpData[cbData-1] != 0)) {
|
|
//
|
|
// Do this under an exception handler in case the last
|
|
// little bit crosses a page boundary.
|
|
//
|
|
try {
|
|
if (lpData[cbData] == 0) {
|
|
cbData += 1; // increase string length to account for NULL terminator
|
|
}
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
; // guess they really really did not want a NULL terminator
|
|
|
|
}
|
|
}
|
|
AnsiValueBuffer = ValueData;
|
|
AnsiValueLength = cbData;
|
|
|
|
UnicodeValueLength = cbData * sizeof( WCHAR );
|
|
UnicodeValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0,
|
|
UnicodeValueLength
|
|
);
|
|
if (UnicodeValueBuffer == NULL) {
|
|
Error = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else {
|
|
|
|
Status = RtlMultiByteToUnicodeN( UnicodeValueBuffer,
|
|
UnicodeValueLength,
|
|
&Index,
|
|
AnsiValueBuffer,
|
|
AnsiValueLength
|
|
);
|
|
if (!NT_SUCCESS( Status )) {
|
|
Error = RtlNtStatusToDosError( Status );
|
|
} else {
|
|
ValueData = (LPBYTE)UnicodeValueBuffer;
|
|
cbData = Index;
|
|
Error = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
} else {
|
|
Error = ERROR_SUCCESS;
|
|
}
|
|
|
|
if ( Error == ERROR_SUCCESS ) {
|
|
|
|
//
|
|
// Call the Base API, passing it the supplied parameters and the
|
|
// counted Unicode strings.
|
|
//
|
|
|
|
if( IsLocalHandle( hKey )) {
|
|
|
|
Error = (LONG)LocalBaseRegSetValue (
|
|
hKey,
|
|
ValueName,
|
|
dwType,
|
|
ValueData,
|
|
cbData
|
|
);
|
|
#if defined(_WIN64)
|
|
if ( Error == 0)
|
|
Wow64RegSetKeyDirty (hKey);
|
|
#endif
|
|
} else {
|
|
|
|
Error = (LONG)BaseRegSetValue (
|
|
DereferenceRemoteHandle( hKey ),
|
|
ValueName,
|
|
dwType,
|
|
ValueData,
|
|
cbData
|
|
);
|
|
}
|
|
}
|
|
|
|
if( ValueData != lpData ) {
|
|
RtlFreeHeap( RtlProcessHeap(), 0, UnicodeValueBuffer );
|
|
}
|
|
if ( lpValueName ) {
|
|
// free the allocated unicode string
|
|
RtlFreeUnicodeString( &TempValueName );
|
|
}
|
|
|
|
ExitCleanup:
|
|
CLOSE_LOCAL_HANDLE(TempHandle);
|
|
return Error;
|
|
}
|
|
|
|
LONG
|
|
APIENTRY
|
|
RegSetValueExW (
|
|
HKEY hKey,
|
|
LPCWSTR lpValueName,
|
|
DWORD Reserved,
|
|
DWORD dwType,
|
|
CONST BYTE* lpData,
|
|
DWORD cbData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Win32 Unicode RPC wrapper for setting a value.
|
|
|
|
RegSetValueExW converts the lpValueName argument to a counted Unicode
|
|
string and then calls BaseRegSetValue.
|
|
|
|
--*/
|
|
|
|
{
|
|
UNICODE_STRING ValueName;
|
|
UNALIGNED WCHAR *String;
|
|
DWORD StringLength;
|
|
LONG Error;
|
|
HKEY TempHandle = NULL;
|
|
ULONG Length;
|
|
|
|
#if DBG
|
|
if ( BreakPointOnEntry ) {
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// Limit the capabilities associated with HKEY_PERFORMANCE_DATA.
|
|
//
|
|
|
|
if( hKey == HKEY_PERFORMANCE_DATA ) {
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
if ((hKey == HKEY_PERFORMANCE_TEXT) ||
|
|
(hKey == HKEY_PERFORMANCE_NLSTEXT)) {
|
|
return(PerfRegSetValue(hKey,
|
|
( LPWSTR )lpValueName,
|
|
Reserved,
|
|
dwType,
|
|
( LPBYTE )lpData,
|
|
cbData));
|
|
}
|
|
|
|
//
|
|
// Ensure Reserved is zero to avoid future compatability problems.
|
|
//
|
|
|
|
if( Reserved != 0 ) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
hKey = MapPredefinedHandle( hKey, &TempHandle );
|
|
if( hKey == NULL ) {
|
|
Error = ERROR_INVALID_HANDLE;
|
|
goto ExitCleanup;
|
|
}
|
|
|
|
//
|
|
// Special hack to help out all the people who
|
|
// believe the length of a NULL terminated string is
|
|
// strlen(foo) instead of strlen(foo) + 1.
|
|
//
|
|
String = (UNALIGNED WCHAR *)lpData;
|
|
StringLength = cbData/sizeof(WCHAR);
|
|
if (((dwType == REG_SZ) || (dwType == REG_EXPAND_SZ) || (dwType == REG_MULTI_SZ)) &&
|
|
(StringLength > 0) &&
|
|
(String[StringLength-1] != 0)) {
|
|
//
|
|
// Do this under an exception handler in case the last
|
|
// little bit crosses a page boundary.
|
|
//
|
|
try {
|
|
if (String[StringLength] == 0) {
|
|
cbData += sizeof(WCHAR); // increase string length to account for NULL terminator
|
|
}
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
; // guess they really really did not want a NULL terminator
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if( lpValueName != NULL ) {
|
|
Length = wcslen( lpValueName ) * sizeof( WCHAR );
|
|
ValueName.Length = (USHORT)Length;
|
|
if( Length != (ULONG)ValueName.Length ) {
|
|
//
|
|
// 32K overflow
|
|
//
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
goto ExitCleanup;
|
|
}
|
|
}
|
|
//
|
|
// Convert the value name to a counted Unicode string.
|
|
//
|
|
|
|
RtlInitUnicodeString( &ValueName, lpValueName );
|
|
|
|
//
|
|
// Add the NULL to the Length, so that RPC will transmit it
|
|
//
|
|
ValueName.Length += sizeof( UNICODE_NULL );
|
|
|
|
if( ValueName.Length == 0 ) {
|
|
//
|
|
// overflow in RtlInitUnicodeString
|
|
//
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
goto ExitCleanup;
|
|
}
|
|
//
|
|
// Call the Base API, passing it the supplied parameters and the
|
|
// counted Unicode strings.
|
|
//
|
|
|
|
if( IsLocalHandle( hKey )) {
|
|
|
|
Error = (LONG)LocalBaseRegSetValue (
|
|
hKey,
|
|
&ValueName,
|
|
dwType,
|
|
( LPBYTE )lpData,
|
|
cbData
|
|
);
|
|
#if defined(_WIN64)
|
|
if ( Error == 0)
|
|
Wow64RegSetKeyDirty (hKey);
|
|
#endif
|
|
|
|
} else {
|
|
|
|
Error = (LONG)BaseRegSetValue (
|
|
DereferenceRemoteHandle( hKey ),
|
|
&ValueName,
|
|
dwType,
|
|
( LPBYTE )lpData,
|
|
cbData
|
|
);
|
|
}
|
|
|
|
ExitCleanup:
|
|
CLOSE_LOCAL_HANDLE(TempHandle);
|
|
return Error;
|
|
}
|