reg.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
FORCEINLINE BOOL	IsHKCRKey (_In_ HKEY hKey)
FORCEINLINE void	MakeHKCRKey (_Inout_ HKEY *hKey)
LONG WINAPI	CreateHKCRKey (_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	OpenHKCRKey (_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _In_ PHKEY phkResult)
LONG WINAPI	DeleteHKCRKey (_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ REGSAM RegSam, _In_ DWORD Reserved)
LONG WINAPI	DeleteHKCRValue (_In_ HKEY hKey, _In_ PUNICODE_STRING ValueName)
LONG WINAPI	QueryHKCRValue (_In_ HKEY hKey, _In_ LPCWSTR Name, _In_ LPDWORD Reserved, _In_ LPDWORD Type, _In_ LPBYTE Data, _In_ LPDWORD Count)
LONG WINAPI	SetHKCRValue (_In_ HKEY hKey, _In_ LPCWSTR Name, _In_ DWORD Reserved, _In_ DWORD Type, _In_ CONST BYTE *Data, _In_ DWORD DataSize)
LONG WINAPI	EnumHKCRKey (_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	EnumHKCRValue (_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	QueryInfoHKCRKey (_In_ HKEY hKey, _Out_writes_to_opt_(*lpcchClass, *lpcchClass+1) LPWSTR lpClass, _Inout_opt_ LPDWORD lpcchClass, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPDWORD lpcSubKeys, _Out_opt_ LPDWORD lpcbMaxSubKeyLen, _Out_opt_ LPDWORD lpcbMaxClassLen, _Out_opt_ LPDWORD lpcValues, _Out_opt_ LPDWORD lpcbMaxValueNameLen, _Out_opt_ LPDWORD lpcbMaxValueLen, _Out_opt_ LPDWORD lpcbSecurityDescriptor, _Out_opt_ PFILETIME lpftLastWriteTime)

Function Documentation

CreateHKCRKey()

LONG WINAPI CreateHKCRKey	(	_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 266 of file hkcr.c.

{
    LONG ErrorCode;
    HKEY QueriedKey, TestKey;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    ErrorCode = GetPreferredHKCRKey(hKey, &QueriedKey);
 
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* The current key doesn't exist on HKCU side, so we can only create it in HKLM */
        ErrorCode = RegCreateKeyExW(
            hKey,
            lpSubKey,
            Reserved,
            lpClass,
            dwOptions,
            samDesired,
            lpSecurityAttributes,
            phkResult,
            lpdwDisposition);
        if (ErrorCode == ERROR_SUCCESS)
            MakeHKCRKey(phkResult);
        return ErrorCode;
    }
 
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Somehow we failed for another reason (maybe deleted key or whatever) */
        return ErrorCode;
    }
 
    /* See if the subkey already exists in HKCU. */
    ErrorCode = RegOpenKeyExW(QueriedKey, lpSubKey, 0, READ_CONTROL, &TestKey);
    if (ErrorCode != ERROR_FILE_NOT_FOUND)
    {
        if (ErrorCode == ERROR_SUCCESS)
        {
            /* Great. Close the test one and do the real create operation */
            RegCloseKey(TestKey);
            ErrorCode = RegCreateKeyExW(
                QueriedKey,
                lpSubKey,
                Reserved,
                lpClass,
                dwOptions,
                samDesired,
                lpSecurityAttributes,
                phkResult,
                lpdwDisposition);
            if (ErrorCode == ERROR_SUCCESS)
                MakeHKCRKey(phkResult);
        }
        if (QueriedKey != hKey)
            RegCloseKey(QueriedKey);
 
        return ERROR_SUCCESS;
    }
 
    if (QueriedKey != hKey)
        RegCloseKey(QueriedKey);
 
    /* So we must do the create operation in HKLM, creating the missing parent keys if needed. */
    ErrorCode = GetFallbackHKCRKey(hKey, &QueriedKey, TRUE);
    if (ErrorCode != ERROR_SUCCESS)
        return ErrorCode;
 
    /* Do the key creation */
    ErrorCode = RegCreateKeyEx(
        QueriedKey,
        lpSubKey,
        Reserved,
        lpClass,
        dwOptions,
        samDesired,
        lpSecurityAttributes,
        phkResult,
        lpdwDisposition);
 
    if (QueriedKey != hKey)
        RegCloseKey(QueriedKey);
 
    if (ErrorCode == ERROR_SUCCESS)
        MakeHKCRKey(phkResult);
 
    return ErrorCode;
}

Referenced by RegCreateKeyExW().

DeleteHKCRKey()

LONG WINAPI DeleteHKCRKey	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	lpSubKey,
		_In_ REGSAM	RegSam,
		_In_ DWORD	Reserved
	)

Definition at line 441 of file hkcr.c.

{
    HKEY QueriedKey;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    ErrorCode = GetPreferredHKCRKey(hKey, &QueriedKey);
 
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* The key doesn't exist on HKCU side, no chance for a subkey */
        return RegDeleteKeyExW(hKey, lpSubKey, RegSam, Reserved);
    }
 
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Somehow we failed for another reason (maybe deleted key or whatever) */
        return ErrorCode;
    }
 
    ErrorCode = RegDeleteKeyExW(QueriedKey, lpSubKey, RegSam, Reserved);
 
    /* Close it if we must */
    if (QueriedKey != hKey)
    {
        /* The original key is on the machine view */
        RegCloseKey(QueriedKey);
    }
 
    /* Anything else than ERROR_FILE_NOT_FOUND means that we found it, even if it is with failures. */
    if (ErrorCode != ERROR_FILE_NOT_FOUND)
        return ErrorCode;
 
    /* If we're here, we must open from HKLM key. */
    ErrorCode = GetFallbackHKCRKey(hKey, &QueriedKey, FALSE);
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Maybe the key doesn't exist in the HKLM view */
        return ErrorCode;
    }
 
    ErrorCode = RegDeleteKeyExW(QueriedKey, lpSubKey, RegSam, Reserved);
 
    /* Close it if we must */
    if (QueriedKey != hKey)
    {
        RegCloseKey(QueriedKey);
    }
 
    return ErrorCode;
}

Referenced by RegDeleteKeyExW().

DeleteHKCRValue()

LONG WINAPI DeleteHKCRValue	(	_In_ HKEY	hKey,
		_In_ PUNICODE_STRING	ValueName
	)

Definition at line 504 of file hkcr.c.

{
    HKEY hActualKey;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    /* Does the HKCU key and value exist? */
    ErrorCode = GetPreferredHKCRKey(hKey, &hActualKey);
    if (ErrorCode == ERROR_SUCCESS)
    {
        if (!ValueExists(hActualKey, ValueName))
        {
            if (hActualKey != hKey)
            {
                RegCloseKey(hActualKey);
            }
            ErrorCode = ERROR_FILE_NOT_FOUND;
        }
    }
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        ErrorCode = GetFallbackHKCRKey(hKey, &hActualKey, FALSE);
    }
 
    if (ErrorCode == ERROR_SUCCESS)
    {
        NTSTATUS Status = NtDeleteValueKey(hActualKey, ValueName);
        ErrorCode = NT_SUCCESS(Status) ? ERROR_SUCCESS : RtlNtStatusToDosError(Status);
    }
    if (hActualKey != hKey)
    {
        RegCloseKey(hActualKey);
    }
    return ErrorCode;
}

Referenced by RegDeleteValueA(), and RegDeleteValueW().

EnumHKCRKey()

LONG WINAPI EnumHKCRKey	(	_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 682 of file hkcr.c.

{
    HKEY PreferredKey, FallbackKey;
    DWORD NumPreferredSubKeys;
    DWORD MaxFallbackSubKeyLen;
    DWORD FallbackIndex;
    WCHAR* FallbackSubKeyName = NULL;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    /* Get the preferred key */
    ErrorCode = GetPreferredHKCRKey(hKey, &PreferredKey);
    if (ErrorCode != ERROR_SUCCESS)
    {
        if (ErrorCode == ERROR_FILE_NOT_FOUND)
        {
            /* Only the HKLM key exists */
            return RegEnumKeyExW(
                hKey,
                dwIndex,
                lpName,
                lpcbName,
                lpReserved,
                lpClass,
                lpcbClass,
                lpftLastWriteTime);
        }
        return ErrorCode;
    }
 
    /* Get the fallback key */
    ErrorCode = GetFallbackHKCRKey(hKey, &FallbackKey, FALSE);
    if (ErrorCode != ERROR_SUCCESS)
    {
        if (PreferredKey != hKey)
            RegCloseKey(PreferredKey);
        if (ErrorCode == ERROR_FILE_NOT_FOUND)
        {
            /* Only the HKCU key exists */
            return RegEnumKeyExW(
                hKey,
                dwIndex,
                lpName,
                lpcbName,
                lpReserved,
                lpClass,
                lpcbClass,
                lpftLastWriteTime);
        }
        return ErrorCode;
    }
 
    /* Get some info on the HKCU side */
    ErrorCode = GetSubkeyInfoHelper(PreferredKey, &NumPreferredSubKeys, NULL);
    if (ErrorCode != ERROR_SUCCESS)
        goto Exit;
 
    if (dwIndex < NumPreferredSubKeys)
    {
        /* HKCU side takes precedence */
        ErrorCode = RegEnumKeyExW(
            PreferredKey,
            dwIndex,
            lpName,
            lpcbName,
            lpReserved,
            lpClass,
            lpcbClass,
            lpftLastWriteTime);
        goto Exit;
    }
 
    /* Here it gets tricky. We must enumerate the values from the HKLM side,
     * without reporting those which are present on the HKCU side */
 
    /* Squash out the indices from HKCU */
    dwIndex -= NumPreferredSubKeys;
 
    /* Get some info */
    ErrorCode = GetSubkeyInfoHelper(FallbackKey, NULL, &MaxFallbackSubKeyLen);
    if (ErrorCode != ERROR_SUCCESS)
    {
        ERR("Could not query info of key %p (Err: %d)\n", FallbackKey, ErrorCode);
        goto Exit;
    }
 
    MaxFallbackSubKeyLen++;
    TRACE("Maxfallbacksubkeylen: %d\n", MaxFallbackSubKeyLen);
 
    /* Allocate our buffer */
    FallbackSubKeyName = RtlAllocateHeap(
        RtlGetProcessHeap(), 0, MaxFallbackSubKeyLen * sizeof(WCHAR));
    if (!FallbackSubKeyName)
    {
        ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        goto Exit;
    }
 
    /* We must begin at the very first subkey of the fallback key,
     * and then see if we meet keys that already are in the preferred key.
     * In that case, we must bump dwIndex, as otherwise we would enumerate a key we already
     * saw in a previous call.
     */
    FallbackIndex = 0;
    while (TRUE)
    {
        HKEY PreferredSubKey;
        DWORD FallbackSubkeyLen = MaxFallbackSubKeyLen;
 
        /* Try enumerating */
        ErrorCode = RegEnumKeyExW(
            FallbackKey,
            FallbackIndex,
            FallbackSubKeyName,
            &FallbackSubkeyLen,
            NULL,
            NULL,
            NULL,
            NULL);
        if (ErrorCode != ERROR_SUCCESS)
        {
            if (ErrorCode != ERROR_NO_MORE_ITEMS)
                ERR("Returning %d.\n", ErrorCode);
            goto Exit;
        }
        FallbackSubKeyName[FallbackSubkeyLen] = L'\0';
 
        /* See if there is such a value on HKCU side */
        ErrorCode = RegOpenKeyExW(
            PreferredKey,
            FallbackSubKeyName,
            0,
            READ_CONTROL,
            &PreferredSubKey);
 
        if (ErrorCode == ERROR_SUCCESS)
        {
            RegCloseKey(PreferredSubKey);
            /* So we already enumerated it on HKCU side. */
            dwIndex++;
        }
        else if (ErrorCode != ERROR_FILE_NOT_FOUND)
        {
            ERR("Got error %d while querying for %s on HKCU side.\n", ErrorCode, FallbackSubKeyName);
            goto Exit;
        }
 
        /* See if we caught up */
        if (FallbackIndex == dwIndex)
            break;
 
        FallbackIndex++;
    }
 
    /* We can finally enumerate on the fallback side */
    ErrorCode = RegEnumKeyExW(
        FallbackKey,
        dwIndex,
        lpName,
        lpcbName,
        lpReserved,
        lpClass,
        lpcbClass,
        lpftLastWriteTime);
 
Exit:
    if (PreferredKey != hKey)
        RegCloseKey(PreferredKey);
    if (FallbackKey != hKey)
        RegCloseKey(FallbackKey);
    if (FallbackSubKeyName)
        RtlFreeHeap(RtlGetProcessHeap(), 0, FallbackSubKeyName);
 
    return ErrorCode;
}

Referenced by RegEnumKeyExW().

EnumHKCRValue()

LONG WINAPI EnumHKCRValue	(	_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 873 of file hkcr.c.

{
    HKEY PreferredKey, FallbackKey;
    DWORD NumPreferredValues;
    DWORD MaxFallbackValueNameLen;
    DWORD FallbackIndex;
    WCHAR* FallbackValueName = NULL;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    /* Get the preferred key */
    ErrorCode = GetPreferredHKCRKey(hKey, &PreferredKey);
    if (ErrorCode != ERROR_SUCCESS)
    {
        if (ErrorCode == ERROR_FILE_NOT_FOUND)
        {
            /* Only the HKLM key exists */
            return RegEnumValueW(
                hKey,
                dwIndex,
                lpName,
                lpcbName,
                lpReserved,
                lpdwType,
                lpData,
                lpcbData);
        }
        return ErrorCode;
    }
 
    /* Get the fallback key */
    ErrorCode = GetFallbackHKCRKey(hKey, &FallbackKey, FALSE);
    if (ErrorCode != ERROR_SUCCESS)
    {
        if (PreferredKey != hKey)
            RegCloseKey(PreferredKey);
        if (ErrorCode == ERROR_FILE_NOT_FOUND)
        {
            /* Only the HKCU key exists */
            return RegEnumValueW(
                hKey,
                dwIndex,
                lpName,
                lpcbName,
                lpReserved,
                lpdwType,
                lpData,
                lpcbData);
        }
        return ErrorCode;
    }
 
    /* Get some info on the HKCU side */
    ErrorCode = RegQueryInfoKeyW(
        PreferredKey,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        &NumPreferredValues,
        NULL,
        NULL,
        NULL,
        NULL);
    if (ErrorCode != ERROR_SUCCESS)
        goto Exit;
 
    if (dwIndex < NumPreferredValues)
    {
        /* HKCU side takes precedence */
        return RegEnumValueW(
            PreferredKey,
            dwIndex,
            lpName,
            lpcbName,
            lpReserved,
            lpdwType,
            lpData,
            lpcbData);
        goto Exit;
    }
 
    /* Here it gets tricky. We must enumerate the values from the HKLM side,
     * without reporting those which are present on the HKCU side */
 
    /* Squash out the indices from HKCU */
    dwIndex -= NumPreferredValues;
 
    /* Get some info */
    ErrorCode = RegQueryInfoKeyW(
        FallbackKey,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        NULL,
        &MaxFallbackValueNameLen,
        NULL,
        NULL,
        NULL);
    if (ErrorCode != ERROR_SUCCESS)
    {
        ERR("Could not query info of key %p (Err: %d)\n", FallbackKey, ErrorCode);
        goto Exit;
    }
 
    MaxFallbackValueNameLen++;
    TRACE("Maxfallbacksubkeylen: %d\n", MaxFallbackValueNameLen);
 
    /* Allocate our buffer */
    FallbackValueName = RtlAllocateHeap(
        RtlGetProcessHeap(), 0, MaxFallbackValueNameLen * sizeof(WCHAR));
    if (!FallbackValueName)
    {
        ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        goto Exit;
    }
 
    /* We must begin at the very first subkey of the fallback key,
     * and then see if we meet keys that already are in the preferred key.
     * In that case, we must bump dwIndex, as otherwise we would enumerate a key we already
     * saw in a previous call.
     */
    FallbackIndex = 0;
    while (TRUE)
    {
        DWORD FallbackValueNameLen = MaxFallbackValueNameLen;
 
        /* Try enumerating */
        ErrorCode = RegEnumValueW(
            FallbackKey,
            FallbackIndex,
            FallbackValueName,
            &FallbackValueNameLen,
            NULL,
            NULL,
            NULL,
            NULL);
        if (ErrorCode != ERROR_SUCCESS)
        {
            if (ErrorCode != ERROR_NO_MORE_ITEMS)
                ERR("Returning %d.\n", ErrorCode);
            goto Exit;
        }
        FallbackValueName[FallbackValueNameLen] = L'\0';
 
        /* See if there is such a value on HKCU side */
        ErrorCode = RegQueryValueExW(
            PreferredKey,
            FallbackValueName,
            NULL,
            NULL,
            NULL,
            NULL);
 
        if (ErrorCode == ERROR_SUCCESS)
        {
            /* So we already enumerated it on HKCU side. */
            dwIndex++;
        }
        else if (ErrorCode != ERROR_FILE_NOT_FOUND)
        {
            ERR("Got error %d while querying for %s on HKCU side.\n", ErrorCode, FallbackValueName);
            goto Exit;
        }
 
        /* See if we caught up */
        if (FallbackIndex == dwIndex)
            break;
 
        FallbackIndex++;
    }
 
    /* We can finally enumerate on the fallback side */
    ErrorCode = RegEnumValueW(
        FallbackKey,
        dwIndex,
        lpName,
        lpcbName,
        lpReserved,
        lpdwType,
        lpData,
        lpcbData);
 
Exit:
    if (PreferredKey != hKey)
        RegCloseKey(PreferredKey);
    if (FallbackKey != hKey)
        RegCloseKey(FallbackKey);
    if (FallbackValueName)
        RtlFreeHeap(RtlGetProcessHeap(), 0, FallbackValueName);
 
    return ErrorCode;
}

Referenced by RegEnumValueW().

IsHKCRKey()

FORCEINLINE BOOL IsHKCRKey

(

_In_ HKEY

hKey

)

Definition at line 13 of file reg.h.

{
    return ((ULONG_PTR)hKey & 0x2) != 0;
}

Referenced by CreateHKCRKey(), DeleteHKCRKey(), DeleteHKCRValue(), EnumHKCRKey(), EnumHKCRValue(), OpenHKCRKey(), QueryHKCRValue(), QueryInfoHKCRKey(), RegCreateKeyExW(), RegDeleteKeyExW(), RegDeleteValueA(), RegDeleteValueW(), RegEnumKeyExW(), RegEnumValueW(), RegOpenKeyExW(), RegQueryInfoKeyW(), RegQueryValueExW(), RegSetValueExW(), SetHKCRValue(), and ValueExists().

MakeHKCRKey()

FORCEINLINE void MakeHKCRKey

(

_Inout_ HKEY *

hKey

)

Definition at line 20 of file reg.h.

{
    *hKey = (HKEY)((ULONG_PTR)(*hKey) | 0x2);
}

Referenced by CreateHKCRKey(), OpenClassesRootKey(), and OpenHKCRKey().

OpenHKCRKey()

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

Definition at line 370 of file hkcr.c.

{
    HKEY QueriedKey;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    ErrorCode = GetPreferredHKCRKey(hKey, &QueriedKey);
 
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* The key doesn't exist on HKCU side, no chance for a subkey */
        ErrorCode = RegOpenKeyExW(hKey, lpSubKey, ulOptions, samDesired, phkResult);
        if (ErrorCode == ERROR_SUCCESS)
            MakeHKCRKey(phkResult);
        return ErrorCode;
    }
 
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Somehow we failed for another reason (maybe deleted key or whatever) */
        return ErrorCode;
    }
 
    /* Try on the HKCU side */
    ErrorCode = RegOpenKeyExW(QueriedKey, lpSubKey, ulOptions, samDesired, phkResult);
    if (ErrorCode == ERROR_SUCCESS)
        MakeHKCRKey(phkResult);
 
    /* Close it if we must */
    if (QueriedKey != hKey)
    {
        RegCloseKey(QueriedKey);
    }
 
    /* Anything else than ERROR_FILE_NOT_FOUND means that we found it, even if it is with failures. */
    if (ErrorCode != ERROR_FILE_NOT_FOUND)
        return ErrorCode;
 
    /* If we're here, we must open from HKLM key. */
    ErrorCode = GetFallbackHKCRKey(hKey, &QueriedKey, FALSE);
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Maybe the key doesn't exist in the HKLM view */
        return ErrorCode;
    }
 
    ErrorCode = RegOpenKeyExW(QueriedKey, lpSubKey, ulOptions, samDesired, phkResult);
    if (ErrorCode == ERROR_SUCCESS)
        MakeHKCRKey(phkResult);
 
    /* Close it if we must */
    if (QueriedKey != hKey)
    {
        RegCloseKey(QueriedKey);
    }
 
    return ErrorCode;
}

Referenced by RegOpenKeyExW().

QueryHKCRValue()

LONG WINAPI QueryHKCRValue	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	Name,
		_In_ LPDWORD	Reserved,
		_In_ LPDWORD	Type,
		_In_ LPBYTE	Data,
		_In_ LPDWORD	Count
	)

Definition at line 548 of file hkcr.c.

{
    HKEY QueriedKey;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    ErrorCode = GetPreferredHKCRKey(hKey, &QueriedKey);
 
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* The key doesn't exist on HKCU side, no chance for a value in it */
        return RegQueryValueExW(hKey, Name, Reserved, Type, Data, Count);
    }
 
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Somehow we failed for another reason (maybe deleted key or whatever) */
        return ErrorCode;
    }
 
    ErrorCode = RegQueryValueExW(QueriedKey, Name, Reserved, Type, Data, Count);
 
    /* Close it if we must */
    if (QueriedKey != hKey)
    {
        /* The original key is on the machine view */
        RegCloseKey(QueriedKey);
    }
 
    /* Anything else than ERROR_FILE_NOT_FOUND means that we found it, even if it is with failures. */
    if (ErrorCode != ERROR_FILE_NOT_FOUND)
        return ErrorCode;
 
    /* If we're here, we must open from HKLM key. */
    ErrorCode = GetFallbackHKCRKey(hKey, &QueriedKey, FALSE);
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Maybe the key doesn't exist in the HKLM view */
        return ErrorCode;
    }
 
    ErrorCode = RegQueryValueExW(QueriedKey, Name, Reserved, Type, Data, Count);
 
    /* Close it if we must */
    if (QueriedKey != hKey)
    {
        RegCloseKey(QueriedKey);
    }
 
    return ErrorCode;
}

Referenced by RegQueryValueExW().

QueryInfoHKCRKey()

LONG WINAPI QueryInfoHKCRKey	(	_In_ HKEY	hKey,
		_Out_writes_to_opt_ *, *+1lpcchClass LPWSTR	lpClass,
		_Inout_opt_ LPDWORD	lpcchClass,
		_Reserved_ LPDWORD	lpReserved,
		_Out_opt_ LPDWORD	lpcSubKeys,
		_Out_opt_ LPDWORD	lpcbMaxSubKeyLen,
		_Out_opt_ LPDWORD	lpcbMaxClassLen,
		_Out_opt_ LPDWORD	lpcValues,
		_Out_opt_ LPDWORD	lpcbMaxValueNameLen,
		_Out_opt_ LPDWORD	lpcbMaxValueLen,
		_Out_opt_ LPDWORD	lpcbSecurityDescriptor,
		_Out_opt_ PFILETIME	lpftLastWriteTime
	)

Definition at line 1087 of file hkcr.c.

{
    HKEY PreferredKey, FallbackKey;
    LONG retval, err;
    DWORD OtherSubKeys = 0, OtherMaxSub = 0, OtherMaxClass = 0;
    DWORD OtherValues = 0, OtherMaxName = 0, OtherMaxVal = 0;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    retval = GetFallbackHKCRKey(hKey, &FallbackKey, FALSE);
    if (retval == ERROR_SUCCESS)
    {
        retval = RegQueryInfoKeyW(FallbackKey, lpClass, lpcchClass, lpReserved,
                                  &OtherSubKeys, &OtherMaxSub, &OtherMaxClass,
                                  &OtherValues, &OtherMaxName, &OtherMaxVal,
                                  lpcbSecurityDescriptor, lpftLastWriteTime);
        if (FallbackKey != hKey)
            RegCloseKey(FallbackKey);
    }
 
    err = GetPreferredHKCRKey(hKey, &PreferredKey);
    if (err == ERROR_SUCCESS)
    {
        err = RegQueryInfoKeyW(PreferredKey, lpClass, lpcchClass, lpReserved,
                               lpcSubKeys, lpcbMaxSubKeyLen, lpcbMaxClassLen,
                               lpcValues, lpcbMaxValueNameLen, lpcbMaxValueLen,
                               lpcbSecurityDescriptor, lpftLastWriteTime);
        if (PreferredKey != hKey)
            RegCloseKey(PreferredKey);
    }
 
    if (lpcSubKeys)
        *lpcSubKeys = (err ? 0 : *lpcSubKeys) + OtherSubKeys;
    if (lpcValues)
        *lpcValues = (err ? 0 : *lpcValues) + OtherValues;
    if (lpcbMaxSubKeyLen)
        *lpcbMaxSubKeyLen = max((err ? 0 : *lpcbMaxSubKeyLen), OtherMaxSub);
    if (lpcbMaxClassLen)
        *lpcbMaxClassLen = max((err ? 0 : *lpcbMaxClassLen), OtherMaxClass);
    if (lpcbMaxValueNameLen)
        *lpcbMaxValueNameLen = max((err ? 0 : *lpcbMaxValueNameLen), OtherMaxName);
    if (lpcbMaxValueLen)
        *lpcbMaxValueLen = max((err ? 0 : *lpcbMaxValueLen), OtherMaxVal);
 
    return (err == ERROR_SUCCESS) ? ERROR_SUCCESS : retval;
}

Referenced by RegQueryInfoKeyW().

SetHKCRValue()

LONG WINAPI SetHKCRValue	(	_In_ HKEY	hKey,
		_In_ LPCWSTR	Name,
		_In_ DWORD	Reserved,
		_In_ DWORD	Type,
		_In_ CONST BYTE *	Data,
		_In_ DWORD	DataSize
	)

Definition at line 613 of file hkcr.c.

{
    HKEY QueriedKey;
    LONG ErrorCode;
 
    ASSERT(IsHKCRKey(hKey));
 
    /* Remove the HKCR flag while we're working */
    hKey = (HKEY)(((ULONG_PTR)hKey) & ~0x2);
 
    ErrorCode = GetPreferredHKCRKey(hKey, &QueriedKey);
 
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* The key doesn't exist on HKCU side, no chance to put a value in it */
        return RegSetValueExW(hKey, Name, Reserved, Type, Data, DataSize);
    }
 
    if (ErrorCode != ERROR_SUCCESS)
    {
        /* Somehow we failed for another reason (maybe deleted key or whatever) */
        return ErrorCode;
    }
 
    /* Check if the value already exists in the preferred key */
    ErrorCode = RegQueryValueExW(QueriedKey, Name, NULL, NULL, NULL, NULL);
    if (ErrorCode != ERROR_FILE_NOT_FOUND)
    {
        if (ErrorCode == ERROR_SUCCESS)
        {
            /* Yes, so we have the right to modify it */
            ErrorCode = RegSetValueExW(QueriedKey, Name, Reserved, Type, Data, DataSize);
        }
        if (QueriedKey != hKey)
            RegCloseKey(QueriedKey);
        return ErrorCode;
    }
    if (QueriedKey != hKey)
        RegCloseKey(QueriedKey);
 
    /* So we must set the value in the HKLM version */
    ErrorCode = GetPreferredHKCRKey(hKey, &QueriedKey);
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* No choice: put this in HKCU */
        return RegSetValueExW(hKey, Name, Reserved, Type, Data, DataSize);
    }
    else if (ErrorCode != ERROR_SUCCESS)
    {
        return ErrorCode;
    }
 
    ErrorCode = RegSetValueExW(QueriedKey, Name, Reserved, Type, Data, DataSize);
 
    if (QueriedKey != hKey)
        RegCloseKey(QueriedKey);
 
    return ErrorCode;
}

Referenced by RegSetValueExW().