#include <advapi32.h>
#include <ndk/cmfuncs.h>
#include <pseh/pseh2.h>
#include "reg.h"

Include dependency graph for reg.c:

Macros
#define	MAX_DEFAULT_HANDLES 6

#define	REG_MAX_NAME_SIZE 256

#define	REG_MAX_DATA_SIZE 2048

#define	ClosePredefKey(Handle)

#define	IsPredefKey(HKey) (((ULONG_PTR)(HKey) & 0xF0000000) == 0x80000000)

#define	GetPredefKeyIndex(HKey) ((ULONG_PTR)(HKey) & 0x0FFFFFFF)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (reg)

static NTSTATUS	MapDefaultKey (PHANDLE ParentKey, HKEY Key)

static VOID	CloseDefaultKeys (VOID)

static NTSTATUS	OpenClassesRootKey (PHANDLE KeyHandle)

static NTSTATUS	OpenLocalMachineKey (PHANDLE KeyHandle)

static NTSTATUS	OpenUsersKey (PHANDLE KeyHandle)

static NTSTATUS	OpenCurrentConfigKey (PHANDLE KeyHandle)

static __inline int	is_string (DWORD type)

BOOL	RegInitialize (VOID)

BOOL	RegCleanup (VOID)

static NTSTATUS	OpenPredefinedKey (IN ULONG Index, OUT HANDLE Handle)

static NTSTATUS	MapDefaultKey (OUT PHANDLE RealKey, IN HKEY Key)

static NTSTATUS	OpenClassesRootKey (_Out_ PHANDLE KeyHandle)

LONG WINAPI	RegDisablePredefinedCache (VOID)

LONG WINAPI	RegDisablePredefinedCacheEx (VOID)

LONG WINAPI	RegOverridePredefKey (IN HKEY hKey, IN HKEY hNewHKey OPTIONAL)

LONG WINAPI	RegCloseKey (HKEY hKey)

static NTSTATUS	RegpCopyTree (IN HKEY hKeySrc, IN HKEY hKeyDest)

LONG WINAPI	RegCopyTreeW (IN HKEY hKeySrc, IN LPCWSTR lpSubKey OPTIONAL, IN HKEY hKeyDest)

LONG WINAPI	RegCopyTreeA (IN HKEY hKeySrc, IN LPCSTR lpSubKey OPTIONAL, IN HKEY hKeyDest)

LONG WINAPI	RegConnectRegistryA (IN LPCSTR lpMachineName, IN HKEY hKey, OUT PHKEY phkResult)

LONG WINAPI	RegConnectRegistryW (LPCWSTR lpMachineName, HKEY hKey, PHKEY phkResult)

static NTSTATUS	CreateNestedKey (PHKEY KeyHandle, POBJECT_ATTRIBUTES ObjectAttributes, PUNICODE_STRING ClassString, DWORD dwOptions, REGSAM samDesired, DWORD *lpdwDisposition)

LONG WINAPI	RegCreateKeyExA (_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD Reserved, _In_ LPSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_ LPDWORD lpdwDisposition)

LONG WINAPI	RegCreateKeyExW (_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)

LONG WINAPI	RegCreateKeyA (HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)

LONG WINAPI	RegCreateKeyW (HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)

LONG WINAPI	RegDeleteKeyA (_In_ HKEY hKey, _In_ LPCSTR lpSubKey)

LONG WINAPI	RegDeleteKeyW (_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)

LONG WINAPI	RegDeleteKeyExA (_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ REGSAM samDesired, _In_ DWORD Reserved)

LONG WINAPI	RegDeleteKeyExW (_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ REGSAM samDesired, _In_ DWORD Reserved)

LONG WINAPI	RegDeleteKeyValueW (IN HKEY hKey, IN LPCWSTR lpSubKey OPTIONAL, IN LPCWSTR lpValueName OPTIONAL)

LONG WINAPI	RegDeleteKeyValueA (IN HKEY hKey, IN LPCSTR lpSubKey OPTIONAL, IN LPCSTR lpValueName OPTIONAL)

LSTATUS WINAPI	RegDeleteTreeW (HKEY hKey, LPCWSTR lpszSubKey)

LONG WINAPI	RegDeleteTreeA (IN HKEY hKey, IN LPCSTR lpSubKey OPTIONAL)

LONG WINAPI	RegDisableReflectionKey (IN HKEY hBase)

LONG WINAPI	RegEnableReflectionKey (IN HKEY hBase)

static VOID	RegpApplyRestrictions (DWORD dwFlags, DWORD dwType, DWORD cbData, PLONG ret)

LSTATUS WINAPI	RegGetValueW (HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)

LSTATUS WINAPI	RegGetValueA (HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)

LONG WINAPI	RegSetKeyValueW (IN HKEY hKey, IN LPCWSTR lpSubKey OPTIONAL, IN LPCWSTR lpValueName OPTIONAL, IN DWORD dwType, IN LPCVOID lpData OPTIONAL, IN DWORD cbData)

LONG WINAPI	RegSetKeyValueA (IN HKEY hKey, IN LPCSTR lpSubKey OPTIONAL, IN LPCSTR lpValueName OPTIONAL, IN DWORD dwType, IN LPCVOID lpData OPTIONAL, IN DWORD cbData)

LONG WINAPI	RegDeleteValueA (HKEY hKey, LPCSTR lpValueName)

LONG WINAPI	RegDeleteValueW (HKEY hKey, LPCWSTR lpValueName)

LONG WINAPI	RegEnumKeyA (HKEY hKey, DWORD dwIndex, LPSTR lpName, DWORD cbName)

LONG WINAPI	RegEnumKeyW (HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cbName)

LONG WINAPI	RegEnumKeyExA (_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)

LONG WINAPI	RegEnumKeyExW (_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)

LONG WINAPI	RegEnumValueA (_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpdwReserved, _Out_opt_ LPDWORD lpdwType, _Out_opt_ LPBYTE lpData, _Inout_opt_ LPDWORD lpcbData)

LONG WINAPI	RegEnumValueW (_In_ HKEY hKey, _In_ DWORD index, _Out_ LPWSTR value, _Inout_ PDWORD val_count, _Reserved_ PDWORD reserved, _Out_opt_ PDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ PDWORD count)

LONG WINAPI	RegFlushKey (HKEY hKey)

LONG WINAPI	RegGetKeySecurity (HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor, LPDWORD lpcbSecurityDescriptor)

LONG WINAPI	RegLoadKeyA (HKEY hKey, LPCSTR lpSubKey, LPCSTR lpFile)

LONG WINAPI	RegLoadKeyW (HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpFile)

LONG WINAPI	RegNotifyChangeKeyValue (HKEY hKey, BOOL bWatchSubtree, DWORD dwNotifyFilter, HANDLE hEvent, BOOL fAsynchronous)

LONG WINAPI	RegOpenCurrentUser (IN REGSAM samDesired, OUT PHKEY phkResult)

LONG WINAPI	RegOpenKeyA (HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult)

LONG WINAPI	RegOpenKeyW (HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)

LONG WINAPI	RegOpenKeyExA (_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)

LONG WINAPI	RegOpenKeyExW (HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)

LONG WINAPI	RegOpenUserClassesRoot (IN HANDLE hToken, IN DWORD dwOptions, IN REGSAM samDesired, OUT PHKEY phkResult)

LONG WINAPI	RegQueryInfoKeyA (HKEY hKey, LPSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)

LONG WINAPI	RegQueryInfoKeyW (HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)

LONG WINAPI	RegQueryMultipleValuesA (HKEY hKey, PVALENTA val_list, DWORD num_vals, LPSTR lpValueBuf, LPDWORD ldwTotsize)

LONG WINAPI	RegQueryMultipleValuesW (HKEY hKey, PVALENTW val_list, DWORD num_vals, LPWSTR lpValueBuf, LPDWORD ldwTotsize)

LONG WINAPI	RegQueryReflectionKey (IN HKEY hBase, OUT BOOL *bIsReflectionDisabled)

LONG WINAPI	RegQueryValueExA (_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)

LONG WINAPI	RegQueryValueExW (_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)

LSTATUS WINAPI	RegQueryValueA (HKEY hkey, LPCSTR name, LPSTR data, LPLONG count)

LSTATUS WINAPI	RegQueryValueW (HKEY hkey, LPCWSTR name, LPWSTR data, LPLONG count)

LONG WINAPI	RegReplaceKeyA (HKEY hKey, LPCSTR lpSubKey, LPCSTR lpNewFile, LPCSTR lpOldFile)

LONG WINAPI	RegReplaceKeyW (HKEY hKey, LPCWSTR lpSubKey, LPCWSTR lpNewFile, LPCWSTR lpOldFile)

LONG WINAPI	RegRestoreKeyA (HKEY hKey, LPCSTR lpFile, DWORD dwFlags)

LONG WINAPI	RegRestoreKeyW (HKEY hKey, LPCWSTR lpFile, DWORD dwFlags)

LONG WINAPI	RegSaveKeyA (HKEY hKey, LPCSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes)

LONG WINAPI	RegSaveKeyW (HKEY hKey, LPCWSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes)

LONG WINAPI	RegSaveKeyExA (HKEY hKey, LPCSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD Flags)

LONG WINAPI	RegSaveKeyExW (HKEY hKey, LPCWSTR lpFile, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD Flags)

LONG WINAPI	RegSetKeySecurity (HKEY hKey, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR pSecurityDescriptor)

LONG WINAPI	RegSetValueExA (HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)

LONG WINAPI	RegSetValueExW (_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)

LONG WINAPI	RegSetValueA (HKEY hKeyOriginal, LPCSTR lpSubKey, DWORD dwType, LPCSTR lpData, DWORD cbData)

LONG WINAPI	RegSetValueW (HKEY hKeyOriginal, LPCWSTR lpSubKey, DWORD dwType, LPCWSTR lpData, DWORD cbData)

LONG WINAPI	RegUnLoadKeyA (HKEY hKey, LPCSTR lpSubKey)

LONG WINAPI	RegUnLoadKeyW (HKEY hKey, LPCWSTR lpSubKey)

Variables
static RTL_CRITICAL_SECTION	HandleTableCS

static HANDLE	DefaultHandleTable [MAX_DEFAULT_HANDLES]

static HANDLE	ProcessHeap

static BOOLEAN	DefaultHandlesDisabled = FALSE

static BOOLEAN	DefaultHandleHKUDisabled = FALSE

static BOOLEAN	DllInitialized = FALSE

Macro Definition Documentation

◆ ClosePredefKey

#define ClosePredefKey ( Handle )

Value:

    if ((ULONG_PTR)Handle & 0x1) {                                             \
        NtClose(Handle);                                                       \
    }

Definition at line 44 of file reg.c.

◆ GetPredefKeyIndex

#define GetPredefKeyIndex ( HKey ) ((ULONG_PTR)(HKey) & 0x0FFFFFFF)

Definition at line 50 of file reg.c.

◆ IsPredefKey

#define IsPredefKey ( HKey ) (((ULONG_PTR)(HKey) & 0xF0000000) == 0x80000000)

Definition at line 48 of file reg.c.

◆ MAX_DEFAULT_HANDLES

#define MAX_DEFAULT_HANDLES 6

Definition at line 27 of file reg.c.

◆ REG_MAX_DATA_SIZE

#define REG_MAX_DATA_SIZE 2048

Definition at line 29 of file reg.c.

◆ REG_MAX_NAME_SIZE

#define REG_MAX_NAME_SIZE 256

Definition at line 28 of file reg.c.

Function Documentation

◆ CloseDefaultKeys()

static VOID CloseDefaultKeys ( VOID )

static

Definition at line 216 of file reg.c.

{
    ULONG i;
    RegInitialize(); /* HACK until delay-loading is implemented */
    RtlEnterCriticalSection(&HandleTableCS);
 
    for (i = 0; i < MAX_DEFAULT_HANDLES; i++)
    {
        if (DefaultHandleTable[i] != NULL)
        {
            NtClose(DefaultHandleTable[i]);
            DefaultHandleTable[i] = NULL;
        }
    }
 
    RtlLeaveCriticalSection(&HandleTableCS);
}

Referenced by RegCleanup().

◆ CreateNestedKey()

static NTSTATUS CreateNestedKey	(	PHKEY	KeyHandle,
		POBJECT_ATTRIBUTES	ObjectAttributes,
		PUNICODE_STRING	ClassString,
		DWORD	dwOptions,
		REGSAM	samDesired,
		DWORD *	lpdwDisposition
	)

static

Definition at line 915 of file reg.c.

{
    OBJECT_ATTRIBUTES LocalObjectAttributes;
    UNICODE_STRING LocalKeyName;
    ULONG Disposition;
    NTSTATUS Status;
    ULONG FullNameLength;
    ULONG Length;
    PWCHAR Ptr;
    HANDLE LocalKeyHandle;
 
    Status = NtCreateKey((PHANDLE) KeyHandle,
                         samDesired,
                         ObjectAttributes,
                         0,
                         ClassString,
                         dwOptions,
                         (PULONG)lpdwDisposition);
    TRACE("NtCreateKey(%wZ) called (Status %lx)\n", ObjectAttributes->ObjectName, Status);
    if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
        return Status;
 
    /* Copy object attributes */
    RtlCopyMemory(&LocalObjectAttributes,
                  ObjectAttributes,
                  sizeof(OBJECT_ATTRIBUTES));
    RtlCreateUnicodeString(&LocalKeyName,
                           ObjectAttributes->ObjectName->Buffer);
    LocalObjectAttributes.ObjectName = &LocalKeyName;
    FullNameLength = LocalKeyName.Length / sizeof(WCHAR);
 
    LocalKeyHandle = NULL;
 
    /* Remove the last part of the key name and try to create the key again. */
    while (Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        Ptr = wcsrchr(LocalKeyName.Buffer, '\\');
        if (Ptr == NULL || Ptr == LocalKeyName.Buffer)
        {
            Status = STATUS_UNSUCCESSFUL;
            break;
        }
 
        *Ptr = (WCHAR)0;
        LocalKeyName.Length = (USHORT)wcslen(LocalKeyName.Buffer) * sizeof(WCHAR);
 
        Status = NtCreateKey(&LocalKeyHandle,
                             KEY_CREATE_SUB_KEY,
                             &LocalObjectAttributes,
                             0,
                             NULL,
                             0,
                             &Disposition);
        TRACE("NtCreateKey(%wZ) called (Status %lx)\n", &LocalKeyName, Status);
    }
 
    if (!NT_SUCCESS(Status))
    {
        RtlFreeUnicodeString(&LocalKeyName);
        return Status;
    }
 
    /* Add removed parts of the key name and create them too. */
    Length = wcslen(LocalKeyName.Buffer);
    while (TRUE)
    {
        if (LocalKeyHandle)
            NtClose (LocalKeyHandle);
 
        LocalKeyName.Buffer[Length] = L'\\';
        Length = wcslen (LocalKeyName.Buffer);
        LocalKeyName.Length = Length * sizeof(WCHAR);
 
        if (Length == FullNameLength)
        {
            Status = NtCreateKey((PHANDLE) KeyHandle,
                                 samDesired,
                                 ObjectAttributes,
                                 0,
                                 ClassString,
                                 dwOptions,
                                 (PULONG)lpdwDisposition);
            break;
        }
 
        Status = NtCreateKey(&LocalKeyHandle,
                             KEY_CREATE_SUB_KEY,
                             &LocalObjectAttributes,
                             0,
                             NULL,
                             0,
                             &Disposition);
        TRACE("NtCreateKey(%wZ) called (Status %lx)\n", &LocalKeyName, Status);
        if (!NT_SUCCESS(Status))
            break;
    }
 
    RtlFreeUnicodeString(&LocalKeyName);
 
    return Status;
}

Referenced by RegCreateKeyExW().

◆ is_string()

static __inline int is_string ( DWORD type )

static

Definition at line 61 of file reg.c.

{
    return (type == REG_SZ) || (type == REG_EXPAND_SZ) || (type == REG_MULTI_SZ);
}

Referenced by RegEnumValueA(), RegEnumValueW(), RegQueryValueExA(), RegQueryValueExW(), RegSetValueExA(), and RegSetValueExW().

◆ MapDefaultKey() [1/2]

static NTSTATUS MapDefaultKey	(	OUT PHANDLE	RealKey,
		IN HKEY	Key
	)

static

Definition at line 153 of file reg.c.

{
    PHANDLE Handle;
    ULONG Index;
    BOOLEAN DoOpen, DefDisabled;
    NTSTATUS Status = STATUS_SUCCESS;
 
    TRACE("MapDefaultKey (Key %x)\n", Key);
 
    if (!IsPredefKey(Key))
    {
        *RealKey = (HANDLE)((ULONG_PTR)Key & ~0x1);
        return STATUS_SUCCESS;
    }
 
    /* Handle special cases here */
    Index = GetPredefKeyIndex(Key);
    if (Index >= MAX_DEFAULT_HANDLES)
    {
        return STATUS_INVALID_PARAMETER;
    }
    RegInitialize(); /* HACK until delay-loading is implemented */
    RtlEnterCriticalSection (&HandleTableCS);
 
    if (Key == HKEY_CURRENT_USER)
        DefDisabled = DefaultHandleHKUDisabled;
    else
        DefDisabled = DefaultHandlesDisabled;
 
    if (!DefDisabled)
    {
        Handle = &DefaultHandleTable[Index];
        DoOpen = (*Handle == NULL);
    }
    else
    {
        Handle = RealKey;
        DoOpen = TRUE;
    }
 
    if (DoOpen)
    {
        /* create/open the default handle */
        Status = OpenPredefinedKey(Index,
                                   Handle);
    }
 
    if (NT_SUCCESS(Status))
    {
        if (!DefDisabled)
            *RealKey = *Handle;
        else
            *(PULONG_PTR)Handle |= 0x1;
    }
 
    RtlLeaveCriticalSection (&HandleTableCS);
 
    return Status;
}

◆ MapDefaultKey() [2/2]

static NTSTATUS MapDefaultKey	(	PHANDLE	ParentKey,
		HKEY	Key
	)

static

◆ OpenClassesRootKey() [1/2]

static NTSTATUS OpenClassesRootKey ( _Out_ PHANDLE KeyHandle )

static

Definition at line 236 of file reg.c.

{
    OBJECT_ATTRIBUTES Attributes;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\CLASSES");
    NTSTATUS Status;
 
    TRACE("OpenClassesRootKey()\n");
 
    InitializeObjectAttributes(&Attributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenKey(KeyHandle,
                       MAXIMUM_ALLOWED,
                       &Attributes);
 
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Mark it as HKCR */
    MakeHKCRKey((HKEY*)KeyHandle);
 
    return Status;
}

◆ OpenClassesRootKey() [2/2]

static NTSTATUS OpenClassesRootKey ( PHANDLE KeyHandle )

static

Referenced by OpenPredefinedKey().

◆ OpenCurrentConfigKey()

static NTSTATUS OpenCurrentConfigKey ( PHANDLE KeyHandle )

static

Definition at line 307 of file reg.c.

{
    OBJECT_ATTRIBUTES Attributes;
    UNICODE_STRING KeyName =
        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\Current");
 
    TRACE("OpenCurrentConfigKey()\n");
 
    InitializeObjectAttributes(&Attributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    return NtOpenKey(KeyHandle,
                     MAXIMUM_ALLOWED,
                     &Attributes);
}

Referenced by OpenPredefinedKey().

◆ OpenLocalMachineKey()

static NTSTATUS OpenLocalMachineKey ( PHANDLE KeyHandle )

static

Definition at line 264 of file reg.c.

{
    OBJECT_ATTRIBUTES Attributes;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine");
    NTSTATUS Status;
 
    TRACE("OpenLocalMachineKey()\n");
 
    InitializeObjectAttributes(&Attributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenKey(KeyHandle,
                       MAXIMUM_ALLOWED,
                       &Attributes);
 
    TRACE("NtOpenKey(%wZ) => %08x\n", &KeyName, Status);
 
    return Status;
}

Referenced by OpenPredefinedKey().

◆ OpenPredefinedKey()

static NTSTATUS OpenPredefinedKey	(	IN ULONG	Index,
		OUT HANDLE	Handle
	)

static

Definition at line 105 of file reg.c.

{
    NTSTATUS Status;
 
    switch (Index)
    {
        case 0: /* HKEY_CLASSES_ROOT */
            Status = OpenClassesRootKey (Handle);
            break;
 
        case 1: /* HKEY_CURRENT_USER */
            Status = RtlOpenCurrentUser (MAXIMUM_ALLOWED,
                                         Handle);
            break;
 
        case 2: /* HKEY_LOCAL_MACHINE */
            Status = OpenLocalMachineKey (Handle);
            break;
 
        case 3: /* HKEY_USERS */
            Status = OpenUsersKey (Handle);
            break;
#if 0
        case 4: /* HKEY_PERFORMANCE_DATA */
            Status = OpenPerformanceDataKey (Handle);
            break;
#endif
 
        case 5: /* HKEY_CURRENT_CONFIG */
            Status = OpenCurrentConfigKey (Handle);
            break;
 
        case 6: /* HKEY_DYN_DATA */
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        default:
            WARN("MapDefaultHandle() no handle creator\n");
            Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
    return Status;
}

Referenced by MapDefaultKey(), and RegOverridePredefKey().

◆ OpenUsersKey()

static NTSTATUS OpenUsersKey ( PHANDLE KeyHandle )

static

Definition at line 288 of file reg.c.

{
    OBJECT_ATTRIBUTES Attributes;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\User");
 
    TRACE("OpenUsersKey()\n");
 
    InitializeObjectAttributes(&Attributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    return NtOpenKey(KeyHandle,
                     MAXIMUM_ALLOWED,
                     &Attributes);
}

Referenced by OpenPredefinedKey().

◆ RegCleanup()

BOOL RegCleanup ( VOID )

Definition at line 93 of file reg.c.

{
    TRACE("RegCleanup()\n");
 
    CloseDefaultKeys();
    RtlDeleteCriticalSection(&HandleTableCS);
 
    return TRUE;
}

Referenced by DllMain().

◆ RegCloseKey()

LONG WINAPI RegCloseKey ( HKEY hKey )

Definition at line 423 of file reg.c.

{
    NTSTATUS Status;
 
    /* don't close null handle or a pseudo handle */
    if (!hKey)
    {
        return ERROR_INVALID_HANDLE;
    }
 
    if (((ULONG_PTR)hKey & 0xF0000000) == 0x80000000)
    {
        return ERROR_SUCCESS;
    }
 
    Status = NtClose(hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
  return ERROR_SUCCESS;
}

◆ RegConnectRegistryA()

LONG WINAPI RegConnectRegistryA	(	IN LPCSTR	lpMachineName,
		IN HKEY	hKey,
		OUT PHKEY	phkResult
	)

Definition at line 840 of file reg.c.

{
    UNICODE_STRING MachineName = { 0, 0, NULL };
    LONG Ret;
 
    if (lpMachineName != NULL &&
        !RtlCreateUnicodeStringFromAsciiz(&MachineName, lpMachineName))
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    Ret = RegConnectRegistryW(MachineName.Buffer,
                              hKey,
                              phkResult);
 
    RtlFreeUnicodeString(&MachineName);
 
    return Ret;
}

Referenced by test_regconnectregistry().

◆ RegConnectRegistryW()

LONG WINAPI RegConnectRegistryW	(	LPCWSTR	lpMachineName,
		HKEY	hKey,
		PHKEY	phkResult
	)

Definition at line 869 of file reg.c.

{
    LONG ret;
 
    TRACE("(%s,%p,%p): stub\n",debugstr_w(lpMachineName),hKey,phkResult);
 
    if (!lpMachineName || !*lpMachineName)
    {
        /* Use the local machine name */
        ret = RegOpenKeyW( hKey, NULL, phkResult );
    }
    else
    {
        WCHAR compName[MAX_COMPUTERNAME_LENGTH + 1];
        DWORD len = sizeof(compName) / sizeof(WCHAR);
 
        /* MSDN says lpMachineName must start with \\ : not so */
        if( lpMachineName[0] == '\\' &&  lpMachineName[1] == '\\')
            lpMachineName += 2;
 
        if (GetComputerNameW(compName, &len))
        {
            if (!_wcsicmp(lpMachineName, compName))
                ret = RegOpenKeyW(hKey, NULL, phkResult);
            else
            {
                FIXME("Connect to %s is not supported.\n",debugstr_w(lpMachineName));
                ret = ERROR_BAD_NETPATH;
            }
        }
        else
            ret = GetLastError();
    }
 
    return ret;
}

Referenced by CM_Open_Class_Key_ExW(), CM_Open_DevNode_Key_Ex(), RegConnectRegistryA(), SetupDiCreateDeviceInfoListExW(), and SetupDiOpenClassRegKeyExW().

◆ RegCopyTreeA()

LONG WINAPI RegCopyTreeA	(	IN HKEY	hKeySrc,
		IN LPCSTR lpSubKey	OPTIONAL,
		IN HKEY	hKeyDest
	)

Definition at line 811 of file reg.c.

{
    UNICODE_STRING SubKeyName = { 0, 0, NULL };
    LONG Ret;
 
    if (lpSubKey != NULL &&
        !RtlCreateUnicodeStringFromAsciiz(&SubKeyName, lpSubKey))
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    Ret = RegCopyTreeW(hKeySrc,
                       SubKeyName.Buffer,
                       hKeyDest);
 
    RtlFreeUnicodeString(&SubKeyName);
 
    return Ret;
}

Referenced by InitFunctionPtrs().

◆ RegCopyTreeW()

LONG WINAPI RegCopyTreeW	(	IN HKEY	hKeySrc,
		IN LPCWSTR lpSubKey	OPTIONAL,
		IN HKEY	hKeyDest
	)

Definition at line 736 of file reg.c.

{
    HANDLE DestKeyHandle, KeyHandle, CurKey, SubKeyHandle = NULL;
    NTSTATUS Status;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKeySrc);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    Status = MapDefaultKey(&DestKeyHandle,
                           hKeyDest);
    if (!NT_SUCCESS(Status))
    {
        goto Cleanup2;
    }
 
    if (lpSubKey != NULL)
    {
        OBJECT_ATTRIBUTES ObjectAttributes;
        UNICODE_STRING SubKeyName;
 
        RtlInitUnicodeString(&SubKeyName, lpSubKey);
 
        InitializeObjectAttributes(&ObjectAttributes,
                                   &SubKeyName,
                                   OBJ_CASE_INSENSITIVE,
                                   KeyHandle,
                                   NULL);
 
        Status = NtOpenKey(&SubKeyHandle,
                           KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
                           &ObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            goto Cleanup;
        }
 
        CurKey = SubKeyHandle;
    }
    else
        CurKey = KeyHandle;
 
    Status = RegpCopyTree(CurKey,
                          hKeyDest);
 
    if (SubKeyHandle != NULL)
    {
        NtClose(SubKeyHandle);
    }
 
Cleanup:
    ClosePredefKey(DestKeyHandle);
Cleanup2:
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by CopyKey(), RegCopyTreeA(), and ScmCopyControlSet().

◆ RegCreateKeyA()

LONG WINAPI RegCreateKeyA	(	HKEY	hKey,
		LPCSTR	lpSubKey,
		PHKEY	phkResult
	)

Definition at line 1174 of file reg.c.

{
    return RegCreateKeyExA(hKey,
                           lpSubKey,
                           0,
                           NULL,
                           0,
                           MAXIMUM_ALLOWED,
                           NULL,
                           phkResult,
                           NULL);
}

Referenced by create_new_eventlog(), create_reg_entries(), create_test_entries(), CryptRegisterOIDFunction(), CryptRegisterOIDInfo(), DllRegisterServer(), init_key(), lineGetTranslateCapsA(), register_testentry(), register_zone_domains(), RegSetValueA(), setup_main_key(), test_AddERExcludedApplicationA(), test_appsearch_reglocator(), test_classesroot_enum(), test_CreateMRUListLazyW(), test_CreateMRUListW(), test_debug_heap(), test_deleted_key(), test_enum_value(), test_ExitCode(), test_getstring_no_extra(), test_install_from(), test_internet_features(), test_internet_features_registry(), test_MRUListA(), test_MsiEnumPatches(), test_MsiEnumPatchesEx_userunmanaged(), test_MsiEnumProducts(), test_MsiGetComponentPath(), test_MsiGetComponentPathEx(), test_MsiGetPatchInfoEx(), test_MsiGetProductCode(), test_MsiGetProductInfoEx(), test_MsiGetUserInfo(), test_MsiOpenProduct(), test_MsiQueryComponentState(), test_MsiQueryFeatureState(), test_MsiQueryProductState(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListGetInfo(), test_MsiSourceListSetInfo(), test_open_class_key(), test_publish_components(), test_reg_copy_tree(), test_reg_delete_key(), test_reg_delete_tree(), test_reg_query_value(), test_registerOIDInfo(), test_registry(), test_RegNotifyChangeKeyValue(), test_rw_order(), test_SetZoneAttributes(), test_SHCopyKey(), test_SHDeleteKey(), test_string_termination(), test_write_registry_values(), test_zone_domain_cache(), WNetCachePassword(), WNetEnumCachedPasswords(), WNetGetCachedPassword(), and WNetRemoveCachedPassword().

◆ RegCreateKeyExA()

LONG WINAPI RegCreateKeyExA	(	_In_ HKEY	hKey,
		_In_ LPCSTR	lpSubKey,
		_In_ DWORD	Reserved,
		_In_ LPSTR	lpClass,
		_In_ DWORD	dwOptions,
		_In_ REGSAM	samDesired,
		_In_ LPSECURITY_ATTRIBUTES	lpSecurityAttributes,
		_Out_ PHKEY	phkResult,
		_Out_ LPDWORD	lpdwDisposition
	)

Definition at line 1029 of file reg.c.

{
    UNICODE_STRING SubKeyString;
    UNICODE_STRING ClassString;
    DWORD ErrorCode;
 
    RtlInitEmptyUnicodeString(&ClassString, NULL, 0);
    RtlInitEmptyUnicodeString(&SubKeyString, NULL, 0);
 
    if (lpClass)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&ClassString, lpClass))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    if (lpSubKey)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&SubKeyString, lpSubKey))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    ErrorCode = RegCreateKeyExW(
        hKey,
        SubKeyString.Buffer,
        Reserved,
        ClassString.Buffer,
        dwOptions,
        samDesired,
        lpSecurityAttributes,
        phkResult,
        lpdwDisposition);
 
Exit:
    RtlFreeUnicodeString(&SubKeyString);
    RtlFreeUnicodeString(&ClassString);
 
    return ErrorCode;
}

Referenced by add_key_(), create_container_key(), create_test_association(), create_test_class(), create_test_verb_dde(), CRYPT_GetDefaultOIDKey(), CryptGetDefaultOIDDllList(), CryptRegisterOIDInfo(), expect_LayerValue_imp(), FindAdapterKey(), get_key_value(), is_elevated_process(), ODBC_ReplicateODBCInstToRegistry(), ODBC_ReplicateODBCToRegistry(), reg_unreg_wine_test_class(), RegCreateKeyA(), register_keys(), register_mediatypes_extension(), register_progid(), set_component_path(), setLayerValue(), SHAddToRecentDocs(), SHGetSettings(), SHOpenRegStream2A(), SHSetValueA(), START_TEST(), test_appsearch(), test_basic_import_31(), test_classesroot(), test_classesroot_enum(), test_CoGetClassObject(), test_CoGetPSClsid(), test_copy_key_class(), test_delete_key_value(), test_envvar(), test_ExitCode(), test_invalid_import_31(), test_MsiEnumClients(), test_MsiEnumComponents(), test_MsiEnumComponentsEx(), test_MsiEnumPatches(), test_MsiEnumPatchesEx_machine(), test_MsiEnumPatchesEx_usermanaged(), test_MsiEnumPatchesEx_userunmanaged(), test_MsiEnumProducts(), test_MsiEnumProductsEx(), test_MsiGetComponentPath(), test_MsiGetComponentPathEx(), test_MsiGetPatchInfo(), test_MsiGetPatchInfoEx(), test_MsiGetProductCode(), test_MsiGetProductInfoEx(), test_MsiGetProductProperty(), test_MsiGetUserInfo(), test_MsiOpenProduct(), test_MsiProvideQualifiedComponentEx(), test_MsiQueryComponentState(), test_MsiQueryFeatureState(), test_MsiQueryProductState(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListSetInfo(), test_null(), test_OleRegGetUserType(), test_publish_components(), test_redirection(), test_reg_create_key(), test_reg_open_key(), test_reg_query_info(), test_register_progid_info(), test_symlinks(), test_TreatAsClass(), and testRegStore().

◆ RegCreateKeyExW()

LONG WINAPI RegCreateKeyExW	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	lpSubKey,
		_In_ DWORD	Reserved,
		_In_opt_ LPWSTR	lpClass,
		_In_ DWORD	dwOptions,
		_In_ REGSAM	samDesired,
		_In_opt_ LPSECURITY_ATTRIBUTES	lpSecurityAttributes,
		_Out_ PHKEY	phkResult,
		_Out_opt_ LPDWORD	lpdwDisposition
	)

Definition at line 1091 of file reg.c.

{
    UNICODE_STRING SubKeyString;
    UNICODE_STRING ClassString;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE ParentKey;
    ULONG Attributes = OBJ_CASE_INSENSITIVE;
    NTSTATUS Status;
 
    TRACE("RegCreateKeyExW() called\n");
 
    /* get the real parent key */
    Status = MapDefaultKey(&ParentKey,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    TRACE("ParentKey %p\n", ParentKey);
 
    if (IsHKCRKey(ParentKey))
    {
        LONG ErrorCode = CreateHKCRKey(
            ParentKey,
            lpSubKey,
            Reserved,
            lpClass,
            dwOptions,
            samDesired,
            lpSecurityAttributes,
            phkResult,
            lpdwDisposition);
        ClosePredefKey(ParentKey);
        return ErrorCode;
    }
 
    if (dwOptions & REG_OPTION_OPEN_LINK)
        Attributes |= OBJ_OPENLINK;
 
    RtlInitUnicodeString(&ClassString,
                         lpClass);
    RtlInitUnicodeString(&SubKeyString,
                         lpSubKey);
    InitializeObjectAttributes(&ObjectAttributes,
                               &SubKeyString,
                               Attributes,
                               (HANDLE)ParentKey,
                               lpSecurityAttributes ? (PSECURITY_DESCRIPTOR)lpSecurityAttributes->lpSecurityDescriptor : NULL);
    Status = CreateNestedKey(phkResult,
                             &ObjectAttributes,
                             (lpClass == NULL)? NULL : &ClassString,
                             dwOptions,
                             samDesired,
                             lpdwDisposition);
 
    ClosePredefKey(ParentKey);
 
    TRACE("Status %x\n", Status);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by _InitializeLocalSpooler(), _SHOpenProfilesKey(), ACTION_RegisterClassInfo(), ACTION_UnregisterClassInfo(), add_userkey(), COpenWithList::AddAppToMRUList(), AddNewLayout(), AddUninstallKey(), ApplyEventlogSettings(), ApplyRegistryValues(), BuildVolatileEnvironment(), CategoryMgr_RegisterCategory(), CliSaveImeHotKey(), CM_Open_Class_Key_ExW(), CM_Open_DevNode_Key_Ex(), ComDBOpen(), ConCfgOpenUserSettings(), connections_on_notify(), ConnectRegistry(), CopyKey(), CopySystemProfile(), create_key(), create_mru_list(), CreateAppPathRegKey(), CreateDeviceInstance(), CreateEventLog(), CreateHKCRKey(), CreateInstanceKey(), CreateNewKey(), CreateRegAppPath(), CreateSymLink(), CreateUserProfileExW(), CredWriteW(), CriticalDeviceCoInstaller(), CRYPT_ImportSystemRootCertsToReg(), CRYPT_RegReadFromReg(), CRYPT_RegWriteToReg(), CRYPT_SysRegOpenStoreW(), CRYPT_WriteSerializedToReg(), DeleteJob(), DeleteUninstallKey(), DIALOG_Execute(), CNetConnection::Disconnect(), DllRegisterServer(), DMORegister(), do_typelib_reg_key(), DoStartStartupItems(), EditTypeDlg_WriteClass(), CSysTray::EnableService(), EnumTfLanguageProfiles_Constructor(), FillList(), FilterMapper3_CreateCategory(), FilterMapper_RegisterFilter(), FilterMapper_RegisterPin(), FilterMapper_RegisterPinType(), get_cert_mgr_usages(), get_fusion_filename(), GetCurrentDPI(), GetFallbackHKCRKey(), CSysTray::GetServicesEnabled(), INetCfgComponentControl_fnApplyRegistryChanges(), INetCfgLock_fnAcquireWriteLock(), CRegPropertyBag::Init(), InitAppRegKey(), InitializeFormList(), InitLogs(), InitSettings(), InputProcessorProfiles_AddLanguageProfile(), InputProcessorProfiles_Register(), InputProcessorProfiles_SetDefaultLanguageProfile(), InstallDefaultSystemSoundScheme(), InstallEventSource(), InstallNetDevice(), InstallOneInterface(), InstallSystemSoundLabels(), InstallSystemSoundScheme(), InstallSystemSoundSchemeNames(), load_devices_from_reg(), LoadJobs(), LoadRecoveryOptions(), LocalAddMonitor(), MAIN_LoadSettings(), MainWnd_OnOpenRegKey(), MMDevice_Create(), MRU_SaveChanged(), msi_publish_patches(), MSIREG_OpenClassesUpgradeCodesKey(), MSIREG_OpenFeaturesKey(), MSIREG_OpenInstallerFeaturesKey(), MSIREG_OpenInstallProps(), MSIREG_OpenPatchesKey(), MSIREG_OpenProductKey(), MSIREG_OpenUninstallKey(), MSIREG_OpenUpgradeCodesKey(), MSIREG_OpenUserDataComponentKey(), MSIREG_OpenUserDataFeaturesKey(), MSIREG_OpenUserDataPatchKey(), MSIREG_OpenUserDataProductKey(), MSIREG_OpenUserDataProductPatchesKey(), myAddPrinterDriverEx(), notif_thread_proc(), open_cred_mgr_key(), open_key(), OpenConfigurationKey(), OpenImageFileExecOptions(), PNP_CreateKey(), PNP_GetClassInstance(), PNP_GetHwProfInfo(), PNP_SetClassRegProp(), ProcessSetupInf(), ProcessUnattendSection(), ProfilesEnumGuid_Constructor(), RegCreateKeyExA(), RegCreateKeyW(), register_categories(), register_coclasses(), register_converters(), register_decoders(), register_encoders(), register_interfaces(), register_key_defvalueA(), register_key_defvalueW(), register_mediatypes_extension(), register_mediatypes_parsing(), register_metadatareaders(), register_pixelformats(), register_server(), RegisterBDAComponent(), RegisterComponent(), RegisterHelperDll(), RegisterSdbEntry(), RegisterService(), RegisterTypeLib(), registry_callback(), registry_get_handle(), RegSetDWORDValue(), run_add(), run_copy(), SampSetupAddMemberToAlias(), save_cert_mgr_usages(), save_sys_colors(), SaveBoard(), SaveDWORDToRegistry(), SaveJob(), SaveSettings(), SaveShutdownSelState(), SaveStringToRegistry(), ScmCopyControlSet(), ScmCopyTree(), ScmCreateNewControlPipe(), ScmCreateServiceKey(), ScmWriteSecurityDescriptor(), set_profile_device_key(), set_proxy(), COpenWithList::SetDefaultHandler(), SetFindFlags(), SetHotPlugFlags(), SetNtpClientValues(), SetParametersValues(), SetPerUserSecValuesW(), SETUP_CreateClassKey(), SETUPDI_CreateDevKey(), SETUPDI_CreateDrvKey(), SetupDiCreateDeviceInterfaceRegKeyW(), SetupDiCreateDevRegKeyW(), SHAddToRecentDocs(), SHCreateSessionKey(), SHELL_FS_HideExtension(), SHGetShellKey(), SHOpenRegStream2W(), SHRegCreateUSKeyW(), SHSetValueW(), START_TEST(), StoreDriveSettings(), test4(), Test_CreateOpenKey(), test_IQueryAssociations_GetString(), test_legacy_filter_registration(), test_OleDoAutoConvert(), test_OleRegGetUserType(), test_system_security_access(), TestMyEventProvider(), testSystemStore(), TLB_register_interface(), TRASH_CanTrashFile(), unregister_converters(), unregister_decoders(), unregister_encoders(), unregister_metadatareaders(), unregister_pixelformats(), unregister_server(), UpdateRegistryString(), UXTHEME_BackupSystemMetrics(), WinHttpSetDefaultProxyConfiguration(), WINTRUST_WriteProviderToReg(), WINTRUST_WriteSingleUsageEntry(), WintrustGetRegPolicyFlags(), WintrustSetRegPolicyFlags(), wnet_use_connection(), write_reg_key(), write_types(), WriteCabinetState(), WritePortSettings(), WriteStartupRecoveryOptions(), and WriteUserLocale().

◆ RegCreateKeyW()

LONG WINAPI RegCreateKeyW	(	HKEY	hKey,
		LPCWSTR	lpSubKey,
		PHKEY	phkResult
	)

Definition at line 1196 of file reg.c.

{
    return RegCreateKeyExW(hKey,
                           lpSubKey,
                           0,
                           NULL,
                           0,
                           MAXIMUM_ALLOWED,
                           NULL,
                           phkResult,
                           NULL);
}

Referenced by _SHGetCurrentVersionPath(), _SHGetUserShellFolderPath(), _SHRegisterFolders(), ACTION_ForceReboot(), ACTION_RegisterClassInfo(), ACTION_RegisterExtensionInfo(), AddERExcludedApplicationW(), ApplyScheme(), CRYPT_SIPWriteFunction(), DEVENUM_CreateAMCategoryKey(), DEVENUM_IPropertyBag_Write(), do_process_key(), ATL::CRegObject::do_process_key(), FILEDLG95_MRU_get_slot(), get_mapping_key(), CTrayBandSite::GetDefaultBandsStream(), CTrayBandSite::GetUserBandsStream(), I_CryptReadTrustedPublisherDWORDValueFromRegistry(), Imm32WriteImeLayout(), InputList_PrepareUserRegistry(), ITERATE_RegisterFonts(), ITERATE_UnregisterFonts(), KmtFltAddAltitude(), LocalAddMonitor(), LocalDeleteMonitor(), MSACM_ReadCache(), MSACM_WriteCache(), MSACM_WriteCurrentPriorities(), msi_publish_sourcelist(), msi_reg_set_subkey_val(), MSIREG_OpenUserComponentsKey(), MSIREG_OpenUserPatchesKey(), MSIREG_OpenUserUpgradeCodesKey(), NdrDllRegisterProxy(), open_assemblies_key(), open_driver_reg(), open_global_assembly_key(), open_local_assembly_key(), OpenMediaSubkey(), OpenNetworkSubkey(), OpenSourceKey(), OpenURLSubkey(), RegInitializeRegistry(), register_appid(), register_codepages(), register_progid(), register_verb(), registry_callback(), RegSetKeyValueW(), RegSetValueW(), SaveSettings(), SetupRegisterAllClasses(), SetupRegisterClass(), SHCopyKeyW(), SHPropertyBag_OnRegKey(), SHRegGetCLSIDKeyW(), SHRegWriteUSValueW(), SQLWritePrivateProfileStringW(), START_TEST(), stillimagew_RegisterLaunchApplication(), stillimagew_UnregisterLaunchApplication(), test_FolderShortcut(), test_Installer_RegistryValue(), TOOLBAR_Save(), UXTHEME_ApplyTheme(), and write_registry_values().

◆ RegDeleteKeyA()

LONG WINAPI RegDeleteKeyA	(	_In_ HKEY	hKey,
		_In_ LPCSTR	lpSubKey
	)

Definition at line 1219 of file reg.c.

{
    return RegDeleteKeyExA(hKey, lpSubKey, 0, 0);
}

Referenced by cleanup_eventlog(), CryptUnregisterOIDFunction(), CryptUnregisterOIDInfo(), delete_container_key(), delete_key(), delete_key_(), delete_key_portable(), delete_tree(), delete_tree_(), DllUnregisterServer(), init_key(), is_elevated_process(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), ok_registry(), reg_unreg_wine_test_class(), setperusersecvalues_test(), SHAddToRecentDocs(), SHDeleteEmptyKeyA(), SHDeleteOrphanKeyA(), START_TEST(), test_appsearch(), test_appsearch_reglocator(), test_classesroot(), test_debug_heap(), test_delete_key_value(), test_directshow_filter(), test_enum_value(), test_ExitCode(), test_install_from(), test_Installer_InstallProduct(), test_internet_features(), test_internet_features_registry(), test_key_formats(), test_MsiEnumPatches(), test_MsiEnumPatchesEx_userunmanaged(), test_MsiEnumProducts(), test_MsiGetComponentPath(), test_MsiGetComponentPathEx(), test_MsiGetPatchInfoEx(), test_MsiGetProductCode(), test_MsiGetProductInfoEx(), test_MsiGetProductProperty(), test_MsiGetUserInfo(), test_MsiInstallProduct(), test_MsiOpenProduct(), test_MsiQueryComponentState(), test_MsiQueryFeatureState(), test_MsiQueryProductState(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListGetInfo(), test_MsiSourceListSetInfo(), test_OleDoAutoConvert(), test_OleRegGetUserType(), test_open_class_key(), test_publish_components(), test_publish_product(), test_redirection(), test_reg_create_key(), test_reg_delete_key(), test_reg_open_key(), test_reg_query_info(), test_reg_query_value(), test_regcat(), test_register_product(), test_register_progid_info(), test_registerOIDFunction(), test_registry(), test_RegNotifyChangeKeyValue(), test_rw_order(), test_string_termination(), test_symlinks(), test_TreatAsClass(), test_write_registry_values(), test_zone_domain_cache(), testRegStore(), unregister_keys(), unregister_server(), unregister_testentry(), and unregister_zone_domains().

◆ RegDeleteKeyExA()

LONG WINAPI RegDeleteKeyExA	(	_In_ HKEY	hKey,
		_In_ LPCSTR	lpSubKey,
		_In_ REGSAM	samDesired,
		_In_ DWORD	Reserved
	)

Definition at line 1249 of file reg.c.

{
    LONG ErrorCode;
    UNICODE_STRING SubKeyName;
 
    if (lpSubKey)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&SubKeyName, lpSubKey))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&SubKeyName, NULL, 0);
 
    ErrorCode = RegDeleteKeyExW(hKey, SubKeyName.Buffer, samDesired, Reserved);
 
    RtlFreeUnicodeString(&SubKeyName);
 
    return ErrorCode;
}

Referenced by delete_key_(), delete_tree_(), init_functionpointers(), InitFunctionPtrs(), and RegDeleteKeyA().

◆ RegDeleteKeyExW()

LONG WINAPI RegDeleteKeyExW	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	lpSubKey,
		_In_ REGSAM	samDesired,
		_In_ DWORD	Reserved
	)

Definition at line 1281 of file reg.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING SubKeyName;
    HANDLE ParentKey;
    HANDLE TargetKey;
    NTSTATUS Status;
 
    /* Make sure we got a subkey */
    if (!lpSubKey)
    {
        /* Fail */
        return ERROR_INVALID_PARAMETER;
    }
 
    Status = MapDefaultKey(&ParentKey,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (IsHKCRKey(ParentKey))
    {
        LONG ErrorCode = DeleteHKCRKey(ParentKey, lpSubKey, samDesired, Reserved);
        ClosePredefKey(ParentKey);
        return ErrorCode;
    }
 
    if (samDesired & KEY_WOW64_32KEY)
        ERR("Wow64 not yet supported!\n");
 
    if (samDesired & KEY_WOW64_64KEY)
        ERR("Wow64 not yet supported!\n");
 
 
    RtlInitUnicodeString(&SubKeyName, lpSubKey);
    InitializeObjectAttributes(&ObjectAttributes,
                               &SubKeyName,
                               OBJ_CASE_INSENSITIVE,
                               ParentKey,
                               NULL);
    Status = NtOpenKey(&TargetKey,
                       DELETE,
                       &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        goto Cleanup;
    }
 
    Status = NtDeleteKey(TargetKey);
    NtClose(TargetKey);
 
Cleanup:
    ClosePredefKey(ParentKey);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by delete_key(), DeleteHKCRKey(), init_functionpointers(), RegDeleteKeyExA(), RegDeleteKeyW(), and TLB_unregister_interface().

◆ RegDeleteKeyValueA()

LONG WINAPI RegDeleteKeyValueA	(	IN HKEY	hKey,
		IN LPCSTR lpSubKey	OPTIONAL,
		IN LPCSTR lpValueName	OPTIONAL
	)

Definition at line 1425 of file reg.c.

{
    UNICODE_STRING SubKey = { 0, 0, NULL }, ValueName = { 0, 0, NULL };
    LONG Ret;
 
    if (lpSubKey != NULL &&
        !RtlCreateUnicodeStringFromAsciiz(&SubKey, lpSubKey))
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    if (lpValueName != NULL &&
        !RtlCreateUnicodeStringFromAsciiz(&ValueName, lpValueName))
    {
        RtlFreeUnicodeString(&SubKey);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    Ret = RegDeleteKeyValueW(hKey,
                             SubKey.Buffer,
                             SubKey.Buffer);
 
    RtlFreeUnicodeString(&SubKey);
    RtlFreeUnicodeString(&ValueName);
 
    return Ret;
}

Referenced by InitFunctionPtrs().

◆ RegDeleteKeyValueW()

LONG WINAPI RegDeleteKeyValueW	(	IN HKEY	hKey,
		IN LPCWSTR lpSubKey	OPTIONAL,
		IN LPCWSTR lpValueName	OPTIONAL
	)

Definition at line 1356 of file reg.c.

{
    UNICODE_STRING ValueName;
    HANDLE KeyHandle, CurKey, SubKeyHandle = NULL;
    NTSTATUS Status;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (lpSubKey != NULL)
    {
        OBJECT_ATTRIBUTES ObjectAttributes;
        UNICODE_STRING SubKeyName;
 
        RtlInitUnicodeString(&SubKeyName, lpSubKey);
 
        InitializeObjectAttributes(&ObjectAttributes,
                                   &SubKeyName,
                                   OBJ_CASE_INSENSITIVE,
                                   KeyHandle,
                                   NULL);
 
        Status = NtOpenKey(&SubKeyHandle,
                           KEY_SET_VALUE,
                           &ObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            goto Cleanup;
        }
 
        CurKey = SubKeyHandle;
    }
    else
        CurKey = KeyHandle;
 
    RtlInitUnicodeString(&ValueName, lpValueName);
 
    Status = NtDeleteValueKey(CurKey,
                              &ValueName);
 
    if (SubKeyHandle != NULL)
    {
        NtClose(SubKeyHandle);
    }
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by RegDeleteKeyValueA().

◆ RegDeleteKeyW()

LONG WINAPI RegDeleteKeyW	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	lpSubKey
	)

Definition at line 1234 of file reg.c.

{
    return RegDeleteKeyExW(hKey, lpSubKey, 0, 0);
}

Referenced by ACTION_UnregisterClassInfo(), ACTION_UnregisterExtensionInfo(), ACTION_UnregisterMIMEInfo(), ATL::AtlRegisterClassCategoriesHelper(), AtlRegisterClassCategoriesHelper(), CliSaveImeHotKey(), COMCAT_ICatRegister_UnRegisterCategories(), COMCAT_UnRegisterClassCategories(), CoTreatAsClass(), CredDeleteW(), CRYPT_RegWriteToReg(), CRYPT_SIPDeleteFunction(), del_mapping_key(), delete_key(), delete_local_assembly_key(), delete_test_key(), DeleteAppPathRegKey(), DeleteRegAppPath(), DeleteSubKey(), DeleteUninstallKey(), devinst_RegDeleteTreeW(), DllUnregisterServer(), DMOUnregister(), do_process_key(), ATL::CRegObject::do_process_key(), do_reg_operation(), FilterMapper3_UnregisterFilter(), FilterMapper_UnregisterFilter(), Imm32WriteImeLayout(), InputList_PrepareUserRegistry(), ITERATE_UnpublishComponent(), LocalAddMonitor(), MSACM_WriteCurrentPriorities(), myRegDeleteTreeW(), package_RegDeleteTreeW(), PNP_DeleteClassKey(), PNP_GetClassInstance(), reg_delete_tree(), RegDeleteTreeW(), ATL::CRegObject::RegDeleteTreeX(), RegisterSdbEntry(), RemoveEventLog(), run_delete(), ScmDeleteRegKey(), ScmDeleteTree(), ServicesPageWndProc(), SETUP_CreateClassKey(), SHDeleteEmptyKeyW(), SHDeleteKeyW(), SHDeleteOrphanKeyW(), SHPropertyBag_OnRegKey(), SQLRemoveDriverW(), SQLRemoveTranslatorW(), START_TEST(), Test_CreateOpenKey(), test_DeletePwrScheme(), test_directshow_filter(), test_FolderShortcut(), test_install_class(), test_IQueryAssociations_GetString(), test_legacy_filter_registration(), test_OleRegGetUserType(), test_SetupDiInstallClassExA(), test_SHGetShellKey(), test_SQLGetPrivateProfileString(), test_SQLGetPrivateProfileStringW(), test_SQLWritePrivateProfileString(), test_StdRegProv(), test_system_security_access(), testCertOpenSystemStore(), testSystemRegStore(), testSystemStore(), TLB_unregister_interface(), UnloadUserProfile(), unregister_dmo_from_category(), unregister_mediatypes_parsing(), UnregisterComponent(), UnRegisterTypeLib(), WINTRUST_RemoveProviderFromReg(), and WNetCancelConnection2W().

◆ RegDeleteTreeA()

LONG WINAPI RegDeleteTreeA	(	IN HKEY	hKey,
		IN LPCSTR lpSubKey	OPTIONAL
	)

Definition at line 1837 of file reg.c.

{
    UNICODE_STRING SubKeyName = { 0, 0, NULL };
    LONG Ret;
 
    if (lpSubKey != NULL &&
        !RtlCreateUnicodeStringFromAsciiz(&SubKeyName, lpSubKey))
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    Ret = RegDeleteTreeW(hKey,
                         SubKeyName.Buffer);
 
    RtlFreeUnicodeString(&SubKeyName);
 
    return Ret;
}

Referenced by InitFunctionPtrs(), unregister_coclasses(), and unregister_mediatypes_extension().

◆ RegDeleteTreeW()

LSTATUS WINAPI RegDeleteTreeW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey
	)

Definition at line 1743 of file reg.c.

{
    LONG ret;
    DWORD dwMaxSubkeyLen, dwMaxValueLen;
    DWORD dwMaxLen, dwSize;
    NTSTATUS Status;
    HANDLE KeyHandle;
    HKEY hSubKey;
    WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
 
    TRACE("(hkey=%p,%p %s)\n", hKey, lpszSubKey, debugstr_w(lpszSubKey));
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    hSubKey = KeyHandle;
 
    if(lpszSubKey)
    {
        ret = RegOpenKeyExW(KeyHandle, lpszSubKey, 0, KEY_READ, &hSubKey);
        if (ret)
        {
            ClosePredefKey(KeyHandle);
            return ret;
        }
    }
 
    /* Get highest length for keys, values */
    ret = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
            &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
    if (ret) goto cleanup;
 
    dwMaxSubkeyLen++;
    dwMaxValueLen++;
    dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
    if (dwMaxLen > sizeof(szNameBuf)/sizeof(WCHAR))
    {
        /* Name too big: alloc a buffer for it */
        if (!(lpszName = RtlAllocateHeap( RtlGetProcessHeap(), 0, dwMaxLen*sizeof(WCHAR))))
        {
            ret = ERROR_NOT_ENOUGH_MEMORY;
            goto cleanup;
        }
    }
 
 
    /* Recursively delete all the subkeys */
    while (TRUE)
    {
        dwSize = dwMaxLen;
        if (RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL,
                          NULL, NULL, NULL)) break;
 
        ret = RegDeleteTreeW(hSubKey, lpszName);
        if (ret) goto cleanup;
    }
 
    if (lpszSubKey)
        ret = RegDeleteKeyW(KeyHandle, lpszSubKey);
    else
        while (TRUE)
        {
            dwSize = dwMaxLen;
            if (RegEnumValueW(KeyHandle, 0, lpszName, &dwSize,
                  NULL, NULL, NULL, NULL)) break;
 
            ret = RegDeleteValueW(KeyHandle, lpszName);
            if (ret) goto cleanup;
        }
 
cleanup:
    /* Free buffer if allocated */
    if (lpszName != szNameBuf)
        RtlFreeHeap( RtlGetProcessHeap(), 0, lpszName);
    if(lpszSubKey)
        RegCloseKey(hSubKey);
 
    ClosePredefKey(KeyHandle);
 
    return ret;
}

◆ RegDeleteValueA()

LONG WINAPI RegDeleteValueA	(	HKEY	hKey,
		LPCSTR	lpValueName
	)

Definition at line 2316 of file reg.c.

{
    UNICODE_STRING ValueName;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    RtlCreateUnicodeStringFromAsciiz(&ValueName, lpValueName);
    Status = NtDeleteValueKey(KeyHandle,
                              &ValueName);
    RtlFreeUnicodeString (&ValueName);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by cleanup_eventlog(), delete_value_(), DeleteRegistryValue(), ICRemove(), IStream_fnRelease(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), process_pending_renames(), restore_value(), save_cert_mgr_usages(), setLayerValue(), SHDeleteValueA(), START_TEST(), test_AddERExcludedApplicationA(), test_appsearch_reglocator(), test_debug_heap(), test_delete_value(), test_envvar(), test_GetAcceptLanguagesA(), test_ICInfo(), test_internet_features_registry(), test_machine_guid(), test_MsiEnumClients(), test_MsiEnumComponentsEx(), test_MsiEnumPatches(), test_MsiEnumPatchesEx_machine(), test_MsiEnumPatchesEx_usermanaged(), test_MsiEnumPatchesEx_userunmanaged(), test_MsiGetComponentPath(), test_MsiGetComponentPathEx(), test_MsiGetPatchInfoEx(), test_MsiGetProductCode(), test_MsiGetProductInfoEx(), test_MsiGetProductProperty(), test_MsiGetUserInfo(), test_MsiOpenProduct(), test_MsiQueryComponentState(), test_MsiQueryFeatureState(), test_MsiQueryProductState(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListGetInfo(), test_MsiSourceListSetInfo(), test_null(), test_process_components(), test_publish_assemblies(), test_publish_features(), test_register_font(), test_register_product(), test_register_user(), test_registry(), test_symlinks(), test_XcvDataPort_ConfigureLPTPortCommandOK(), test_XcvDataPort_GetTransmissionRetryTimeout(), WhichPlatform(), and WNetRemoveCachedPassword().

◆ RegDeleteValueW()

LONG WINAPI RegDeleteValueW	(	HKEY	hKey,
		LPCWSTR	lpValueName
	)

Definition at line 2352 of file reg.c.

{
    UNICODE_STRING ValueName;
    NTSTATUS Status;
    HANDLE KeyHandle;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    RtlInitUnicodeString(&ValueName, lpValueName);
 
    Status = NtDeleteValueKey(KeyHandle,
                              &ValueName);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by _CmdWndProc(), _HandleDeletePort(), ACTION_MsiUnpublishAssemblies(), ACTION_ProcessComponents(), ConCfgWriteUserSettings(), connections_on_notify(), CryptSetProviderExW(), delete_value(), delete_value_state(), devinst_RegDeleteTreeW(), do_reg_operation(), FilterMapper_UnregisterFilter(), INetCfgComponentControl_fnApplyRegistryChanges(), INTERNET_SaveProxySettings(), IStream_fnRelease(), ITERATE_RemoveEnvironmentString(), ITERATE_UnregisterFonts(), ITERATE_WriteEnvironmentString(), LocalDeleteForm(), LocalmonDeletePort(), MainWnd_OnUpdateRegistry(), ModifyStatus(), msi_unpublish_feature(), myRegDeleteTreeW(), package_RegDeleteTreeW(), pendingRename(), PNP_SetClassRegProp(), PNP_SetDeviceRegProp(), ProcessRunKeys(), RChangeServiceConfig2W(), RegDeleteTreeW(), remove_product_upgrade_code(), run_delete(), SaveSetting(), ScmDeleteTree(), ScmSetFailureActions(), ScmWriteDependencies(), set_domain(), set_name_servers(), set_profile_device_key(), set_proxy(), SetAutoDaylight(), SHDeleteValueW(), SKDeleteValueW(), SQLRemoveDriverW(), SQLRemoveTranslatorW(), START_TEST(), stillimagew_UnregisterLaunchApplication(), test_save(), UXTHEME_ApplyTheme(), write_shared_dlls_count(), and WriteParameterArray().

◆ RegDisablePredefinedCache()

LONG WINAPI RegDisablePredefinedCache ( VOID )

Definition at line 332 of file reg.c.

{
    RegInitialize(); /* HACK until delay-loading is implemented */
    RtlEnterCriticalSection(&HandleTableCS);
    DefaultHandleHKUDisabled = TRUE;
    RtlLeaveCriticalSection(&HandleTableCS);
    return ERROR_SUCCESS;
}

◆ RegDisablePredefinedCacheEx()

LONG WINAPI RegDisablePredefinedCacheEx ( VOID )

Definition at line 348 of file reg.c.

{
    RegInitialize(); /* HACK until delay-loading is implemented */
    RtlEnterCriticalSection(&HandleTableCS);
    DefaultHandlesDisabled = TRUE;
    DefaultHandleHKUDisabled = TRUE;
    RtlLeaveCriticalSection(&HandleTableCS);
    return ERROR_SUCCESS;
}

◆ RegDisableReflectionKey()

LONG WINAPI RegDisableReflectionKey ( IN HKEY hBase )

Definition at line 1864 of file reg.c.

{
    FIXME("RegDisableReflectionKey(0x%p) UNIMPLEMENTED!\n", hBase);
    return ERROR_CALL_NOT_IMPLEMENTED;
}

◆ RegEnableReflectionKey()

LONG WINAPI RegEnableReflectionKey ( IN HKEY hBase )

Definition at line 1877 of file reg.c.

{
    FIXME("RegEnableReflectionKey(0x%p) UNIMPLEMENTED!\n", hBase);
    return ERROR_CALL_NOT_IMPLEMENTED;
}

◆ RegEnumKeyA()

LONG WINAPI RegEnumKeyA	(	HKEY	hKey,
		DWORD	dwIndex,
		LPSTR	lpName,
		DWORD	cbName
	)

Definition at line 2388 of file reg.c.

{
    DWORD dwLength;
 
    dwLength = cbName;
    return RegEnumKeyExA(hKey,
                         dwIndex,
                         lpName,
                         &dwLength,
                         NULL,
                         NULL,
                         NULL,
                         NULL);
}

Referenced by delete_key(), delete_registry_key(), find_registry_key(), init_registered_oid_info(), lineGetCountryA(), lineGetTranslateCapsA(), test_classesroot_enum(), test_deleted_key(), test_RegQueryValueExPerformanceData(), and test_SHGetObjectCompatFlags().

◆ RegEnumKeyExA()

LONG WINAPI RegEnumKeyExA	(	_In_ HKEY	hKey,
		_In_ DWORD	dwIndex,
		_Out_ LPSTR	lpName,
		_Inout_ LPDWORD	lpcbName,
		_Reserved_ LPDWORD	lpReserved,
		_Out_opt_ LPSTR	lpClass,
		_Inout_opt_ LPDWORD	lpcbClass,
		_Out_opt_ PFILETIME	lpftLastWriteTime
	)

Definition at line 2439 of file reg.c.

{
    WCHAR* NameBuffer = NULL;
    WCHAR* ClassBuffer = NULL;
    DWORD NameLength, ClassLength;
    LONG ErrorCode;
 
    /* Allocate our buffers */
    if (*lpcbName > 0)
    {
        NameLength = *lpcbName;
        NameBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, *lpcbName * sizeof(WCHAR));
        if (NameBuffer == NULL)
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    if (lpClass)
    {
        if (*lpcbClass > 0)
        {
            ClassLength = *lpcbClass;
            ClassBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, *lpcbClass * sizeof(WCHAR));
            if (ClassBuffer == NULL)
            {
                ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
                goto Exit;
            }
        }
    }
 
    /* Do the actual call */
    ErrorCode = RegEnumKeyExW(
        hKey,
        dwIndex,
        NameBuffer,
        lpcbName,
        lpReserved,
        ClassBuffer,
        lpcbClass,
        lpftLastWriteTime);
 
    if (ErrorCode != ERROR_SUCCESS)
        goto Exit;
 
    /* Convert the strings */
    RtlUnicodeToMultiByteN(lpName, *lpcbName, 0, NameBuffer, *lpcbName * sizeof(WCHAR));
    /* NULL terminate if we can */
    if (NameLength > *lpcbName)
        lpName[*lpcbName] = '\0';
 
    if (lpClass)
    {
        RtlUnicodeToMultiByteN(lpClass, *lpcbClass, 0, NameBuffer, *lpcbClass * sizeof(WCHAR));
        if (ClassLength > *lpcbClass)
            lpClass[*lpcbClass] = '\0';
    }
 
Exit:
    if (NameBuffer)
        RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
    if (ClassBuffer)
        RtlFreeHeap(RtlGetProcessHeap(), 0, ClassBuffer);
 
    return ErrorCode;
}

Referenced by delete_tree(), delete_tree_(), DP_LoadSP(), find_typelib_key(), FindProvRegVals(), FindProvTypesRegVals(), IDirectPlay4AImpl_EnumConnections(), IDirectPlayLobby3AImpl_EnumAddressTypes(), IDirectPlayLobby3AImpl_EnumLocalApplications(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), RegEnumKeyA(), RSAENH_CPGetProvParam(), scan_subkeys(), SHEnumKeyExA(), and SHRegEnumUSKeyA().

◆ RegEnumKeyExW()

LONG WINAPI RegEnumKeyExW	(	_In_ HKEY	hKey,
		_In_ DWORD	dwIndex,
		_Out_ LPWSTR	lpName,
		_Inout_ LPDWORD	lpcbName,
		_Reserved_ LPDWORD	lpReserved,
		_Out_opt_ LPWSTR	lpClass,
		_Inout_opt_ LPDWORD	lpcbClass,
		_Out_opt_ PFILETIME	lpftLastWriteTime
	)

Definition at line 2524 of file reg.c.

{
    union
    {
        KEY_NODE_INFORMATION Node;
        KEY_BASIC_INFORMATION Basic;
    } *KeyInfo;
 
    ULONG BufferSize;
    ULONG ResultSize;
    ULONG NameLength;
    ULONG ClassLength = 0;
    HANDLE KeyHandle;
    LONG ErrorCode = ERROR_SUCCESS;
    NTSTATUS Status;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (IsHKCRKey(KeyHandle))
    {
        ErrorCode = EnumHKCRKey(
            KeyHandle,
            dwIndex,
            lpName,
            lpcbName,
            lpReserved,
            lpClass,
            lpcbClass,
            lpftLastWriteTime);
        ClosePredefKey(KeyHandle);
        return ErrorCode;
    }
 
    if (*lpcbName > 0)
    {
        NameLength = min (*lpcbName - 1, REG_MAX_NAME_SIZE) * sizeof (WCHAR);
    }
    else
    {
        NameLength = 0;
    }
 
    if (lpClass)
    {
        if (*lpcbClass > 0)
        {
            ClassLength = min (*lpcbClass - 1, REG_MAX_NAME_SIZE) * sizeof(WCHAR);
        }
        else
        {
            ClassLength = 0;
        }
 
        BufferSize = ((sizeof(KEY_NODE_INFORMATION) + NameLength + 3) & ~3) + ClassLength;
    }
    else
    {
        BufferSize = sizeof(KEY_BASIC_INFORMATION) + NameLength;
    }
 
    KeyInfo = RtlAllocateHeap(ProcessHeap,
                              0,
                              BufferSize);
    if (KeyInfo == NULL)
    {
        ErrorCode = ERROR_OUTOFMEMORY;
        goto Cleanup;
    }
 
    Status = NtEnumerateKey(KeyHandle,
                            (ULONG)dwIndex,
                            lpClass ? KeyNodeInformation : KeyBasicInformation,
                            KeyInfo,
                            BufferSize,
                            &ResultSize);
    TRACE("NtEnumerateKey() returned status 0x%X\n", Status);
    if (!NT_SUCCESS(Status))
    {
        ErrorCode = RtlNtStatusToDosError (Status);
    }
    else
    {
        if (lpClass == NULL)
        {
            if (KeyInfo->Basic.NameLength > NameLength)
            {
                ErrorCode = ERROR_MORE_DATA;
            }
            else
            {
                RtlCopyMemory(lpName,
                              KeyInfo->Basic.Name,
                              KeyInfo->Basic.NameLength);
                *lpcbName = (DWORD)(KeyInfo->Basic.NameLength / sizeof(WCHAR));
                lpName[*lpcbName] = 0;
            }
        }
        else
        {
            if (KeyInfo->Node.NameLength > NameLength ||
                KeyInfo->Node.ClassLength > ClassLength)
            {
                ErrorCode = ERROR_MORE_DATA;
            }
            else
            {
                RtlCopyMemory(lpName,
                              KeyInfo->Node.Name,
                              KeyInfo->Node.NameLength);
                *lpcbName = KeyInfo->Node.NameLength / sizeof(WCHAR);
                lpName[*lpcbName] = 0;
                RtlCopyMemory(lpClass,
                              (PVOID)((ULONG_PTR)KeyInfo->Node.Name + KeyInfo->Node.ClassOffset),
                              KeyInfo->Node.ClassLength);
                *lpcbClass = (DWORD)(KeyInfo->Node.ClassLength / sizeof(WCHAR));
                lpClass[*lpcbClass] = 0;
            }
        }
 
        if (ErrorCode == ERROR_SUCCESS && lpftLastWriteTime != NULL)
        {
            if (lpClass == NULL)
            {
                lpftLastWriteTime->dwLowDateTime = KeyInfo->Basic.LastWriteTime.u.LowPart;
                lpftLastWriteTime->dwHighDateTime = KeyInfo->Basic.LastWriteTime.u.HighPart;
            }
            else
            {
                lpftLastWriteTime->dwLowDateTime = KeyInfo->Node.LastWriteTime.u.LowPart;
                lpftLastWriteTime->dwHighDateTime = KeyInfo->Node.LastWriteTime.u.HighPart;
            }
        }
    }
 
    RtlFreeHeap(ProcessHeap,
                0,
                KeyInfo);
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    return ErrorCode;
}

Referenced by _enumeratorRememberedW(), _InitializePrintProviderList(), CDefaultContextMenu::AddStaticEntriesForKey(), AddUserProfiles(), AllSysInfo(), build_zonemap_from_reg(), BuildLogListAndFilterList(), BuildParameterArray(), capGetDriverDescriptionW(), CategoryMgr_FindClosestCategory(), CATIDEnumGUID_Next(), CertEnumSystemStore(), CheckLogOrSourceExistence(), CliGetImeHotKeysFromRegistry(), CLSIDEnumGUID_Next(), COMCAT_IEnumCATEGORYINFO_Next(), COMCAT_IsClassOfCategories(), ComponentInfo_GetGuidList(), CopyKey(), CreateComponentEnumerator(), CreateKeyboardLayoutList(), CRYPT_RegReadSerializedFromReg(), CryptEnumProvidersW(), CryptSIPRetrieveSubjectGuid(), delete_test_key(), DEVENUM_ReadPins(), DEVENUM_ReadPinTypes(), devinst_RegDeleteTreeW(), DirectPlayEnumerateAW(), DMOUnregister(), EnumClientServiceProtocol(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), EnumerateSoundProfiles(), EnumerateTimeZoneList(), EnumHKCRKey(), EnumInterfaces(), EnumPwrSchemes(), EnumTfLanguageProfiles_Next(), export_registry_data(), fetch_machine_component(), fetch_machine_product(), fetch_user_component(), fetch_user_product(), FileTypesDlg_DoList(), GetAllInstanceList(), GetAllInstanceListSize(), GetClassMediaFile(), CQueryAssociations::GetCommand(), GetDeviceInstanceList(), GetEnumeratorInstanceList(), GetEnumeratorInstanceListSize(), GetNthChildKeyName(), GetProfiles(), IEnumDMO_fnNext(), ImportAppProfile(), ImportSoundEntry(), InitializePrinterList(), InitializePrintMonitorList(), InitializePrintProcessorList(), InitIconOverlays(), InitNotifications(), Int_EnumDependentServicesW(), LayoutList_Create(), load_devices_from_reg(), COpenWithList::LoadAppList(), LoadEventLabels(), LoadEventSources(), LoadLogFiles(), LoadUsernameHint(), LocalEnumPrintProcessors(), MCI_SysInfo(), MSACM_RegisterAllDrivers(), myRegDeleteTreeW(), next_LanguageProfile(), CEnumRegKey::NextKey(), OnTreeExpanding(), package_RegDeleteTreeW(), PNP_EnumerateSubKeys(), ProfilesEnumGuid_Next(), query_all(), query_value(), read_types(), RefreshTreeItem(), reg_delete_tree(), RegDeleteTreeW(), ATL::CRegObject::RegDeleteTreeX(), RegEnumKeyExA(), RegEnumKeyW(), RegFindRecurse(), RegFindWalk(), register_legacy_filters(), RegQueryRegistryKeys(), RemoveEventLog(), run_copy(), ScmCopyTree(), ScmCreateServiceDatabase(), ScmDeleteRegKey(), ScmDeleteTree(), SdbUninstallByName(), search_domain_for_zone(), search_for_domain_mapping(), SETUP_CreateInterfaceList(), SetupDiClassGuidsFromNameExW(), SetupDiOpenDeviceInterfaceW(), SHCopyKeyW(), SHCreatePropSheetExtArrayEx(), SHDeleteKeyW(), SHEnumKeyExW(), SHRegEnumUSKeyW(), START_TEST(), txt_export_registry_data(), UnRegisterTypeLib(), and wnetInit().

◆ RegEnumKeyW()

LONG WINAPI RegEnumKeyW	(	HKEY	hKey,
		DWORD	dwIndex,
		LPWSTR	lpName,
		DWORD	cbName
	)

Definition at line 2413 of file reg.c.

{
    DWORD dwLength;
 
    dwLength = cbName;
    return RegEnumKeyExW(hKey,
                         dwIndex,
                         lpName,
                         &dwLength,
                         NULL,
                         NULL,
                         NULL,
                         NULL);
}

Referenced by CRegFolderEnum::AddItemsFromKey(), AVIBuildFilterW(), CNewMenu::CacheItems(), CryptEnumProvidersW(), CryptEnumProviderTypesW(), delete_key(), DEVENUM_IEnumMoniker_Next(), DEVENUM_IEnumMoniker_Skip(), DirectPlayEnumerateAW(), DisplayStatus(), EditTypeDlg_ReadClass(), EditTypeDlg_WriteClass(), enum_key(), EnumOLEVERB_Next(), HCR_GetDefaultVerbW(), Imm32GetImeLayout(), ImportSoundProfiles(), InstallerImpl_RegistryValue(), lineGetCountryW(), LoadClassicColorSchemes(), LoadSchemeSizes(), MIDIMAP_LoadSettingsScheme(), registry_enumerate_credentials(), ShellExecute_FromContextMenuHandlers(), UIINSERTOBJECTDLG_PopulateObjectTypes(), ViewTree_LoadAll(), and ViewTree_LoadTree().

◆ RegEnumValueA()

LONG WINAPI RegEnumValueA	(	_In_ HKEY	hKey,
		_In_ DWORD	dwIndex,
		_Out_ LPSTR	lpName,
		_Inout_ LPDWORD	lpcbName,
		_Reserved_ LPDWORD	lpdwReserved,
		_Out_opt_ LPDWORD	lpdwType,
		_Out_opt_ LPBYTE	lpData,
		_Inout_opt_ LPDWORD	lpcbData
	)

Definition at line 2688 of file reg.c.

{
    WCHAR* NameBuffer;
    DWORD NameBufferSize, NameLength;
    LONG ErrorCode;
    DWORD LocalType = REG_NONE;
    BOOL NameOverflow = FALSE;
 
    /* Do parameter checks now, once and for all. */
    if (!lpName || !lpcbName)
        return ERROR_INVALID_PARAMETER;
 
    if ((lpData && !lpcbData) || lpdwReserved)
        return ERROR_INVALID_PARAMETER;
 
    /* Get the size of the buffer we must use for the first call to RegEnumValueW */
    ErrorCode = RegQueryInfoKeyW(
        hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &NameBufferSize, NULL, NULL, NULL);
    if (ErrorCode != ERROR_SUCCESS)
        return ErrorCode;
 
    /* Add space for the null terminator */
    NameBufferSize++;
 
    /* Allocate the buffer for the unicode name */
    NameBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, NameBufferSize * sizeof(WCHAR));
    if (NameBuffer == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    /*
     * This code calls RegEnumValueW twice, because we need to know the type of the enumerated value.
     * So for the first call, we check if we overflow on the name, as we have no way of knowing if this
     * is an overflow on the data or on the name during the the second call. So the first time, we make the
     * call with the supplied value. This is merdique, but this is how it is.
     */
    NameLength = *lpcbName;
    ErrorCode = RegEnumValueW(
        hKey,
        dwIndex,
        NameBuffer,
        &NameLength,
        NULL,
        &LocalType,
        NULL,
        NULL);
    if (ErrorCode != ERROR_SUCCESS)
    {
        if (ErrorCode == ERROR_MORE_DATA)
            NameOverflow = TRUE;
        else
            goto Exit;
    }
 
    if (is_string(LocalType) && lpcbData)
    {
        /* We must allocate a buffer to get the unicode data */
        DWORD DataBufferSize = *lpcbData * sizeof(WCHAR);
        WCHAR* DataBuffer = NULL;
        DWORD DataLength = *lpcbData;
        LPSTR DataStr = (LPSTR)lpData;
 
        if (lpData)
            DataBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, *lpcbData * sizeof(WCHAR));
 
        /* Do the real call */
        ErrorCode = RegEnumValueW(
            hKey,
            dwIndex,
            NameBuffer,
            &NameBufferSize,
            lpdwReserved,
            lpdwType,
            (LPBYTE)DataBuffer,
            &DataBufferSize);
 
        *lpcbData = DataBufferSize / sizeof(WCHAR);
 
        if (ErrorCode != ERROR_SUCCESS)
        {
            RtlFreeHeap(RtlGetProcessHeap(), 0, DataBuffer);
            goto Exit;
        }
 
        /* Copy the data whatever the error code is */
        if (lpData)
        {
            /* Do the data conversion */
            RtlUnicodeToMultiByteN(DataStr, DataLength, 0, DataBuffer, DataBufferSize);
            /* NULL-terminate if there is enough room */
            if ((DataLength > *lpcbData) && (DataStr[*lpcbData - 1] != '\0'))
                DataStr[*lpcbData] = '\0';
        }
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, DataBuffer);
    }
    else
    {
        /* No data conversion needed. Do the call with provided buffers */
        ErrorCode = RegEnumValueW(
            hKey,
            dwIndex,
            NameBuffer,
            &NameBufferSize,
            lpdwReserved,
            lpdwType,
            lpData,
            lpcbData);
 
        if (ErrorCode != ERROR_SUCCESS)
        {
            goto Exit;
        }
    }
 
    if (NameOverflow)
    {
        ErrorCode = ERROR_MORE_DATA;
        goto Exit;
    }
 
    /* Convert the name string */
    RtlUnicodeToMultiByteN(lpName, *lpcbName, lpcbName, NameBuffer, NameBufferSize * sizeof(WCHAR));
    lpName[*lpcbName] = ANSI_NULL;
 
Exit:
    if (NameBuffer)
        RtlFreeHeap(RtlGetProcessHeap(), 0, NameBuffer);
 
    return ErrorCode;
}

Referenced by ICInfo(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), RegisterDefaultAcceptHeaders(), SHEnumValueA(), SHRegEnumUSValueA(), SQLGetPrivateProfileString(), test_classesroot_enum(), test_deleted_key(), test_enum_value(), test_RegQueryValueExPerformanceData(), test_rw_order(), test_SHGetObjectCompatFlags(), test_string_termination(), TTIsEmbeddingEnabledForFacename(), and WNetEnumCachedPasswords().

◆ RegEnumValueW()

LONG WINAPI RegEnumValueW	(	_In_ HKEY	hKey,
		_In_ DWORD	index,
		_Out_ LPWSTR	value,
		_Inout_ PDWORD	val_count,
		_Reserved_ PDWORD	reserved,
		_Out_opt_ PDWORD	type,
		_Out_opt_ LPBYTE	data,
		_Inout_opt_ PDWORD	count
	)

Definition at line 2850 of file reg.c.

{
    HANDLE KeyHandle;
    NTSTATUS status;
    ULONG total_size;
    char buffer[256], *buf_ptr = buffer;
    KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
    static const int info_size = FIELD_OFFSET( KEY_VALUE_FULL_INFORMATION, Name );
 
    TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
          hKey, index, value, val_count, reserved, type, data, count );
 
    if (!value || !val_count)
        return ERROR_INVALID_PARAMETER;
 
    if ((data && !count) || reserved)
        return ERROR_INVALID_PARAMETER;
 
    status = MapDefaultKey(&KeyHandle, hKey);
    if (!NT_SUCCESS(status))
    {
        return RtlNtStatusToDosError(status);
    }
 
    if (IsHKCRKey(KeyHandle))
    {
        LONG ErrorCode = EnumHKCRValue(
            KeyHandle,
            index,
            value,
            val_count,
            reserved,
            type,
            data,
            count);
        ClosePredefKey(KeyHandle);
        return ErrorCode;
    }
 
    total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
    if (data) total_size += *count;
    total_size = min( sizeof(buffer), total_size );
 
    status = NtEnumerateValueKey( KeyHandle, index, KeyValueFullInformation,
                                  buffer, total_size, &total_size );
    if (status && (status != STATUS_BUFFER_OVERFLOW) && (status != STATUS_BUFFER_TOO_SMALL)) goto done;
 
    if (value || data)
    {
        /* retry with a dynamically allocated buffer */
        while ((status == STATUS_BUFFER_OVERFLOW) || (status == STATUS_BUFFER_TOO_SMALL))
        {
            if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
            if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
            {
                status = ERROR_NOT_ENOUGH_MEMORY;
                goto done;
            }
            info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
            status = NtEnumerateValueKey( KeyHandle, index, KeyValueFullInformation,
                                          buf_ptr, total_size, &total_size );
        }
 
        if (status) goto done;
 
        if (value)
        {
            if (info->NameLength/sizeof(WCHAR) >= *val_count)
            {
                status = STATUS_BUFFER_OVERFLOW;
                goto overflow;
            }
            memcpy( value, info->Name, info->NameLength );
            *val_count = info->NameLength / sizeof(WCHAR);
            value[*val_count] = 0;
        }
 
        if (data)
        {
            if (info->DataLength > *count)
            {
                status = STATUS_BUFFER_OVERFLOW;
                goto overflow;
            }
            memcpy( data, buf_ptr + info->DataOffset, info->DataLength );
            if (is_string(info->Type) && info->DataLength <= *count - sizeof(WCHAR))
            {
                /* if the type is REG_SZ and data is not 0-terminated
                 * and there is enough space in the buffer NT appends a \0 */
                WCHAR *ptr = (WCHAR *)(data + info->DataLength);
                if (ptr > (WCHAR *)data && ptr[-1]) *ptr = 0;
            }
        }
    }
    else status = STATUS_SUCCESS;
 
 overflow:
    if (type) *type = info->Type;
    if (count) *count = info->DataLength;
 
 done:
    if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
    ClosePredefKey(KeyHandle);
    return RtlNtStatusToDosError(status);
}

Referenced by CDesktopFolderEnum::AddItemsFromClassicStartMenuKey(), BuildCodePageList(), ConCfgReadUserSettings(), Control_RegisterRegistryApplets(), CopyKey(), CreateNTPServerList(), devinst_RegDeleteTreeW(), DoLoadItems(), ensure_useragent(), enum_values(), EnumHKCRValue(), CRegKeyEx::EnumValueName(), export_registry_data(), fill_source_list(), FillServerAddressCombo(), GetClassMediaFile(), GetEnumOptions(), GetUsedPorts(), InitializePrintMonitor2(), InitShellServices(), InitTTFontCache(), InstallerImpl_RegistryValue(), IsLayoutExists(), ITERATE_FindRelatedProducts(), LoadHelpers(), LocaleList_Create(), MainWnd_OnUpdateRegistry(), MMDevPropStore_GetAt(), MMDevPropStore_GetCount(), MSACM_RegisterAllDrivers(), MSI_EnumComponentQualifiers(), MsiEnumClientsW(), MsiEnumFeaturesW(), MsiEnumRelatedProductsW(), MsiGetProductCodeW(), MsiSourceListEnumMediaDisksW(), myRegDeleteTreeW(), CEnumRegKey::NextValue(), OnInitMenu(), package_RegDeleteTreeW(), ProcessRunKeys(), query_all(), CFontCache::Read(), RefreshListView(), RegDeleteTreeW(), RegEnumValueA(), RegFindRecurse(), CControlPanelEnum::RegisterRegistryCPanelApps(), RegQueryRegistryValues(), SSOThread::Run(), run_copy(), run_delete(), ScmCopyTree(), ScmDeleteTree(), SetDefaultPrinterW(), SetSystemEnvironment(), SetUserEnvironment(), SHCopyKeyW(), SHEnumValueW(), SHGetObjectCompatFlags(), SHRegEnumUSValueW(), SQLGetInstalledDriversW(), SQLGetPrivateProfileStringW(), START_TEST(), test_enum_value(), txt_export_registry_data(), URL_GuessScheme(), and wWinMain().

◆ RegFlushKey()

LONG WINAPI RegFlushKey ( HKEY hKey )

Definition at line 2971 of file reg.c.

{
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    if (hKey == HKEY_PERFORMANCE_DATA)
    {
        return ERROR_SUCCESS;
    }
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    Status = NtFlushKey(KeyHandle);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by create_new_eventlog(), CreateEventLog(), CreateUserHive(), ATL::CRegKey::Flush(), ImportRegistryFile(), InstallEventSource(), RemoveEventLog(), RSetServiceObjectSecurity(), SaveCurrentLocale(), SaveGeoID(), ScmCopyControlSet(), ScmSetLastKnownGoodControlSet(), test_deleted_key(), test_NonExistentPath(), TestMyEventProvider(), and UnloadUserProfile().

◆ RegGetKeySecurity()

LONG WINAPI RegGetKeySecurity	(	HKEY	hKey,
		SECURITY_INFORMATION	SecurityInformation,
		PSECURITY_DESCRIPTOR	pSecurityDescriptor,
		LPDWORD	lpcbSecurityDescriptor
	)

Definition at line 3007 of file reg.c.

{
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    if (hKey == HKEY_PERFORMANCE_DATA)
    {
        return ERROR_INVALID_HANDLE;
    }
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        TRACE("MapDefaultKey() failed (Status %lx)\n", Status);
        return RtlNtStatusToDosError(Status);
    }
 
    Status = NtQuerySecurityObject(KeyHandle,
                                   SecurityInformation,
                                   pSecurityDescriptor,
                                   *lpcbSecurityDescriptor,
                                   lpcbSecurityDescriptor);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
         WARN("NtQuerySecurityObject() failed (Status %lx)\n", Status);
         return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by AccRewriteGetHandleRights(), ATL::CRegKey::GetKeySecurity(), and CRegistryKey::GetSecurityDescriptor().

◆ RegGetValueA()

LSTATUS WINAPI RegGetValueA	(	HKEY	hKey,
		LPCSTR	pszSubKey,
		LPCSTR	pszValue,
		DWORD	dwFlags,
		LPDWORD	pdwType,
		PVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 2068 of file reg.c.

{
    DWORD dwType, cbData = pcbData ? *pcbData : 0;
    PVOID pvBuf = NULL;
    LONG ret;
 
    TRACE("(%p,%s,%s,%ld,%p,%p,%p=%ld)\n",
          hKey, pszSubKey, pszValue, dwFlags, pdwType, pvData, pcbData,
          cbData);
 
    if (pvData && !pcbData)
        return ERROR_INVALID_PARAMETER;
    if ((dwFlags & RRF_RT_REG_EXPAND_SZ) && !(dwFlags & RRF_NOEXPAND) &&
            ((dwFlags & RRF_RT_ANY) != RRF_RT_ANY))
        return ERROR_INVALID_PARAMETER;
 
    if (pszSubKey && pszSubKey[0])
    {
        ret = RegOpenKeyExA(hKey, pszSubKey, 0, KEY_QUERY_VALUE, &hKey);
        if (ret != ERROR_SUCCESS) return ret;
    }
 
    ret = RegQueryValueExA(hKey, pszValue, NULL, &dwType, pvData, &cbData);
 
    /* If we are going to expand we need to read in the whole the value even
     * if the passed buffer was too small as the expanded string might be
     * smaller than the unexpanded one and could fit into cbData bytes. */
    if ((ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) &&
        (dwType == REG_EXPAND_SZ && !(dwFlags & RRF_NOEXPAND)))
    {
        do {
            HeapFree(GetProcessHeap(), 0, pvBuf);
 
            pvBuf = HeapAlloc(GetProcessHeap(), 0, cbData);
            if (!pvBuf)
            {
                ret = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            if (ret == ERROR_MORE_DATA || !pvData)
                ret = RegQueryValueExA(hKey, pszValue, NULL,
                                       &dwType, pvBuf, &cbData);
            else
            {
                /* Even if cbData was large enough we have to copy the
                 * string since ExpandEnvironmentStrings can't handle
                 * overlapping buffers. */
                CopyMemory(pvBuf, pvData, cbData);
            }
 
            /* Both the type or the value itself could have been modified in
             * between so we have to keep retrying until the buffer is large
             * enough or we no longer have to expand the value. */
        } while (dwType == REG_EXPAND_SZ && ret == ERROR_MORE_DATA);
 
        if (ret == ERROR_SUCCESS)
        {
            /* Recheck dwType in case it changed since the first call */
            if (dwType == REG_EXPAND_SZ)
            {
                cbData = ExpandEnvironmentStringsA(pvBuf, pvData,
                                                   pcbData ? *pcbData : 0);
                dwType = REG_SZ;
                if(pvData && pcbData && cbData > *pcbData)
                    ret = ERROR_MORE_DATA;
            }
            else if (pvData)
                CopyMemory(pvData, pvBuf, *pcbData);
        }
 
        HeapFree(GetProcessHeap(), 0, pvBuf);
    }
 
    if (pszSubKey && pszSubKey[0])
        RegCloseKey(hKey);
 
    RegpApplyRestrictions(dwFlags, dwType, cbData, &ret);
 
    if (pvData && ret != ERROR_SUCCESS && (dwFlags & RRF_ZEROONFAILURE))
        ZeroMemory(pvData, *pcbData);
 
    if (pdwType) *pdwType = dwType;
    if (pcbData) *pcbData = cbData;
 
    return ret;
}

Referenced by HCR_GetClassNameA(), InitFunctionPtrs(), install_from_registered_dir(), SQLGetPrivateProfileString(), SQLRemoveDriverW(), SQLRemoveTranslatorW(), and write_registry_values().

◆ RegGetValueW()

LSTATUS WINAPI RegGetValueW	(	HKEY	hKey,
		LPCWSTR	pszSubKey,
		LPCWSTR	pszValue,
		DWORD	dwFlags,
		LPDWORD	pdwType,
		PVOID	pvData,
		LPDWORD	pcbData
	)

Definition at line 1962 of file reg.c.

{
    DWORD dwType, cbData = pcbData ? *pcbData : 0;
    PVOID pvBuf = NULL;
    LONG ret;
 
    TRACE("(%p,%s,%s,%ld,%p,%p,%p=%ld)\n",
          hKey, debugstr_w(pszSubKey), debugstr_w(pszValue), dwFlags, pdwType,
          pvData, pcbData, cbData);
 
    if (pvData && !pcbData)
        return ERROR_INVALID_PARAMETER;
    if ((dwFlags & RRF_RT_REG_EXPAND_SZ) && !(dwFlags & RRF_NOEXPAND) &&
            ((dwFlags & RRF_RT_ANY) != RRF_RT_ANY))
        return ERROR_INVALID_PARAMETER;
 
    if (pszSubKey && pszSubKey[0])
    {
        ret = RegOpenKeyExW(hKey, pszSubKey, 0, KEY_QUERY_VALUE, &hKey);
        if (ret != ERROR_SUCCESS) return ret;
    }
 
    ret = RegQueryValueExW(hKey, pszValue, NULL, &dwType, pvData, &cbData);
 
    /* If we are going to expand we need to read in the whole the value even
     * if the passed buffer was too small as the expanded string might be
     * smaller than the unexpanded one and could fit into cbData bytes. */
    if ((ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) &&
        dwType == REG_EXPAND_SZ && !(dwFlags & RRF_NOEXPAND))
    {
        do
        {
            HeapFree(GetProcessHeap(), 0, pvBuf);
 
            pvBuf = HeapAlloc(GetProcessHeap(), 0, cbData);
            if (!pvBuf)
            {
                ret = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            if (ret == ERROR_MORE_DATA || !pvData)
                ret = RegQueryValueExW(hKey, pszValue, NULL,
                                       &dwType, pvBuf, &cbData);
            else
            {
                /* Even if cbData was large enough we have to copy the
                 * string since ExpandEnvironmentStrings can't handle
                 * overlapping buffers. */
                CopyMemory(pvBuf, pvData, cbData);
            }
 
            /* Both the type or the value itself could have been modified in
             * between so we have to keep retrying until the buffer is large
             * enough or we no longer have to expand the value. */
        }
        while (dwType == REG_EXPAND_SZ && ret == ERROR_MORE_DATA);
 
        if (ret == ERROR_SUCCESS)
        {
            /* Recheck dwType in case it changed since the first call */
            if (dwType == REG_EXPAND_SZ)
            {
                cbData = ExpandEnvironmentStringsW(pvBuf, pvData,
                                                   pcbData ? *pcbData : 0) * sizeof(WCHAR);
                dwType = REG_SZ;
                if (pvData && pcbData && cbData > *pcbData)
                    ret = ERROR_MORE_DATA;
            }
            else if (pvData)
                CopyMemory(pvData, pvBuf, *pcbData);
        }
 
        HeapFree(GetProcessHeap(), 0, pvBuf);
    }
 
    if (pszSubKey && pszSubKey[0])
        RegCloseKey(hKey);
 
    RegpApplyRestrictions(dwFlags, dwType, cbData, &ret);
 
    if (pvData && ret != ERROR_SUCCESS && (dwFlags & RRF_ZEROONFAILURE))
        ZeroMemory(pvData, *pcbData);
 
    if (pdwType)
        *pdwType = dwType;
 
    if (pcbData)
        *pcbData = cbData;
 
    return ret;
}

Referenced by AddFSClassKeysToArray(), CRegFolderEnum::AddItemsFromKey(), AssocGetPerceivedType(), CDefaultContextMenu::BrowserFlagsFromVerb(), ComponentInfo_GetDWORDValue(), ComponentInfo_GetGUIDValue(), ComponentInfo_GetStringValue(), create_monodata(), DoGetProductType(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), CDrvDefExt::ExtraPageProc(), FILEDLG95_MRU_get_slot(), FILEDLG95_MRU_save_filename(), CDrvDefExt::GeneralPageProc(), get_stringvalue(), GetCLSIDForFileTypeFromExtension(), CNetConnectionPropertyUi::GetDeviceInstanceID(), GetInterfaceName(), CQueryAssociations::GetString(), HCR_GetClassNameW(), InitializeRecycleBinDlg(), InitIconOverlays(), CFileDefExt::InitOpensWithField(), COpenWithList::IsHidden(), IsNamespaceExtensionHidden(), COpenWithList::Load(), load_config_driver(), load_settings(), COpenWithList::LoadFromProgIdKey(), CNewMenu::LoadItem(), LoadPropSheetHandlers(), COpenWithList::LoadRecommendedFromHKCR(), COpenWithList::LoadRecommendedFromHKCU(), MMDevice_GetPropValue(), msi_check_product_patches(), msi_get_patch_state(), OpenKeyFromFileType(), PixelFormatInfo_GetChannelMask(), read_bitmap_patterns(), read_metadata_patterns(), COpenWithList::SetDefaultHandler(), SQLGetPrivateProfileStringW(), and WshShell3_RegRead().

◆ RegInitialize()

BOOL RegInitialize ( VOID )

Definition at line 70 of file reg.c.

{
    TRACE("RegInitialize()\n");
 
    /* Lazy init hack */
    if (!DllInitialized)
    {
        ProcessHeap = RtlGetProcessHeap();
        RtlZeroMemory(DefaultHandleTable,
                      MAX_DEFAULT_HANDLES * sizeof(HANDLE));
        RtlInitializeCriticalSection(&HandleTableCS);
 
        DllInitialized = TRUE;
    }
 
    return TRUE;
}

Referenced by CloseDefaultKeys(), DllMain(), MapDefaultKey(), RegDisablePredefinedCache(), RegDisablePredefinedCacheEx(), RegOpenUserClassesRoot(), and RegOverridePredefKey().

◆ RegLoadKeyA()

LONG WINAPI RegLoadKeyA	(	HKEY	hKey,
		LPCSTR	lpSubKey,
		LPCSTR	lpFile
	)

Definition at line 3052 of file reg.c.

{
    UNICODE_STRING FileName;
    UNICODE_STRING KeyName;
    LONG ErrorCode;
 
    RtlInitEmptyUnicodeString(&KeyName, NULL, 0);
    RtlInitEmptyUnicodeString(&FileName, NULL, 0);
 
    if (lpSubKey)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&KeyName, lpSubKey))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    if (lpFile)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFile))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    ErrorCode = RegLoadKeyW(hKey,
                            KeyName.Buffer,
                            FileName.Buffer);
 
Exit:
    RtlFreeUnicodeString(&FileName);
    RtlFreeUnicodeString(&KeyName);
 
    return ErrorCode;
}

Referenced by test_reg_load_key().

◆ RegLoadKeyW()

LONG WINAPI RegLoadKeyW	(	HKEY	hKey,
		LPCWSTR	lpSubKey,
		LPCWSTR	lpFile
	)

Definition at line 3099 of file reg.c.

{
    OBJECT_ATTRIBUTES FileObjectAttributes;
    OBJECT_ATTRIBUTES KeyObjectAttributes;
    UNICODE_STRING FileName;
    UNICODE_STRING KeyName;
    HANDLE KeyHandle;
    NTSTATUS Status;
    LONG ErrorCode = ERROR_SUCCESS;
 
    if (hKey == HKEY_PERFORMANCE_DATA)
    {
        return ERROR_INVALID_HANDLE;
    }
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (!RtlDosPathNameToNtPathName_U(lpFile,
                                      &FileName,
                                      NULL,
                                      NULL))
    {
      ErrorCode = ERROR_BAD_PATHNAME;
      goto Cleanup;
    }
 
    InitializeObjectAttributes(&FileObjectAttributes,
                               &FileName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    RtlInitUnicodeString(&KeyName, lpSubKey);
 
    InitializeObjectAttributes(&KeyObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               KeyHandle,
                               NULL);
 
    Status = NtLoadKey(&KeyObjectAttributes,
                       &FileObjectAttributes);
 
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                FileName.Buffer);
 
    if (!NT_SUCCESS(Status))
    {
        ErrorCode = RtlNtStatusToDosError(Status);
        goto Cleanup;
    }
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    return ErrorCode;
}

Referenced by CreateUserProfileExW(), LoadHive(), LoadUserProfileW(), and RegLoadKeyA().

◆ RegNotifyChangeKeyValue()

LONG WINAPI RegNotifyChangeKeyValue	(	HKEY	hKey,
		BOOL	bWatchSubtree,
		DWORD	dwNotifyFilter,
		HANDLE	hEvent,
		BOOL	fAsynchronous
	)

Definition at line 3172 of file reg.c.

{
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE KeyHandle;
    NTSTATUS Status;
    LONG ErrorCode = ERROR_SUCCESS;
 
    if (hKey == HKEY_PERFORMANCE_DATA)
    {
        return ERROR_INVALID_HANDLE;
    }
 
    if ((fAsynchronous != FALSE) && (hEvent == NULL))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    /* FIXME: Remote key handles must fail */
 
    Status = NtNotifyChangeKey(KeyHandle,
                               hEvent,
                               0,
                               0,
                               &IoStatusBlock,
                               dwNotifyFilter,
                               bWatchSubtree,
                               0,
                               0,
                               fAsynchronous);
    if (!NT_SUCCESS(Status) && Status != STATUS_TIMEOUT)
    {
        ErrorCode = RtlNtStatusToDosError(Status);
    }
 
    ClosePredefKey(KeyHandle);
 
    return ErrorCode;
}

Referenced by notif_thread_proc(), ATL::CRegKey::NotifyChangeKeyValue(), test_RegNotifyChangeKeyValue(), and WsSetupCatalogProtection().

◆ RegOpenCurrentUser()

LONG WINAPI RegOpenCurrentUser	(	IN REGSAM	samDesired,
		OUT PHKEY	phkResult
	)

Definition at line 3229 of file reg.c.

{
    NTSTATUS Status;
 
    Status = RtlOpenCurrentUser((ACCESS_MASK)samDesired,
                                (PHANDLE)phkResult);
    if (!NT_SUCCESS(Status))
    {
        /* NOTE - don't set the last error code! just return the error! */
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by CreateUserEnvironment(), DeleteUserCursorScheme(), get_mmioFromProfile(), LoadShutdownSelState(), MIDIMAP_LoadSettings(), SaveCursorScheme(), SaveShutdownSelState(), SetDefaultLanguage(), StartScreenSaver(), test_invalid_stdin(), test_RegOpenCurrentUser(), WlxScreenSaverNotify(), wnet_use_connection(), WNetCancelConnection2W(), wnetInit(), and WNetOpenEnumW().

◆ RegOpenKeyA()

LONG WINAPI RegOpenKeyA	(	HKEY	hKey,
		LPCSTR	lpSubKey,
		PHKEY	phkResult
	)

Definition at line 3254 of file reg.c.

{
    TRACE("RegOpenKeyA hKey 0x%x lpSubKey %s phkResult %p\n",
          hKey, lpSubKey, phkResult);
 
    if (!phkResult)
        return ERROR_INVALID_PARAMETER;
 
    if (!hKey && !lpSubKey)
    {
        *phkResult = hKey;
        return ERROR_SUCCESS;
    }
 
    return RegOpenKeyExA(hKey,
                         lpSubKey,
                         0,
                         MAXIMUM_ALLOWED,
                         phkResult);
}

Referenced by _test_key_exists(), _test_key_not_exists(), _test_reg_key(), check_dirid(), check_reg_entries(), cleanup_eventlog(), create_new_eventlog(), CryptGetOIDFunctionValue(), CryptSetOIDFunctionValue(), device_disabled_registry(), DirectDrawEnumerateExA(), DllMain(), env_absent(), env_present(), filedlg_collect_places_pidls(), find_fallback_font(), FindDfltProvRegVals(), FindProvRegVals(), FindProvTypesRegVals(), get_app_key(), get_owner_company(), get_progfiles_dir(), get_program_files_dir(), get_reg_dword(), get_shell_icon_size(), get_user_dirs(), GetAdaptersInfo(), is_places_bar_enabled(), lffromreg(), lineGetCountryA(), lineGetTranslateCapsA(), load_wine_gecko_v(), LoadRegistryMMEDrivers(), metricfromreg(), MIDIMAP_LoadSettingsScheme(), MMDRV_Init(), pa_absent(), pa_present(), pub_absent(), pub_present(), r_verifyProxyEnable(), rci_absent(), rci_present(), register_zone_domains(), RegisterDefaultAcceptHeaders(), RegQueryValueA(), rei_absent(), rei_present(), rmi_absent(), rmi_present(), rpi_absent(), rpi_present(), setup_dsound_options(), setup_main_key(), SHRegOpenKeyA(), SHRestricted(), SmoothScrollWindow(), spy_init(), sr_absent(), sr_present(), test_AddERExcludedApplicationA(), test_autocreation(), test_child_heap(), test_classesroot(), test_classesroot_enum(), test_classesroot_mask(), test_deleted_key(), test_device_interface_key(), test_GetAcceptLanguagesA(), test_install_from(), test_install_services(), test_Installer_InstallProduct(), test_installprops(), test_internet_features(), test_internet_features_registry(), test_MsiInstallProduct(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_MsiSourceListSetInfo(), test_perflib_key(), test_publish_assemblies(), test_publish_components(), test_publish_features(), test_publish_product(), test_reg_close_key(), test_reg_copy_tree(), test_reg_delete_key(), test_reg_delete_tree(), test_reg_load_key(), test_reg_open_key(), test_register_class_info(), test_register_extension_info(), test_register_mime_info(), test_register_product(), test_register_progid_info(), test_registerDefaultOIDFunction(), test_registerOIDInfo(), test_registrar(), test_registry(), test_registry_property_a(), test_RegQueryValueExPerformanceData(), test_self_registration(), test_SetZoneAttributes(), test_SHCopyKey(), test_SHDeleteKey(), test_SHGetFolderPathA(), test_SHGetObjectCompatFlags(), test_symlinks(), test_url_action(), test_write_registry_values(), test_zone_domain_cache(), test_zone_domain_mappings(), uniquecontainer(), unregister_zone_domains(), wined3d_dll_init(), wrv_absent(), and wrv_present().

◆ RegOpenKeyExA()

LONG WINAPI RegOpenKeyExA	(	_In_ HKEY	hKey,
		_In_ LPCSTR	lpSubKey,
		_In_ DWORD	ulOptions,
		_In_ REGSAM	samDesired,
		_Out_ PHKEY	phkResult
	)

Definition at line 3318 of file reg.c.

{
    UNICODE_STRING SubKeyString;
    LONG ErrorCode;
 
    TRACE("RegOpenKeyExA hKey 0x%x lpSubKey %s ulOptions 0x%x samDesired 0x%x phkResult %p\n",
          hKey, lpSubKey, ulOptions, samDesired, phkResult);
 
    if (lpSubKey)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&SubKeyString, lpSubKey))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&SubKeyString, NULL, 0);
 
    ErrorCode = RegOpenKeyExW(hKey, SubKeyString.Buffer, ulOptions, samDesired, phkResult);
 
    RtlFreeUnicodeString(&SubKeyString);
 
    return ErrorCode;
}

Referenced by check_user_privs(), create_test_verb_dde(), CRYPT_GetFuncFromReg(), CryptUnregisterOIDInfo(), debugstr_iid(), delete_key(), delete_reg_entries(), delete_registry_key(), delete_tree(), delete_tree_(), DeleteRegistryValue(), DP_LoadSP(), find_default_printer(), find_registry_key(), font_absent(), font_present(), get_owner_company(), get_system_dirs(), GetAdapterFriendlyName(), GetDriverName(), GetNetworkParams(), HaveDefaultMailClient(), HCR_GetIconA(), HCR_MapTypeToValueA(), HCR_RegOpenClassIDKey(), ICInfo(), ICInstall(), ICRemove(), IDirectMusic8Impl_GetDefaultPort(), IDirectPlay4AImpl_EnumConnections(), IDirectPlayLobby3AImpl_EnumAddressTypes(), IDirectPlayLobby3AImpl_EnumLocalApplications(), init_registered_oid_info(), initialize(), is_ie_hardened(), main(), Main_DirectDraw_GetDeviceIdentifier7(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), on_vmware(), open_container_key(), open_key_(), pf_absent(), pf_present(), pp_absent(), pp_present(), ppc_absent(), ppc_present(), PrintSystemInfo(), proxy_active(), QueryConfig2A(), rci_absent(), rci_present(), read_oid_info(), ReadRegistryComputerNameValue(), ReadRegistryValue(), reg_get_typelib_module(), RegGetValueA(), RegOpenKeyA(), rp_absent(), rp_present(), rpi_absent(), rpi_present(), ru_absent(), ru_present(), scan_subkeys(), set_domain(), set_name_servers(), setup_adapter(), SHADD_get_policy(), SHDeleteEmptyKeyA(), SHDeleteOrphanKeyA(), SHDeleteValueA(), SHELL_IsShortcut(), SHGetValueA(), SHOpenRegStream2A(), SHPinDllOfCLSID(), SHRegDuplicateHKey(), START_TEST(), test_classesroot(), test_enumdisplaydevices_adapter(), test_file_in_use(), test_file_in_use_cab(), test_get_profiles_dir(), test_ICInfo(), test_impersonation_level(), test_installprops(), test_machine_guid(), test_mixed_package(), test_MsiConfigureProductEx(), test_MsiInstallProduct(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_MsiSourceListSetInfo(), test_NonExistentPath(), test_null(), test_process_components(), test_publish(), test_publish_assemblies(), test_publish_features(), test_publish_product(), test_redirection(), test_reg_open_key(), test_register_font(), test_register_product(), test_register_typelib(), test_register_user(), test_RegPolicyFlags(), test_RegQueryValueExPerformanceData(), test_remove_upgrade_code(), test_SetupDiOpenClassRegKeyExA(), test_SHCreateDefaultContextMenu(), test_SHQueryValueEx(), test_SQLInstallDriverEx(), test_SQLInstallTranslatorEx(), test_stub(), test_symlinks(), test_TreatAsClass(), test_XcvDataPort_ConfigureLPTPortCommandOK(), test_XcvDataPort_GetTransmissionRetryTimeout(), uniquecontainer(), unregister_keys(), verify_key_(), verify_key_nonexist_(), WhichPlatform(), and WriteRegistryValue().

◆ RegOpenKeyExW()

LONG WINAPI RegOpenKeyExW	(	HKEY	hKey,
		LPCWSTR	lpSubKey,
		DWORD	ulOptions,
		REGSAM	samDesired,
		PHKEY	phkResult
	)

Definition at line 3353 of file reg.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING SubKeyString;
    HANDLE KeyHandle;
    NTSTATUS Status;
    ULONG Attributes = OBJ_CASE_INSENSITIVE;
    LONG ErrorCode = ERROR_SUCCESS;
 
    TRACE("RegOpenKeyExW hKey 0x%x lpSubKey %S ulOptions 0x%x samDesired 0x%x phkResult %p\n",
          hKey, lpSubKey, ulOptions, samDesired, phkResult);
    if (!phkResult)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    if (!hKey && lpSubKey && phkResult)
    {
        return ERROR_INVALID_HANDLE;
    }
 
    if (IsPredefKey(hKey) && (!lpSubKey || !*lpSubKey))
    {
        *phkResult = hKey;
        return ERROR_SUCCESS;
    }
 
    Status = MapDefaultKey(&KeyHandle, hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (IsHKCRKey(KeyHandle))
    {
        ErrorCode = OpenHKCRKey(KeyHandle, lpSubKey, ulOptions, samDesired, phkResult);
        ClosePredefKey(KeyHandle);
        return ErrorCode;
    }
 
    if (ulOptions & REG_OPTION_OPEN_LINK)
        Attributes |= OBJ_OPENLINK;
 
    if (lpSubKey == NULL || wcscmp(lpSubKey, L"\\") == 0)
        RtlInitUnicodeString(&SubKeyString, L"");
    else
        RtlInitUnicodeString(&SubKeyString, lpSubKey);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &SubKeyString,
                               Attributes,
                               KeyHandle,
                               NULL);
 
    Status = NtOpenKey((PHANDLE)phkResult,
                       samDesired,
                       &ObjectAttributes);
 
    if (Status == STATUS_DATATYPE_MISALIGNMENT)
    {
        HANDLE hAligned;
        UNICODE_STRING AlignedString;
 
        Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
                                           &SubKeyString,
                                           &AlignedString);
        if (NT_SUCCESS(Status))
        {
            /* Try again with aligned parameters */
            InitializeObjectAttributes(&ObjectAttributes,
                                       &AlignedString,
                                       Attributes,
                                       KeyHandle,
                                       NULL);
 
            Status = NtOpenKey(&hAligned,
                               samDesired,
                               &ObjectAttributes);
 
            RtlFreeUnicodeString(&AlignedString);
 
            if (NT_SUCCESS(Status))
                *phkResult = hAligned;
        }
        else
        {
            /* Restore the original error */
            Status = STATUS_DATATYPE_MISALIGNMENT;
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        ErrorCode = RtlNtStatusToDosError(Status);
    }
 
 
    ClosePredefKey(KeyHandle);
 
    return ErrorCode;
}

Referenced by _CmdWndProc(), CBandSiteMenu::_CreateMenuPart(), _enumeratorRememberedW(), _HandleConfigureLPTPortCommandOK(), _InitializeLocalSpooler(), _InitializePrintProviderList(), _LocalGetPrinterHandleData(), _LocalGetPrintServerHandleData(), _LocalSetPrinterHandleData(), _LocalSetPrintServerHandleData(), _OpenEnvironment(), _tryLoadProvider(), AboutDlgProc(), AddClassKeyToArray(), CDesktopFolderEnum::AddItemsFromClassicStartMenuKey(), AddNewLayout(), AddNotificationDll(), AddSoundProfile(), CDefaultContextMenu::AddStaticEntriesForKey(), AddUserProfiles(), AllSysInfo(), ApplyChanges(), ApplyOrCancelChanges(), BuildCodePageList(), BuildLogListAndFilterList(), BuildParameterArray(), BuildServiceArray(), BuildVolatileEnvironment(), CallNotificationDll(), CallNotificationDlls(), CanUserWritePwrScheme(), capGetDriverDescriptionW(), CategoryMgr_FindClosestCategory(), CategoryMgr_RegisterCategory(), CategoryMgr_UnregisterCategory(), ChangeNtProductType(), CheckForLiveCD(), CheckForLoadedProfile(), CheckLogOrSourceExistence(), ChooseFavorite(), ChooseGinaUI(), CliGetImeHotKeysFromRegistry(), CliGetPreloadKeyboardLayouts(), CliSetSingleHotKey(), CM_Open_Class_Key_ExW(), CM_Open_DevNode_Key_Ex(), ComponentInfo_GetGuidList(), ConCfgOpenUserSettings(), ConverterSupportsFormat(), CopyKey(), create_EnumMoniker(), create_monodata(), CreateAppPathRegKey(), CreateComponentEnumerator(), CreateComponentInfo(), CreateDeviceInstance(), CreateEnvironmentBlock(), CreateEventLog(), CreateHKCRKey(), CreateKeyboardLayoutList(), CreateNewValue(), CreateNotificationObject(), CreateNTPServerList(), CreateStandardProfile(), CreateTempDir(), CreateUserHive(), CreateUserProfileExW(), CredReadW(), CriticalDeviceCoInstaller(), CRYPT_CreateMachineGuid(), CRYPT_OpenParentStore(), CRYPT_OpenSIPFunctionKey(), CRYPT_RegReadSerializedFromReg(), CRYPT_SysRegOpenStoreW(), CRYPTDLG_CheckOnlineCRL(), CryptSIPRetrieveSubjectGuid(), DecrementRefCount(), delete_key(), delete_test_key(), DeleteExt(), DeleteHelperCommand(), DeleteKey(), DeleteProfileW(), DeleteSubKey(), DEVENUM_IEnumMoniker_Next(), DEVENUM_ReadPins(), DEVENUM_ReadPinTypes(), devinst_RegDeleteTreeW(), DirectPlayEnumerateAW(), DisableShellext(), CNetConnection::Disconnect(), DisplayClassCoinstallers(), DisplayImageInfo(), DllMain(), DllRegisterServer(), DllUnregisterServer(), DMOGetName(), DMOGetTypes(), DMOUnregister(), DoGetProductType(), DoLoadItems(), DoWriteProductOption(), DoWriteSoundEvents(), DRIVER_GetLibName(), EditTypeDlg_ReadClass(), enum_key(), enum_values(), EnumClientServiceProtocol(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), EnumerateNetworkComponent(), EnumerateSoundProfiles(), EnumerateTimeZoneList(), EnumHKCRKey(), EnumInterfaces(), EnumPwrSchemes(), EnumTfLanguageProfiles_Clone(), export_registry_data(), ExportRegistryFile(), FDebugBreakForService(), fetch_machine_component(), fetch_machine_product(), fetch_user_component(), fetch_user_product(), FILEDLG95_unixfs_is_rooted_at_desktop(), FileTypesDlg_InsertToLV(), FillServerAddressCombo(), FilterMapper_RegisterPin(), FilterMapper_RegisterPinType(), FilterMapper_UnregisterFilter(), FilterMapper_UnregisterPin(), find_typelib_key(), FindNetworkAdapter(), ForceFriendlyUI(), get_default_proxy_reg_value(), get_fusion_filename(), get_install_root(), get_mono_path_from_registry(), GetActivePwrScheme(), GetAllUsersProfileDirectoryW(), GetAutoDaylight(), GetBooleanRegValue(), GetBootResourceList(), GetClassMediaFile(), CQueryAssociations::GetCommand(), GetComputerNames(), GetCurrentHwProfileW(), GetCurrentUserKey(), GetDefaultPrinterFromRegistry(), GetDefaultPrinterW(), GetDefaultUserProfileDirectoryW(), GetDesktopPath(), CNetConnectionPropertyUi::GetDeviceInstanceID(), GetDeviceInstanceList(), GetDeviceInstanceListSize(), GetDisplayNameFileAndID(), GetEnumeratorInstanceList(), GetEnumeratorInstanceListSize(), GetEnumOptions(), GetEventMessageFileDLL(), GetExplorerRegValueSet(), GetFallbackHKCRKey(), GetFileTypeIconsByKey(), GetGinaPath(), GetHotPlugFlags(), GetInterfaceFriendlyName(), GetInterfaceNameInternal(), GetIntervalSetting(), GetJapaneseUninstallCmdLine(), GetLayoutCount(), GetLayoutName(), GetLPTTransmissionRetryTimeout(), GetPerAdapterInfo(), GetPreferredHKCRKey(), GetProfile(), GetProfileCount(), GetProfiles(), GetProfilesDirectoryW(), GetProfileType(), GetProgramsPath(), CNetConnection::GetProperties(), GetPwrDiskSpindownRange(), GetRegistrySettings(), GetRegValue(), GetResourceList(), GetServiceInstanceList(), GetServiceInstanceListSize(), GetSetupType(), GetShell(), GetShutdownReasonUI(), CQueryAssociations::GetString(), GetSyncSetting(), GetTimeZoneListIndex(), CZipFolder::GetUIObjectOf(), GetUsedPorts(), GetUserProfileDirectoryW(), GetUserWaitInterval(), GUILoggedOutSAS(), HCR_GetDefaultVerbW(), HCR_GetExecuteCommandW(), HCR_GetFolderAttributes(), HCR_GetIconW(), HCR_MapTypeToValueW(), IEnumDMO_Constructor(), IEnumDMO_fnNext(), ImageView_LoadSettings(), ImmLoadLayout(), ImpersonateTokenWithEveryoneOrWithout(), ImportAppProfile(), ImportRegistryFile(), ImportSoundEntry(), ImportSoundLabel(), ImportSoundProfiles(), IncrementRefCount(), INetCfgComponent_fnOpenParamKey(), INetCfgLock_fnAcquireWriteLock(), INetCfgLock_fnIsWriteLocked(), CQueryAssociations::Init(), CRegPropertyBag::Init(), InitAudioDlg(), CEnumRegKey::Initialize(), InitializeDefaultUserLocale(), InitializeDialog(), InitializeDirectPlayDialog(), InitializeFormList(), InitializePnPManager(), InitializePrinterList(), InitializePrintMonitor2(), InitializePrintMonitorList(), InitializePrintProcessorList(), InitializeProfiles(), InitializeProgramFilesDir(), InitIconOverlays(), InitKeyboardLayouts(), InitNotifications(), InitPropertiesDlg(), InitSettings(), InitTTFontCache(), InputList_PrepareUserRegistry(), InputProcessorProfiles_AddLanguageProfile(), InputProcessorProfiles_EnableLanguageProfile(), InputProcessorProfiles_EnableLanguageProfileByDefault(), InputProcessorProfiles_GetDefaultLanguageProfile(), InputProcessorProfiles_IsEnabledLanguageProfile(), InstallDevice(), InstallOneService(), InstallReactOS(), Int_EnumDependentServicesW(), IntGetIcdData(), IntLoadKeyboardLayout(), IsConsoleBoot(), IsExtensionAShortcut(), IsFriendlyUIActive(), IsInternetESCEnabledLocal(), IsLayoutExists(), IsLiveCD(), IsShowHibernateButtonActive(), IsWindowsOS(), CNetConnectionPropertyUi::LANPropertiesUIDlg(), LayoutList_Create(), load_mapi_providers(), COpenWithList::LoadAppList(), LoadBoard(), CNewMenu::LoadCachedItems(), LoadCurrentLocale(), LoadDNSSettings(), LoadDWORDFromRegistry(), LoadEventLabel(), LoadEventLabels(), LoadFilterSettings(), LoadHelpers(), LoadInstallableVDD(), CNewMenu::LoadItem(), LoadLogFiles(), COpenWithList::LoadProgIdList(), CInputPin::LoadProxyPlugins(), COutputPin::LoadProxyPlugins(), CKsProxy::LoadProxyPlugins(), COpenWithList::LoadRecommendedFromHKCR(), COpenWithList::LoadRecommendedFromHKCU(), LoadRegistrySettings(), LoadSettings(), LoadShutdownSelState(), LoadSoundProfiles(), LoadStringFromRegistry(), LoadUsernameHint(), LoadUserProfileW(), LocaleList_Create(), LocalEnumPrintProcessors(), MainWnd_OnInstall(), MainWnd_OnUpdateRegistry(), MCI_GetDevTypeFromFileName(), MCI_SysInfo(), MMDevPropStore_OpenPropKey(), MMSYS_InstallDevice(), MRU_SaveChanged(), MSACM_RegisterAllDrivers(), MSACM_RegisterDriverFromRegistry(), msi_check_product_patches(), msi_get_patch_state(), MsiGetPatchInfoExW(), MSIREG_DeleteClassesUpgradeCodesKey(), MSIREG_DeleteLocalClassesFeaturesKey(), MSIREG_DeleteLocalClassesProductKey(), MSIREG_DeleteProductKey(), MSIREG_DeleteUninstallKey(), MSIREG_DeleteUpgradeCodesKey(), MSIREG_DeleteUserDataComponentKey(), MSIREG_DeleteUserDataPatchKey(), MSIREG_DeleteUserDataProductKey(), MSIREG_OpenClassesUpgradeCodesKey(), MSIREG_OpenFeaturesKey(), MSIREG_OpenInstallerFeaturesKey(), MSIREG_OpenInstallProps(), MSIREG_OpenPatchesKey(), MSIREG_OpenProductKey(), MSIREG_OpenUninstallKey(), MSIREG_OpenUpgradeCodesKey(), MSIREG_OpenUserComponentsKey(), MSIREG_OpenUserDataComponentKey(), MSIREG_OpenUserDataFeaturesKey(), MSIREG_OpenUserDataPatchKey(), MSIREG_OpenUserDataProductKey(), MSIREG_OpenUserDataProductPatchesKey(), myRegDeleteTreeW(), NetBTInit(), NetIDPage_OnApply(), NetIDPage_OnInitDialog(), NetworkDlg_OnOK(), next_LanguageProfile(), OnAutoSync(), OnTreeExpanding(), open_env_key(), open_export_key(), open_key(), OpenChildKeyRead(), OpenComputerNameKey(), OpenConfigurationKey(), OpenHardwareProfileKey(), OpenHKCRKey(), OpenHostNameKey(), OpenHostsFile(), OpenImageFileExecOptions(), OpenKey(), OpenKeyFromFileType(), OpenRegKey(), OpenServiceParametersKey(), package_RegDeleteTreeW(), pendingRename(), PNP_AddID(), PNP_CreateKey(), PNP_GetClassCount(), PNP_GetClassInstance(), PNP_GetClassName(), PNP_GetClassRegProp(), PNP_GetCustomDevProp(), PNP_GetDeviceRegProp(), PNP_GetHwProfInfo(), PNP_HwProfFlags(), PNP_IsDockStationPresent(), PNP_SetClassRegProp(), PNP_SetDeviceRegProp(), PNP_ValidateDeviceInstance(), POWRPROF_GetMachinePowerPolicy(), POWRPROF_GetUserPowerPolicy(), PrintOSVersion(), process_extensions(), ProcessPage_OnDebug(), ProcessPageShowContextMenu(), ProcessRunKeys(), ProcessRunOnceEx(), ProcessSetupInf(), ProcessUnattendSection(), query_all(), query_typelib_path(), query_value(), QueryAppSettings(), QueryConfig2W(), QueryUserRegValueW(), RCloseServiceHandle(), RControlService(), read_bitmap_patterns(), read_key(), read_metadata_patterns(), read_types(), ReadAttributes(), ReadBindingString(), ReadGlobalPwrPolicy(), ReadKeysSettings(), ReadPerInstanceRegistryParameters(), ReadPortSettings(), ReadRegistryValue(), RefreshListView(), RefreshTreeItem(), reg_delete_tree(), reg_export(), RegDeleteTreeW(), ATL::CRegObject::RegDeleteTreeX(), RegFindRecurse(), RegFindWalk(), RegGetDWORD(), RegGetDWORDValue(), RegGetSZ(), RegGetValueW(), register_legacy_filters(), registry_enumerate_credentials(), registry_get_handle(), RegOpenKeyExA(), RegOpenKeyW(), RegQueryRegistryKeys(), RegQueryRegistryValues(), RegSetDWORDValue(), RegTGetKeyHandle(), RemoveEventLog(), CNetConnection::Rename(), REnumDependentServicesA(), REnumDependentServicesW(), ReportProductInfoEvent(), ReturnNtProduct(), run_copy(), run_delete(), run_query(), RunSetupThreadProc(), SampIsSetupRunning(), SaveAppSettings(), SaveCurrentLocale(), SaveDefaultUserHive(), SaveGeoID(), SavePropertiesDlg(), SaveSettings(), ScmAssignNewTag(), ScmAutoStartServices(), ScmCopyControlSet(), ScmCopyTree(), ScmCreateServiceDatabase(), ScmCreateServiceKey(), ScmDeleteControlSet(), ScmDeleteMarkedServices(), ScmDeleteRegKey(), ScmDeleteTree(), ScmGetControlSetValues(), ScmGetNoInteractiveServicesValue(), ScmGetSetupInProgress(), ScmInitNamedPipeCriticalSection(), ScmOpenServiceKey(), ScmReadSecurityDescriptor(), ScmSetLastKnownGoodControlSet(), SdbUninstallByGuid(), SdbUninstallByName(), search_reg(), SECUR32_initializeProviders(), SelectExtOnRename(), set_installer_properties(), SetAutoAdminLogon(), SetAutoDaylight(), COpenWithList::SetDefaultHandler(), SetDefaultLanguage(), SetDefaultPrinterW(), SetInstallationCompleted(), SetKeyboardLayoutName(), SetNTPServer(), SetProfileData(), SetSetupType(), SetSystemEnvironment(), SetTime(), SETUP_CreateClassKey(), SETUP_CreateInterfaceList(), SETUPAPI_GetCurrentHwProfile(), SetupDeviceInstance(), SETUPDI_CreateDrvKey(), SETUPDI_OpenDevKey(), SETUPDI_OpenDrvKey(), SetupDiCallClassInstaller(), SetupDiClassGuidsFromNameExW(), SetupDiOpenClassRegKeyExW(), SetupDiOpenDeviceInfoW(), SetupDiOpenDeviceInterfaceRegKey(), SetupDiOpenDeviceInterfaceW(), SetupDiOpenDevRegKey(), SetupIsActive(), SetUserEnvironment(), SetUserSysColors(), SetUserWaitInterval(), SetUserWallpaper(), SetWelcomeText(), SHAboutInfoW(), SHCoCreateInstance(), SHCopyKeyW(), SHCreatePropSheetExtArrayEx(), SHDeleteEmptyKeyW(), SHDeleteKeyW(), SHDeleteOrphanKeyW(), SHDeleteValueW(), SHDOCVW_GetShellInstanceObjectClassObject(), SHELL_FindExecutableByVerb(), SHELL_TryAppPathW(), SHGetShellKey(), SHGetValueW(), SHOpenRegStream2W(), SHPropertyBag_OnRegKey(), SHRegGetCLSIDKeyW(), SHRegOpenUSKeyW(), SIC_LoadOverlayIcon(), SockLoadHelperDll(), SockLoadTransportList(), SockLoadTransportMapping(), SQLGetInstalledDriversW(), START_TEST(), StartScreenSaver(), StartShell(), test4(), test_CallForAttributes(), Test_CreateOpenKey(), Test_DuplicateHandle(), test_set_value(), test_SetupDiInstallClassExA(), test_setvalue_on_wow64(), test_SQLGetPrivateProfileString(), test_SQLGetPrivateProfileStringW(), test_SQLWritePrivateProfileString(), TestInterfaceRegistry(), TestKeyAccess_(), TestModuleRegistry(), TestMyEventProvider(), testRegStoreSavedCerts(), TLB_unregister_interface(), TOOLBAR_Restore(), TreeWndNotifyProc(), TTIsEmbeddingEnabledForFacename(), txt_export_registry_data(), txt_open_export_key(), UIINSERTOBJECTDLG_PopulateObjectTypes(), UnloadUserProfile(), unregister_categories(), unregister_coclasses(), unregister_converters(), unregister_decoders(), unregister_dmo_from_category(), unregister_encoders(), unregister_interfaces(), unregister_mediatypes_extension(), unregister_mediatypes_parsing(), unregister_metadatareaders(), unregister_pixelformats(), UnregisterComponent(), UnRegisterTypeLib(), UpdateCaretBlinkTimeReg(), UpdateRegistryForFontSubstitutes(), UpdateTcpIpInformation(), UpdateUsersShellFolderSettings(), URL_ApplyDefault(), URL_GuessScheme(), UserInstStubWrapperW(), UXTHEME_RestoreSystemMetrics(), ViewDlg_Apply(), ViewDlg_RestoreDefaults(), ViewTree_LoadAll(), ViewTree_LoadTree(), WinHttpGetDefaultProxyConfiguration(), WinHttpGetIEProxyConfigForCurrentUser(), WINTRUST_ReadProviderFromReg(), WlxActivateUserShell(), WlxScreenSaverNotify(), wmain(), wnetInit(), WNetOpenEnumW(), WriteComputerSettings(), WriteDefaultLogonData(), WriteKeysSettings(), WriteOwnerSettings(), WritePortSettings(), WriteSettings(), and wWinMain().

◆ RegOpenKeyW()

LONG WINAPI RegOpenKeyW	(	HKEY	hKey,
		LPCWSTR	lpSubKey,
		PHKEY	phkResult
	)

Definition at line 3288 of file reg.c.

{
    TRACE("RegOpenKeyW hKey 0x%x lpSubKey %S phkResult %p\n",
          hKey, lpSubKey, phkResult);
 
    if (!phkResult)
        return ERROR_INVALID_PARAMETER;
 
    if (!hKey && !lpSubKey)
    {
        *phkResult = hKey;
        return ERROR_SUCCESS;
    }
 
    return RegOpenKeyExW(hKey,
                         lpSubKey,
                         0,
                         MAXIMUM_ALLOWED,
                         phkResult);
}

Referenced by _HandleAddPort(), _HandleDeletePort(), ACTION_UnregisterClassInfo(), CRegFolderEnum::AddItemsFromKey(), AddPrintMonitorList(), CDefaultContextMenu::AddStaticContextMenusToMenu(), AVIBuildFilterW(), build_zonemap_from_reg(), cache_container_set_size(), capGetDriverDescriptionW(), connections_on_initdialog(), connections_on_notify(), Control_RegisterRegistryApplets(), CreateNewKey(), CryptAcquireContextW(), CryptEnumProvidersW(), CryptEnumProviderTypesW(), CryptGetDefaultProviderW(), CryptSetProviderExW(), DEVENUM_ICreateDevEnum_CreateClassEnumerator(), DEVENUM_IPropertyBag_Read(), do_process_key(), ATL::CRegObject::do_process_key(), EnableTheming(), ensure_useragent(), find_mime_from_ext(), FTP_Connect(), general_on_notify(), get_dest_dir(), get_engine_clsid(), get_feature_from_reg(), get_mapping_key(), get_mime_clsid(), get_mime_filter(), get_mmioFromProfile(), get_privateprofile_sectionkey(), get_protocol_cf(), get_url_encoding(), get_zone_from_domains(), get_zone_from_reg(), GetAcceptLanguagesW(), GetActiveClassicTheme(), GetFindFlags(), go_home(), HlinkGetSpecialReference(), Imm32GetImeLayout(), Imm32WriteImeLayout(), init_driver(), InitShellServices(), InstallerImpl_RegistryValue(), InstallOneService(), INTERNET_LoadProxySettings(), INTERNET_SaveProxySettings(), IntLoadPreloadKeyboardLayouts(), IsThemeActive(), lineGetCountryW(), COpenWithList::Load(), load_config_driver(), load_process_feature(), load_settings(), load_wine_gecko(), LoadClassicColorSchemes(), LoadCurrentScheme(), LoadSchemeFromReg(), LoadSchemeSizes(), LoadSettings(), LoadSMBiosData(), LocalmonAddPort(), LocalmonAddPortEx(), LocalmonDeletePort(), MakeService(), MIDIMAP_LoadSettings(), MIDIMAP_LoadSettingsScheme(), MMDevEnum_GetDefaultAudioEndpoint(), MSACM_ReorderDriversByPriority(), MSI_GetProductInfo(), MSIREG_OpenUserComponentsKey(), MSIREG_OpenUserPatchesKey(), MSIREG_OpenUserUpgradeCodesKey(), NetBTInit(), OnInitMenu(), open_zone_key(), OpenMediaSubkey(), OpenNetworkSubkey(), OpenSourceKey(), OpenURLSubkey(), process_args_from_reg(), QueryStringValue(), ReadCabinetState(), RegConnectRegistryW(), RegDeleteKeyW(), CControlPanelEnum::RegisterRegistryCPanelApps(), registry_callback(), RegQueryValueW(), RenameValue(), SaveSystemSettings(), search_domain_for_zone(), set_installer_properties(), set_lang(), SHCreatePropSheetExtArrayEx(), SHELL_FS_HideExtension(), ShellExecute_FromContextMenuHandlers(), ShellExecute_GetClassKey(), SHGetObjectCompatFlags(), SHGetRestriction(), SHRegOpenKeyW(), SQLRemoveDriverW(), SQLRemoveTranslatorW(), START_TEST(), StartWithDesktop(), SuggestKeys(), tapiGetLocationInfoW(), test_BCryptGetFipsAlgorithmMode(), test_DeletePwrScheme(), test_device_key(), test_Installer_RegistryValue(), test_readTrustedPublisherDWORD(), test_register_device_iface(), test_registry_property_w(), test_save(), test_SHCreateSessionKey(), test_WritePwrScheme(), try_application_url(), UniformResourceLocatorW_InvokeCommand(), UXTHEME_LoadTheme(), and write_config_value().

◆ RegOpenUserClassesRoot()

LONG WINAPI RegOpenUserClassesRoot	(	IN HANDLE	hToken,
		IN DWORD	dwOptions,
		IN REGSAM	samDesired,
		OUT PHKEY	phkResult
	)

Definition at line 3466 of file reg.c.

{
    const WCHAR UserClassesKeyPrefix[] = L"\\Registry\\User\\";
    const WCHAR UserClassesKeySuffix[] = L"_Classes";
    PTOKEN_USER TokenUserData;
    ULONG RequiredLength;
    UNICODE_STRING UserSidString, UserClassesKeyRoot;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
 
    /* check parameters */
    if (hToken == NULL || dwOptions != 0 || phkResult == NULL)
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /*
     * Get the user sid from the token
     */
 
ReadTokenSid:
    /* determine how much memory we need */
    Status = NtQueryInformationToken(hToken,
                                     TokenUser,
                                     NULL,
                                     0,
                                     &RequiredLength);
    if (!NT_SUCCESS(Status) && (Status != STATUS_BUFFER_TOO_SMALL))
    {
        /* NOTE - as opposed to all other registry functions windows does indeed
                  change the last error code in case the caller supplied a invalid
                  handle for example! */
        return RtlNtStatusToDosError(Status);
    }
    RegInitialize(); /* HACK until delay-loading is implemented */
    TokenUserData = RtlAllocateHeap(ProcessHeap,
                                    0,
                                    RequiredLength);
    if (TokenUserData == NULL)
    {
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    /* attempt to read the information */
    Status = NtQueryInformationToken(hToken,
                                     TokenUser,
                                     TokenUserData,
                                     RequiredLength,
                                     &RequiredLength);
    if (!NT_SUCCESS(Status))
    {
        RtlFreeHeap(ProcessHeap,
                    0,
                    TokenUserData);
        if (Status == STATUS_BUFFER_TOO_SMALL)
        {
            /* the information appears to have changed?! try again */
            goto ReadTokenSid;
        }
 
        /* NOTE - as opposed to all other registry functions windows does indeed
                  change the last error code in case the caller supplied a invalid
                  handle for example! */
        return RtlNtStatusToDosError(Status);
    }
 
    /*
     * Build the absolute path for the user's registry in the form
     * "\Registry\User<SID>_Classes"
     */
    Status = RtlConvertSidToUnicodeString(&UserSidString,
                                          TokenUserData->User.Sid,
                                          TRUE);
 
    /* we don't need the user data anymore, free it */
    RtlFreeHeap(ProcessHeap,
                0,
                TokenUserData);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    /* allocate enough memory for the entire key string */
    UserClassesKeyRoot.Length = 0;
    UserClassesKeyRoot.MaximumLength = UserSidString.Length +
                                       sizeof(UserClassesKeyPrefix) +
                                       sizeof(UserClassesKeySuffix);
    UserClassesKeyRoot.Buffer = RtlAllocateHeap(ProcessHeap,
                                                0,
                                                UserClassesKeyRoot.MaximumLength);
    if (UserClassesKeyRoot.Buffer == NULL)
    {
        RtlFreeUnicodeString(&UserSidString);
        return RtlNtStatusToDosError(Status);
    }
 
    /* build the string */
    RtlAppendUnicodeToString(&UserClassesKeyRoot,
                             UserClassesKeyPrefix);
    RtlAppendUnicodeStringToString(&UserClassesKeyRoot,
                                   &UserSidString);
    RtlAppendUnicodeToString(&UserClassesKeyRoot,
                             UserClassesKeySuffix);
 
    TRACE("RegOpenUserClassesRoot: Absolute path: %wZ\n", &UserClassesKeyRoot);
 
    /*
     * Open the key
     */
    InitializeObjectAttributes(&ObjectAttributes,
                               &UserClassesKeyRoot,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenKey((PHANDLE)phkResult,
                       samDesired,
                       &ObjectAttributes);
 
    RtlFreeUnicodeString(&UserSidString);
    RtlFreeUnicodeString(&UserClassesKeyRoot);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

◆ RegOverridePredefKey()

LONG WINAPI RegOverridePredefKey	(	IN HKEY	hKey,
		IN HKEY hNewHKey	OPTIONAL
	)

Definition at line 365 of file reg.c.

{
    LONG ErrorCode = ERROR_SUCCESS;
 
    if ((hKey == HKEY_CLASSES_ROOT ||
         hKey == HKEY_CURRENT_CONFIG ||
         hKey == HKEY_CURRENT_USER ||
         hKey == HKEY_LOCAL_MACHINE ||
         hKey == HKEY_PERFORMANCE_DATA ||
         hKey == HKEY_USERS) &&
        !IsPredefKey(hNewHKey))
    {
        PHANDLE Handle;
        ULONG Index;
 
        Index = GetPredefKeyIndex(hKey);
        Handle = &DefaultHandleTable[Index];
 
        if (hNewHKey == NULL)
        {
            /* restore the default mapping */
            NTSTATUS Status = OpenPredefinedKey(Index,
                                                &hNewHKey);
            if (!NT_SUCCESS(Status))
            {
                return RtlNtStatusToDosError(Status);
            }
 
            ASSERT(hNewHKey != NULL);
        }
        RegInitialize(); /* HACK until delay-loading is implemented */
        RtlEnterCriticalSection(&HandleTableCS);
 
        /* close the currently mapped handle if existing */
        if (*Handle != NULL)
        {
            NtClose(*Handle);
        }
 
        /* update the mapping */
        *Handle = hNewHKey;
 
        RtlLeaveCriticalSection(&HandleTableCS);
    }
    else
        ErrorCode = ERROR_INVALID_HANDLE;
 
    return ErrorCode;
}

◆ RegpApplyRestrictions()

static VOID RegpApplyRestrictions	(	DWORD	dwFlags,
		DWORD	dwType,
		DWORD	cbData,
		PLONG	ret
	)

static

Definition at line 1890 of file reg.c.

{
    /* Check if the type is restricted by the passed flags */
    if (*ret == ERROR_SUCCESS || *ret == ERROR_MORE_DATA)
    {
        DWORD dwMask = 0;
 
        switch (dwType)
        {
        case REG_NONE: dwMask = RRF_RT_REG_NONE; break;
        case REG_SZ: dwMask = RRF_RT_REG_SZ; break;
        case REG_EXPAND_SZ: dwMask = RRF_RT_REG_EXPAND_SZ; break;
        case REG_MULTI_SZ: dwMask = RRF_RT_REG_MULTI_SZ; break;
        case REG_BINARY: dwMask = RRF_RT_REG_BINARY; break;
        case REG_DWORD: dwMask = RRF_RT_REG_DWORD; break;
        case REG_QWORD: dwMask = RRF_RT_REG_QWORD; break;
        }
 
        if (dwFlags & dwMask)
        {
            /* Type is not restricted, check for size mismatch */
            if (dwType == REG_BINARY)
            {
                DWORD cbExpect = 0;
 
                if ((dwFlags & RRF_RT_ANY) == RRF_RT_DWORD)
                    cbExpect = 4;
                else if ((dwFlags & RRF_RT_ANY) == RRF_RT_QWORD)
                    cbExpect = 8;
 
                if (cbExpect && cbData != cbExpect)
                    *ret = ERROR_DATATYPE_MISMATCH;
            }
        }
        else *ret = ERROR_UNSUPPORTED_TYPE;
    }
}

Referenced by RegGetValueA(), and RegGetValueW().

◆ RegpCopyTree()

static NTSTATUS RegpCopyTree	(	IN HKEY	hKeySrc,
		IN HKEY	hKeyDest
	)

static

Definition at line 449 of file reg.c.

{
    typedef struct
    {
        LIST_ENTRY ListEntry;
        HANDLE hKeySrc;
        HANDLE hKeyDest;
    } REGP_COPY_KEYS, *PREGP_COPY_KEYS;
 
    LIST_ENTRY copyQueueHead;
    PREGP_COPY_KEYS copyKeys, newCopyKeys;
    union
    {
        KEY_VALUE_FULL_INFORMATION *KeyValue;
        KEY_NODE_INFORMATION *KeyNode;
        PVOID Buffer;
    } Info;
    ULONG Index, BufferSizeRequired, BufferSize = 0x200;
    NTSTATUS Status = STATUS_SUCCESS;
    NTSTATUS Status2 = STATUS_SUCCESS;
 
    InitializeListHead(&copyQueueHead);
 
    Info.Buffer = RtlAllocateHeap(ProcessHeap,
                                  0,
                                  BufferSize);
    if (Info.Buffer == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    copyKeys = RtlAllocateHeap(ProcessHeap,
                               0,
                               sizeof(REGP_COPY_KEYS));
    if (copyKeys != NULL)
    {
        copyKeys->hKeySrc = hKeySrc;
        copyKeys->hKeyDest = hKeyDest;
        InsertHeadList(&copyQueueHead,
                       &copyKeys->ListEntry);
 
        /* FIXME - copy security from hKeySrc to hKeyDest or just for the subkeys? */
 
        do
        {
            copyKeys = CONTAINING_RECORD(copyQueueHead.Flink,
                                         REGP_COPY_KEYS,
                                         ListEntry);
 
            /* enumerate all values and copy them */
            Index = 0;
            for (;;)
            {
                Status2 = NtEnumerateValueKey(copyKeys->hKeySrc,
                                              Index,
                                              KeyValueFullInformation,
                                              Info.KeyValue,
                                              BufferSize,
                                              &BufferSizeRequired);
                if (NT_SUCCESS(Status2))
                {
                    UNICODE_STRING ValueName;
                    PVOID Data;
 
                    /* don't use RtlInitUnicodeString as the string is not NULL-terminated! */
                    ValueName.Length = Info.KeyValue->NameLength;
                    ValueName.MaximumLength = ValueName.Length;
                    ValueName.Buffer = Info.KeyValue->Name;
 
                    Data = (PVOID)((ULONG_PTR)Info.KeyValue + Info.KeyValue->DataOffset);
 
                    Status2 = NtSetValueKey(copyKeys->hKeyDest,
                                            &ValueName,
                                            Info.KeyValue->TitleIndex,
                                            Info.KeyValue->Type,
                                            Data,
                                            Info.KeyValue->DataLength);
 
                    /* don't break, let's try to copy as many values as possible */
                    if (!NT_SUCCESS(Status2) && NT_SUCCESS(Status))
                    {
                        Status = Status2;
                    }
 
                    Index++;
                }
                else if (Status2 == STATUS_BUFFER_OVERFLOW)
                {
                    PVOID Buffer;
 
                    ASSERT(BufferSize < BufferSizeRequired);
 
                    Buffer = RtlReAllocateHeap(ProcessHeap,
                                               0,
                                               Info.Buffer,
                                               BufferSizeRequired);
                    if (Buffer != NULL)
                    {
                        Info.Buffer = Buffer;
                        /* try again */
                    }
                    else
                    {
                        /* don't break, let's try to copy as many values as possible */
                        Status2 = STATUS_INSUFFICIENT_RESOURCES;
                        Index++;
 
                        if (NT_SUCCESS(Status))
                        {
                            Status = Status2;
                        }
                    }
                }
                else
                {
                    /* break to avoid an infinite loop in case of denied access or
                       other errors! */
                    if (Status2 != STATUS_NO_MORE_ENTRIES && NT_SUCCESS(Status))
                    {
                        Status = Status2;
                    }
 
                    break;
                }
            }
 
            /* enumerate all subkeys and open and enqueue them */
            Index = 0;
            for (;;)
            {
                Status2 = NtEnumerateKey(copyKeys->hKeySrc,
                                         Index,
                                         KeyNodeInformation,
                                         Info.KeyNode,
                                         BufferSize,
                                         &BufferSizeRequired);
                if (NT_SUCCESS(Status2))
                {
                    HANDLE KeyHandle, NewKeyHandle;
                    OBJECT_ATTRIBUTES ObjectAttributes;
                    UNICODE_STRING SubKeyName, ClassName;
 
                    /* don't use RtlInitUnicodeString as the string is not NULL-terminated! */
                    SubKeyName.Length = Info.KeyNode->NameLength;
                    SubKeyName.MaximumLength = SubKeyName.Length;
                    SubKeyName.Buffer = Info.KeyNode->Name;
                    ClassName.Length = Info.KeyNode->ClassLength;
                    ClassName.MaximumLength = ClassName.Length;
                    ClassName.Buffer = (PWSTR)((ULONG_PTR)Info.KeyNode + Info.KeyNode->ClassOffset);
 
                    /* open the subkey with sufficient rights */
 
                    InitializeObjectAttributes(&ObjectAttributes,
                                               &SubKeyName,
                                               OBJ_CASE_INSENSITIVE,
                                               copyKeys->hKeySrc,
                                               NULL);
 
                    Status2 = NtOpenKey(&KeyHandle,
                                        KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
                                        &ObjectAttributes);
                    if (NT_SUCCESS(Status2))
                    {
                        /* FIXME - attempt to query the security information */
 
                        InitializeObjectAttributes(&ObjectAttributes,
                                               &SubKeyName,
                                               OBJ_CASE_INSENSITIVE,
                                               copyKeys->hKeyDest,
                                               

Macros

Functions

Variables

Macro Definition Documentation

◆ ClosePredefKey

◆ GetPredefKeyIndex

◆ IsPredefKey

◆ MAX_DEFAULT_HANDLES

◆ REG_MAX_DATA_SIZE

◆ REG_MAX_NAME_SIZE

Function Documentation

◆ CloseDefaultKeys()

◆ CreateNestedKey()

◆ is_string()

◆ MapDefaultKey() [1/2]

◆ MapDefaultKey() [2/2]

◆ OpenClassesRootKey() [1/2]

◆ OpenClassesRootKey() [2/2]

◆ OpenCurrentConfigKey()

◆ OpenLocalMachineKey()

◆ OpenPredefinedKey()

◆ OpenUsersKey()

◆ RegCleanup()

◆ RegCloseKey()

◆ RegConnectRegistryA()

◆ RegConnectRegistryW()

◆ RegCopyTreeA()

◆ RegCopyTreeW()

◆ RegCreateKeyA()

◆ RegCreateKeyExA()

◆ RegCreateKeyExW()

◆ RegCreateKeyW()

◆ RegDeleteKeyA()

◆ RegDeleteKeyExA()

◆ RegDeleteKeyExW()

◆ RegDeleteKeyValueA()

◆ RegDeleteKeyValueW()

◆ RegDeleteKeyW()

◆ RegDeleteTreeA()

◆ RegDeleteTreeW()

◆ RegDeleteValueA()

◆ RegDeleteValueW()

◆ RegDisablePredefinedCache()

◆ RegDisablePredefinedCacheEx()

◆ RegDisableReflectionKey()

◆ RegEnableReflectionKey()

◆ RegEnumKeyA()

◆ RegEnumKeyExA()

◆ RegEnumKeyExW()

◆ RegEnumKeyW()

◆ RegEnumValueA()

◆ RegEnumValueW()

◆ RegFlushKey()

◆ RegGetKeySecurity()

◆ RegGetValueA()

◆ RegGetValueW()

◆ RegInitialize()

◆ RegLoadKeyA()

◆ RegLoadKeyW()

◆ RegNotifyChangeKeyValue()

◆ RegOpenCurrentUser()

◆ RegOpenKeyA()

◆ RegOpenKeyExA()

◆ RegOpenKeyExW()

◆ RegOpenKeyW()

◆ RegOpenUserClassesRoot()

◆ RegOverridePredefKey()

◆ RegpApplyRestrictions()

◆ RegpCopyTree()