reg.c File Reference

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

Include dependency graph for reg.c:

Go to the source code of this file.

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)
static int	load_string (HINSTANCE hModule, UINT resId, LPWSTR pwszBuffer, INT cMaxChars)
LONG WINAPI	RegLoadMUIStringW (IN HKEY hKey, IN LPCWSTR pszValue OPTIONAL, OUT LPWSTR pszOutBuf, IN DWORD cbOutBuf, OUT LPDWORD pcbData OPTIONAL, IN DWORD Flags, IN LPCWSTR pszDirectory OPTIONAL)
LONG WINAPI	RegLoadMUIStringA (IN HKEY hKey, IN LPCSTR pszValue OPTIONAL, OUT LPSTR pszOutBuf, IN DWORD cbOutBuf, OUT LPDWORD pcbData OPTIONAL, IN DWORD Flags, IN LPCSTR pszDirectory OPTIONAL)

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 920 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().

load_string()

static int load_string ( HINSTANCE  hModule, UINT  resId, LPWSTR  pwszBuffer, INT  cMaxChars  )

static

Definition at line 5126 of file reg.c.

{
    HGLOBAL hMemory;
    HRSRC hResource;
    WCHAR* pString;
    int idxString;
 
    /* Negative values have to be inverted. */
    if (HIWORD(resId) == 0xffff)
        resId = (UINT)(-((INT)resId));
 
    /* Load the resource into memory and get a pointer to it. */
    hResource = FindResourceW(hModule, MAKEINTRESOURCEW(LOWORD(resId >> 4) + 1), (LPWSTR)RT_STRING);
    if (!hResource) return 0;
    hMemory = LoadResource(hModule, hResource);
    if (!hMemory) return 0;
    pString = LockResource(hMemory);
 
    /* Strings are length-prefixed. Lowest nibble of resId is an index. */
    idxString = resId & 0xf;
    while (idxString--) pString += *pString + 1;
 
    /* If no buffer is given, return length of the string. */
    if (!pwszBuffer) return *pString;
 
    /* Else copy over the string, respecting the buffer size. */
    cMaxChars = (*pString < cMaxChars) ? *pString : (cMaxChars - 1);
    if (cMaxChars >= 0)
    {
        memcpy(pwszBuffer, pString + 1, cMaxChars * sizeof(WCHAR));
        pwszBuffer[cMaxChars] = L'\0';
    }
 
    return cMaxChars;
}

Referenced by RegLoadMUIStringW().

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

Referenced by RegCopyTreeW(), RegCreateKeyExW(), RegDeleteKeyExW(), RegDeleteTreeW(), RegDeleteValueA(), RegDeleteValueW(), RegEnumKeyExW(), RegEnumValueW(), RegFlushKey(), RegGetKeySecurity(), RegLoadKeyW(), RegNotifyChangeKeyValue(), RegOpenKeyExW(), RegQueryInfoKeyW(), RegQueryValueExW(), RegReplaceKeyW(), RegRestoreKeyW(), RegSaveKeyW(), RegSetKeySecurity(), RegSetKeyValueA(), RegSetKeyValueW(), RegSetValueA(), RegSetValueExW(), RegSetValueW(), and RegUnLoadKeyW().

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 424 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 845 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 874 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 816 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 740 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 RegCopyTreeA().

RegCreateKeyA()

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

Definition at line 1179 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 1034 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(), 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_CoGetClassObject(), test_CoGetPSClsid(), test_copy_key_class(), 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_register_progid_info(), 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 1096 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(), CInputProcessorProfiles::AddLanguageProfile(), AddNewLayout(), AddToFavoritesDlgProc(), AddUninstallKey(), ApplyEventlogSettings(), ApplyRegistryValues(), BuildVolatileEnvironment(), CliSaveImeHotKey(), CM_Open_Class_Key_ExW(), CM_Open_DevNode_Key_Ex(), ComDBOpen(), ConCfgOpenUserSettings(), connections_on_notify(), ConnectRegistry(), CopyKey(), CopySystemProfile(), create_key(), create_mru_list(), CreateAppPath(), CreateDeviceInstance(), CreateEventLog(), CreateHKCRKey(), CProfilesEnumGuid::CreateInstance(), CEnumTfLanguageProfiles::CreateInstance(), CreateInstanceKey(), CreateNewKey(), CreatePersistentIpForwardEntry(), 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(), FillList(), FilterMapper3_CreateCategory(), FilterMapper_RegisterFilter(), FilterMapper_RegisterPin(), FilterMapper_RegisterPinType(), get_cert_mgr_usages(), get_fusion_filename(), GetCurrentDPI(), GetFallbackHKCRKey(), CSysTray::GetServicesEnabled(), CRegTreeOptions::GetSetState(), ImageView_SaveSettings(), INetCfgComponentControl_fnApplyRegistryChanges(), INetCfgLock_fnAcquireWriteLock(), CRegPropertyBag::Init(), init_locale(), InitAppRegKey(), InitializeFormList(), InitLogs(), InitSettings(), InstallDefaultSystemSoundScheme(), InstallEventSource(), InstallNetDevice(), InstallOneInterface(), InstallSystemSoundLabels(), InstallSystemSoundScheme(), InstallSystemSoundSchemeNames(), load_devices_from_reg(), LoadJobs(), LoadRecoveryOptions(), LocalAddMonitor(), MAIN_LoadSettings(), MainWnd_OnOpenRegKey(), MMDevice_Create(), MRU_SaveChanged(), 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(), OnToggleRequireLogon(), open_cred_mgr_key(), open_key(), OpenConfigurationKey(), OpenImageFileExecOptions(), PNP_CreateKey(), PNP_GetClassInstance(), PNP_GetHwProfInfo(), PNP_SetClassRegProp(), ProcessSetupInf(), ProcessUnattendSection(), publish_patches(), RegCopyTreeW(), RegCreateKeyExA(), RegCreateKeyW(), CInputProcessorProfiles::Register(), 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(), CCategoryMgr::RegisterCategory(), RegisterComponent(), RegisterHelperDll(), RegisterSdbEntry(), RegisterService(), RegisterTypeLib(), registry_callback(), registry_get_handle(), RegSetDWORDValue(), RegSetKeyValueW(), run_add(), run_copy(), SampSetupAddMemberToAlias(), save_cert_mgr_usages(), save_sys_colors(), SaveBoard(), SaveDWORDToRegistry(), SaveJob(), SaveSettings(), SaveShutdownSelState(), SaveStringToRegistry(), ScmCopyControlSet(), ScmCreateNewControlPipe(), ScmCreateServiceKey(), ScmWriteSecurityDescriptor(), set_profile_device_key(), set_proxy(), SetComputerNameExW(), COpenWithList::SetDefaultHandler(), CInputProcessorProfiles::SetDefaultLanguageProfile(), SetFindFlags(), SetHotPlugFlags(), SetNtpClientValues(), SetParametersValues(), SetPerUserSecValuesW(), SetUnreadMailInfo(), SETUP_CreateClassKey(), SETUPDI_CreateDevKey(), SETUPDI_CreateDrvKey(), SetupDiCreateDeviceInterfaceRegKeyW(), SetupDiCreateDevRegKeyW(), SetUserGeoID(), SHAddToRecentDocs(), SHCreateSessionKey(), SHGetShellKey(), SHOpenRegStream2W(), SHRegCreateUSKeyW(), SHRegWriteUSValueW(), SHSetUnreadMailCountW(), 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(), WriteComputerSettings(), WritePortSettings(), WriteStartupRecoveryOptions(), and WriteUserLocale().

RegCreateKeyW()

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

Definition at line 1201 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_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(), publish_sourcelist(), RegInitializeRegistry(), register_appid(), register_codepages(), register_progid(), register_verb(), registry_callback(), 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 1224 of file reg.c.

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

Referenced by cleanup_eventlog(), CryptUnregisterOIDFunction(), CryptUnregisterOIDInfo(), delete_container_key(), delete_key(), delete_key_(), 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 1254 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_registry_key(), delete_tree_(), RegDeleteKeyA(), test_appsearch(), test_feature_override(), test_Installer_InstallProduct(), 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_MsiInstallProduct(), test_MsiOpenProduct(), test_MsiProvideQualifiedComponentEx(), test_MsiQueryComponentState(), test_MsiQueryFeatureState(), test_MsiQueryProductState(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListSetInfo(), test_null(), test_process_components(), test_publish_components(), test_publish_features(), test_publish_product(), and test_register_user().

RegDeleteKeyExW()

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

Definition at line 1286 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(), package_RegDeleteTreeW(), RegDeleteKeyExA(), RegDeleteKeyW(), and TLB_unregister_interface().

RegDeleteKeyValueA()

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

Definition at line 1392 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,
                             ValueName.Buffer);
 
    RtlFreeUnicodeString(&SubKey);
    RtlFreeUnicodeString(&ValueName);
 
    return Ret;
}

RegDeleteKeyValueW()

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

Definition at line 1361 of file reg.c.

{
    HKEY hSubKey = hKey;
    LONG ErrorCode;
 
    if (lpSubKey)
    {
        ErrorCode = RegOpenKeyExW(hKey, lpSubKey, 0, KEY_SET_VALUE, &hSubKey);
        if (ErrorCode)
        {
            return ErrorCode;
        }
    }
    ErrorCode = RegDeleteValueW(hSubKey, lpValueName);
 
    if (hSubKey != hKey)
    {
        RegCloseKey(hSubKey);
    }
    return ErrorCode;
}

Referenced by RegDeleteKeyValueA().

RegDeleteKeyW()

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

Definition at line 1239 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(), DeleteAppPath(), 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(), PNP_DeleteClassKey(), PNP_GetClassInstance(), reg_delete_tree(), RegDeleteTreeW(), ATL::CRegObject::RegDeleteTreeX(), RegisterSdbEntry(), RemoveEventLog(), run_delete(), ScmDeleteRegKey(), 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 1805 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 unregister_coclasses(), and unregister_mediatypes_extension().

RegDeleteTreeW()

LSTATUS WINAPI RegDeleteTreeW	(	HKEY	hKey,
		LPCWSTR	lpszSubKey
	)

Definition at line 1711 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;
}

Referenced by RegDeleteTreeA(), and RegDeleteTreeW().

RegDeleteValueA()

LONG WINAPI RegDeleteValueA	(	HKEY	hKey,
		LPCSTR	lpValueName
	)

Definition at line 2287 of file reg.c.

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

Referenced by cleanup_eventlog(), delete_value_(), DeleteRegistryValue(), ICRemove(), IStream_fnRelease(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), process_pending_renames(), reset_adapter(), restore_value(), save_cert_mgr_usages(), setLayerValue(), SHDeleteValueA(), START_TEST(), test_AddERExcludedApplicationA(), test_appsearch_reglocator(), test_debug_heap(), 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_XcvDataPort_ConfigureLPTPortCommandOK(), test_XcvDataPort_GetTransmissionRetryTimeout(), WhichPlatform(), and WNetRemoveCachedPassword().

RegDeleteValueW()

LONG WINAPI RegDeleteValueW	(	HKEY	hKey,
		LPCWSTR	lpValueName
	)

Definition at line 2330 of file reg.c.

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

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

RegDisablePredefinedCache()

LONG WINAPI RegDisablePredefinedCache

(

VOID

)

Definition at line 333 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 349 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 1833 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 1846 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 2368 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(), SHLWAPI_GetRegistryCompatFlags(), 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 2419 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 2504 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(), CRegTreeOptions::AddItemsFromRegistry(), CDefaultContextMenu::AddStaticEntriesForKey(), AddUserProfiles(), AllSysInfo(), build_zonemap_from_reg(), BuildLogListAndFilterList(), BuildParameterArray(), capGetDriverDescriptionW(), 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(), EnumDynamicTimeZoneInformation(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), EnumerateSoundProfiles(), EnumerateTimeZoneList(), EnumHKCRKey(), EnumInterfaces(), EnumPwrSchemes(), export_registry_data(), fetch_machine_component(), fetch_machine_product(), fetch_user_component(), fetch_user_product(), FileTypesDlg_Refresh(), CCategoryMgr::FindClosestCategory(), 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(), CProfilesEnumGuid::Next(), CEnumTfLanguageProfiles::Next(), CEnumTfLanguageProfiles::next_LanguageProfile(), CEnumRegKey::NextKey(), OnTreeExpanding(), package_RegDeleteTreeW(), PNP_EnumerateSubKeys(), PrintAdapterDescription(), query_all(), query_perf_data(), query_value(), read_types(), RefreshTreeItem(), reg_delete_tree(), RegCopyTreeW(), RegDeleteTreeW(), ATL::CRegObject::RegDeleteTreeX(), RegEnumKeyExA(), RegEnumKeyW(), RegFindRecurse(), RegFindWalk(), register_legacy_filters(), RegQueryRegistryKeys(), RemoveEventLog(), run_copy(), ScmCreateServiceDatabase(), ScmDeleteRegKey(), SdbUninstallByName(), search_domain_for_zone(), search_for_domain_mapping(), SETUP_CreateInterfaceList(), SetupDiClassGuidsFromNameExW(), SetupDiOpenDeviceInterfaceW(), SHCopyKeyW(), SHCreatePropSheetExtArrayEx(), SHDeleteKeyW(), SHEnumerateUnreadMailAccountsW(), SHEnumKeyExW(), SHGetUnreadMailCountW(), 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 2393 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(), DCIA_AddShellExSubkey(), delete_key(), DEVENUM_IEnumMoniker_Next(), DEVENUM_IEnumMoniker_Skip(), DirectPlayEnumerateAW(), DisplayStatus(), EditTypeDlg_ReadClass(), EditTypeDlg_WriteClass(), enum_key(), EnumOLEVERB_Next(), FindExeCplClass(), GetSpecialKLID(), HCR_GetDefaultVerbW(), Imm32GetImeLayoutList(), ImportSoundProfiles(), InstallerImpl_RegistryValue(), KLIDFromSpecialHKL(), lineGetCountryW(), CLangBarItemList::Load(), LoadClassicColorSchemes(), LoadSchemeSizes(), MIDIMAP_LoadSettingsScheme(), registry_enumerate_credentials(), SHELL32_OpenPropSheet(), ShellExecute_FromContextMenuHandlers(), and UIINSERTOBJECTDLG_PopulateObjectTypes().

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 2668 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_SHGetObjectCompatFlags(), 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 2830 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 BuildCodePageList(), ConCfgReadUserSettings(), Control_RegisterRegistryApplets(), CopyKey(), CreateNTPServerList(), DeletePersistentRoutes(), 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(), IntDeleteRegFontEntries(), Internal_EnumLanguageGroupLocales(), Internal_EnumSystemCodePages(), Internal_EnumSystemLanguageGroups(), IsLayoutExists(), ITERATE_FindRelatedProducts(), LoadHelpers(), LocaleList_Create(), MainWnd_OnUpdateRegistry(), MMDevPropStore_GetAt(), MMDevPropStore_GetCount(), MSACM_RegisterAllDrivers(), MsiGetProductCodeW(), MsiSourceListEnumMediaDisksW(), myRegDeleteTreeW(), CEnumRegKey::NextValue(), OnInitMenu(), package_RegDeleteTreeW(), PrintPersistentRoutes(), ProcessRunKeys(), query_all(), CFontCache::Read(), RefreshListView(), RegDeleteTreeW(), RegEnumValueA(), RegFindRecurse(), CControlPanelEnum::RegisterRegistryCPanelApps(), RegKeyHasValues(), RegQueryRegistryValues(), SSOThread::Run(), run_copy(), run_delete(), SetDefaultPrinterW(), SetSystemEnvironment(), SetUserEnvironment(), SHCopyKeyW(), SHEnumValueW(), SHGetObjectCompatFlags(), SHRegEnumUSValueW(), SQLGetInstalledDriversW(), SQLGetPrivateProfileStringW(), START_TEST(), TryShellExecuteHooks(), txt_export_registry_data(), url_guess_scheme(), URL_GuessScheme(), and wWinMain().

RegFlushKey()

LONG WINAPI RegFlushKey

(

HKEY

hKey

)

Definition at line 2951 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(), ATL::CRegKey::Flush(), ImportRegistryFile(), InstallEventSource(), RemoveEventLog(), RSetServiceObjectSecurity(), SaveCurrentLocale(), SaveGeoID(), ScmCopyControlSet(), ScmSetLastKnownGoodControlSet(), test_NonExistentPath(), TestMyEventProvider(), and UnloadUserProfile().

RegGetKeySecurity()

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

Definition at line 2987 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 2037 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(), 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 1931 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(), CDefaultContextMenu::AddStaticEntriesForKey(), AssocGetPerceivedType(), ComponentInfo_GetGUIDValue(), ComponentInfo_GetUINTValue(), create_monodata(), DoGetProductType(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), CDrvDefExt::ExtraPageProc(), FILEDLG95_MRU_get_slot(), FILEDLG95_MRU_save_filename(), FindExeCplClass(), CDrvDefExt::GeneralPageProc(), get_stringvalue(), GetCLSIDForFileTypeFromExtension(), CNetConnectionPropertyUi::GetDeviceInstanceID(), GetInterfaceName(), GetRegCustomizedDriveIcon(), GetRegString(), CQueryAssociations::GetString(), HCR_GetClassNameW(), InitializeRecycleBinDlg(), InitIconOverlays(), CFileDefExt::InitOpensWithField(), COpenWithList::IsHidden(), COpenWithList::Load(), load_config_driver(), load_settings(), COpenWithList::LoadFromProgIdKey(), CNewMenu::LoadItem(), LoadKeyboardLayoutW(), COpenWithList::LoadRecommendedFromHKCR(), COpenWithList::LoadRecommendedFromHKCU(), MMDevice_GetPropValue(), OpenKeyFromFileType(), PixelFormatInfo_GetChannelMask(), read_bitmap_patterns(), read_metadata_patterns(), RegQueryDword(), COpenWithList::SetDefaultHandler(), SHELL32_AssocGetExtensionDescription(), SHELL32_IsShellFolderNamespaceItemHidden(), SHELL_GetRegCLSID(), SHELL_GetShellExtensionRegCLSID(), SHELL_QueryCLSIDValue(), 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 3032 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;
}

RegLoadKeyW()

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

Definition at line 3079 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().

RegLoadMUIStringA()

LONG WINAPI RegLoadMUIStringA	(	IN HKEY	hKey,
		IN LPCSTR pszValue	OPTIONAL,
		OUT LPSTR	pszOutBuf,
		IN DWORD	cbOutBuf,
		OUT LPDWORD pcbData	OPTIONAL,
		IN DWORD	Flags,
		IN LPCSTR pszDirectory	OPTIONAL
	)

Definition at line 5268 of file reg.c.

{
    UNICODE_STRING valueW, baseDirW;
    WCHAR* pwszBuffer;
    DWORD cbData = cbOutBuf * sizeof(WCHAR);
    LONG result;
 
    valueW.Buffer = baseDirW.Buffer = pwszBuffer = NULL;
    if (!RtlCreateUnicodeStringFromAsciiz(&valueW, pszValue) ||
        !RtlCreateUnicodeStringFromAsciiz(&baseDirW, pszDirectory) ||
        !(pwszBuffer = HeapAlloc(GetProcessHeap(), 0, cbData)))
    {
        result = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
 
    result = RegLoadMUIStringW(hKey, valueW.Buffer, pwszBuffer, cbData, NULL, Flags,
        baseDirW.Buffer);
 
    if (result == ERROR_SUCCESS)
    {
        cbData = WideCharToMultiByte(CP_ACP, 0, pwszBuffer, -1, pszOutBuf, cbOutBuf, NULL, NULL);
        if (pcbData)
            *pcbData = cbData;
    }
 
cleanup:
    HeapFree(GetProcessHeap(), 0, pwszBuffer);
    RtlFreeUnicodeString(&baseDirW);
    RtlFreeUnicodeString(&valueW);
 
    return result;
}

Referenced by CRegFolder::GetDetailsOf(), and HCR_GetClassNameA().

RegLoadMUIStringW()

LONG WINAPI RegLoadMUIStringW	(	IN HKEY	hKey,
		IN LPCWSTR pszValue	OPTIONAL,
		OUT LPWSTR	pszOutBuf,
		IN DWORD	cbOutBuf,
		OUT LPDWORD pcbData	OPTIONAL,
		IN DWORD	Flags,
		IN LPCWSTR pszDirectory	OPTIONAL
	)

Definition at line 5168 of file reg.c.

{
    DWORD dwValueType, cbData;
    LPWSTR pwszTempBuffer = NULL, pwszExpandedBuffer = NULL;
    LONG result;
 
    /* Parameter sanity checks. */
    if (!hKey || !pszOutBuf)
        return ERROR_INVALID_PARAMETER;
 
    if (pszDirectory && *pszDirectory)
    {
        FIXME("BaseDir parameter not yet supported!\n");
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Check for value existence and correctness of it's type, allocate a buffer and load it. */
    result = RegQueryValueExW(hKey, pszValue, NULL, &dwValueType, NULL, &cbData);
    if (result != ERROR_SUCCESS) goto cleanup;
    if (!(dwValueType == REG_SZ || dwValueType == REG_EXPAND_SZ) || !cbData)
    {
        result = ERROR_FILE_NOT_FOUND;
        goto cleanup;
    }
    pwszTempBuffer = HeapAlloc(GetProcessHeap(), 0, cbData);
    if (!pwszTempBuffer)
    {
        result = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
    result = RegQueryValueExW(hKey, pszValue, NULL, &dwValueType, (LPBYTE)pwszTempBuffer, &cbData);
    if (result != ERROR_SUCCESS) goto cleanup;
 
    /* Expand environment variables, if appropriate, or copy the original string over. */
    if (dwValueType == REG_EXPAND_SZ)
    {
        cbData = ExpandEnvironmentStringsW(pwszTempBuffer, NULL, 0) * sizeof(WCHAR);
        if (!cbData) goto cleanup;
        pwszExpandedBuffer = HeapAlloc(GetProcessHeap(), 0, cbData);
        if (!pwszExpandedBuffer)
        {
            result = ERROR_NOT_ENOUGH_MEMORY;
            goto cleanup;
        }
        ExpandEnvironmentStringsW(pwszTempBuffer, pwszExpandedBuffer, cbData);
    }
    else
    {
        pwszExpandedBuffer = HeapAlloc(GetProcessHeap(), 0, cbData);
        memcpy(pwszExpandedBuffer, pwszTempBuffer, cbData);
    }
 
    /* If the value references a resource based string, parse the value and load the string.
     * Else just copy over the original value. */
    result = ERROR_SUCCESS;
    if (*pwszExpandedBuffer != L'@') /* '@' is the prefix for resource based string entries. */
    {
        lstrcpynW(pszOutBuf, pwszExpandedBuffer, cbOutBuf / sizeof(WCHAR));
    }
    else
    {
        WCHAR* pComma = wcsrchr(pwszExpandedBuffer, L',');
        UINT uiStringId;
        HMODULE hModule;
 
        /* Format of the expanded value is 'path_to_dll,-resId' */
        if (!pComma || pComma[1] != L'-')
        {
            result = ERROR_BADKEY;
            goto cleanup;
        }
 
        uiStringId = _wtoi(pComma + 2);
        *pComma = L'\0';
 
        hModule = LoadLibraryExW(pwszExpandedBuffer + 1, NULL, LOAD_LIBRARY_AS_DATAFILE);
        if (!hModule || !load_string(hModule, uiStringId, pszOutBuf, cbOutBuf / sizeof(WCHAR)))
            result = ERROR_BADKEY;
        FreeLibrary(hModule);
    }
 
cleanup:
    HeapFree(GetProcessHeap(), 0, pwszTempBuffer);
    HeapFree(GetProcessHeap(), 0, pwszExpandedBuffer);
    return result;
}

Referenced by RegLoadMUIStringA().

RegNotifyChangeKeyValue()

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

Definition at line 3152 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(), and WsSetupCatalogProtection().

RegOpenCurrentUser()

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

Definition at line 3209 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(), MIDIMAP_LoadSettings(), RegOpenLoggedOnHKCU(), SaveCursorScheme(), SetDefaultLanguage(), StartScreenSaver(), test_invalid_stdin(), WlxScreenSaverNotify(), wnet_use_connection(), WNetCancelConnection2W(), wnetInit(), and WNetOpenEnumW().

RegOpenKeyA()

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

Definition at line 3234 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(), 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 3298 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 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(), getDhcpInfoForAdapter(), 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(), reset_adapter(), 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(), SHGetValueA(), SHLWAPI_GetRegistryCompatFlags(), SHOpenRegStream2A(), SHPinDllOfCLSID(), SHRegDuplicateHKey(), START_TEST(), 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_register_font(), test_register_product(), test_register_typelib(), test_register_user(), test_RegPolicyFlags(), test_remove_upgrade_code(), test_SetupDiOpenClassRegKeyExA(), test_SHCreateDefaultContextMenu(), test_SHQueryValueEx(), test_SQLInstallDriverEx(), test_SQLInstallTranslatorEx(), test_stub(), test_TreatAsClass(), test_XcvDataPort_ConfigureLPTPortCommandOK(), test_XcvDataPort_GetTransmissionRetryTimeout(), uniquecontainer(), unregister_keys(), unset_domain(), unset_name_servers(), 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 3333 of file reg.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING SubKeyString;
    HANDLE KeyHandle;
    NTSTATUS Status;
    ULONG Attributes = OBJ_CASE_INSENSITIVE;
    LONG ErrorCode = ERROR_SUCCESS;
    BOOLEAN SubKeyStringAllocated = FALSE;
 
    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);
 
        /* Handle unaligned lpSubKey */
        if ((ULONG_PTR)lpSubKey & 1)
        {
            UNICODE_STRING AlignedString;
 
            Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
                                               &SubKeyString,
                                               &AlignedString);
            if (!NT_SUCCESS(Status))
            {
                goto Exit;
            }
 
            SubKeyString = AlignedString;
            SubKeyStringAllocated = TRUE;
        }
    }
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &SubKeyString,
                               Attributes,
                               KeyHandle,
                               NULL);
 
    Status = NtOpenKey((PHANDLE)phkResult,
                       samDesired,
                       &ObjectAttributes);
 
Exit:
 
    if (SubKeyStringAllocated)
    {
        RtlFreeUnicodeString(&SubKeyString);
    }
 
    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(), CRegTreeOptions::AddItemsFromRegistry(), CInputProcessorProfiles::AddLanguageProfile(), AddNewLayout(), AddNotificationDll(), AddSoundProfile(), CDefaultContextMenu::AddStaticContextMenusToMenu(), CDefaultContextMenu::AddStaticEntriesForKey(), AddUserProfiles(), AllSysInfo(), ApplyChanges(), ApplyOrCancelChanges(), BuildCodePageList(), BuildLogListAndFilterList(), BuildParameterArray(), BuildServiceArray(), BuildVolatileEnvironment(), CanUserWritePwrScheme(), capGetDriverDescriptionW(), ChangeNtProductType(), check_product_patches(), CheckForLiveCD(), CheckForLoadedProfile(), CheckLogOrSourceExistence(), ChooseFavorite(), ChooseGinaUI(), CliGetImeHotKeysFromRegistry(), CliGetPreloadKeyboardLayouts(), CliSetSingleHotKey(), CEnumTfLanguageProfiles::Clone(), CM_Open_Class_Key_ExW(), CM_Open_DevNode_Key_Ex(), ComponentInfo_GetGuidList(), ConCfgOpenUserSettings(), ConverterSupportsFormat(), CopyKey(), create_EnumMoniker(), create_monodata(), 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(), DCIA_AddShellExSubkey(), DecrementRefCount(), delete_key(), delete_test_key(), DeleteExt(), DeleteHelperCommand(), DeleteKey(), DeletePersistentRoutes(), 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(), CInputProcessorProfiles::EnableLanguageProfile(), CInputProcessorProfiles::EnableLanguageProfileByDefault(), enum_key(), enum_values(), EnumClientServiceProtocol(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), EnumerateNetworkComponent(), EnumerateSoundProfiles(), EnumerateTimeZoneList(), EnumHKCRKey(), EnumInterfaces(), EnumPwrSchemes(), 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(), CCategoryMgr::FindClosestCategory(), FindExeCplClass(), FindNetworkAdapter(), ForceFriendlyUI(), get_default_proxy_reg_value(), get_fusion_filename(), get_install_root(), get_language_sort(), get_mono_path_from_registry(), get_patch_state(), GetAcceptLanguagesW(), GetActivePwrScheme(), GetAllocatedResourceList(), GetAllUsersProfileDirectoryW(), GetAssocClass(), GetAutoDaylight(), GetBooleanRegValue(), GetBootResourceList(), GetClassMediaFile(), CQueryAssociations::GetCommand(), GetComputerNameExW(), GetComputerNames(), GetCurrentHwProfileW(), GetCurrentUserKey(), CInputProcessorProfiles::GetDefaultLanguageProfile(), GetDefaultPrinterFromRegistry(), GetDefaultPrinterW(), GetDefaultUserProfileDirectoryW(), GetDesktopPath(), CNetConnectionPropertyUi::GetDeviceInstanceID(), GetDeviceInstanceList(), GetDeviceInstanceListSize(), getDhcpInfoForAdapter(), GetDisplayNameFileAndID(), GetDynamicTimeZoneInformation(), GetDynamicTimeZoneInformationEffectiveYears(), GetEnumeratorInstanceList(), GetEnumeratorInstanceListSize(), GetEnumOptions(), GetEventMessageFileDLL(), GetFallbackHKCRKey(), GetFileTypeIconsByKey(), GetGinaPath(), GetHotPlugFlags(), GetInterfaceFriendlyName(), GetInterfaceNameInternal(), GetIntervalSetting(), GetJapaneseUninstallCmdLine(), GetLayoutCount(), GetLayoutName(), GetLPTTransmissionRetryTimeout(), GetPerAdapterInfo(), GetPolicyDWORDValue(), GetPolicyValues(), GetPreferredHKCRKey(), GetProfile(), GetProfileCount(), GetProfiles(), GetProfilesDirectoryW(), GetProfileType(), GetProgramsPath(), CNetConnection::GetProperties(), GetPwrDiskSpindownRange(), GetRegistrySettings(), GetRegValue(), GetServiceInstanceList(), GetServiceInstanceListSize(), CRegTreeOptions::GetSetState(), GetSettings(), GetSetupType(), GetShell(), GetShutdownReasonUI(), CQueryAssociations::GetString(), GetSubkeyInfoHelper(), GetSyncSetting(), GetTimeZoneInformationForYear(), GetTimeZoneListIndex(), GetTypeName(), CZipFolder::GetUIObjectOf(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetUIObjectOf(), GetUsedPorts(), GetUserDefaultGeoName(), GetUserGeoID(), GetUserProfileDirectoryW(), GetUserWaitInterval(), GUILoggedOutSAS(), HandleLogon(), HandleMruData(), CDeviceNode::HasResources(), HCR_GetDefaultVerbW(), HCR_GetExecuteCommandW(), HCR_GetFolderAttributes(), HCR_GetIconW(), HCR_GetProgIdKeyOfExtension(), 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(), CRegTreeOptions::InitTree(), InitTTFontCache(), InitWorkstationInfo(), InputList_PrepareUserRegistry(), InstallDevice(), InstallOneService(), InstallReactOS(), InstallScreenSaverW(), Int_EnumDependentServicesW(), Internal_EnumLanguageGroupLocales(), Internal_EnumSystemCodePages(), Internal_EnumSystemLanguageGroups(), IntGetIcdData(), IntLoadKeyboardLayout(), IsConsoleBoot(), CInputProcessorProfiles::IsEnabledLanguageProfile(), IsExplorerSystemShell(), IsExtensionAShortcut(), IsFriendlyUIActive(), IsInternetESCEnabledLocal(), IsLayoutExists(), IsLiveCD(), IsShowHibernateButtonActive(), IsValidLanguageGroup(), IsWindowsOS(), KLIDFromSpecialHKL(), CNetConnectionPropertyUi::LANPropertiesUIDlg(), LayoutList_Create(), load_mapi_providers(), load_provider(), LoadAdvancedSettings(), COpenWithList::LoadAppList(), LoadBoard(), CNewMenu::LoadCachedItems(), LoadCoolSwitchSettings(), LoadCurrentLocale(), LoadDNSSettings(), LoadDWORDFromRegistry(), LoadEventLabel(), LoadEventLabels(), LoadFilterSettings(), LoadHelpers(), LoadInstallableVDD(), CNewMenu::LoadItem(), LoadLogFiles(), LoadNotifyDll(), COpenWithList::LoadProgIdList(), CInputPin::LoadProxyPlugins(), COutputPin::LoadProxyPlugins(), CKsProxy::LoadProxyPlugins(), COpenWithList::LoadRecommendedFromHKCR(), COpenWithList::LoadRecommendedFromHKCU(), LoadRegistrySettings(), LoadSettings(), LoadShutdownSelState(), LoadSoundProfiles(), LoadStringFromRegistry(), LoadUsernameHint(), LoadUserProfileW(), locale_return_reg_string(), LocaleList_Create(), LocalEnumPrintProcessors(), MainWnd_OnInstall(), MainWnd_OnUpdateRegistry(), MCI_GetDevTypeFromFileName(), MCI_SysInfo(), MMDevPropStore_OpenPropKey(), MMSYS_InstallDevice(), MRU_SaveChanged(), MSACM_RegisterAllDrivers(), MSACM_RegisterDriverFromRegistry(), 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(), CEnumTfLanguageProfiles::next_LanguageProfile(), OnAutoSync(), OnInitSecurityDlg(), OnTreeExpanding(), open_env_key(), open_export_key(), open_key(), OpenChildKeyRead(), OpenComputerNameKey(), OpenConfigurationKey(), OpenHardwareProfileKey(), OpenHKCRKey(), OpenHostNameKey(), OpenHostsFile(), OpenImageFileExecOptions(), OpenKey(), OpenKeyboardLayouts(), 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(), PrintAdapterDescription(), PrintOSVersion(), PrintPersistentRoutes(), process_extensions(), ProcessPage_OnDebug(), ProcessPageShowContextMenu(), ProcessRunKeys(), ProcessRunOnceEx(), ProcessSetupInf(), ProcessUnattendSection(), query_all(), query_perf_data(), query_typelib_path(), query_value(), QueryAppSettings(), QueryConfig2W(), QueryUserRegValueW(), RControlService(), read_bitmap_patterns(), read_key(), read_metadata_patterns(), read_types(), ReadAttributes(), ReadBindingString(), ReadGlobalPwrPolicy(), ReadKeysSettings(), ReadPerInstanceRegistryParameters(), ReadPortSettings(), ReadRegistryValue(), RefreshListView(), RefreshTreeItem(), reg_delete_tree(), reg_duplicate_hkey(), reg_export(), RegCopyTreeW(), RegDeleteKeyExW(), RegDeleteKeyValueW(), RegDeleteTreeW(), ATL::CRegObject::RegDeleteTreeX(), RegFindRecurse(), RegFindWalk(), RegGetDWORD(), RegGetDWORDValue(), RegGetSZ(), RegGetValueW(), register_legacy_filters(), CCategoryMgr::RegisterCategory(), registry_enumerate_credentials(), registry_get_handle(), RegKeyExists(), RegOpenCurrentUser(), RegOpenKeyExA(), RegOpenKeyW(), RegQueryRegistryKeys(), RegQueryRegistryValues(), RegSetDWORDValue(), RegTGetKeyHandle(), RemoveEventLog(), CNetConnection::Rename(), REnumDependentServicesA(), REnumDependentServicesW(), ReportProductInfoEvent(), ReturnNtProduct(), run_copy(), run_delete(), run_query(), RunningOnLiveMedium(), RunSetupThreadProc(), SampIsSetupRunning(), SaveAdvancedSettings(), SaveAppSettings(), SaveCurrentLocale(), SaveDefaultUserHive(), SaveGeoID(), SavePropertiesDlg(), SaveSettings(), SaveWorkstationInfo(), ScmAssignNewTag(), ScmAutoStartServices(), ScmCopyControlSet(), ScmCreateServiceDatabase(), ScmCreateServiceKey(), ScmDeleteControlSet(), ScmDeleteMarkedServices(), ScmDeleteRegKey(), ScmDeleteService(), ScmGetControlSetValues(), ScmGetNoInteractiveServicesValue(), ScmGetSetupInProgress(), ScmInitNamedPipeCriticalSection(), ScmOpenServiceKey(), ScmReadSecurityDescriptor(), ScmSetLastKnownGoodControlSet(), SdbUninstallByGuid(), SdbUninstallByName(), search_reg(), SECUR32_initializeProviders(), SelectExtOnRename(), set_installer_properties(), SetAutoAdminLogon(), SetAutoDaylight(), SetClassId(), SetComputerNameExW(), 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(), SH32_CoCreateInstance(), SH32_InvokeOpenWith(), SHAboutInfoW(), SHCopyKeyW(), SHCreatePropSheetExtArrayEx(), SHDeleteEmptyKeyW(), SHDeleteKeyW(), SHDeleteOrphanKeyW(), SHDeleteValueW(), SHDOCVW_GetShellInstanceObjectClassObject(), SHELL32_OpenPropSheet(), SHELL_FindExecutableByVerb(), SHELL_TryAppPathW(), ShellExecute_GetClassKey(), ShellShutdownDialog(), SHEnumerateUnreadMailAccountsW(), SHGetShellKey(), SHGetUnreadMailCountW(), SHGetValueW(), SHOpenRegStream2W(), SHPropertyBag_OnRegKey(), SHRegGetCLSIDKeyW(), SHRegOpenUSKeyW(), SockLoadHelperDll(), SockLoadTransportList(), SockLoadTransportMapping(), SQLGetInstalledDriversW(), START_TEST(), StartScreenSaver(), StartShell(), SuggestKeys(), test4(), test_CallForAttributes(), Test_CreateOpenKey(), Test_DuplicateHandle(), Test_KLID(), test_set_value(), test_SetupDiInstallClassExA(), test_setvalue_on_wow64(), TEST_SHGetComputerDisplayNameW(), test_SQLGetPrivateProfileString(), test_SQLGetPrivateProfileStringW(), test_SQLWritePrivateProfileString(), TestInterfaceRegistry(), TestKeyAccess_(), TestModuleRegistry(), TestMyEventProvider(), testRegStoreSavedCerts(), TLB_unregister_interface(), TOOLBAR_Restore(), TreeWndNotifyProc(), TryShellExecuteHooks(), 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(), CCategoryMgr::UnregisterCategory(), UnregisterComponent(), UnRegisterTypeLib(), UpdateCaretBlinkTimeReg(), UpdateRegistryForFontSubstitutes(), UpdateTcpIpInformation(), UpdateUsersShellFolderSettings(), url_apply_default_scheme(), URL_ApplyDefault(), url_guess_scheme(), URL_GuessScheme(), UserInstStubWrapperW(), UsersPageProc(), UXTHEME_RestoreSystemMetrics(), W32TmServiceMain(), WinHttpGetDefaultProxyConfiguration(), WinHttpGetIEProxyConfigForCurrentUser(), WINTRUST_ReadProviderFromReg(), Winver_GetOSInfo(), WlxActivateUserShell(), WlxScreenSaverNotify(), wmain(), wnetInit(), WNetOpenEnumW(), WriteDefaultLogonData(), WriteKeysSettings(), WriteOwnerSettings(), WritePortSettings(), WriteSettings(), and wWinMain().

RegOpenKeyW()

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

Definition at line 3268 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(), 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(), Imm32GetImeLayoutList(), Imm32IsCUASEnabledInRegistry(), Imm32IsTIMDisabledInRegistry(), 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(), LoadKeyboardLayoutW(), 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(), SHGetObjectCompatFlags(), SHGetRestriction(), SHRegOpenKeyW(), SQLRemoveDriverW(), SQLRemoveTranslatorW(), START_TEST(), StartWithDesktop(), 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 3441 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 366 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 1859 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 451 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;
                        BufferSize = BufferSizeRequired;
                        /* 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,
                                               NULL);
 
                        Status2 = NtCreateKey(&NewKeyHandle,
                                              KEY_ALL_ACCESS,
                                              &ObjectAttributes,
                                              Info.KeyNode->TitleIndex,
                                              &ClassName,
                                              0,
                                              NULL);
                        if (NT_SUCCESS(Status2))
                        {
                            newCopyKeys = RtlAllocateHeap(ProcessHeap,
                                                          0,
                                                          sizeof(REGP_COPY_KEYS));
                            if (newCopyKeys != NULL)
                            {
                                /* save the handles and enqueue the subkey */
                                newCopyKeys->hKeySrc = KeyHandle;
                                newCopyKeys->hKeyDest = NewKeyHandle;
                                InsertTailList(&copyQueueHead,
                                               &newCopyKeys->ListEntry);
                            }
                            else
                            {
                                NtClose(KeyHandle);
                                NtClose(NewKeyHandle);
 
                                Status2 = STATUS_INSUFFICIENT_RESOURCES;
                            }
                        }
                        else
                        {
                            NtClose(KeyHandle);
                        }
                    }
 
                    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;
                        BufferSize = BufferSizeRequired;
                        /* try again */
                    }
                    else
                    {
                        /* don't break, let's try to copy as many keys 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;
                }
            }
 
            /* close the handles and remove the entry from the list */
            if (copyKeys->hKeySrc != hKeySrc)
            {
                NtClose(copyKeys->hKeySrc);
            }
            if (copyKeys->hKeyDest != hKeyDest)
            {
                NtClose(copyKeys->hKeyDest);
            }
 
            RemoveEntryList(&copyKeys->ListEntry);
 
            RtlFreeHeap(ProcessHeap,
                        0,
                        copyKeys);
        } while (!IsListEmpty(&copyQueueHead));
    }
    else
        Status = STATUS_INSUFFICIENT_RESOURCES;
 
    RtlFreeHeap(ProcessHeap,
                0,
                Info.Buffer);
 
    return Status;
}

Referenced by RegCopyTreeW().

RegQueryInfoKeyA()

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
	)

Definition at line 3583 of file reg.c.

{
    WCHAR ClassName[MAX_PATH];
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;
    LONG ErrorCode;
    NTSTATUS Status;
    DWORD cClass = 0;
 
    if ((lpClass) && (!lpcClass))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    RtlInitUnicodeString(&UnicodeString,
                         NULL);
    if (lpClass != NULL)
    {
        RtlInitEmptyUnicodeString(&UnicodeString,
                                  ClassName,
                                  sizeof(ClassName));
        cClass = sizeof(ClassName) / sizeof(WCHAR);
    }
 
    ErrorCode = RegQueryInfoKeyW(hKey,
                                 UnicodeString.Buffer,
                                 &cClass,
                                 lpReserved,
                                 lpcSubKeys,
                                 lpcMaxSubKeyLen,
                                 lpcMaxClassLen,
                                 lpcValues,
                                 lpcMaxValueNameLen,
                                 lpcMaxValueLen,
                                 lpcbSecurityDescriptor,
                                 lpftLastWriteTime);
    if ((ErrorCode == ERROR_SUCCESS) && (lpClass != NULL))
    {
        if (*lpcClass == 0)
        {
            return ErrorCode;
        }
 
        RtlInitEmptyAnsiString(&AnsiString, lpClass, *lpcClass);
        UnicodeString.Length = cClass * sizeof(WCHAR);
        Status = RtlUnicodeStringToAnsiString(&AnsiString,
                                              &UnicodeString,
                                              FALSE);
        ErrorCode = RtlNtStatusToDosError(Status);
        cClass = AnsiString.Length;
        lpClass[cClass] = ANSI_NULL;
    }
 
    if (lpcClass != NULL)
    {
        *lpcClass = cClass;
    }
 
    return ErrorCode;
}

Referenced by delete_registry_key(), delete_tree(), delete_tree_(), find_registry_key(), FindProvRegVals(), FindProvTypesRegVals(), lineGetCountryA(), lineGetTranslateCapsA(), mru_RegDeleteTreeA(), myRegDeleteTreeA(), SHDeleteEmptyKeyA(), SHDeleteOrphanKeyA(), SHQueryInfoKeyA(), SHRegQueryInfoUSKeyA(), test_copy_key_class(), and TestKeyAccess_().

RegQueryInfoKeyW()

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
	)

Definition at line 3662 of file reg.c.

{
    KEY_FULL_INFORMATION FullInfoBuffer;
    PKEY_FULL_INFORMATION FullInfo;
    ULONG FullInfoSize;
    ULONG ClassLength = 0;
    HANDLE KeyHandle;
    NTSTATUS Status;
    ULONG Length;
    LONG ErrorCode = ERROR_SUCCESS;
 
    if ((lpClass) && (!lpcClass))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (IsHKCRKey(KeyHandle))
    {
        ErrorCode = QueryInfoHKCRKey(KeyHandle, lpClass, lpcClass, lpReserved,
                                     lpcSubKeys, lpcMaxSubKeyLen, lpcMaxClassLen,
                                     lpcValues, lpcMaxValueNameLen, lpcMaxValueLen,
                                     lpcbSecurityDescriptor, lpftLastWriteTime);
        ClosePredefKey(KeyHandle);
        return ErrorCode;
    }
 
    if (lpClass != NULL)
    {
        if (*lpcClass > 0)
        {
            ClassLength = min(*lpcClass - 1, REG_MAX_NAME_SIZE) * sizeof(WCHAR);
        }
        else
        {
            ClassLength = 0;
        }
 
        FullInfoSize = sizeof(KEY_FULL_INFORMATION) + ((ClassLength + 3) & ~3);
        FullInfo = RtlAllocateHeap(ProcessHeap,
                                   0,
                                   FullInfoSize);
        if (FullInfo == NULL)
        {
            ErrorCode = ERROR_OUTOFMEMORY;
            goto Cleanup;
        }
    }
    else
    {
        FullInfoSize = sizeof(KEY_FULL_INFORMATION);
        FullInfo = &FullInfoBuffer;
    }
 
    if (lpcbSecurityDescriptor != NULL)
        *lpcbSecurityDescriptor = 0;
 
    Status = NtQueryKey(KeyHandle,
                        KeyFullInformation,
                        FullInfo,
                        FullInfoSize,
                        &Length);
    TRACE("NtQueryKey() returned status 0x%X\n", Status);
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
    {
        ErrorCode = RtlNtStatusToDosError(Status);
        goto Cleanup;
    }
 
    TRACE("SubKeys %d\n", FullInfo->SubKeys);
    if (lpcSubKeys != NULL)
    {
        *lpcSubKeys = FullInfo->SubKeys;
    }
 
    TRACE("MaxNameLen %lu\n", FullInfo->MaxNameLen);
    if (lpcMaxSubKeyLen != NULL)
    {
        *lpcMaxSubKeyLen = FullInfo->MaxNameLen / sizeof(WCHAR);
    }
 
    TRACE("MaxClassLen %lu\n", FullInfo->MaxClassLen);
    if (lpcMaxClassLen != NULL)
    {
        *lpcMaxClassLen = FullInfo->MaxClassLen / sizeof(WCHAR);
    }
 
    TRACE("Values %lu\n", FullInfo->Values);
    if (lpcValues != NULL)
    {
        *lpcValues = FullInfo->Values;
    }
 
    TRACE("MaxValueNameLen %lu\n", FullInfo->MaxValueNameLen);
    if (lpcMaxValueNameLen != NULL)
    {
        *lpcMaxValueNameLen = FullInfo->MaxValueNameLen / sizeof(WCHAR);
    }
 
    TRACE("MaxValueDataLen %lu\n", FullInfo->MaxValueDataLen);
    if (lpcMaxValueLen != NULL)
    {
        *lpcMaxValueLen = FullInfo->MaxValueDataLen;
    }
 
    if (lpcbSecurityDescriptor != NULL)
    {
        Status = NtQuerySecurityObject(KeyHandle,
                                       OWNER_SECURITY_INFORMATION |
                                       GROUP_SECURITY_INFORMATION |
                                       DACL_SECURITY_INFORMATION,
                                       NULL,
                                       0,
                                       lpcbSecurityDescriptor);
        TRACE("NtQuerySecurityObject() returned status 0x%X\n", Status);
    }
 
    if (lpftLastWriteTime != NULL)
    {
        lpftLastWriteTime->dwLowDateTime = FullInfo->LastWriteTime.u.LowPart;
        lpftLastWriteTime->dwHighDateTime = FullInfo->LastWriteTime.u.HighPart;
    }
 
    if (lpClass != NULL)
    {
        if (*lpcClass == 0)
        {
            goto Cleanup;
        }
 
        if (FullInfo->ClassLength > ClassLength)
        {
            ErrorCode = ERROR_INSUFFICIENT_BUFFER;
        }
        else
        {
            RtlCopyMemory(lpClass,
                          FullInfo->Class,
                          FullInfo->ClassLength);
            lpClass[FullInfo->ClassLength / sizeof(WCHAR)] = UNICODE_NULL;
        }
    }
 
    if (lpcClass != NULL)
    {
        *lpcClass = FullInfo->ClassLength / sizeof(WCHAR);
    }
 
Cleanup:
    if (lpClass != NULL)
    {
        RtlFreeHeap(ProcessHeap,
                    0,
                    FullInfo);
    }
 
    ClosePredefKey(KeyHandle);
 
    return ErrorCode;
}

Referenced by _InitializePrintProviderList(), _test_key_deleted(), AddEntryToTree(), BuildLogListAndFilterList(), BuildParameterArray(), ComponentInfo_GetGuidList(), ConCfgReadUserSettings(), CredEnumerateW(), CryptEnumProvidersW(), CryptEnumProviderTypesW(), delete_test_key(), DEVENUM_ReadPins(), DEVENUM_ReadPinTypes(), devinst_RegDeleteTreeW(), DisplayStatus(), enum_values(), EnumHKCRValue(), EnumInterfaces(), get_client_counts(), GetClassMediaFile(), CQueryAssociations::GetCommand(), GetDeviceInstanceListSize(), GetEnumOptions(), CRegistryKey::GetLastWriteTime(), GetLongestChildKeyName(), CRegistryKey::GetMaxValueDataSize(), CRegistryKey::GetMaxValueNameLength(), GetProfileCount(), CRegistryKey::GetSecurityDescriptorLength(), GetServiceInstanceListSize(), CRegistryKey::GetSubkeyCount(), GetSubkeyInfoHelper(), GetUniqueConnectionName(), CRegistryKey::GetValueCount(), InitializePrinterList(), InitializePrintMonitor2(), InitializePrintMonitorList(), InitializePrintProcessorList(), InitIconOverlays(), InitSettings(), InstallerImpl_RegistryValue(), Int_EnumDependentServicesW(), is_key_empty(), lineGetCountryW(), LoadEventSources(), LoadHelpers(), LoadLogFile(), LoadLogFiles(), LocalEnumPrintProcessors(), MCI_SysInfo(), MSACM_RegisterAllDrivers(), MsiSourceListEnumMediaDisksW(), myRegDeleteTreeW(), OleRegEnumVerbs(), OnTreeExpanding(), package_RegDeleteTreeW(), PNP_GetClassCount(), ProcessRunKeys(), ProcessRunOnceEx(), query_all(), QueryInfoHKCRKey(), read_bitmap_patterns(), read_metadata_patterns(), RefreshListView(), RefreshTreeItem(), reg_delete_tree(), RegCopyTreeW(), RegDeleteTreeW(), RegEnumValueA(), RegFindRecurse(), RegFindWalk(), register_legacy_filters(), RegQueryInfoKeyA(), remove_product_upgrade_code(), RemoveEventLog(), run_copy(), RunOnceExInstance::RunOnceExInstance(), RunOnceExSection::RunOnceExSection(), ScmDeleteRegKey(), search_domain_for_zone(), search_for_domain_mapping(), SHCopyKeyW(), SHDeleteEmptyKeyW(), SHDeleteKeyW(), SHDeleteOrphanKeyW(), SHQueryInfoKeyW(), SHRegQueryInfoUSKeyW(), test4(), test_reg_query_info(), TestKeyAccess_(), and txt_export_class_and_last_write().

RegQueryMultipleValuesA()

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

Definition at line 3847 of file reg.c.

{
    ULONG i;
    DWORD maxBytes = *ldwTotsize;
    LPSTR bufptr = lpValueBuf;
    LONG ErrorCode;
 
    if (maxBytes >= (1024*1024))
        return ERROR_MORE_DATA;
 
    *ldwTotsize = 0;
 
    TRACE("RegQueryMultipleValuesA(%p,%p,%ld,%p,%p=%ld)\n",
          hKey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
 
    for (i = 0; i < num_vals; i++)
    {
        val_list[i].ve_valuelen = 0;
        ErrorCode = RegQueryValueExA(hKey,
                                     val_list[i].ve_valuename,
                                     NULL,
                                     NULL,
                                     NULL,
                                     &val_list[i].ve_valuelen);
        if (ErrorCode != ERROR_SUCCESS)
        {
            return ErrorCode;
        }
 
        if (lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
        {
            ErrorCode = RegQueryValueExA(hKey,
                                         val_list[i].ve_valuename,
                                         NULL,
                                         &val_list[i].ve_type,
                                         (LPBYTE)bufptr,
                                         &val_list[i].ve_valuelen);
            if (ErrorCode != ERROR_SUCCESS)
            {
                return ErrorCode;
            }
 
            val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
 
            bufptr += val_list[i].ve_valuelen;
        }
 
        *ldwTotsize += val_list[i].ve_valuelen;
    }
 
    return (lpValueBuf != NULL && *ldwTotsize <= maxBytes) ? ERROR_SUCCESS : ERROR_MORE_DATA;
}

RegQueryMultipleValuesW()

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

Definition at line 3911 of file reg.c.

{
    ULONG i;
    DWORD maxBytes = *ldwTotsize;
    LPSTR bufptr = (LPSTR)lpValueBuf;
    LONG ErrorCode;
 
    if (maxBytes >= (1024*1024))
        return ERROR_MORE_DATA;
 
    *ldwTotsize = 0;
 
    TRACE("RegQueryMultipleValuesW(%p,%p,%ld,%p,%p=%ld)\n",
          hKey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
 
    for (i = 0; i < num_vals; i++)
    {
        val_list[i].ve_valuelen = 0;
        ErrorCode = RegQueryValueExW(hKey,
                                     val_list[i].ve_valuename,
                                     NULL,
                                     NULL,
                                     NULL,
                                     &val_list[i].ve_valuelen);
        if (ErrorCode != ERROR_SUCCESS)
        {
            return ErrorCode;
         }
 
        if (lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
        {
            ErrorCode = RegQueryValueExW(hKey,
                                         val_list[i].ve_valuename,
                                         NULL,
                                         &val_list[i].ve_type,
                                         (LPBYTE)bufptr,
                                         &val_list[i].ve_valuelen);
            if (ErrorCode != ERROR_SUCCESS)
            {
                return ErrorCode;
            }
 
            val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
 
            bufptr += val_list[i].ve_valuelen;
        }
 
        *ldwTotsize += val_list[i].ve_valuelen;
    }
 
    return (lpValueBuf != NULL && *ldwTotsize <= maxBytes) ? ERROR_SUCCESS : ERROR_MORE_DATA;
}

RegQueryReflectionKey()

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

Definition at line 3975 of file reg.c.

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

RegQueryValueA()

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

Definition at line 4212 of file reg.c.

{
    DWORD ret;
    HKEY subkey = hkey;
 
    TRACE("(%p,%s,%p,%d)\n", hkey, debugstr_a(name), data, count ? *count : 0 );
 
    if (name && name[0])
    {
    if ((ret = RegOpenKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
    }
    ret = RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, (LPDWORD)count );
    if (subkey != hkey) RegCloseKey( subkey );
    if (ret == ERROR_FILE_NOT_FOUND)
    {
    /* return empty string if default value not found */
    if (data) *data = 0;
    if (count) *count = 1;
    ret = ERROR_SUCCESS;
    }
    return ret;
}

Referenced by AVIFILE_GetFileHandlerByExtension(), AVIMakeCompressedStream(), debugstr_iid(), HCR_MapTypeToValueA(), OLECONVERT_CreateCompObjStream(), reg_get_typelib_module(), SHRegQueryValueA(), test_device_interface_key(), test_reg_copy_tree(), test_reg_delete_tree(), test_reg_query_value(), test_register_typelib(), and test_RegQueryValueExPerformanceData().

RegQueryValueExA()

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

Definition at line 4009 of file reg.c.

{
    UNICODE_STRING nameW;
    DWORD DataLength;
    DWORD ErrorCode;
    DWORD BufferSize = 0;
    WCHAR* Buffer;
    CHAR* DataStr = (CHAR*)data;
    DWORD LocalType;
 
    /* Validate those parameters, the rest will be done with the first RegQueryValueExW call */
    if ((data && !count) || reserved)
        return ERROR_INVALID_PARAMETER;
 
    if (name)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&nameW, name))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&nameW, NULL, 0);
 
    ErrorCode = RegQueryValueExW(hkeyorg, nameW.Buffer, NULL, &LocalType, NULL, &BufferSize);
    if (ErrorCode != ERROR_SUCCESS)
    {
        if ((!data) && count)
            *count = 0;
        RtlFreeUnicodeString(&nameW);
        return ErrorCode;
    }
 
    /* See if we can directly handle the call without caring for conversion */
    if (!is_string(LocalType) || !count)
    {
        ErrorCode = RegQueryValueExW(hkeyorg, nameW.Buffer, reserved, type, data, count);
        RtlFreeUnicodeString(&nameW);
        return ErrorCode;
    }
 
    /* Allocate a unicode string to get the data */
    Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferSize);
    if (!Buffer)
    {
        RtlFreeUnicodeString(&nameW);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    ErrorCode = RegQueryValueExW(hkeyorg, nameW.Buffer, reserved, type, (LPBYTE)Buffer, &BufferSize);
    if (ErrorCode != ERROR_SUCCESS)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
        RtlFreeUnicodeString(&nameW);
        return ErrorCode;
    }
 
    /* We don't need this anymore */
    RtlFreeUnicodeString(&nameW);
 
    /* Get the length for the multi-byte string (without the terminating NULL!) */
    DataLength = *count;
    RtlUnicodeToMultiByteSize(count, Buffer, BufferSize);
 
    if ((!data) || (DataLength < *count))
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
        return  data ? ERROR_MORE_DATA : ERROR_SUCCESS;
    }
 
    /* We can finally do the conversion */
    RtlUnicodeToMultiByteN(DataStr, DataLength, NULL, Buffer, BufferSize);
 
    /* NULL-terminate if there is enough room */
    if (DataLength > *count)
        DataStr[*count] = '\0';
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 
    return ERROR_SUCCESS;
}

Referenced by _test_reg_key(), check_dirid(), check_reg_dword(), check_reg_entries(), check_reg_multi(), check_reg_str(), CRYPT_GetFuncFromReg(), CRYPT_LoadSIPFuncFromKey(), DirectDrawEnumerateExA(), DirectPlayEnumerateAW(), DllMain(), DP_LoadSP(), expect_LayerValue_imp(), find_default_printer(), FindDfltProvRegVals(), FindProvRegVals(), FindProvTypesRegVals(), font_present(), get_cert_mgr_usages(), get_config_key(), get_config_key_dword(), get_progfiles_dir(), get_program_files_dir(), get_reg_dword(), get_shell_icon_size(), get_system_dirs(), get_user_dirs(), GetAdaptersInfo(), getDhcpInfoForAdapter(), GetDriverName(), GetNetworkParams(), GetNotificationHandler(), HaveDefaultMailClient(), HCR_GetClassNameA(), HCR_RegGetIconA(), IDirectMusic8Impl_GetDefaultPort(), IDirectPlay4AImpl_EnumConnections(), IDirectPlayLobby3AImpl_EnumAddressTypes(), IDirectPlayLobby3AImpl_EnumLocalApplications(), is_ie_hardened(), lffromreg(), lineGetCountryA(), lineGetTranslateCapsA(), main(), Main_DirectDraw_GetDeviceIdentifier7(), metricfromreg(), MIDIMAP_LoadSettings(), MIDIMAP_LoadSettingsScheme(), MMDRV_Init(), MSACM_ReadCache(), NetBTInit(), ODBC_ReplicateODBCInstToRegistry(), ODBC_ReplicateODBCToRegistry(), PrintAdapterDescription(), PrintSystemInfo(), process_pending_renames(), proxy_active(), pub_present(), QueryConfig2A(), r_verify_reg_nonexist(), r_verifyProxyEnable(), read_key_value(), ReadKey(), ReadRegistryComputerNameValue(), ReadRegistryValue(), reg_get_typelib_module(), reg_get_val_str(), RegGetValueA(), RegQueryMultipleValuesA(), RegQueryValueA(), RegReadStringA(), RunApplicationA_EnumLocalApplications(), save_value(), scan_subkeys(), set_lang(), SHGetSettings(), SHOpenRegStream2A(), SHPinDllOfCLSID(), SHQueryValueExA(), SHRegQueryUSValueA(), SmoothScrollWindow(), spy_init(), START_TEST(), test_autocreation(), test_basic_import(), test_basic_import_unicode(), test_child_heap(), test_enumdisplaydevices_adapter(), test_export(), test_get_profiles_dir(), test_GetAcceptLanguagesA(), test_ICInfo(), test_import(), test_install_services(), test_Installer_InstallProduct(), test_installprops(), test_machine_guid(), test_mixed_package(), test_MsiConfigureProductEx(), test_MsiInstallProduct(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_NonExistentPath(), test_null(), test_process_components(), test_publish(), test_publish_components(), test_reg_binary(), test_reg_dword(), test_register_font(), test_register_product(), test_registerDefaultOIDFunction(), test_registerOIDInfo(), test_registrar(), test_registry(), test_RegPolicyFlags(), test_remove_upgrade_code(), test_SHGetFolderPathA(), test_SQLInstallDriverEx(), test_SQLInstallTranslatorEx(), test_unicode_import(), test_url_action(), test_write_registry_values(), test_XcvDataPort_ConfigureLPTPortCommandOK(), test_XcvDataPort_GetTransmissionRetryTimeout(), testRegStore(), uniquecontainer(), UXTHEME_RestoreSystemMetrics(), verify_reg_(), verify_reg_nonexist_(), WhichPlatform(), WINTRUST_ReadProviderFromReg(), and WNetGetCachedPassword().

RegQueryValueExW()

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

Definition at line 4103 of file reg.c.

{
    HANDLE hkey;
    NTSTATUS status;
    UNICODE_STRING name_str;
    DWORD total_size;
    char buffer[256], *buf_ptr = buffer;
    KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
    static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
 
    TRACE("(%p,%s,%p,%p,%p,%p=%d)\n",
          hkeyorg, debugstr_w(name), reserved, type, data, count,
          (count && data) ? *count : 0 );
 
    if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
 
    status = MapDefaultKey(&hkey, hkeyorg);
    if (!NT_SUCCESS(status))
    {
        return RtlNtStatusToDosError(status);
    }
 
    if (IsHKCRKey(hkey))
    {
        LONG ErrorCode = QueryHKCRValue(hkey, name, reserved, type, data, count);
        ClosePredefKey(hkey);
        return ErrorCode;
    }
 
    RtlInitUnicodeString( &name_str, name );
 
    if (data)
        total_size = min( sizeof(buffer), *count + info_size );
    else
        total_size = info_size;
 
 
    status = NtQueryValueKey( hkey, &name_str, KeyValuePartialInformation,
                              buffer, total_size, &total_size );
 
    if (!NT_SUCCESS(status) && status != STATUS_BUFFER_OVERFLOW)
    {
        // NT: Valid handles with inexistant/null values or invalid (but not NULL) handles sets type to REG_NONE
        // On windows these conditions are likely to be side effects of the implementation...
        if (status == STATUS_INVALID_HANDLE && hkey)
        {
            if (type) *type = REG_NONE;
            if (count) *count = 0;
        }
        else if (status == STATUS_OBJECT_NAME_NOT_FOUND)
        {
            if (type) *type = REG_NONE;
            if (data == NULL && count) *count = 0;
        }
        goto done;
    }
 
    if (data)
    {
        /* retry with a dynamically allocated buffer */
        while (status == STATUS_BUFFER_OVERFLOW && total_size - info_size <= *count)
        {
            if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
            if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
            {
                ClosePredefKey(hkey);
                return ERROR_NOT_ENOUGH_MEMORY;
            }
            info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
            status = NtQueryValueKey( hkey, &name_str, KeyValuePartialInformation,
                                      buf_ptr, total_size, &total_size );
        }
 
        if (NT_SUCCESS(status))
        {
            memcpy( data, buf_ptr + info_size, total_size - info_size );
            /* if the type is REG_SZ and data is not 0-terminated
             * and there is enough space in the buffer NT appends a \0 */
            if (is_string(info->Type) && total_size - info_size <= *count-sizeof(WCHAR))
            {
                WCHAR *ptr = (WCHAR *)(data + total_size - info_size);
                if (ptr > (WCHAR *)data && ptr[-1]) *ptr = 0;
            }
        }
        else if (status != STATUS_BUFFER_OVERFLOW) goto done;
    }
    else status = STATUS_SUCCESS;
 
    if (type) *type = info->Type;
    if (count) *count = total_size - info_size;
 
 done:
    if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
    ClosePredefKey(hkey);
    return RtlNtStatusToDosError(status);
}

Referenced by _enumeratorRememberedW(), _InitializeLocalSpooler(), _InitializePrintProviderList(), _LocalGetPrinterHandleData(), _LocalGetPrintServerHandleData(), _SHGetCurrentVersionPath(), _SHGetProfilesValue(), _SHGetUserShellFolderPath(), _SHRegisterFolders(), _test_hkey_main_Value_W(), _tryLoadProvider(), AddInstallationSource(), AddNotificationDll(), AddPrintMonitorList(), AddSoundProfile(), AddUserProfile(), AllocAndRegQueryWSZ(), append_multi_sz_value(), AppendStringToMultiSZ(), AssocQ(), BuildLogListAndFilterList(), BuildVolatileEnvironment(), cache_container_set_size(), capGetDriverDescriptionW(), CheckForLiveCD(), CheckLogOrSourceExistence(), ChooseFavorite(), CliGetPreloadKeyboardLayouts(), CliReadRegistryValue(), COM_OpenKeyForAppIdFromCLSID(), COMCAT_GetCategoryDesc(), ComDBClaimNextFreePort(), ComDBClaimPort(), ComDBGetCurrentPortUsage(), ComDBOpen(), ComDBReleasePort(), ComDBResizeDatabase(), comp_find_package(), comp_find_prodcode(), ComponentInfo_GetStringValue(), connections_on_initdialog(), create_local_service(), create_mru_list(), create_server(), CreateEnvironmentBlock(), CAppDB::CreateInstalledAppByRegistryKey(), CreateNewValue(), CreateNotificationObject(), CreateServiceListEntry(), CreateTempDir(), CreateUserProfileExW(), CriticalDeviceCoInstaller(), CRYPT_CreateMachineGuid(), CRYPT_GetDefaultOIDDlls(), CRYPT_GetFuncFromReg(), CRYPT_LoadSIPFuncFromKey(), CRYPT_RegReadSerializedFromReg(), CryptAcquireContextW(), CRYPTDLG_CheckOnlineCRL(), CryptEnumProvidersW(), CryptEnumProviderTypesW(), CryptGetDefaultOIDDllList(), CryptGetDefaultProviderW(), CryptGetOIDFunctionValue(), DecrementRefCount(), delete_multi_sz_value(), DeleteExt(), DeleteProfileW(), DEVENUM_IPropertyBag_Read(), DEVENUM_ReadPins(), DIALOG_Execute(), DIALOG_ProgramAttributes(), DirectPlayEnumerateAW(), DisableShellext(), CNetConnection::Disconnect(), DllMain(), DMOGetName(), do_reg_operation(), DoTestComputerName(), DRIVER_GetLibName(), EditTypeDlg_ReadClass(), EnumClientServiceProtocol(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), EnumerateSoundProfiles(), EnumHKCRValue(), FileTypesDlg_InsertToLV(), FillList(), FillServerAddressCombo(), find_fallback_font(), find_mime_from_ext(), FindNetworkAdapter(), ForceFriendlyUI(), FTP_Connect(), get_action_policy(), get_config_key_as_dword(), get_config_key_dword(), get_config_key_string(), get_cred_mgr_encryption_key(), get_default_proxy_reg_value(), get_dest_dir(), get_dword_from_reg(), get_feature_from_reg(), get_fusion_filename(), get_install_root(), get_language_sort(), get_mime_clsid(), get_mime_filter(), get_mmioFromProfile(), get_mono_path_from_registry(), get_object_dll_path(), get_protocol_cf(), get_ps_clsid_from_registry(), get_reg_str(), get_shared_dlls_count(), get_string_from_reg(), get_threading_model(), get_url_encoding(), get_zone_for_scheme(), get_zone_from_reg(), GetAcceptLanguagesW(), GetActivePwrScheme(), GetAdapterFriendlyName(), GetAllocatedResourceList(), GetAllUsersProfileDirectoryW(), CInstalledApplicationInfo::GetApplicationRegDword(), GetAutoDaylight(), GetBooleanRegValue(), GetBooleanValue(), GetBootResourceList(), GetClassMediaFile(), GetComputerNameExW(), GetComputerNames(), GetConfigurationData(), GetCurrentDPI(), GetCurrentHwProfileW(), GetCurrentLoggedOnUserName(), CInputProcessorProfiles::GetDefaultLanguageProfile(), GetDefaultPrinterFromRegistry(), GetDefaultPrinterW(), GetDefaultUserProfileDirectoryW(), GetDesktopPath(), getDhcpInfoForAdapter(), GetDisplayNameFileAndID(), GetDWordValue(), GetDynamicTimeZoneInformationEffectiveYears(), GetEventMessageFileDLL(), GetFileTypeIconsByKey(), GetFindFlags(), GetGinaPath(), GetHotPlugFlags(), GetInterfaceFriendlyName(), GetInterfaceNameInternal(), GetIntervalSetting(), GetIntValue(), GetJapaneseUninstallCmdLine(), GetLayoutCount(), GetLayoutName(), GetLongValue(), GetLPTTransmissionRetryTimeout(), GetPerAdapterInfo(), GetPolicyValues(), GetPortType(), GetProfile(), GetProfilesDirectoryW(), GetProfileType(), GetProgramsPath(), CNetConnection::GetProperties(), GetPwrDiskSpindownRange(), GetRegDWORD(), GetRegInt(), GetRegistrySettings(), GetRegValue(), GetServiceInstanceList(), GetServiceInstanceListSize(), GetServiceMainFunctions(), CSysTray::GetServicesEnabled(), GetSettings(), GetSetupType(), GetShell(), GetShutdownReasonUI(), GetStringValue(), GetSyncSetting(), GetTimeZoneInformationForYear(), GetTimeZoneListIndex(), GetTypeName(), GetUserDefaultGeoName(), GetUserGeoID(), GetUserProfileDirectoryW(), GetUserWaitInterval(), go_home(), HandleLogon(), CDeviceNode::HasResources(), HCR_GetClassNameW(), HCR_GetFolderAttributes(), HCR_RegGetIconW(), HlinkGetSpecialReference(), I_CryptReadTrustedPublisherDWORDValueFromRegistry(), IEnumDMO_fnNext(), ImageView_LoadSettings(), Imm32GetImeLayoutList(), Imm32IsCUASEnabledInRegistry(), Imm32IsTIMDisabledInRegistry(), Imm32WriteImeLayout(), ImmLoadLayout(), ImportAppProfile(), ImportSoundLabel(), IncrementRefCount(), INetCfgLock_fnAcquireWriteLock(), INetCfgLock_fnIsWriteLocked(), init_driver(), init_locale(), InitAudioDlg(), InitControl(), InitializeDefaultUserLocale(), InitializePrinterList(), InitializePrintProcessorList(), InitKeyboardLayouts(), InitPropertiesDlg(), InitSettings(), InitWorkstationInfo(), InputList_FindPreloadKLID(), InstallDevice(), InstallerImpl_RegistryValue(), InstallOneService(), Int_EnumDependentServicesW(), INTERNET_LoadProxySettings(), IntGetIcdData(), IntLoadKeyboardLayout(), IntLoadPreloadKeyboardLayouts(), CInputProcessorProfiles::IsEnabledLanguageProfile(), IsExplorerSystemShell(), IsFriendlyUIActive(), IsInternetESCEnabledLocal(), IsLayoutExists(), IsShortcut(), IsShowHibernateButtonActive(), IsThemeActive(), IsValidLanguageGroup(), IsWindowsOS(), ITERATE_FindRelatedProducts(), ITERATE_RemoveEnvironmentString(), ITERATE_WriteEnvironmentString(), KLIDFromSpecialHKL(), LayoutList_ReadLayout(), lineGetCountryW(), COpenWithList::Load(), load_mapi_provider(), load_mapi_providers(), load_mapping_settings(), load_provider(), load_wine_gecko_v(), LoadAdvancedSettings(), LoadBoard(), CNewMenu::LoadCachedItems(), LoadCurrentLocale(), LoadDNSSettings(), LoadDWORDFromRegistry(), LoadEventLabel(), LoadFilterSettings(), LoadInstallableVDD(), LoadLogFile(), LoadRecoveryOptions(), LoadRegistrySettings(), LoadSchemeFromReg(), LoadSettings(), LoadShutdownSelState(), LoadSMBiosData(), LoadStringFromRegistry(), LoadTcpFilterSettingsFromRegistry(), LoadUsernameHint(), LocalAddForm(), LocalAddMonitor(), LocalDeleteForm(), locale_return_reg_string(), LocalGetPrintProcessorDirectory(), LocalSetForm(), main(), MAIN_AutoStart(), MAIN_CreateMainWindow(), MAIN_LoadSettings(), MakeService(), MCI_GetDevTypeFromFileName(), MIDIMAP_LoadSettings(), MIDIMAP_LoadSettingsScheme(), MMDevEnum_GetDefaultAudioEndpoint(), MMSYS_InstallDevice(), ModifyStatus(), ModifyValue(), MouseOnDialogInit(), MSACM_RegisterDriverFromRegistry(), MSACM_ReorderDriversByPriority(), msi_reg_get_val_dword(), msi_reg_get_val_str(), MsiSourceListEnumSourcesW(), MsiSourceListGetInfoW(), NetBTInit(), NetIDPage_OnApply(), NetIDPage_OnInitDialog(), CEnumRegKey::NextValue(), notif_thread_proc(), notify_if_changed(), OleRegGetUserType(), OLEUTL_ReadRegistryDWORDValue(), OpenHostsFile(), pendingRename(), PNP_AddID(), PNP_GetClassName(), PNP_GetClassRegProp(), PNP_GetCustomDevProp(), PNP_GetDeviceRegProp(), PNP_GetHwProfInfo(), PNP_HwProfFlags(), PNP_IsDockStationPresent(), PopulateCustomPathCombo(), POWRPROF_GetMachinePowerPolicy(), POWRPROF_GetUserPowerPolicy(), PrintOSVersion(), process_args_from_reg(), process_extensions(), ProcessPage_OnDebug(), ProcessPageShowContextMenu(), query_reg_path(), query_value(), QueryAppSettings(), QueryConfig2W(), QueryHKCRValue(), QueryKeyValue(), QueryNameServer(), QueryRegistryValue(), QueryStringValue(), QueryTimeZoneData(), QueryUserRegValueW(), read_credential_blob(), read_key(), read_oid_info(), read_types(), ReadAttributes(), ReadBindingString(), ReadCabinetState(), ReadGlobalPwrPolicy(), ReadKeysSettings(), ReadPortSettings(), ReadProcessorPwrScheme(), ReadRegDwordValue(), ReadRegistryValue(), ReadRegSzKey(), ReadRegSzValue(), ReadSZFlagsFromRegistry(), reg_get_multisz(), reg_get_sz(), reg_get_value(), RegFindRecurse(), RegGetDWORD(), RegGetDWORDValue(), RegGetSZ(), RegGetValueW(), register_legacy_filters(), registry_credential_matches_filter(), registry_read_credential(), registry_read_filelist(), registry_read_formatopts(), registry_read_maximized(), registry_read_pagemargins(), registry_read_previewpages(), registry_read_winrect(), RegistryPropertyBag_IPropertyBag_Read(), RegLoadMUIStringW(), RegQueryDword(), RegQueryMultipleValuesW(), RegQueryValueExA(), RegQueryValueW(), RegQueryValueWithAlloc(), RegReadStringW(), RegTGetDwordValue(), RegTGetStringValue(), RegValueExists(), RenameValue(), ReportProductInfoEvent(), ReturnNtProduct(), RQueryServiceConfig2A(), RQueryServiceConfig2W(), run_add(), run_copy(), RunningOnLiveMedium(), RunSetupThreadProc(), SampIsSetupRunning(), ScmAssignNewTag(), ScmAutoStartServices(), ScmCreateNewControlPipe(), ScmGetControlSetValues(), ScmGetNoInteractiveServicesValue(), ScmGetSetupInProgress(), ScmInitNamedPipeCriticalSection(), ScmIsDeleteFlagSet(), ScmReadSecurityDescriptor(), ScmReadString(), ScmSetFailureActions(), SdbUninstallByGuid(), SdbUninstallByName(), search_reg(), SECUR32_initializeProviders(), SelectExtOnRename(), set_installer_properties(), SetAutoAdminLogon(), SetComputerNameExW(), SetDefaultLanguage(), SetDefaultPrinterW(), SetHKCRValue(), SetKeyboardLayoutName(), SetRegTextData(), SetTime(), SETUP_CreateInterfaceList(), SETUP_GetClassIconInfo(), SETUP_GetIconIndex(), SETUP_GetValueString(), SETUPAPI_GetCurrentHwProfile(), SetupDeviceInstance(), SETUPDI_CreateDrvKey(), SETUPDI_OpenDrvKey(), SetupDiBuildClassInfoListExW(), SetupDiCallClassInstaller(), SetupDiChangeState(), SetupDiClassGuidsFromNameExW(), SetupDiGetDeviceRegistryPropertyW(), SetupDiOpenDeviceInfoW(), SetupDiOpenDeviceInterfaceW(), SetupIsActive(), CClassNode::SetupNode(), SetUserSysColors(), SetUserWallpaper(), SetWelcomeText(), SHDOCVW_GetShellInstanceObjectClassObject(), SHELL_FS_HideExtension(), SHELL_IsShortcut(), ShellShutdownDialog(), SHLoadRegUIStringW(), SHOpenRegStream2W(), SHPropertyBag_OnRegKey(), SHQueryValueExW(), SHRegQueryUSValueW(), SHRegWriteUSValueW(), SockLoadHelperDll(), SockLoadTransportList(), SockLoadTransportMapping(), START_TEST(), StartScreenSaver(), StartShell(), tapiGetLocationInfoW(), test4(), test_BCryptGetFipsAlgorithmMode(), test_CallForAttributes(), Test_KLID(), test_readTrustedPublisherDWORD(), test_RegQueryValueExPerformanceData(), test_save(), test_set_value(), test_setvalue_on_wow64(), TestInterfaceRegistry(), TestModuleRegistry(), TOOLBAR_Restore(), TRASH_CanTrashFile(), try_application_url(), UniformResourceLocatorW_InvokeCommand(), UnloadServiceDll(), UnloadUserProfile(), UpdateTcpIpInformation(), url_apply_default_scheme(), URL_ApplyDefault(), UserInstStubWrapperW(), UsersPageProc(), UXTHEME_LoadTheme(), UXTHEME_RestoreSystemMetrics(), W32TmServiceMain(), WinHttpGetDefaultProxyConfiguration(), WinHttpGetIEProxyConfigForCurrentUser(), WINTRUST_ReadProviderFromReg(), WintrustGetRegPolicyFlags(), Winver_GetRegValueString(), WlxActivateUserShell(), WlxScreenSaverNotify(), wnetInit(), WsNcEntryInitializeFromRegistry(), and wWinMain().

RegQueryValueW()

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

Definition at line 4241 of file reg.c.

{
    DWORD ret;
    HKEY subkey = hkey;
 
    TRACE("(%p,%s,%p,%d)\n", hkey, debugstr_w(name), data, count ? *count : 0 );
    if (hkey == NULL)
    {
       return ERROR_INVALID_HANDLE;
    }
    if (name && name[0])
    {
        ret = RegOpenKeyW( hkey, name, &subkey);
        if (ret != ERROR_SUCCESS)
        {
            return ret;
        }
    }
 
    ret = RegQueryValueExW( subkey, NULL, NULL, NULL, (LPBYTE)data, (LPDWORD)count );
 
    if (subkey != hkey)
    {
        RegCloseKey( subkey );
    }
 
    if (ret == ERROR_FILE_NOT_FOUND)
    {
        /* return empty string if default value not found */
        if (data)
            *data = 0;
        if (count)
            *count = sizeof(WCHAR);
        ret = ERROR_SUCCESS;
    }
    return ret;
}

Referenced by AVIBuildFilterW(), clsid_from_string_reg(), CoGetTreatAsClass(), CoTreatAsClass(), dde_connect(), EnumOLEVERB_Next(), execute_from_key(), get_engine_clsid(), GetClassFile(), HCR_GetDefaultVerbW(), HCR_MapTypeToValueW(), OleGetAutoConvert(), ProgIDFromCLSID(), query_typelib_path(), SHELL_FindExecutable(), SHELL_FindExecutableByVerb(), SHELL_FS_HideExtension(), SHRegQueryValueW(), test_reg_query_value(), test_WritePwrScheme(), and UIINSERTOBJECTDLG_PopulateObjectTypes().

RegReplaceKeyA()

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

Definition at line 4286 of file reg.c.

{
    UNICODE_STRING SubKey;
    UNICODE_STRING NewFile;
    UNICODE_STRING OldFile;
    LONG ErrorCode;
 
    RtlInitEmptyUnicodeString(&SubKey, NULL, 0);
    RtlInitEmptyUnicodeString(&OldFile, NULL, 0);
    RtlInitEmptyUnicodeString(&NewFile, NULL, 0);
 
    if (lpSubKey)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&SubKey, lpSubKey))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    if (lpOldFile)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&OldFile, lpOldFile))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    if (lpNewFile)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&NewFile, lpNewFile))
        {
            ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
    }
 
    ErrorCode = RegReplaceKeyW(hKey,
                               SubKey.Buffer,
                               NewFile.Buffer,
                               OldFile.Buffer);
 
Exit:
    RtlFreeUnicodeString(&OldFile);
    RtlFreeUnicodeString(&NewFile);
    RtlFreeUnicodeString(&SubKey);
 
    return ErrorCode;
}

RegReplaceKeyW()

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

Definition at line 4347 of file reg.c.

{
    OBJECT_ATTRIBUTES KeyObjectAttributes;
    OBJECT_ATTRIBUTES NewObjectAttributes;
    OBJECT_ATTRIBUTES OldObjectAttributes;
    UNICODE_STRING SubKeyName;
    UNICODE_STRING NewFileName;
    UNICODE_STRING OldFileName;
    BOOLEAN CloseRealKey;
    HANDLE RealKeyHandle;
    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);
    }
 
    /* Open the real key */
    if (lpSubKey != NULL && *lpSubKey != (WCHAR)0)
    {
        RtlInitUnicodeString(&SubKeyName, lpSubKey);
        InitializeObjectAttributes(&KeyObjectAttributes,
                                   &SubKeyName,
                                   OBJ_CASE_INSENSITIVE,
                                   KeyHandle,
                                   NULL);
        Status = NtOpenKey(&RealKeyHandle,
                           MAXIMUM_ALLOWED,
                           &KeyObjectAttributes);
        if (!NT_SUCCESS(Status))
        {
            ErrorCode = RtlNtStatusToDosError(Status);
            goto Cleanup;
        }
 
        CloseRealKey = TRUE;
    }
    else
    {
        RealKeyHandle = KeyHandle;
        CloseRealKey = FALSE;
    }
 
    /* Convert new file name */
    if (!RtlDosPathNameToNtPathName_U(lpNewFile,
                                      &NewFileName,
                                      NULL,
                                      NULL))
    {
        if (CloseRealKey)
        {
            NtClose(RealKeyHandle);
        }
 
        ErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    InitializeObjectAttributes(&NewObjectAttributes,
                               &NewFileName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    /* Convert old file name */
    if (!RtlDosPathNameToNtPathName_U(lpOldFile,
                                      &OldFileName,
                                      NULL,
                                      NULL))
    {
        RtlFreeHeap(RtlGetProcessHeap (),
                    0,
                    NewFileName.Buffer);
        if (CloseRealKey)
        {
            NtClose(RealKeyHandle);
        }
 
        ErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    InitializeObjectAttributes(&OldObjectAttributes,
                               &OldFileName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtReplaceKey(&NewObjectAttributes,
                          RealKeyHandle,
                          &OldObjectAttributes);
 
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                OldFileName.Buffer);
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                NewFileName.Buffer);
 
    if (CloseRealKey)
    {
        NtClose(RealKeyHandle);
    }
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    return ErrorCode;
}

Referenced by RegReplaceKeyA().

RegRestoreKeyA()

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

Definition at line 4481 of file reg.c.

{
    UNICODE_STRING FileName;
    LONG ErrorCode;
 
    if (lpFile)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFile))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&FileName, NULL, 0);
 
    ErrorCode = RegRestoreKeyW(hKey,
                               FileName.Buffer,
                               dwFlags);
 
    RtlFreeUnicodeString(&FileName);
 
    return ErrorCode;
}

RegRestoreKeyW()

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

Definition at line 4512 of file reg.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING FileName;
    HANDLE FileHandle;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    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))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &FileName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        FILE_GENERIC_READ,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                FileName.Buffer);
    if (!NT_SUCCESS(Status))
    {
        goto Cleanup;
    }
 
    Status = NtRestoreKey(KeyHandle,
                          FileHandle,
                          (ULONG)dwFlags);
    NtClose (FileHandle);
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by RegRestoreKeyA().

RegSaveKeyA()

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

Definition at line 4587 of file reg.c.

{
    UNICODE_STRING FileName;
    LONG ErrorCode;
 
    if (lpFile)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFile))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&FileName, NULL, 0);
 
    ErrorCode = RegSaveKeyW(hKey,
                            FileName.Buffer,
                            lpSecurityAttributes);
    RtlFreeUnicodeString(&FileName);
 
    return ErrorCode;
}

Referenced by test_reg_save_key().

RegSaveKeyExA()

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

Definition at line 4697 of file reg.c.

{
    UNICODE_STRING FileName;
    LONG ErrorCode;
 
    if (lpFile)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFile))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&FileName, NULL, 0);
 
    ErrorCode = RegSaveKeyExW(hKey,
                              FileName.Buffer,
                              lpSecurityAttributes,
                              Flags);
    RtlFreeUnicodeString(&FileName);
 
    return ErrorCode;
}

RegSaveKeyExW()

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

Definition at line 4730 of file reg.c.

{
    switch (Flags)
    {
        case REG_STANDARD_FORMAT:
        case REG_LATEST_FORMAT:
        case REG_NO_COMPRESSION:
            break;
        default:
            return ERROR_INVALID_PARAMETER;
    }
 
    FIXME("RegSaveKeyExW(): Flags ignored!\n");
 
    return RegSaveKeyW(hKey,
                       lpFile,
                       lpSecurityAttributes);
}

Referenced by RegSaveKeyExA(), and SaveDefaultUserHive().

RegSaveKeyW()

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

Definition at line 4617 of file reg.c.

{
    PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING FileName;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE FileHandle;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (!RtlDosPathNameToNtPathName_U(lpFile,
                                      &FileName,
                                      NULL,
                                      NULL))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    if (lpSecurityAttributes != NULL)
    {
        SecurityDescriptor = lpSecurityAttributes->lpSecurityDescriptor;
    }
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &FileName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               SecurityDescriptor);
    Status = NtCreateFile(&FileHandle,
                          GENERIC_WRITE | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          FILE_ATTRIBUTE_NORMAL,
                          FILE_SHARE_READ,
                          FILE_CREATE,
                          FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
                          NULL,
                          0);
    RtlFreeHeap(RtlGetProcessHeap(),
                0,
                FileName.Buffer);
    if (!NT_SUCCESS(Status))
    {
        goto Cleanup;
    }
 
    Status = NtSaveKey(KeyHandle,
                       FileHandle);
    NtClose (FileHandle);
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by ExportRegistryFile(), RegSaveKeyA(), and RegSaveKeyExW().

RegSetKeySecurity()

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

Definition at line 4759 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))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    Status = NtSetSecurityObject(KeyHandle,
                                 SecurityInformation,
                                 pSecurityDescriptor);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by AccRewriteSetHandleRights(), and ATL::CRegKey::SetKeySecurity().

RegSetKeyValueA()

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

Definition at line 2210 of file reg.c.

{
    HANDLE KeyHandle, CurKey, SubKeyHandle = NULL;
    NTSTATUS Status;
    LONG Ret;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (lpSubKey != NULL)
    {
        OBJECT_ATTRIBUTES ObjectAttributes;
        UNICODE_STRING SubKeyName;
 
        if (!RtlCreateUnicodeStringFromAsciiz(&SubKeyName, lpSubKey))
        {
            Ret = ERROR_NOT_ENOUGH_MEMORY;
            goto Cleanup;
        }
 
        InitializeObjectAttributes(&ObjectAttributes,
                                   &SubKeyName,
                                   OBJ_CASE_INSENSITIVE,
                                   KeyHandle,
                                   NULL);
 
        Status = NtOpenKey(&SubKeyHandle,
                           KEY_SET_VALUE,
                           &ObjectAttributes);
 
        RtlFreeUnicodeString(&SubKeyName);
 
        if (!NT_SUCCESS(Status))
        {
            Ret = RtlNtStatusToDosError(Status);
            goto Cleanup;
        }
 
        CurKey = SubKeyHandle;
    }
    else
        CurKey = KeyHandle;
 
    Ret = RegSetValueExA(CurKey,
                         lpValueName,
                         0,
                         dwType,
                         lpData,
                         cbData);
 
    if (SubKeyHandle != NULL)
    {
        NtClose(SubKeyHandle);
    }
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    return Ret;
}

RegSetKeyValueW()

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

Definition at line 2139 of file reg.c.

{
    HANDLE KeyHandle, CurKey, SubKeyHandle = NULL;
    NTSTATUS Status;
    LONG Ret;
 
    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))
        {
            Ret = RtlNtStatusToDosError(Status);
            goto Cleanup;
        }
 
        CurKey = SubKeyHandle;
    }
    else
        CurKey = KeyHandle;
 
    Ret = RegSetValueExW(CurKey,
                         lpValueName,
                         0,
                         dwType,
                         lpData,
                         cbData);
 
    if (SubKeyHandle != NULL)
    {
        NtClose(SubKeyHandle);
    }
 
Cleanup:
    ClosePredefKey(KeyHandle);
 
    return Ret;
}

Referenced by set_registry_entry(), update_registry_value(), and WshShell3_RegWrite().

RegSetValueA()

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

Definition at line 4954 of file reg.c.

{
    HKEY subkey;
    HANDLE hKey;
    DWORD ret;
    NTSTATUS Status;
 
    TRACE("(%p,%s,%d,%s,%d)\n", hKeyOriginal, debugstr_a(lpSubKey), dwType, debugstr_a(lpData), cbData );
 
    if (dwType != REG_SZ || !lpData) return ERROR_INVALID_PARAMETER;
 
    Status = MapDefaultKey(&hKey, hKeyOriginal);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError (Status);
    }
    subkey = hKey;
 
    if (lpSubKey && lpSubKey[0])  /* need to create the subkey */
    {
        ret = RegCreateKeyA(hKey, lpSubKey, &subkey);
        if (ret != ERROR_SUCCESS)
            goto Cleanup;
    }
 
    ret = RegSetValueExA( subkey, NULL, 0, REG_SZ, (const BYTE*)lpData, strlen(lpData)+1 );
    if (subkey != hKey)
        RegCloseKey(subkey);
 
Cleanup:
    ClosePredefKey(hKey);
 
    return ret;
}

Referenced by init_key(), register_server(), register_testentry(), test_appsearch_reglocator(), test_device_interface_key(), test_getstring_no_extra(), test_null(), test_reg_copy_tree(), test_reg_delete_tree(), test_reg_query_value(), test_RegQueryValueExPerformanceData(), and test_set_value().

RegSetValueExA()

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

Definition at line 4799 of file reg.c.

{
    UNICODE_STRING ValueName;
    LPWSTR pValueName;
    ANSI_STRING AnsiString;
    UNICODE_STRING Data;
    LONG ErrorCode;
    LPBYTE pData;
    DWORD DataSize;
    NTSTATUS Status;
 
    /* Convert SubKey name to Unicode */
    if (lpValueName != NULL && lpValueName[0] != '\0')
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&ValueName, lpValueName))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
    {
        ValueName.Buffer = NULL;
    }
 
    pValueName = (LPWSTR)ValueName.Buffer;
 
 
    if (is_string(dwType) && (cbData != 0))
    {
        /* Convert ANSI string Data to Unicode */
        /* If last character NOT zero then increment length */
        LONG bNoNulledStr = ((lpData[cbData-1] != '\0') ? 1 : 0);
        AnsiString.Buffer = (PSTR)lpData;
        AnsiString.Length = cbData + bNoNulledStr;
        AnsiString.MaximumLength = cbData + bNoNulledStr;
        Status = RtlAnsiStringToUnicodeString(&Data,
                                     &AnsiString,
                                     TRUE);
 
        if (!NT_SUCCESS(Status))
        {
            if (pValueName != NULL)
                RtlFreeUnicodeString(&ValueName);
 
            return RtlNtStatusToDosError(Status);
        }
        pData = (LPBYTE)Data.Buffer;
        DataSize = cbData * sizeof(WCHAR);
    }
    else
    {
        Data.Buffer = NULL;
        pData = (LPBYTE)lpData;
        DataSize = cbData;
    }
 
    ErrorCode = RegSetValueExW(hKey,
                               pValueName,
                               Reserved,
                               dwType,
                               pData,
                               DataSize);
 
    if (pValueName != NULL)
        RtlFreeUnicodeString(&ValueName);
 
    if (Data.Buffer != NULL)
        RtlFreeUnicodeString(&Data);
 
    return ErrorCode;
}

Referenced by add_value_(), crash_and_debug(), crash_and_winedbg(), create_test_association(), create_test_class(), create_test_entries(), create_test_verb_dde(), CryptRegisterOIDFunction(), ICInstall(), IntSetupDiSetDeviceRegistryPropertyAW(), IStream_fnRelease(), lineGetTranslateCapsA(), MSACM_WriteCache(), NdrDllRegisterProxy(), ODBC_ReplicateODBCInstToRegistry(), ODBC_ReplicateODBCToRegistry(), process_pending_renames(), reg_unreg_wine_test_class(), register_coclasses(), register_codepages(), register_converters(), register_decoders(), register_encoders(), register_interfaces(), register_key_defvalueA(), register_keys(), register_mediatypes_parsing(), register_metadatareaders(), register_pixelformats(), register_progid(), register_zone_domains(), RegSetKeyValueA(), RegSetValueA(), reset_adapter(), restore_value(), save_cert_mgr_usages(), save_sys_colors(), set_component_path(), set_domain(), set_name_servers(), setLayerValue(), setup_adapter(), SHSetValueA(), SQLRemoveDriverW(), SQLRemoveTranslatorW(), START_TEST(), store_key_pair(), store_key_permissions(), test_appsearch(), test_appsearch_reglocator(), test_CoGetPSClsid(), test_debug_heap(), test_envvar(), test_ExitCode(), test_GetAcceptLanguagesA(), test_internet_features_registry(), test_machine_guid(), test_MsiConfigureProductEx(), test_MsiEnumClients(), test_MsiEnumComponentsEx(), test_MsiEnumPatches(), test_MsiEnumPatchesEx_machine(), test_MsiEnumPatchesEx_usermanaged(), test_MsiEnumPatchesEx_userunmanaged(), 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_MsiSourceListAddSource(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListGetInfo(), test_NonExistentPath(), test_null(), test_OleRegGetUserType(), test_publish_components(), test_registry(), test_write_registry_values(), test_XcvDataPort_ConfigureLPTPortCommandOK(), test_XcvDataPort_GetTransmissionRetryTimeout(), test_zone_domain_cache(), testRegStore(), WhichPlatform(), WNetCachePassword(), write_registry_values(), and WriteRegistryValue().

RegSetValueExW()

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

Definition at line 4882 of file reg.c.

{
    UNICODE_STRING ValueName;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    Status = MapDefaultKey(&KeyHandle,
                           hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    if (IsHKCRKey(KeyHandle))
    {
        LONG ErrorCode = SetHKCRValue(KeyHandle, lpValueName, Reserved, dwType, lpData, cbData);
        ClosePredefKey(KeyHandle);
        return ErrorCode;
    }
 
    if (is_string(dwType) && (cbData != 0))
    {
        PWSTR pwsData = (PWSTR)lpData;
 
        _SEH2_TRY
        {
            if((pwsData[cbData / sizeof(WCHAR) - 1] != L'\0') &&
                (pwsData[cbData / sizeof(WCHAR)] == L'\0'))
            {
                /* Increment length if last character is not zero and next is zero */
                cbData += sizeof(WCHAR);
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Do not fail if we fault where we were told not to go */
        }
        _SEH2_END;
    }
 
    RtlInitUnicodeString(&ValueName, lpValueName);
 
    Status = NtSetValueKey(KeyHandle,
                           &ValueName,
                           0,
                           dwType,
                           (PVOID)lpData,
                           (ULONG)cbData);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by _HandleAddPort(), _HandleConfigureLPTPortCommandOK(), _InitializeLocalSpooler(), _LocalSetPrinterHandleData(), _LocalSetPrintServerHandleData(), _RegSetStringValueW(), _SHGetCurrentVersionPath(), _SHGetProfilesValue(), _SHGetUserShellFolderPath(), _SHRegisterFolders(), _tmain(), ACTION_MsiPublishAssemblies(), ACTION_PublishFeatures(), add_userkey(), AddERExcludedApplicationW(), AddInstallationSource(), CInputProcessorProfiles::AddLanguageProfile(), AddNewLayout(), AddToFavoritesDlgProc(), AddUninstallKey(), append_multi_sz_value(), AppendStringToMultiSZ(), ApplyChanges(), ApplyOrCancelChanges(), ApplyScheme(), BuildVolatileEnvironment(), CNewMenu::CacheItems(), ChangeNtProductType(), ChangePortNumber(), CliSaveImeHotKey(), CM_Open_Class_Key_ExW(), COMCAT_ICatRegister_RegisterCategories(), ComDBClaimNextFreePort(), ComDBClaimPort(), ComDBOpen(), ComDBReleasePort(), ComDBResizeDatabase(), ConCfgWriteUserSettings(), connections_on_notify(), CopyKey(), CopySystemProfile(), CreateAppPath(), CreateDeviceInstance(), CreateEventLog(), CreateInstanceKey(), CreateNewValue(), CreateStandardProfile(), CreateUserProfileExW(), CriticalDeviceCoInstaller(), CRYPT_CreateMachineGuid(), CRYPT_SetDefaultOIDDlls(), CRYPT_SIPWriteFunction(), CRYPT_WriteSerializedToReg(), CryptRegisterOIDFunction(), CryptRegisterOIDInfo(), CryptSetOIDFunctionValue(), CryptSetProviderExW(), DecrementRefCount(), delete_multi_sz_value(), DEVENUM_IPropertyBag_Write(), DIALOG_Execute(), CNetConnection::Disconnect(), DllRegisterServer(), DMORegister(), do_process_key(), ATL::CRegObject::do_process_key(), do_reg_operation(), do_typelib_reg_key(), DoInstallFontFile(), DoTestComputerName(), DoWriteProductOption(), DoWriteSoundEvents(), EditTypeDlg_WriteClass(), CInputProcessorProfiles::EnableLanguageProfile(), CInputProcessorProfiles::EnableLanguageProfileByDefault(), CSysTray::EnableService(), EnableTheming(), FILEDLG95_MRU_save_filename(), FillList(), FilterMapper3_CreateCategory(), FilterMapper_RegisterFilter(), FilterMapper_RegisterPin(), general_on_notify(), get_cred_mgr_encryption_key(), GetCurrentDPI(), GetCurrentHwProfileW(), ImageView_SaveSettings(), Imm32WriteImeLayout(), ImpersonateTokenWithEveryoneOrWithout(), IncrementRefCount(), INetCfgComponentControl_fnApplyRegistryChanges(), INetCfgLock_fnAcquireWriteLock(), init_locale(), InitializeDefaultUserLocale(), InitializeFormList(), InitializeProfiles(), InitializeProgramFilesDir(), InitLogs(), InputList_AddInputMethodToUserRegistry(), InputList_WriteSubst(), InstallDefaultSystemSoundScheme(), InstallEventSource(), InstallNetDevice(), InstallOneService(), InstallParallelPort(), InstallReactOS(), InstallScreenSaverW(), InstallSerialPort(), InstallSystemSoundLabels(), InstallSystemSoundScheme(), InstallSystemSoundSchemeNames(), INTERNET_LoadProxySettings(), INTERNET_SaveProxySettings(), IntSetupDiSetDeviceRegistryPropertyAW(), IStream_fnRelease(), ITERATE_RemoveEnvironmentString(), ITERATE_WriteEnvironmentString(), ITERATE_WriteRegistryValues(), KmtFltAddAltitude(), CNetConnectionPropertyUi::LANPropertiesUIDlg(), LoadEventSources(), LoadLogFile(), LocalAddForm(), LocalAddMonitor(), LocalmonAddPort(), LocalmonAddPortEx(), LocalSetForm(), MAIN_LoadSettings(), MAIN_MenuCommand(), MAIN_SaveSettings(), MainWnd_OnInstall(), MainWnd_OnOpenRegKey(), MainWnd_OnUpdateRegistry(), MMDevice_Create(), MMDevice_SetPropValue(), MMSYS_InstallDevice(), ModifyStatus(), ModifyValue(), MouseOnApply(), MRU_SaveChanged(), MSACM_WriteCurrentPriorities(), msi_reg_set_val_dword(), msi_reg_set_val_multi_str(), msi_reg_set_val_str(), msi_set_last_used_source(), MsiSourceListAddMediaDiskW(), MsiSourceListAddSourceExW(), MsiSourceListSetInfoW(), myAddPrinterDriverEx(), NdrDllRegisterProxy(), NetIDPage_OnApply(), NetworkDlg_OnOK(), OnAutoSync(), OnToggleRequireLogon(), PerformMount(), PNP_AddID(), PNP_SetClassRegProp(), PNP_SetDeviceRegProp(), ProcessSetupInf(), ProcessUnattendSection(), publish_install_properties(), publish_patches(), RChangeServiceConfig2W(), RChangeServiceConfigW(), RCreateServiceW(), RegCopyTreeW(), register_categories(), register_codepages(), register_converters(), register_decoders(), register_encoders(), register_interfaces(), register_key_defvalueW(), register_mediatypes_extension(), register_mediatypes_parsing(), register_metadatareaders(), register_pixelformats(), RegisterBDAComponent(), RegisterHelperDll(), RegisterSdbEntry(), RegisterService(), RegisterTypeLib(), registry_set_filelist(), registry_set_formatopts(), registry_set_options(), registry_set_pagemargins(), registry_set_previewpages(), registry_write_credential(), RegSetDWORDValue(), RegSetKeyValueW(), RegSetOrDelete(), RegSetString(), RegSetValueExA(), RegSetValueW(), CNetConnection::Rename(), RenameValue(), run_add(), run_copy(), save_mapping_settings(), SaveAdvancedSettings(), SaveAppSettings(), SaveBoard(), SaveCustomPath(), SaveDWORDToRegistry(), SaveGeoID(), SavePropertiesDlg(), SaveSetting(), SaveSettings(), SaveShutdownSelState(), SaveStringToRegistry(), SaveSystemSettings(), SaveUserLocale(), SaveWorkstationInfo(), ScmCreateNewControlPipe(), ScmMarkServiceForDelete(), ScmSetFailureActions(), ScmSetLastKnownGoodControlSet(), ScmWriteDependencies(), ScmWriteSecurityDescriptor(), set_profile_device_key(), set_proxy(), set_value_state(), SetActivePwrScheme(), SetAutoAdminLogon(), SetAutoDaylight(), SetClassId(), SetComputerNameExW(), COpenWithList::SetDefaultHandler(), CInputProcessorProfiles::SetDefaultLanguageProfile(), SetDefaultPrinterW(), SetFindFlags(), SetHKCRValue(), SetHotPlugFlags(), SetInstallationCompleted(), SetLastID(), SetNtpClientValues(), SetNTPServer(), SetParametersValues(), SetPerUserSecValuesW(), SetProfileData(), SetSetupType(), SETUP_CreateClassKey(), SETUPDI_CreateDrvKey(), SetupDiChangeState(), SetupDiInstallDevice(), SetupRegisterClass(), SetUserGeoID(), SetUserWaitInterval(), SHRegWriteUSValueW(), SHSetUnreadMailCountW(), SHSetValueW(), SKSetValueW(), SQLWritePrivateProfileStringW(), START_TEST(), CFindFolder::StartSearch(), stillimagew_RegisterLaunchApplication(), StoreDriveSettings(), test4(), test_CallForAttributes(), test_enum_value(), test_Installer_RegistryValue(), test_IQueryAssociations_GetString(), test_legacy_filter_registration(), test_OleRegGetUserType(), test_set_value(), TestMyEventProvider(), TLB_register_interface(), TOOLBAR_Save(), TRASH_CanTrashFile(), update_locale_registry(), UpdateCaretBlinkTimeReg(), UpdateRegistryForFontSubstitutes(), UpdateRegistryString(), UpdateTcpIpInformation(), UpdateUsersShellFolderSettings(), UXTHEME_ApplyTheme(), UXTHEME_BackupSystemMetrics(), WinHttpSetDefaultProxyConfiguration(), WINTRUST_WriteProviderToReg(), WINTRUST_WriteSingleUsageEntry(), WintrustSetRegPolicyFlags(), WlxActivateUserShell(), wnet_use_connection(), write_config_value(), write_credential_blob(), write_reg_key(), write_registry_values(), write_types(), WriteCabinetState(), WriteGlobalPwrPolicy(), WriteKeysSettings(), WriteOwnerSettings(), WriteParameterArray(), WritePortSettings(), WriteProcessorPwrScheme(), WritePwrPolicy(), WritePwrScheme(), WriteStartupRecoveryOptions(), WriteUserLocale(), and ZoneMgrImpl_SetZoneAttributes().

RegSetValueW()

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

Definition at line 5000 of file reg.c.

{
    HKEY subkey;
    HANDLE hKey;
    DWORD ret;
    NTSTATUS Status;
 
    TRACE("(%p,%s,%d,%s,%d)\n", hKeyOriginal, debugstr_w(lpSubKey), dwType, debugstr_w(lpData), cbData );
 
    if (dwType != REG_SZ || !lpData)
        return ERROR_INVALID_PARAMETER;
 
    Status = MapDefaultKey(&hKey,
                           hKeyOriginal);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
    subkey = hKey;
 
    if (lpSubKey && lpSubKey[0])  /* need to create the subkey */
    {
        ret = RegCreateKeyW(hKey, lpSubKey, &subkey);
        if (ret != ERROR_SUCCESS)
            goto Cleanup;
    }
 
    ret = RegSetValueExW( subkey, NULL, 0, REG_SZ, (const BYTE*)lpData,
                          (wcslen( lpData ) + 1) * sizeof(WCHAR) );
    if (subkey != hKey)
        RegCloseKey(subkey);
 
Cleanup:
    ClosePredefKey(hKey);
 
    return ret;
}

Referenced by CoTreatAsClass(), CreateRegAppPath(), DllRegisterServer(), NdrDllRegisterProxy(), OleSetAutoConvert(), SetupRegisterClass(), test_reg_query_value(), and test_set_value().

RegUnLoadKeyA()

LONG WINAPI RegUnLoadKeyA	(	HKEY	hKey,
		LPCSTR	lpSubKey
	)

Definition at line 5049 of file reg.c.

{
    UNICODE_STRING KeyName;
    DWORD ErrorCode;
 
    if (lpSubKey)
    {
        if (!RtlCreateUnicodeStringFromAsciiz(&KeyName, lpSubKey))
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    else
        RtlInitEmptyUnicodeString(&KeyName, NULL, 0);
 
    ErrorCode = RegUnLoadKeyW(hKey,
                              KeyName.Buffer);
 
    RtlFreeUnicodeString (&KeyName);
 
    return ErrorCode;
}

RegUnLoadKeyW()

LONG WINAPI RegUnLoadKeyW	(	HKEY	hKey,
		LPCWSTR	lpSubKey
	)

Definition at line 5078 of file reg.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    HANDLE KeyHandle;
    NTSTATUS Status;
 
    if (hKey == HKEY_PERFORMANCE_DATA)
    {
      return ERROR_INVALID_HANDLE;
    }
 
    Status = MapDefaultKey(&KeyHandle, hKey);
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    RtlInitUnicodeString(&KeyName, lpSubKey);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               KeyHandle,
                               NULL);
 
    Status = NtUnloadKey(&ObjectAttributes);
 
    ClosePredefKey(KeyHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return RtlNtStatusToDosError(Status);
    }
 
    return ERROR_SUCCESS;
}

Referenced by CreateUserProfileExW(), RegUnLoadKeyA(), UnloadHive(), and UnloadUserProfile().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

reg

)

Variable Documentation

DefaultHandleHKUDisabled

BOOLEAN DefaultHandleHKUDisabled = FALSE

static

Definition at line 37 of file reg.c.

Referenced by MapDefaultKey(), RegDisablePredefinedCache(), and RegDisablePredefinedCacheEx().

DefaultHandlesDisabled

BOOLEAN DefaultHandlesDisabled = FALSE

static

Definition at line 36 of file reg.c.

Referenced by MapDefaultKey(), and RegDisablePredefinedCacheEx().

DefaultHandleTable

HANDLE DefaultHandleTable[MAX_DEFAULT_HANDLES]

static

Definition at line 34 of file reg.c.

Referenced by CloseDefaultKeys(), MapDefaultKey(), RegInitialize(), and RegOverridePredefKey().

DllInitialized

BOOLEAN DllInitialized = FALSE

static

Definition at line 38 of file reg.c.

Referenced by RegInitialize().

HandleTableCS

RTL_CRITICAL_SECTION HandleTableCS

static

Definition at line 33 of file reg.c.

Referenced by CloseDefaultKeys(), MapDefaultKey(), RegCleanup(), RegDisablePredefinedCache(), RegDisablePredefinedCacheEx(), RegInitialize(), and RegOverridePredefKey().

ProcessHeap

HANDLE ProcessHeap

static

Definition at line 35 of file reg.c.

Referenced by RegEnumKeyExW(), RegInitialize(), RegOpenUserClassesRoot(), RegpCopyTree(), and RegQueryInfoKeyW().