From: Eric Kohl Date: Sun, 23 Nov 2008 22:36:15 +0000 (+0000) Subject: Fix formatting. No code changes! X-Git-Tag: backups/the-real-msvc@60644^2~36 X-Git-Url: https://git.reactos.org/?p=reactos.git;a=commitdiff_plain;h=4abc5d743f705cd5bde0ba9ab4b84cd2ca6a6d1d;hp=a1afe48a572969f90f59887b23801c7939e7231d Fix formatting. No code changes! svn path=/trunk/; revision=37598 --- diff --git a/reactos/dll/win32/advapi32/reg/reg.c b/reactos/dll/win32/advapi32/reg/reg.c index f0180712742..5c6928d34ef 100644 --- a/reactos/dll/win32/advapi32/reg/reg.c +++ b/reactos/dll/win32/advapi32/reg/reg.c @@ -62,16 +62,16 @@ __inline static int is_string( DWORD type ) * RegInitDefaultHandles */ BOOL -RegInitialize (VOID) +RegInitialize(VOID) { - TRACE("RegInitialize()\n"); + TRACE("RegInitialize()\n"); - ProcessHeap = RtlGetProcessHeap(); - RtlZeroMemory (DefaultHandleTable, - MAX_DEFAULT_HANDLES * sizeof(HANDLE)); - RtlInitializeCriticalSection (&HandleTableCS); + ProcessHeap = RtlGetProcessHeap(); + RtlZeroMemory(DefaultHandleTable, + MAX_DEFAULT_HANDLES * sizeof(HANDLE)); + RtlInitializeCriticalSection(&HandleTableCS); - return TRUE; + return TRUE; } @@ -79,14 +79,14 @@ RegInitialize (VOID) * RegInit */ BOOL -RegCleanup (VOID) +RegCleanup(VOID) { - TRACE("RegCleanup()\n"); + TRACE("RegCleanup()\n"); - CloseDefaultKeys (); - RtlDeleteCriticalSection (&HandleTableCS); + CloseDefaultKeys(); + RtlDeleteCriticalSection(&HandleTableCS); - return TRUE; + return TRUE; } @@ -139,164 +139,167 @@ OpenPredefinedKey(IN ULONG Index, static NTSTATUS -MapDefaultKey (OUT PHANDLE RealKey, - IN HKEY Key) +MapDefaultKey(OUT PHANDLE RealKey, + IN HKEY Key) { - PHANDLE Handle; - ULONG Index; - BOOLEAN DoOpen, DefDisabled; - NTSTATUS Status = STATUS_SUCCESS; + PHANDLE Handle; + ULONG Index; + BOOLEAN DoOpen, DefDisabled; + NTSTATUS Status = STATUS_SUCCESS; - TRACE("MapDefaultKey (Key %x)\n", Key); + TRACE("MapDefaultKey (Key %x)\n", Key); - if (!IsPredefKey(Key)) + if (!IsPredefKey(Key)) { - *RealKey = (HANDLE)((ULONG_PTR)Key & ~0x1); - return STATUS_SUCCESS; + *RealKey = (HANDLE)((ULONG_PTR)Key & ~0x1); + return STATUS_SUCCESS; } - /* Handle special cases here */ - Index = GetPredefKeyIndex(Key); - if (Index >= MAX_DEFAULT_HANDLES) + /* Handle special cases here */ + Index = GetPredefKeyIndex(Key); + if (Index >= MAX_DEFAULT_HANDLES) { - return STATUS_INVALID_PARAMETER; + return STATUS_INVALID_PARAMETER; } - RtlEnterCriticalSection (&HandleTableCS); + RtlEnterCriticalSection (&HandleTableCS); - if (Key == HKEY_CURRENT_USER) - DefDisabled = DefaultHandleHKUDisabled; - else - DefDisabled = DefaultHandlesDisabled; + if (Key == HKEY_CURRENT_USER) + DefDisabled = DefaultHandleHKUDisabled; + else + DefDisabled = DefaultHandlesDisabled; - if (!DefDisabled) + if (!DefDisabled) { - Handle = &DefaultHandleTable[Index]; - DoOpen = (*Handle == NULL); + Handle = &DefaultHandleTable[Index]; + DoOpen = (*Handle == NULL); } - else + else { - Handle = RealKey; - DoOpen = TRUE; + Handle = RealKey; + DoOpen = TRUE; } - if (DoOpen) + if (DoOpen) { - /* create/open the default handle */ - Status = OpenPredefinedKey(Index, - Handle); + /* create/open the default handle */ + Status = OpenPredefinedKey(Index, + Handle); } - if (NT_SUCCESS(Status)) - { - if (!DefDisabled) - *RealKey = *Handle; - else - *(PULONG_PTR)Handle |= 0x1; - } + if (NT_SUCCESS(Status)) + { + if (!DefDisabled) + *RealKey = *Handle; + else + *(PULONG_PTR)Handle |= 0x1; + } - RtlLeaveCriticalSection (&HandleTableCS); + RtlLeaveCriticalSection (&HandleTableCS); - return Status; + return Status; } static VOID -CloseDefaultKeys (VOID) +CloseDefaultKeys(VOID) { - ULONG i; + ULONG i; - RtlEnterCriticalSection (&HandleTableCS); - for (i = 0; i < MAX_DEFAULT_HANDLES; i++) + RtlEnterCriticalSection(&HandleTableCS); + + for (i = 0; i < MAX_DEFAULT_HANDLES; i++) { - if (DefaultHandleTable[i] != NULL) - { - NtClose (DefaultHandleTable[i]); - DefaultHandleTable[i] = NULL; - } + if (DefaultHandleTable[i] != NULL) + { + NtClose(DefaultHandleTable[i]); + DefaultHandleTable[i] = NULL; + } } - RtlLeaveCriticalSection (&HandleTableCS); + + RtlLeaveCriticalSection(&HandleTableCS); } static NTSTATUS -OpenClassesRootKey (PHANDLE KeyHandle) +OpenClassesRootKey(PHANDLE KeyHandle) { - OBJECT_ATTRIBUTES Attributes; - UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\CLASSES"); - - TRACE("OpenClassesRootKey()\n"); - - InitializeObjectAttributes (&Attributes, - &KeyName, - OBJ_CASE_INSENSITIVE, - NULL, - NULL); - return NtOpenKey (KeyHandle, - MAXIMUM_ALLOWED, - &Attributes); + OBJECT_ATTRIBUTES Attributes; + UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\CLASSES"); + + TRACE("OpenClassesRootKey()\n"); + + InitializeObjectAttributes(&Attributes, + &KeyName, + OBJ_CASE_INSENSITIVE, + NULL, + NULL); + return NtOpenKey(KeyHandle, + MAXIMUM_ALLOWED, + &Attributes); } static NTSTATUS -OpenLocalMachineKey (PHANDLE KeyHandle) +OpenLocalMachineKey(PHANDLE KeyHandle) { - 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; + 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; } static NTSTATUS -OpenUsersKey (PHANDLE KeyHandle) +OpenUsersKey(PHANDLE KeyHandle) { - 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); + 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); } static NTSTATUS OpenCurrentConfigKey (PHANDLE KeyHandle) { - 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); + 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); } @@ -308,9 +311,9 @@ OpenCurrentConfigKey (PHANDLE KeyHandle) LONG WINAPI RegDisablePredefinedCache(VOID) { - RtlEnterCriticalSection (&HandleTableCS); + RtlEnterCriticalSection(&HandleTableCS); DefaultHandleHKUDisabled = TRUE; - RtlLeaveCriticalSection (&HandleTableCS); + RtlLeaveCriticalSection(&HandleTableCS); return ERROR_SUCCESS; } @@ -323,10 +326,10 @@ RegDisablePredefinedCache(VOID) LONG STDCALL RegDisablePredefinedCacheEx(VOID) { - RtlEnterCriticalSection (&HandleTableCS); + RtlEnterCriticalSection(&HandleTableCS); DefaultHandlesDisabled = TRUE; DefaultHandleHKUDisabled = TRUE; - RtlLeaveCriticalSection (&HandleTableCS); + RtlLeaveCriticalSection(&HandleTableCS); return ERROR_SUCCESS; } @@ -369,7 +372,7 @@ RegOverridePredefKey(IN HKEY hKey, ASSERT(hNewHKey != NULL); } - RtlEnterCriticalSection (&HandleTableCS); + RtlEnterCriticalSection(&HandleTableCS); /* close the currently mapped handle if existing */ if (*Handle != NULL) @@ -380,7 +383,7 @@ RegOverridePredefKey(IN HKEY hKey, /* update the mapping */ *Handle = hNewHKey; - RtlLeaveCriticalSection (&HandleTableCS); + RtlLeaveCriticalSection(&HandleTableCS); } else ErrorCode = ERROR_INVALID_HANDLE; @@ -395,20 +398,20 @@ RegOverridePredefKey(IN HKEY hKey, * @implemented */ LONG STDCALL -RegCloseKey (HKEY hKey) +RegCloseKey(HKEY hKey) { - NTSTATUS Status; + NTSTATUS Status; - /* don't close null handle or a pseudo handle */ - if ((!hKey) || (((ULONG)hKey & 0xF0000000) == 0x80000000)) + /* don't close null handle or a pseudo handle */ + if ((!hKey) || (((ULONG)hKey & 0xF0000000) == 0x80000000)) { - return ERROR_INVALID_HANDLE; + return ERROR_INVALID_HANDLE; } - Status = NtClose (hKey); - if (!NT_SUCCESS(Status)) + Status = NtClose(hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } return ERROR_SUCCESS; @@ -809,9 +812,9 @@ RegCopyTreeA(IN HKEY hKeySrc, * @implemented */ LONG STDCALL -RegConnectRegistryA (IN LPCSTR lpMachineName, - IN HKEY hKey, - OUT PHKEY phkResult) +RegConnectRegistryA(IN LPCSTR lpMachineName, + IN HKEY hKey, + OUT PHKEY phkResult) { UNICODE_STRING MachineName = {0}; LONG Ret; @@ -839,25 +842,28 @@ RegConnectRegistryA (IN LPCSTR lpMachineName, * @unimplemented */ LONG STDCALL -RegConnectRegistryW (LPCWSTR lpMachineName, - HKEY hKey, - PHKEY phkResult) +RegConnectRegistryW(LPCWSTR lpMachineName, + HKEY hKey, + PHKEY phkResult) { LONG ret; TRACE("(%s,%p,%p): stub\n",debugstr_w(lpMachineName),hKey,phkResult); - if (!lpMachineName || !*lpMachineName) { + if (!lpMachineName || !*lpMachineName) + { /* Use the local machine name */ ret = RegOpenKeyW( hKey, NULL, phkResult ); } - else { + 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)) @@ -871,6 +877,7 @@ RegConnectRegistryW (LPCWSTR lpMachineName, else ret = GetLastError(); } + return ret; } @@ -882,108 +889,110 @@ RegConnectRegistryW (LPCWSTR lpMachineName, */ static NTSTATUS CreateNestedKey(PHKEY KeyHandle, - POBJECT_ATTRIBUTES ObjectAttributes, + POBJECT_ATTRIBUTES ObjectAttributes, PUNICODE_STRING ClassString, DWORD dwOptions, REGSAM samDesired, DWORD *lpdwDisposition) { - 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); + 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) + /* 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 = wcslen (LocalKeyName.Buffer) * sizeof(WCHAR); + Ptr = wcsrchr(LocalKeyName.Buffer, '\\'); + if (Ptr == NULL || Ptr == LocalKeyName.Buffer) + { + Status = STATUS_UNSUCCESSFUL; + break; + } - Status = NtCreateKey (&LocalKeyHandle, - KEY_CREATE_SUB_KEY, - &LocalObjectAttributes, - 0, - NULL, - 0, - &Disposition); - TRACE("NtCreateKey(%wZ) called (Status %lx)\n", &LocalKeyName, Status); + *Ptr = (WCHAR)0; + LocalKeyName.Length = 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)) + if (!NT_SUCCESS(Status)) { - RtlFreeUnicodeString (&LocalKeyName); - return Status; + RtlFreeUnicodeString(&LocalKeyName); + return Status; } - /* Add removed parts of the key name and create them too. */ - Length = wcslen (LocalKeyName.Buffer); - while (TRUE) + /* Add removed parts of the key name and create them too. */ + Length = wcslen(LocalKeyName.Buffer); + while (TRUE) { - if (LocalKeyHandle) - NtClose (LocalKeyHandle); + if (LocalKeyHandle) + NtClose (LocalKeyHandle); - LocalKeyName.Buffer[Length] = L'\\'; - Length = wcslen (LocalKeyName.Buffer); - LocalKeyName.Length = Length * sizeof(WCHAR); + LocalKeyName.Buffer[Length] = L'\\'; + Length = wcslen (LocalKeyName.Buffer); + LocalKeyName.Length = Length * sizeof(WCHAR); - if (Length == FullNameLength) + if (Length == FullNameLength) { - Status = NtCreateKey((PHANDLE) KeyHandle, - samDesired, - ObjectAttributes, - 0, - ClassString, - dwOptions, - (PULONG)lpdwDisposition); - break; + 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; + + 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); + RtlFreeUnicodeString(&LocalKeyName); - return Status; + return Status; } @@ -993,70 +1002,71 @@ CreateNestedKey(PHKEY KeyHandle, * @implemented */ LONG STDCALL -RegCreateKeyExA (HKEY hKey, - LPCSTR lpSubKey, - DWORD Reserved, - LPSTR lpClass, - DWORD dwOptions, - REGSAM samDesired, - LPSECURITY_ATTRIBUTES lpSecurityAttributes, - PHKEY phkResult, - LPDWORD lpdwDisposition) +RegCreateKeyExA(HKEY hKey, + LPCSTR lpSubKey, + DWORD Reserved, + LPSTR lpClass, + DWORD dwOptions, + REGSAM samDesired, + LPSECURITY_ATTRIBUTES lpSecurityAttributes, + PHKEY phkResult, + LPDWORD lpdwDisposition) { - UNICODE_STRING SubKeyString; - UNICODE_STRING ClassString; - OBJECT_ATTRIBUTES Attributes; - HANDLE ParentKey; - NTSTATUS Status; + UNICODE_STRING SubKeyString; + UNICODE_STRING ClassString; + OBJECT_ATTRIBUTES Attributes; + HANDLE ParentKey; + NTSTATUS Status; - TRACE("RegCreateKeyExA() called\n"); + TRACE("RegCreateKeyExA() called\n"); - if (lpSecurityAttributes && lpSecurityAttributes->nLength != sizeof(SECURITY_ATTRIBUTES)) - return ERROR_INVALID_USER_BUFFER; + if (lpSecurityAttributes && lpSecurityAttributes->nLength != sizeof(SECURITY_ATTRIBUTES)) + return ERROR_INVALID_USER_BUFFER; - /* get the real parent key */ - Status = MapDefaultKey (&ParentKey, - hKey); - if (!NT_SUCCESS(Status)) + /* get the real parent key */ + Status = MapDefaultKey(&ParentKey, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - TRACE("ParentKey %x\n", (ULONG)ParentKey); - if (lpClass != NULL) + TRACE("ParentKey %x\n", (ULONG)ParentKey); + + if (lpClass != NULL) { - RtlCreateUnicodeStringFromAsciiz (&ClassString, - lpClass); + RtlCreateUnicodeStringFromAsciiz(&ClassString, + lpClass); } - RtlCreateUnicodeStringFromAsciiz(&SubKeyString, - (LPSTR)lpSubKey); - InitializeObjectAttributes (&Attributes, - &SubKeyString, - OBJ_CASE_INSENSITIVE, - (HANDLE)ParentKey, - lpSecurityAttributes ? (PSECURITY_DESCRIPTOR)lpSecurityAttributes->lpSecurityDescriptor : NULL); - Status = CreateNestedKey(phkResult, - &Attributes, - (lpClass == NULL)? NULL : &ClassString, - dwOptions, - samDesired, - lpdwDisposition); - RtlFreeUnicodeString (&SubKeyString); - if (lpClass != NULL) + RtlCreateUnicodeStringFromAsciiz(&SubKeyString, + (LPSTR)lpSubKey); + InitializeObjectAttributes(&Attributes, + &SubKeyString, + OBJ_CASE_INSENSITIVE, + (HANDLE)ParentKey, + lpSecurityAttributes ? (PSECURITY_DESCRIPTOR)lpSecurityAttributes->lpSecurityDescriptor : NULL); + Status = CreateNestedKey(phkResult, + &Attributes, + (lpClass == NULL)? NULL : &ClassString, + dwOptions, + samDesired, + lpdwDisposition); + RtlFreeUnicodeString(&SubKeyString); + if (lpClass != NULL) { - RtlFreeUnicodeString (&ClassString); + RtlFreeUnicodeString(&ClassString); } - ClosePredefKey(ParentKey); + ClosePredefKey(ParentKey); - TRACE("Status %x\n", Status); - if (!NT_SUCCESS(Status)) + TRACE("Status %x\n", Status); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -1066,61 +1076,62 @@ RegCreateKeyExA (HKEY hKey, * @implemented */ LONG STDCALL -RegCreateKeyExW (HKEY hKey, - LPCWSTR lpSubKey, - DWORD Reserved, - LPWSTR lpClass, - DWORD dwOptions, - REGSAM samDesired, - LPSECURITY_ATTRIBUTES lpSecurityAttributes, - PHKEY phkResult, - LPDWORD lpdwDisposition) +RegCreateKeyExW(HKEY hKey, + LPCWSTR lpSubKey, + DWORD Reserved, + LPWSTR lpClass, + DWORD dwOptions, + REGSAM samDesired, + LPSECURITY_ATTRIBUTES lpSecurityAttributes, + PHKEY phkResult, + LPDWORD lpdwDisposition) { - UNICODE_STRING SubKeyString; - UNICODE_STRING ClassString; - OBJECT_ATTRIBUTES Attributes; - HANDLE ParentKey; - NTSTATUS Status; + UNICODE_STRING SubKeyString; + UNICODE_STRING ClassString; + OBJECT_ATTRIBUTES Attributes; + HANDLE ParentKey; + NTSTATUS Status; - TRACE("RegCreateKeyExW() called\n"); + TRACE("RegCreateKeyExW() called\n"); - if (lpSecurityAttributes && lpSecurityAttributes->nLength != sizeof(SECURITY_ATTRIBUTES)) - return ERROR_INVALID_USER_BUFFER; + if (lpSecurityAttributes && lpSecurityAttributes->nLength != sizeof(SECURITY_ATTRIBUTES)) + return ERROR_INVALID_USER_BUFFER; - /* get the real parent key */ - Status = MapDefaultKey (&ParentKey, - hKey); - if (!NT_SUCCESS(Status)) + /* get the real parent key */ + Status = MapDefaultKey(&ParentKey, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError(Status); + return RtlNtStatusToDosError(Status); } - TRACE("ParentKey %x\n", (ULONG)ParentKey); - RtlInitUnicodeString (&ClassString, - lpClass); - RtlInitUnicodeString (&SubKeyString, - lpSubKey); - InitializeObjectAttributes (&Attributes, - &SubKeyString, - OBJ_CASE_INSENSITIVE, - (HANDLE)ParentKey, - lpSecurityAttributes ? (PSECURITY_DESCRIPTOR)lpSecurityAttributes->lpSecurityDescriptor : NULL); - Status = CreateNestedKey(phkResult, - &Attributes, - (lpClass == NULL)? NULL : &ClassString, - dwOptions, - samDesired, - lpdwDisposition); + TRACE("ParentKey %x\n", (ULONG)ParentKey); + + RtlInitUnicodeString(&ClassString, + lpClass); + RtlInitUnicodeString(&SubKeyString, + lpSubKey); + InitializeObjectAttributes(&Attributes, + &SubKeyString, + OBJ_CASE_INSENSITIVE, + (HANDLE)ParentKey, + lpSecurityAttributes ? (PSECURITY_DESCRIPTOR)lpSecurityAttributes->lpSecurityDescriptor : NULL); + Status = CreateNestedKey(phkResult, + &Attributes, + (lpClass == NULL)? NULL : &ClassString, + dwOptions, + samDesired, + lpdwDisposition); - ClosePredefKey(ParentKey); + ClosePredefKey(ParentKey); - TRACE("Status %x\n", Status); - if (!NT_SUCCESS(Status)) + TRACE("Status %x\n", Status); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -1130,19 +1141,19 @@ RegCreateKeyExW (HKEY hKey, * @implemented */ LONG STDCALL -RegCreateKeyA (HKEY hKey, - LPCSTR lpSubKey, - PHKEY phkResult) +RegCreateKeyA(HKEY hKey, + LPCSTR lpSubKey, + PHKEY phkResult) { - return RegCreateKeyExA (hKey, - lpSubKey, - 0, - NULL, - 0, - MAXIMUM_ALLOWED, - NULL, - phkResult, - NULL); + return RegCreateKeyExA(hKey, + lpSubKey, + 0, + NULL, + 0, + MAXIMUM_ALLOWED, + NULL, + phkResult, + NULL); } @@ -1152,19 +1163,19 @@ RegCreateKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegCreateKeyW (HKEY hKey, - LPCWSTR lpSubKey, - PHKEY phkResult) +RegCreateKeyW(HKEY hKey, + LPCWSTR lpSubKey, + PHKEY phkResult) { - return RegCreateKeyExW (hKey, - lpSubKey, - 0, - NULL, - 0, - MAXIMUM_ALLOWED, - NULL, - phkResult, - NULL); + return RegCreateKeyExW(hKey, + lpSubKey, + 0, + NULL, + 0, + MAXIMUM_ALLOWED, + NULL, + phkResult, + NULL); } @@ -1174,58 +1185,58 @@ RegCreateKeyW (HKEY hKey, * @implemented */ LONG STDCALL -RegDeleteKeyA (HKEY hKey, - LPCSTR lpSubKey) +RegDeleteKeyA(HKEY hKey, + LPCSTR lpSubKey) { - 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); - } - - RtlCreateUnicodeStringFromAsciiz (&SubKeyName, - (LPSTR)lpSubKey); - InitializeObjectAttributes(&ObjectAttributes, - &SubKeyName, - OBJ_CASE_INSENSITIVE, - ParentKey, - NULL); - - Status = NtOpenKey (&TargetKey, - DELETE, - &ObjectAttributes); - RtlFreeUnicodeString (&SubKeyName); - if (!NT_SUCCESS(Status)) + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING SubKeyName; + HANDLE ParentKey; + HANDLE TargetKey; + NTSTATUS Status; + + /* Make sure we got a subkey */ + if (!lpSubKey) { - goto Cleanup; + /* Fail */ + return ERROR_INVALID_PARAMETER; } - Status = NtDeleteKey (TargetKey); - NtClose (TargetKey); + Status = MapDefaultKey(&ParentKey, + hKey); + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } + + RtlCreateUnicodeStringFromAsciiz(&SubKeyName, + (LPSTR)lpSubKey); + InitializeObjectAttributes(&ObjectAttributes, + &SubKeyName, + OBJ_CASE_INSENSITIVE, + ParentKey, + NULL); + + Status = NtOpenKey(&TargetKey, + DELETE, + &ObjectAttributes); + RtlFreeUnicodeString(&SubKeyName); + if (!NT_SUCCESS(Status)) + { + goto Cleanup; + } + + Status = NtDeleteKey(TargetKey); + NtClose (TargetKey); Cleanup: - ClosePredefKey(ParentKey); + ClosePredefKey(ParentKey); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError(Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -1235,58 +1246,59 @@ Cleanup: * @implemented */ LONG STDCALL -RegDeleteKeyW (HKEY hKey, - LPCWSTR lpSubKey) +RegDeleteKeyW(HKEY hKey, + LPCWSTR lpSubKey) { - 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); - } - - RtlInitUnicodeString (&SubKeyName, - (LPWSTR)lpSubKey); - InitializeObjectAttributes (&ObjectAttributes, - &SubKeyName, - OBJ_CASE_INSENSITIVE, - ParentKey, - NULL); - Status = NtOpenKey (&TargetKey, - DELETE, - &ObjectAttributes); - if (!NT_SUCCESS(Status)) + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING SubKeyName; + HANDLE ParentKey; + HANDLE TargetKey; + NTSTATUS Status; + + /* Make sure we got a subkey */ + if (!lpSubKey) { - goto Cleanup; + /* Fail */ + return ERROR_INVALID_PARAMETER; + } + + Status = MapDefaultKey(&ParentKey, + hKey); + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } + + RtlInitUnicodeString(&SubKeyName, + (LPWSTR)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); + Status = NtDeleteKey(TargetKey); + NtClose(TargetKey); Cleanup: - ClosePredefKey(ParentKey); + ClosePredefKey(ParentKey); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } + /************************************************************************ * RegDeleteKeyExA * @@ -1294,16 +1306,16 @@ Cleanup: */ LONG WINAPI -RegDeleteKeyExA ( HKEY hKey, - LPCSTR lpSubKey, - REGSAM samDesired, - DWORD Reserved - ) +RegDeleteKeyExA(HKEY hKey, + LPCSTR lpSubKey, + REGSAM samDesired, + DWORD Reserved) { - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return ERROR_CALL_NOT_IMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return ERROR_CALL_NOT_IMPLEMENTED; } + /************************************************************************ * RegDeleteKeyExW * @@ -1311,16 +1323,16 @@ RegDeleteKeyExA ( HKEY hKey, */ LONG WINAPI -RegDeleteKeyExW (HKEY hKey, - LPCWSTR lpSubKey, - REGSAM samDesired, - DWORD Reserved - ) +RegDeleteKeyExW(HKEY hKey, + LPCWSTR lpSubKey, + REGSAM samDesired, + DWORD Reserved) { - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return ERROR_CALL_NOT_IMPLEMENTED; + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return ERROR_CALL_NOT_IMPLEMENTED; } + /************************************************************************ * RegDeleteKeyValueW * @@ -1711,6 +1723,7 @@ Cleanup: } #endif + /************************************************************************ * RegDeleteTreeW * @@ -1718,7 +1731,8 @@ Cleanup: */ LSTATUS WINAPI -RegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey) +RegDeleteTreeW(HKEY hKey, + LPCWSTR lpszSubKey) { LONG ret; DWORD dwMaxSubkeyLen, dwMaxValueLen; @@ -1858,14 +1872,17 @@ RegEnableReflectionKey(IN HKEY hBase) return ERROR_CALL_NOT_IMPLEMENTED; } + /****************************************************************************** * RegpApplyRestrictions [internal] * * Helper function for RegGetValueA/W. */ static VOID -RegpApplyRestrictions( DWORD dwFlags, DWORD dwType, DWORD cbData, - PLONG ret ) +RegpApplyRestrictions(DWORD dwFlags, + DWORD dwType, + DWORD cbData, + PLONG ret) { /* Check if the type is restricted by the passed flags */ if (*ret == ERROR_SUCCESS || *ret == ERROR_MORE_DATA) @@ -1933,9 +1950,14 @@ RegpApplyRestrictions( DWORD dwFlags, DWORD dwType, DWORD cbData, * An exception is the case where RRF_RT_ANY is specified, because then * RRF_NOEXPAND is allowed. */ -LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, - DWORD dwFlags, LPDWORD pdwType, PVOID pvData, - LPDWORD pcbData ) +LSTATUS WINAPI +RegGetValueW(HKEY hKey, + LPCWSTR pszSubKey, + LPCWSTR pszValue, + DWORD dwFlags, + LPDWORD pdwType, + PVOID pvData, + LPDWORD pcbData) { DWORD dwType, cbData = pcbData ? *pcbData : 0; PVOID pvBuf = NULL; @@ -1965,7 +1987,8 @@ LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, if ((ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && dwType == REG_EXPAND_SZ && !(dwFlags & RRF_NOEXPAND)) { - do { + do + { HeapFree(GetProcessHeap(), 0, pvBuf); pvBuf = HeapAlloc(GetProcessHeap(), 0, cbData); @@ -1989,7 +2012,8 @@ LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, /* 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); + } + while (dwType == REG_EXPAND_SZ && ret == ERROR_MORE_DATA); if (ret == ERROR_SUCCESS) { @@ -1999,7 +2023,7 @@ LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, cbData = ExpandEnvironmentStringsW(pvBuf, pvData, pcbData ? *pcbData : 0) * sizeof(WCHAR); dwType = REG_SZ; - if(pvData && pcbData && cbData > *pcbData) + if (pvData && pcbData && cbData > *pcbData) ret = ERROR_MORE_DATA; } else if (pvData) @@ -2017,8 +2041,11 @@ LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, if (pvData && ret != ERROR_SUCCESS && (dwFlags & RRF_ZEROONFAILURE)) ZeroMemory(pvData, *pcbData); - if (pdwType) *pdwType = dwType; - if (pcbData) *pcbData = cbData; + if (pdwType) + *pdwType = dwType; + + if (pcbData) + *pcbData = cbData; return ret; } @@ -2029,9 +2056,14 @@ LSTATUS WINAPI RegGetValueW( HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, * * See RegGetValueW. */ -LSTATUS WINAPI RegGetValueA( HKEY hKey, LPCSTR pszSubKey, LPCSTR 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) { DWORD dwType, cbData = pcbData ? *pcbData : 0; PVOID pvBuf = NULL; @@ -2275,34 +2307,34 @@ Cleanup: * @implemented */ LONG STDCALL -RegDeleteValueA (HKEY hKey, - LPCSTR lpValueName) +RegDeleteValueA(HKEY hKey, + LPCSTR lpValueName) { - UNICODE_STRING ValueName; - HANDLE KeyHandle; - NTSTATUS Status; + UNICODE_STRING ValueName; + HANDLE KeyHandle; + NTSTATUS Status; - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - RtlCreateUnicodeStringFromAsciiz (&ValueName, - (LPSTR)lpValueName); - Status = NtDeleteValueKey (KeyHandle, - &ValueName); - RtlFreeUnicodeString (&ValueName); + RtlCreateUnicodeStringFromAsciiz(&ValueName, + (LPSTR)lpValueName); + Status = NtDeleteValueKey(KeyHandle, + &ValueName); + RtlFreeUnicodeString (&ValueName); - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -2312,34 +2344,34 @@ RegDeleteValueA (HKEY hKey, * @implemented */ LONG STDCALL -RegDeleteValueW (HKEY hKey, - LPCWSTR lpValueName) +RegDeleteValueW(HKEY hKey, + LPCWSTR lpValueName) { - UNICODE_STRING ValueName; - NTSTATUS Status; - HANDLE KeyHandle; + UNICODE_STRING ValueName; + NTSTATUS Status; + HANDLE KeyHandle; - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - RtlInitUnicodeString (&ValueName, - (LPWSTR)lpValueName); + RtlInitUnicodeString(&ValueName, + (LPWSTR)lpValueName); - Status = NtDeleteValueKey (KeyHandle, - &ValueName); + Status = NtDeleteValueKey(KeyHandle, + &ValueName); - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -2349,22 +2381,22 @@ RegDeleteValueW (HKEY hKey, * @implemented */ LONG STDCALL -RegEnumKeyA (HKEY hKey, - DWORD dwIndex, - LPSTR lpName, - DWORD cbName) +RegEnumKeyA(HKEY hKey, + DWORD dwIndex, + LPSTR lpName, + DWORD cbName) { - DWORD dwLength; - - dwLength = cbName; - return RegEnumKeyExA (hKey, - dwIndex, - lpName, - &dwLength, - NULL, - NULL, - NULL, - NULL); + DWORD dwLength; + + dwLength = cbName; + return RegEnumKeyExA(hKey, + dwIndex, + lpName, + &dwLength, + NULL, + NULL, + NULL, + NULL); } @@ -2374,22 +2406,22 @@ RegEnumKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegEnumKeyW (HKEY hKey, - DWORD dwIndex, - LPWSTR lpName, - DWORD cbName) +RegEnumKeyW(HKEY hKey, + DWORD dwIndex, + LPWSTR lpName, + DWORD cbName) { - DWORD dwLength; - - dwLength = cbName; - return RegEnumKeyExW (hKey, - dwIndex, - lpName, - &dwLength, - NULL, - NULL, - NULL, - NULL); + DWORD dwLength; + + dwLength = cbName; + return RegEnumKeyExW(hKey, + dwIndex, + lpName, + &dwLength, + NULL, + NULL, + NULL, + NULL); } @@ -2399,343 +2431,352 @@ RegEnumKeyW (HKEY hKey, * @implemented */ LONG STDCALL -RegEnumKeyExA (HKEY hKey, - DWORD dwIndex, - LPSTR lpName, - LPDWORD lpcbName, - LPDWORD lpReserved, - LPSTR lpClass, - LPDWORD lpcbClass, - PFILETIME lpftLastWriteTime) +RegEnumKeyExA(HKEY hKey, + DWORD dwIndex, + LPSTR lpName, + LPDWORD lpcbName, + LPDWORD lpReserved, + LPSTR lpClass, + LPDWORD lpcbClass, + PFILETIME lpftLastWriteTime) { - union - { - KEY_NODE_INFORMATION Node; - KEY_BASIC_INFORMATION Basic; - } *KeyInfo; - - UNICODE_STRING StringU; - ANSI_STRING StringA; - LONG ErrorCode = ERROR_SUCCESS; - DWORD NameLength; - DWORD ClassLength = 0; - DWORD BufferSize; - ULONG ResultSize; - HANDLE KeyHandle; - NTSTATUS Status; - - TRACE("RegEnumKeyExA(hKey 0x%x, dwIndex %d, lpName 0x%x, *lpcbName %d, lpClass 0x%x, lpcbClass %d)\n", - hKey, dwIndex, lpName, *lpcbName, lpClass, lpcbClass ? *lpcbClass : 0); - - if ((lpClass) && (!lpcbClass)) - { - return ERROR_INVALID_PARAMETER; - } - - Status = MapDefaultKey(&KeyHandle, hKey); - if (!NT_SUCCESS(Status)) - { - return RtlNtStatusToDosError (Status); - } - - 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; - } - - /* The class name should start at a dword boundary */ - 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 == NULL ? KeyBasicInformation : KeyNodeInformation, - 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_BUFFER_OVERFLOW; - } - else - { - StringU.Buffer = KeyInfo->Basic.Name; - StringU.Length = KeyInfo->Basic.NameLength; - StringU.MaximumLength = KeyInfo->Basic.NameLength; - } - } - else - { - if (KeyInfo->Node.NameLength > NameLength || - KeyInfo->Node.ClassLength > ClassLength) - { - ErrorCode = ERROR_BUFFER_OVERFLOW; - } - else - { - StringA.Buffer = lpClass; - StringA.Length = 0; - StringA.MaximumLength = *lpcbClass; - StringU.Buffer = (PWCHAR)((ULONG_PTR)KeyInfo->Node.Name + KeyInfo->Node.ClassOffset); - StringU.Length = KeyInfo->Node.ClassLength; - StringU.MaximumLength = KeyInfo->Node.ClassLength; - RtlUnicodeStringToAnsiString (&StringA, &StringU, FALSE); - lpClass[StringA.Length] = 0; - *lpcbClass = StringA.Length; - StringU.Buffer = KeyInfo->Node.Name; - StringU.Length = KeyInfo->Node.NameLength; - StringU.MaximumLength = KeyInfo->Node.NameLength; - } - } - - if (ErrorCode == ERROR_SUCCESS) - { - StringA.Buffer = lpName; - StringA.Length = 0; - StringA.MaximumLength = *lpcbName; - RtlUnicodeStringToAnsiString (&StringA, &StringU, FALSE); - lpName[StringA.Length] = 0; - *lpcbName = StringA.Length; - if (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; - } - } - } - } - - /*TRACE("Key Namea0 Length %d\n", StringU.Length);*/ /* BUGBUG could be uninitialized */ - TRACE("Key Namea1 Length %d\n", NameLength); - TRACE("Key Namea Length %d\n", *lpcbName); - TRACE("Key Namea %s\n", lpName); - - RtlFreeHeap (ProcessHeap, - 0, - KeyInfo); - -Cleanup: - ClosePredefKey(KeyHandle); - - return ErrorCode; -} + union + { + KEY_NODE_INFORMATION Node; + KEY_BASIC_INFORMATION Basic; + } *KeyInfo; + UNICODE_STRING StringU; + ANSI_STRING StringA; + LONG ErrorCode = ERROR_SUCCESS; + DWORD NameLength; + DWORD ClassLength = 0; + DWORD BufferSize; + ULONG ResultSize; + HANDLE KeyHandle; + NTSTATUS Status; -/************************************************************************ - * RegEnumKeyExW - * - * @implemented - */ -LONG STDCALL -RegEnumKeyExW (HKEY hKey, - DWORD dwIndex, - LPWSTR lpName, - LPDWORD lpcbName, - LPDWORD lpReserved, - LPWSTR lpClass, - LPDWORD lpcbClass, - PFILETIME lpftLastWriteTime) -{ - union - { - KEY_NODE_INFORMATION Node; - KEY_BASIC_INFORMATION Basic; - } *KeyInfo; + TRACE("RegEnumKeyExA(hKey 0x%x, dwIndex %d, lpName 0x%x, *lpcbName %d, lpClass 0x%x, lpcbClass %d)\n", + hKey, dwIndex, lpName, *lpcbName, lpClass, lpcbClass ? *lpcbClass : 0); - ULONG BufferSize; - ULONG ResultSize; - ULONG NameLength; - ULONG ClassLength = 0; - HANDLE KeyHandle; - LONG ErrorCode = ERROR_SUCCESS; - NTSTATUS Status; + if ((lpClass) && (!lpcbClass)) + { + return ERROR_INVALID_PARAMETER; + } - Status = MapDefaultKey(&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - if (*lpcbName > 0) + if (*lpcbName > 0) { - NameLength = min (*lpcbName - 1, REG_MAX_NAME_SIZE) * sizeof (WCHAR); + NameLength = min (*lpcbName - 1 , REG_MAX_NAME_SIZE) * sizeof (WCHAR); } - else + else { - NameLength = 0; + NameLength = 0; } - if (lpClass) + if (lpClass) { - if (*lpcbClass > 0) - { - ClassLength = min (*lpcbClass - 1, REG_MAX_NAME_SIZE) * sizeof(WCHAR); - } - else - { - ClassLength = 0; - } + 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; + /* The class name should start at a dword boundary */ + BufferSize = ((sizeof(KEY_NODE_INFORMATION) + NameLength + 3) & ~3) + ClassLength; } - else + else { - BufferSize = sizeof(KEY_BASIC_INFORMATION) + NameLength; + BufferSize = sizeof(KEY_BASIC_INFORMATION) + NameLength; } - KeyInfo = RtlAllocateHeap (ProcessHeap, - 0, - BufferSize); - if (KeyInfo == NULL) + KeyInfo = RtlAllocateHeap (ProcessHeap, 0, BufferSize); + if (KeyInfo == NULL) { - ErrorCode = ERROR_OUTOFMEMORY; - goto Cleanup; + ErrorCode = ERROR_OUTOFMEMORY; + goto Cleanup; + } + + Status = NtEnumerateKey(KeyHandle, + (ULONG)dwIndex, + lpClass == NULL ? KeyBasicInformation : KeyNodeInformation, + 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_BUFFER_OVERFLOW; + } + else + { + StringU.Buffer = KeyInfo->Basic.Name; + StringU.Length = KeyInfo->Basic.NameLength; + StringU.MaximumLength = KeyInfo->Basic.NameLength; + } + } + else + { + if (KeyInfo->Node.NameLength > NameLength || + KeyInfo->Node.ClassLength > ClassLength) + { + ErrorCode = ERROR_BUFFER_OVERFLOW; + } + else + { + StringA.Buffer = lpClass; + StringA.Length = 0; + StringA.MaximumLength = *lpcbClass; + StringU.Buffer = (PWCHAR)((ULONG_PTR)KeyInfo->Node.Name + KeyInfo->Node.ClassOffset); + StringU.Length = KeyInfo->Node.ClassLength; + StringU.MaximumLength = KeyInfo->Node.ClassLength; + RtlUnicodeStringToAnsiString (&StringA, &StringU, FALSE); + lpClass[StringA.Length] = 0; + *lpcbClass = StringA.Length; + StringU.Buffer = KeyInfo->Node.Name; + StringU.Length = KeyInfo->Node.NameLength; + StringU.MaximumLength = KeyInfo->Node.NameLength; + } + } + + if (ErrorCode == ERROR_SUCCESS) + { + StringA.Buffer = lpName; + StringA.Length = 0; + StringA.MaximumLength = *lpcbName; + RtlUnicodeStringToAnsiString (&StringA, &StringU, FALSE); + lpName[StringA.Length] = 0; + *lpcbName = StringA.Length; + if (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; + } + } + } } - 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_BUFFER_OVERFLOW; - } - 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_BUFFER_OVERFLOW; - } - 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); + /*TRACE("Key Namea0 Length %d\n", StringU.Length);*/ /* BUGBUG could be uninitialized */ + TRACE("Key Namea1 Length %d\n", NameLength); + TRACE("Key Namea Length %d\n", *lpcbName); + TRACE("Key Namea %s\n", lpName); + + RtlFreeHeap(ProcessHeap, + 0, + KeyInfo); Cleanup: - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - return ErrorCode; + return ErrorCode; } + /************************************************************************ - * RegEnumValueA + * RegEnumKeyExW * * @implemented */ LONG STDCALL -RegEnumValueA( HKEY hKey, DWORD index, LPSTR value, LPDWORD val_count, - LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count ) +RegEnumKeyExW(HKEY hKey, + DWORD dwIndex, + LPWSTR lpName, + LPDWORD lpcbName, + LPDWORD lpReserved, + LPWSTR lpClass, + LPDWORD lpcbClass, + PFILETIME lpftLastWriteTime) { - 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 ); + union + { + KEY_NODE_INFORMATION Node; + KEY_BASIC_INFORMATION Basic; + } *KeyInfo; - //TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n", - // hkey, index, value, val_count, reserved, type, data, count ); + ULONG BufferSize; + ULONG ResultSize; + ULONG NameLength; + ULONG ClassLength = 0; + HANDLE KeyHandle; + LONG ErrorCode = ERROR_SUCCESS; + NTSTATUS Status; - /* NT only checks count, not val_count */ - if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER; - status = MapDefaultKey (&KeyHandle, hKey); - if (!NT_SUCCESS(status)) - { - return RtlNtStatusToDosError (status); - } + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } + + 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_BUFFER_OVERFLOW; + } + 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_BUFFER_OVERFLOW; + } + 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; +} + + +/************************************************************************ + * RegEnumValueA + * + * @implemented + */ +LONG STDCALL +RegEnumValueA(HKEY hKey, + DWORD index, + LPSTR value, + LPDWORD val_count, + LPDWORD reserved, + LPDWORD type, + LPBYTE data, + LPDWORD count) +{ + 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 ); + + /* NT only checks count, not val_count */ + if ((data && !count) || reserved) + return ERROR_INVALID_PARAMETER; + + status = MapDefaultKey(&KeyHandle, hKey); + if (!NT_SUCCESS(status)) + { + return RtlNtStatusToDosError(status); + } total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR); if (data) total_size += *count; @@ -2824,6 +2865,7 @@ RegEnumValueA( HKEY hKey, DWORD index, LPSTR value, LPDWORD val_count, return RtlNtStatusToDosError(status); } + /****************************************************************************** * RegEnumValueW [ADVAPI32.@] * @implemented @@ -2843,10 +2885,16 @@ RegEnumValueA( HKEY hKey, DWORD index, LPSTR value, LPDWORD val_count, * Failure: nonzero error code from Winerror.h */ LONG STDCALL -RegEnumValueW( HKEY hKey, DWORD index, LPWSTR value, PDWORD val_count, - PDWORD reserved, PDWORD type, LPBYTE data, PDWORD count ) +RegEnumValueW(HKEY hKey, + DWORD index, + LPWSTR value, + PDWORD val_count, + PDWORD reserved, + PDWORD type, + LPBYTE data, + PDWORD count) { - HANDLE KeyHandle; + HANDLE KeyHandle; NTSTATUS status; ULONG total_size; char buffer[256], *buf_ptr = buffer; @@ -2859,11 +2907,11 @@ RegEnumValueW( HKEY hKey, DWORD index, LPWSTR value, PDWORD val_count, /* NT only checks count, not val_count */ if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER; - status = MapDefaultKey (&KeyHandle, hKey); - if (!NT_SUCCESS(status)) - { - return RtlNtStatusToDosError (status); - } + status = MapDefaultKey(&KeyHandle, hKey); + if (!NT_SUCCESS(status)) + { + return RtlNtStatusToDosError(status); + } total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR); if (data) total_size += *count; @@ -2932,6 +2980,7 @@ RegEnumValueW( HKEY hKey, DWORD index, LPWSTR value, PDWORD val_count, return RtlNtStatusToDosError(status); } + /************************************************************************ * RegFlushKey * @@ -2940,31 +2989,31 @@ RegEnumValueW( HKEY hKey, DWORD index, LPWSTR value, PDWORD val_count, LONG STDCALL RegFlushKey(HKEY hKey) { - HANDLE KeyHandle; - NTSTATUS Status; + HANDLE KeyHandle; + NTSTATUS Status; - if (hKey == HKEY_PERFORMANCE_DATA) + if (hKey == HKEY_PERFORMANCE_DATA) { - return ERROR_SUCCESS; + return ERROR_SUCCESS; } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - Status = NtFlushKey (KeyHandle); + Status = NtFlushKey(KeyHandle); - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -2975,42 +3024,43 @@ RegFlushKey(HKEY hKey) */ LONG STDCALL RegGetKeySecurity(HKEY hKey, - SECURITY_INFORMATION SecurityInformation, - PSECURITY_DESCRIPTOR pSecurityDescriptor, - LPDWORD lpcbSecurityDescriptor) + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor, + LPDWORD lpcbSecurityDescriptor) { - HANDLE KeyHandle; - NTSTATUS Status; + HANDLE KeyHandle; + NTSTATUS Status; - if (hKey == HKEY_PERFORMANCE_DATA) + if (hKey == HKEY_PERFORMANCE_DATA) { - return ERROR_INVALID_HANDLE; + return ERROR_INVALID_HANDLE; } - Status = MapDefaultKey(&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - TRACE("MapDefaultKey() failed (Status %lx)\n", Status); - return RtlNtStatusToDosError (Status); + TRACE("MapDefaultKey() failed (Status %lx)\n", Status); + return RtlNtStatusToDosError(Status); } + #if 0 - Status = NtQuerySecurityObject(KeyHandle, - SecurityInformation, - pSecurityDescriptor, - *lpcbSecurityDescriptor, - lpcbSecurityDescriptor); + Status = NtQuerySecurityObject(KeyHandle, + SecurityInformation, + pSecurityDescriptor, + *lpcbSecurityDescriptor, + lpcbSecurityDescriptor); #endif - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - WARN("NtQuerySecurityObject() failed (Status %lx)\n", Status); - return RtlNtStatusToDosError (Status); + WARN("NtQuerySecurityObject() failed (Status %lx)\n", Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -3020,27 +3070,27 @@ RegGetKeySecurity(HKEY hKey, * @implemented */ LONG STDCALL -RegLoadKeyA (HKEY hKey, - LPCSTR lpSubKey, - LPCSTR lpFile) +RegLoadKeyA(HKEY hKey, + LPCSTR lpSubKey, + LPCSTR lpFile) { - UNICODE_STRING FileName; - UNICODE_STRING KeyName; - LONG ErrorCode; + UNICODE_STRING FileName; + UNICODE_STRING KeyName; + LONG ErrorCode; - RtlCreateUnicodeStringFromAsciiz (&KeyName, - (LPSTR)lpSubKey); - RtlCreateUnicodeStringFromAsciiz (&FileName, - (LPSTR)lpFile); + RtlCreateUnicodeStringFromAsciiz(&KeyName, + (LPSTR)lpSubKey); + RtlCreateUnicodeStringFromAsciiz(&FileName, + (LPSTR)lpFile); - ErrorCode = RegLoadKeyW (hKey, - KeyName.Buffer, - FileName.Buffer); + ErrorCode = RegLoadKeyW(hKey, + KeyName.Buffer, + FileName.Buffer); - RtlFreeUnicodeString (&FileName); - RtlFreeUnicodeString (&KeyName); + RtlFreeUnicodeString(&FileName); + RtlFreeUnicodeString(&KeyName); - return ErrorCode; + return ErrorCode; } @@ -3050,71 +3100,71 @@ RegLoadKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegLoadKeyW (HKEY hKey, - LPCWSTR lpSubKey, - LPCWSTR lpFile) +RegLoadKeyW(HKEY hKey, + LPCWSTR lpSubKey, + LPCWSTR lpFile) { - OBJECT_ATTRIBUTES FileObjectAttributes; - OBJECT_ATTRIBUTES KeyObjectAttributes; - UNICODE_STRING FileName; - UNICODE_STRING KeyName; - HANDLE KeyHandle; - NTSTATUS Status; - LONG ErrorCode = ERROR_SUCCESS; + 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) + if (hKey == HKEY_PERFORMANCE_DATA) { - return ERROR_INVALID_HANDLE; + return ERROR_INVALID_HANDLE; } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - if (!RtlDosPathNameToNtPathName_U (lpFile, - &FileName, - NULL, - NULL)) + if (!RtlDosPathNameToNtPathName_U(lpFile, + &FileName, + NULL, + NULL)) { ErrorCode = ERROR_BAD_PATHNAME; goto Cleanup; } - InitializeObjectAttributes (&FileObjectAttributes, - &FileName, - OBJ_CASE_INSENSITIVE, - NULL, - NULL); + InitializeObjectAttributes(&FileObjectAttributes, + &FileName, + OBJ_CASE_INSENSITIVE, + NULL, + NULL); - RtlInitUnicodeString (&KeyName, - (LPWSTR)lpSubKey); + RtlInitUnicodeString(&KeyName, + (LPWSTR)lpSubKey); - InitializeObjectAttributes (&KeyObjectAttributes, - &KeyName, - OBJ_CASE_INSENSITIVE, - KeyHandle, - NULL); + InitializeObjectAttributes(&KeyObjectAttributes, + &KeyName, + OBJ_CASE_INSENSITIVE, + KeyHandle, + NULL); - Status = NtLoadKey (&KeyObjectAttributes, - &FileObjectAttributes); + Status = NtLoadKey(&KeyObjectAttributes, + &FileObjectAttributes); - RtlFreeHeap (RtlGetProcessHeap (), - 0, - FileName.Buffer); + RtlFreeHeap(RtlGetProcessHeap(), + 0, + FileName.Buffer); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - ErrorCode = RtlNtStatusToDosError (Status); - goto Cleanup; + ErrorCode = RtlNtStatusToDosError(Status); + goto Cleanup; } Cleanup: - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - return ErrorCode; + return ErrorCode; } @@ -3124,54 +3174,54 @@ Cleanup: * @unimplemented */ LONG STDCALL -RegNotifyChangeKeyValue (HKEY hKey, - BOOL bWatchSubtree, - DWORD dwNotifyFilter, - HANDLE hEvent, - BOOL fAsynchronous) +RegNotifyChangeKeyValue(HKEY hKey, + BOOL bWatchSubtree, + DWORD dwNotifyFilter, + HANDLE hEvent, + BOOL fAsynchronous) { - IO_STATUS_BLOCK IoStatusBlock; - HANDLE KeyHandle; - NTSTATUS Status; - LONG ErrorCode = ERROR_SUCCESS; + IO_STATUS_BLOCK IoStatusBlock; + HANDLE KeyHandle; + NTSTATUS Status; + LONG ErrorCode = ERROR_SUCCESS; - if (hKey == HKEY_PERFORMANCE_DATA) + if (hKey == HKEY_PERFORMANCE_DATA) { - return ERROR_INVALID_HANDLE; + return ERROR_INVALID_HANDLE; } - if (fAsynchronous == TRUE && hEvent == NULL) + if (fAsynchronous == TRUE && hEvent == NULL) { - return ERROR_INVALID_PARAMETER; + return ERROR_INVALID_PARAMETER; } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - /* FIXME: Remote key handles must fail */ + /* 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) + Status = NtNotifyChangeKey(KeyHandle, + hEvent, + 0, + 0, + &IoStatusBlock, + dwNotifyFilter, + bWatchSubtree, + 0, + 0, + fAsynchronous); + if (!NT_SUCCESS(Status) && Status != STATUS_TIMEOUT) { - ErrorCode = RtlNtStatusToDosError (Status); + ErrorCode = RtlNtStatusToDosError(Status); } - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - return ErrorCode; + return ErrorCode; } @@ -3181,20 +3231,20 @@ RegNotifyChangeKeyValue (HKEY hKey, * @implemented */ LONG STDCALL -RegOpenCurrentUser (IN REGSAM samDesired, - OUT PHKEY phkResult) +RegOpenCurrentUser(IN REGSAM samDesired, + OUT PHKEY phkResult) { - NTSTATUS Status; + 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); - } + 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; + return ERROR_SUCCESS; } @@ -3206,24 +3256,29 @@ RegOpenCurrentUser (IN REGSAM samDesired, * @implemented */ LONG STDCALL -RegOpenKeyA (HKEY hKey, - LPCSTR lpSubKey, - PHKEY phkResult) +RegOpenKeyA(HKEY hKey, + LPCSTR lpSubKey, + PHKEY phkResult) { - TRACE("RegOpenKeyA hKey 0x%x lpSubKey %s phkResult %p\n", hKey, lpSubKey, phkResult); + TRACE("RegOpenKeyA hKey 0x%x lpSubKey %s phkResult %p\n", + hKey, lpSubKey, phkResult); - if (!hKey && lpSubKey && phkResult) - { - return ERROR_INVALID_HANDLE; - } + if (!hKey && lpSubKey && phkResult) + { + return ERROR_INVALID_HANDLE; + } - if (!lpSubKey || !*lpSubKey) - { - *phkResult = hKey; - return ERROR_SUCCESS; - } + if (!lpSubKey || !*lpSubKey) + { + *phkResult = hKey; + return ERROR_SUCCESS; + } - return RegOpenKeyExA( hKey, lpSubKey, 0, MAXIMUM_ALLOWED, phkResult); + return RegOpenKeyExA(hKey, + lpSubKey, + 0, + MAXIMUM_ALLOWED, + phkResult); } @@ -3237,23 +3292,29 @@ RegOpenKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegOpenKeyW (HKEY hKey, - LPCWSTR lpSubKey, - PHKEY phkResult) +RegOpenKeyW(HKEY hKey, + LPCWSTR lpSubKey, + PHKEY phkResult) { - TRACE("RegOpenKeyW hKey 0x%x lpSubKey %S phkResult %p\n", hKey, lpSubKey, phkResult); - - if (!hKey && lpSubKey && phkResult) - { - return ERROR_INVALID_HANDLE; - } - - if (!lpSubKey || !*lpSubKey) - { - *phkResult = hKey; - return ERROR_SUCCESS; - } - return RegOpenKeyExW(hKey, lpSubKey, 0, MAXIMUM_ALLOWED, phkResult); + TRACE("RegOpenKeyW hKey 0x%x lpSubKey %S phkResult %p\n", + hKey, lpSubKey, phkResult); + + if (!hKey && lpSubKey && phkResult) + { + return ERROR_INVALID_HANDLE; + } + + if (!lpSubKey || !*lpSubKey) + { + *phkResult = hKey; + return ERROR_SUCCESS; + } + + return RegOpenKeyExW(hKey, + lpSubKey, + 0, + MAXIMUM_ALLOWED, + phkResult); } @@ -3263,44 +3324,48 @@ RegOpenKeyW (HKEY hKey, * @implemented */ LONG STDCALL -RegOpenKeyExA (HKEY hKey, - LPCSTR lpSubKey, - DWORD ulOptions, - REGSAM samDesired, - PHKEY phkResult) +RegOpenKeyExA(HKEY hKey, + LPCSTR lpSubKey, + DWORD ulOptions, + REGSAM samDesired, + PHKEY phkResult) { - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING SubKeyString; - HANDLE KeyHandle; - NTSTATUS Status; - LONG ErrorCode = ERROR_SUCCESS; - - TRACE("RegOpenKeyExA hKey 0x%x lpSubKey %s ulOptions 0x%x samDesired 0x%x phkResult %p\n", - hKey, lpSubKey, ulOptions, samDesired, phkResult); - - Status = MapDefaultKey (&KeyHandle, hKey); - if (!NT_SUCCESS(Status)) - { - return RtlNtStatusToDosError (Status); - } - - RtlCreateUnicodeStringFromAsciiz (&SubKeyString, (LPSTR)lpSubKey); - InitializeObjectAttributes (&ObjectAttributes, - &SubKeyString, - OBJ_CASE_INSENSITIVE, - KeyHandle, - NULL); - - Status = NtOpenKey ((PHANDLE)phkResult, samDesired, &ObjectAttributes); - RtlFreeUnicodeString (&SubKeyString); - if (!NT_SUCCESS(Status)) - { - ErrorCode = RtlNtStatusToDosError (Status); - } - - ClosePredefKey(KeyHandle); - - return ErrorCode; + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING SubKeyString; + HANDLE KeyHandle; + NTSTATUS Status; + LONG ErrorCode = ERROR_SUCCESS; + + TRACE("RegOpenKeyExA hKey 0x%x lpSubKey %s ulOptions 0x%x samDesired 0x%x phkResult %p\n", + hKey, lpSubKey, ulOptions, samDesired, phkResult); + + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } + + RtlCreateUnicodeStringFromAsciiz(&SubKeyString, + (LPSTR)lpSubKey); + InitializeObjectAttributes(&ObjectAttributes, + &SubKeyString, + OBJ_CASE_INSENSITIVE, + KeyHandle, + NULL); + + Status = NtOpenKey((PHANDLE)phkResult, + samDesired, + &ObjectAttributes); + RtlFreeUnicodeString(&SubKeyString); + if (!NT_SUCCESS(Status)) + { + ErrorCode = RtlNtStatusToDosError(Status); + } + + ClosePredefKey(KeyHandle); + + return ErrorCode; } @@ -3310,48 +3375,49 @@ RegOpenKeyExA (HKEY hKey, * @implemented */ LONG STDCALL -RegOpenKeyExW (HKEY hKey, - LPCWSTR lpSubKey, - DWORD ulOptions, - REGSAM samDesired, - PHKEY phkResult) +RegOpenKeyExW(HKEY hKey, + LPCWSTR lpSubKey, + DWORD ulOptions, + REGSAM samDesired, + PHKEY phkResult) { - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING SubKeyString; - HANDLE KeyHandle; - NTSTATUS Status; - LONG ErrorCode = ERROR_SUCCESS; - - TRACE("RegOpenKeyExW hKey 0x%x lpSubKey %S ulOptions 0x%x samDesired 0x%x phkResult %p\n", - hKey, lpSubKey, ulOptions, samDesired, phkResult); - - Status = MapDefaultKey (&KeyHandle, hKey); - if (!NT_SUCCESS(Status)) - { - return RtlNtStatusToDosError (Status); - } - - if (lpSubKey != NULL) - RtlInitUnicodeString (&SubKeyString, (LPWSTR)lpSubKey); - else - RtlInitUnicodeString (&SubKeyString, (LPWSTR)L""); - - InitializeObjectAttributes (&ObjectAttributes, - &SubKeyString, - OBJ_CASE_INSENSITIVE, - KeyHandle, - NULL); - - Status = NtOpenKey ((PHANDLE)phkResult, samDesired, &ObjectAttributes); - - if (!NT_SUCCESS(Status)) - { - ErrorCode = RtlNtStatusToDosError (Status); - } - - ClosePredefKey(KeyHandle); - - return ErrorCode; + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING SubKeyString; + HANDLE KeyHandle; + NTSTATUS Status; + LONG ErrorCode = ERROR_SUCCESS; + + TRACE("RegOpenKeyExW hKey 0x%x lpSubKey %S ulOptions 0x%x samDesired 0x%x phkResult %p\n", + hKey, lpSubKey, ulOptions, samDesired, phkResult); + + Status = MapDefaultKey(&KeyHandle, hKey); + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } + + if (lpSubKey != NULL) + RtlInitUnicodeString(&SubKeyString, (LPWSTR)lpSubKey); + else + RtlInitUnicodeString(&SubKeyString, (LPWSTR)L""); + + InitializeObjectAttributes(&ObjectAttributes, + &SubKeyString, + OBJ_CASE_INSENSITIVE, + KeyHandle, + NULL); + + Status = NtOpenKey((PHANDLE)phkResult, + samDesired, + &ObjectAttributes); + if (!NT_SUCCESS(Status)) + { + ErrorCode = RtlNtStatusToDosError(Status); + } + + ClosePredefKey(KeyHandle); + + return ErrorCode; } @@ -3361,140 +3427,139 @@ RegOpenKeyExW (HKEY hKey, * @implemented */ LONG STDCALL -RegOpenUserClassesRoot (IN HANDLE hToken, - IN DWORD dwOptions, - IN REGSAM samDesired, - OUT PHKEY phkResult) +RegOpenUserClassesRoot(IN HANDLE hToken, + IN DWORD dwOptions, + IN REGSAM samDesired, + OUT PHKEY phkResult) { - 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 - */ + 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); - } - - 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)) - { + /* 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); + } + + 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\_Classes" + */ + Status = RtlConvertSidToUnicodeString(&UserSidString, + TokenUserData->User.Sid, + TRUE); + + /* we don't need the user data anymore, free it */ 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\_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); + 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); + } - TRACE("RegOpenUserClassesRoot: Absolute path: %wZ\n", &UserClassesKeyRoot); + /* build the string */ + RtlAppendUnicodeToString(&UserClassesKeyRoot, + UserClassesKeyPrefix); + RtlAppendUnicodeStringToString(&UserClassesKeyRoot, + &UserSidString); + RtlAppendUnicodeToString(&UserClassesKeyRoot, + UserClassesKeySuffix); - /* - * Open the key - */ + TRACE("RegOpenUserClassesRoot: Absolute path: %wZ\n", &UserClassesKeyRoot); - InitializeObjectAttributes (&ObjectAttributes, - &UserClassesKeyRoot, - OBJ_CASE_INSENSITIVE, - NULL, - NULL); + /* + * Open the key + */ + InitializeObjectAttributes(&ObjectAttributes, + &UserClassesKeyRoot, + OBJ_CASE_INSENSITIVE, + NULL, + NULL); - Status = NtOpenKey((PHANDLE)phkResult, - samDesired, - &ObjectAttributes); + Status = NtOpenKey((PHANDLE)phkResult, + samDesired, + &ObjectAttributes); - RtlFreeUnicodeString(&UserSidString); - RtlFreeUnicodeString(&UserClassesKeyRoot); + RtlFreeUnicodeString(&UserSidString); + RtlFreeUnicodeString(&UserClassesKeyRoot); - if (!NT_SUCCESS(Status)) - { - return RtlNtStatusToDosError (Status); - } + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -3504,58 +3569,58 @@ ReadTokenSid: * @implemented */ LONG STDCALL -RegQueryInfoKeyA (HKEY hKey, - LPSTR lpClass, - LPDWORD lpcbClass, - LPDWORD lpReserved, - LPDWORD lpcSubKeys, - LPDWORD lpcbMaxSubKeyLen, - LPDWORD lpcbMaxClassLen, - LPDWORD lpcValues, - LPDWORD lpcbMaxValueNameLen, - LPDWORD lpcbMaxValueLen, - LPDWORD lpcbSecurityDescriptor, - PFILETIME lpftLastWriteTime) +RegQueryInfoKeyA(HKEY hKey, + LPSTR lpClass, + LPDWORD lpcbClass, + LPDWORD lpReserved, + LPDWORD lpcSubKeys, + LPDWORD lpcbMaxSubKeyLen, + LPDWORD lpcbMaxClassLen, + LPDWORD lpcValues, + LPDWORD lpcbMaxValueNameLen, + LPDWORD lpcbMaxValueLen, + LPDWORD lpcbSecurityDescriptor, + PFILETIME lpftLastWriteTime) { - WCHAR ClassName[MAX_PATH]; - UNICODE_STRING UnicodeString; - ANSI_STRING AnsiString; - LONG ErrorCode; - - RtlInitUnicodeString (&UnicodeString, - NULL); - if (lpClass != NULL) - { - UnicodeString.Buffer = &ClassName[0]; - UnicodeString.MaximumLength = sizeof(ClassName); - AnsiString.MaximumLength = *lpcbClass; - } - - ErrorCode = RegQueryInfoKeyW (hKey, - UnicodeString.Buffer, - lpcbClass, - lpReserved, - lpcSubKeys, - lpcbMaxSubKeyLen, - lpcbMaxClassLen, - lpcValues, - lpcbMaxValueNameLen, - lpcbMaxValueLen, - lpcbSecurityDescriptor, - lpftLastWriteTime); - if ((ErrorCode == ERROR_SUCCESS) && (lpClass != NULL)) - { - AnsiString.Buffer = lpClass; - AnsiString.Length = 0; - UnicodeString.Length = *lpcbClass * sizeof(WCHAR); - RtlUnicodeStringToAnsiString (&AnsiString, - &UnicodeString, - FALSE); - *lpcbClass = AnsiString.Length; - lpClass[AnsiString.Length] = 0; - } - - return ErrorCode; + WCHAR ClassName[MAX_PATH]; + UNICODE_STRING UnicodeString; + ANSI_STRING AnsiString; + LONG ErrorCode; + + RtlInitUnicodeString(&UnicodeString, + NULL); + if (lpClass != NULL) + { + UnicodeString.Buffer = &ClassName[0]; + UnicodeString.MaximumLength = sizeof(ClassName); + AnsiString.MaximumLength = *lpcbClass; + } + + ErrorCode = RegQueryInfoKeyW(hKey, + UnicodeString.Buffer, + lpcbClass, + lpReserved, + lpcSubKeys, + lpcbMaxSubKeyLen, + lpcbMaxClassLen, + lpcValues, + lpcbMaxValueNameLen, + lpcbMaxValueLen, + lpcbSecurityDescriptor, + lpftLastWriteTime); + if ((ErrorCode == ERROR_SUCCESS) && (lpClass != NULL)) + { + AnsiString.Buffer = lpClass; + AnsiString.Length = 0; + UnicodeString.Length = *lpcbClass * sizeof(WCHAR); + RtlUnicodeStringToAnsiString(&AnsiString, + &UnicodeString, + FALSE); + *lpcbClass = AnsiString.Length; + lpClass[AnsiString.Length] = 0; + } + + return ErrorCode; } @@ -3565,323 +3630,436 @@ RegQueryInfoKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegQueryInfoKeyW (HKEY hKey, - LPWSTR lpClass, - LPDWORD lpcbClass, - LPDWORD lpReserved, - LPDWORD lpcSubKeys, - LPDWORD lpcbMaxSubKeyLen, - LPDWORD lpcbMaxClassLen, - LPDWORD lpcValues, - LPDWORD lpcbMaxValueNameLen, - LPDWORD lpcbMaxValueLen, - LPDWORD lpcbSecurityDescriptor, - PFILETIME lpftLastWriteTime) +RegQueryInfoKeyW(HKEY hKey, + LPWSTR lpClass, + LPDWORD lpcbClass, + LPDWORD lpReserved, + LPDWORD lpcSubKeys, + LPDWORD lpcbMaxSubKeyLen, + LPDWORD lpcbMaxClassLen, + LPDWORD lpcValues, + LPDWORD lpcbMaxValueNameLen, + LPDWORD lpcbMaxValueLen, + LPDWORD lpcbSecurityDescriptor, + PFILETIME lpftLastWriteTime) { - 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) && (!lpcbClass)) - { - return ERROR_INVALID_PARAMETER; - } - - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) - { - return RtlNtStatusToDosError (Status); - } - - if (lpClass != NULL) - { - if (*lpcbClass > 0) - { - ClassLength = min(*lpcbClass - 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; - } - - FullInfo->ClassLength = ClassLength; - } - else - { - FullInfoSize = sizeof(KEY_FULL_INFORMATION); - FullInfo = &FullInfoBuffer; - FullInfo->ClassLength = 0; - } - FullInfo->ClassOffset = FIELD_OFFSET(KEY_FULL_INFORMATION, Class); - - Status = NtQueryKey (KeyHandle, - KeyFullInformation, - FullInfo, - FullInfoSize, - &Length); - TRACE("NtQueryKey() returned status 0x%X\n", Status); - if (!NT_SUCCESS(Status)) - { - if (lpClass != NULL) - { - RtlFreeHeap (ProcessHeap, - 0, - FullInfo); - } - - ErrorCode = RtlNtStatusToDosError (Status); - goto Cleanup; + 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) && (!lpcbClass)) + { + return ERROR_INVALID_PARAMETER; + } + + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) + { + return RtlNtStatusToDosError(Status); + } + + if (lpClass != NULL) + { + if (*lpcbClass > 0) + { + ClassLength = min(*lpcbClass - 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; + } + + FullInfo->ClassLength = ClassLength; + } + else + { + FullInfoSize = sizeof(KEY_FULL_INFORMATION); + FullInfo = &FullInfoBuffer; + FullInfo->ClassLength = 0; + } + FullInfo->ClassOffset = FIELD_OFFSET(KEY_FULL_INFORMATION, Class); + + Status = NtQueryKey(KeyHandle, + KeyFullInformation, + FullInfo, + FullInfoSize, + &Length); + TRACE("NtQueryKey() returned status 0x%X\n", Status); + if (!NT_SUCCESS(Status)) + { + if (lpClass != NULL) + { + RtlFreeHeap(ProcessHeap, + 0, + FullInfo); + } + + ErrorCode = RtlNtStatusToDosError(Status); + goto Cleanup; + } + + TRACE("SubKeys %d\n", FullInfo->SubKeys); + if (lpcSubKeys != NULL) + { + *lpcSubKeys = FullInfo->SubKeys; + } + + TRACE("MaxNameLen %lu\n", FullInfo->MaxNameLen); + if (lpcbMaxSubKeyLen != NULL) + { + *lpcbMaxSubKeyLen = FullInfo->MaxNameLen / sizeof(WCHAR) + 1; + } + + TRACE("MaxClassLen %lu\n", FullInfo->MaxClassLen); + if (lpcbMaxClassLen != NULL) + { + *lpcbMaxClassLen = FullInfo->MaxClassLen / sizeof(WCHAR) + 1; + } + + TRACE("Values %lu\n", FullInfo->Values); + if (lpcValues != NULL) + { + *lpcValues = FullInfo->Values; + } + + TRACE("MaxValueNameLen %lu\n", FullInfo->MaxValueNameLen); + if (lpcbMaxValueNameLen != NULL) + { + *lpcbMaxValueNameLen = FullInfo->MaxValueNameLen / sizeof(WCHAR) + 1; } - TRACE("SubKeys %d\n", FullInfo->SubKeys); - if (lpcSubKeys != NULL) + TRACE("MaxValueDataLen %lu\n", FullInfo->MaxValueDataLen); + if (lpcbMaxValueLen != NULL) { - *lpcSubKeys = FullInfo->SubKeys; + *lpcbMaxValueLen = FullInfo->MaxValueDataLen; + } + +#if 0 + if (lpcbSecurityDescriptor != NULL) + { + Status = NtQuerySecurityObject(KeyHandle, + OWNER_SECURITY_INFORMATION | + GROUP_SECURITY_INFORMATION | + DACL_SECURITY_INFORMATION, + NULL, + 0, + lpcbSecurityDescriptor); + if (!NT_SUCCESS(Status)) + { + if (lpClass != NULL) + { + RtlFreeHeap(ProcessHeap, + 0, + FullInfo); + } + + ErrorCode = RtlNtStatusToDosError(Status); + goto Cleanup; + } } +#endif - TRACE("MaxNameLen %lu\n", FullInfo->MaxNameLen); - if (lpcbMaxSubKeyLen != NULL) + if (lpftLastWriteTime != NULL) { - *lpcbMaxSubKeyLen = FullInfo->MaxNameLen / sizeof(WCHAR) + 1; + lpftLastWriteTime->dwLowDateTime = FullInfo->LastWriteTime.u.LowPart; + lpftLastWriteTime->dwHighDateTime = FullInfo->LastWriteTime.u.HighPart; } - TRACE("MaxClassLen %lu\n", FullInfo->MaxClassLen); - if (lpcbMaxClassLen != NULL) + if (lpClass != NULL) { - *lpcbMaxClassLen = FullInfo->MaxClassLen / sizeof(WCHAR) + 1; + if (FullInfo->ClassLength > ClassLength) + { + ErrorCode = ERROR_BUFFER_OVERFLOW; + } + else + { + RtlCopyMemory(lpClass, + FullInfo->Class, + FullInfo->ClassLength); + *lpcbClass = FullInfo->ClassLength / sizeof(WCHAR); + lpClass[*lpcbClass] = 0; + } + + RtlFreeHeap(ProcessHeap, + 0, + FullInfo); } - TRACE("Values %lu\n", FullInfo->Values); - if (lpcValues != NULL) +Cleanup: + ClosePredefKey(KeyHandle); + + return ErrorCode; +} + + +/************************************************************************ + * RegQueryMultipleValuesA + * + * @implemented + */ +LONG STDCALL +RegQueryMultipleValuesA(HKEY hKey, + PVALENTA val_list, + DWORD num_vals, + LPSTR lpValueBuf, + LPDWORD ldwTotsize) +{ + ULONG i; + DWORD maxBytes = *ldwTotsize; + LPSTR bufptr = (LPSTR)lpValueBuf; + LONG ErrorCode; + + if (maxBytes >= (1024*1024)) + return ERROR_TRANSFER_TOO_LONG; + + *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++) { - *lpcValues = FullInfo->Values; + 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; } - TRACE("MaxValueNameLen %lu\n", FullInfo->MaxValueNameLen); - if (lpcbMaxValueNameLen != NULL) - { - *lpcbMaxValueNameLen = FullInfo->MaxValueNameLen / sizeof(WCHAR) + 1; - } + return (lpValueBuf != NULL && *ldwTotsize <= maxBytes) ? ERROR_SUCCESS : ERROR_MORE_DATA; +} + + +/************************************************************************ + * RegQueryMultipleValuesW + * + * @implemented + */ +LONG STDCALL +RegQueryMultipleValuesW(HKEY hKey, + PVALENTW val_list, + DWORD num_vals, + LPWSTR lpValueBuf, + LPDWORD ldwTotsize) +{ + ULONG i; + DWORD maxBytes = *ldwTotsize; + LPSTR bufptr = (LPSTR)lpValueBuf; + LONG ErrorCode; + + if (maxBytes >= (1024*1024)) + return ERROR_TRANSFER_TOO_LONG; + + *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 + * + * @unimplemented + */ +LONG WINAPI +RegQueryReflectionKey(IN HKEY hBase, + OUT BOOL* bIsReflectionDisabled) +{ + FIXME("RegQueryReflectionKey(0x%p, 0x%p) UNIMPLEMENTED!\n", + hBase, bIsReflectionDisabled); + return ERROR_CALL_NOT_IMPLEMENTED; +} + + +/************************************************************************ + * RegQueryValueExA + * + * @implemented + */ +LONG STDCALL +RegQueryValueExA(HKEY hKey, + LPCSTR lpValueName, + LPDWORD lpReserved, + LPDWORD lpType, + LPBYTE lpData, + LPDWORD lpcbData) +{ + UNICODE_STRING ValueName; + UNICODE_STRING ValueData; + ANSI_STRING AnsiString; + LONG ErrorCode; + DWORD Length; + DWORD Type; + + TRACE("hKey 0x%X lpValueName %s lpData 0x%X lpcbData %d\n", + hKey, lpValueName, lpData, lpcbData ? *lpcbData : 0); - TRACE("MaxValueDataLen %lu\n", FullInfo->MaxValueDataLen); - if (lpcbMaxValueLen != NULL) + if (lpData != NULL && lpcbData == NULL) { - *lpcbMaxValueLen = FullInfo->MaxValueDataLen; - } -#if 0 - if (lpcbSecurityDescriptor != NULL) - { - Status = NtQuerySecurityObject(KeyHandle, - OWNER_SECURITY_INFORMATION | - GROUP_SECURITY_INFORMATION | - DACL_SECURITY_INFORMATION, - NULL, - 0, - lpcbSecurityDescriptor); - if (!NT_SUCCESS(Status)) - { - if (lpClass != NULL) - { - RtlFreeHeap(ProcessHeap, - 0, - FullInfo); - } - - ErrorCode = RtlNtStatusToDosError (Status); - goto Cleanup; - } + return ERROR_INVALID_PARAMETER; } -#endif - if (lpftLastWriteTime != NULL) + if (lpData) { - lpftLastWriteTime->dwLowDateTime = FullInfo->LastWriteTime.u.LowPart; - lpftLastWriteTime->dwHighDateTime = FullInfo->LastWriteTime.u.HighPart; + ValueData.Length = 0; + ValueData.MaximumLength = (*lpcbData + 1) * sizeof(WCHAR); + ValueData.Buffer = RtlAllocateHeap(ProcessHeap, + 0, + ValueData.MaximumLength); + if (!ValueData.Buffer) + { + return ERROR_OUTOFMEMORY; + } } - - if (lpClass != NULL) + else { - if (FullInfo->ClassLength > ClassLength) - { - ErrorCode = ERROR_BUFFER_OVERFLOW; - } - else - { - RtlCopyMemory (lpClass, - FullInfo->Class, - FullInfo->ClassLength); - *lpcbClass = FullInfo->ClassLength / sizeof(WCHAR); - lpClass[*lpcbClass] = 0; - } + ValueData.Buffer = NULL; + ValueData.Length = 0; + ValueData.MaximumLength = 0; - RtlFreeHeap (ProcessHeap, - 0, - FullInfo); + if (lpcbData) + *lpcbData = 0; } -Cleanup: - ClosePredefKey(KeyHandle); + RtlCreateUnicodeStringFromAsciiz(&ValueName, + (LPSTR)lpValueName); - return ErrorCode; -} + Length = (lpcbData == NULL) ? 0 : *lpcbData * sizeof(WCHAR); + ErrorCode = RegQueryValueExW(hKey, + ValueName.Buffer, + lpReserved, + &Type, + (lpData == NULL) ? NULL : (LPBYTE)ValueData.Buffer, + &Length); + TRACE("ErrorCode %lu\n", ErrorCode); + RtlFreeUnicodeString(&ValueName); + if (ErrorCode == ERROR_SUCCESS || + ErrorCode == ERROR_MORE_DATA) + { + if (lpType != NULL) + { + *lpType = Type; + } -/************************************************************************ - * RegQueryMultipleValuesA - * - * @implemented - */ -LONG STDCALL -RegQueryMultipleValuesA (HKEY hKey, - PVALENTA val_list, - DWORD num_vals, - LPSTR lpValueBuf, - LPDWORD ldwTotsize) -{ - ULONG i; - DWORD maxBytes = *ldwTotsize; - LPSTR bufptr = (LPSTR)lpValueBuf; - LONG ErrorCode; - - if (maxBytes >= (1024*1024)) - return ERROR_TRANSFER_TOO_LONG; - - *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; -} + if ((Type == REG_SZ) || (Type == REG_MULTI_SZ) || (Type == REG_EXPAND_SZ)) + { + if (ErrorCode == ERROR_SUCCESS && ValueData.Buffer != NULL) + { + RtlInitAnsiString(&AnsiString, NULL); + AnsiString.Buffer = (LPSTR)lpData; + AnsiString.MaximumLength = *lpcbData; + ValueData.Length = Length; + ValueData.MaximumLength = ValueData.Length + sizeof(WCHAR); + RtlUnicodeStringToAnsiString(&AnsiString, &ValueData, FALSE); + } + Length = Length / sizeof(WCHAR); + } + else if (ErrorCode == ERROR_SUCCESS && ValueData.Buffer != NULL) + { + if (*lpcbData < Length) + { + ErrorCode = ERROR_MORE_DATA; + } + else + { + RtlMoveMemory(lpData, ValueData.Buffer, Length); + } + } -/************************************************************************ - * RegQueryMultipleValuesW - * - * @implemented - */ -LONG STDCALL -RegQueryMultipleValuesW (HKEY hKey, - PVALENTW val_list, - DWORD num_vals, - LPWSTR lpValueBuf, - LPDWORD ldwTotsize) -{ - ULONG i; - DWORD maxBytes = *ldwTotsize; - LPSTR bufptr = (LPSTR)lpValueBuf; - LONG ErrorCode; - - if (maxBytes >= (1024*1024)) - return ERROR_TRANSFER_TOO_LONG; - - *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; -} + if (lpcbData != NULL) + { + *lpcbData = Length; + } + } + if (ValueData.Buffer != NULL) + { + RtlFreeHeap(ProcessHeap, 0, ValueData.Buffer); + } -/************************************************************************ - * RegQueryReflectionKey - * - * @unimplemented - */ -LONG WINAPI -RegQueryReflectionKey(IN HKEY hBase, - OUT BOOL* bIsReflectionDisabled) -{ - FIXME("RegQueryReflectionKey(0x%p, 0x%p) UNIMPLEMENTED!\n", - hBase, bIsReflectionDisabled); - return ERROR_CALL_NOT_IMPLEMENTED; + return ErrorCode; } @@ -3971,209 +4149,98 @@ RegQueryValueExW(HKEY hkeyorg, } -/************************************************************************ - * RegQueryValueExA - * - * @implemented - */ -LONG STDCALL -RegQueryValueExA (HKEY hKey, - LPCSTR lpValueName, - LPDWORD lpReserved, - LPDWORD lpType, - LPBYTE lpData, - LPDWORD lpcbData) -{ - UNICODE_STRING ValueName; - UNICODE_STRING ValueData; - ANSI_STRING AnsiString; - LONG ErrorCode; - DWORD Length; - DWORD Type; - - TRACE("hKey 0x%X lpValueName %s lpData 0x%X lpcbData %d\n", - hKey, lpValueName, lpData, lpcbData ? *lpcbData : 0); - - if (lpData != NULL && lpcbData == NULL) - { - return ERROR_INVALID_PARAMETER; - } - - if (lpData) - { - ValueData.Length = 0; - ValueData.MaximumLength = (*lpcbData + 1) * sizeof(WCHAR); - ValueData.Buffer = RtlAllocateHeap (ProcessHeap, - 0, - ValueData.MaximumLength); - if (!ValueData.Buffer) - { - return ERROR_OUTOFMEMORY; - } - } - else - { - ValueData.Buffer = NULL; - ValueData.Length = 0; - ValueData.MaximumLength = 0; - - if (lpcbData) - *lpcbData = 0; - } - - RtlCreateUnicodeStringFromAsciiz (&ValueName, - (LPSTR)lpValueName); - - Length = (lpcbData == NULL) ? 0 : *lpcbData * sizeof(WCHAR); - ErrorCode = RegQueryValueExW (hKey, - ValueName.Buffer, - lpReserved, - &Type, - (lpData == NULL) ? NULL : (LPBYTE)ValueData.Buffer, - &Length); - TRACE("ErrorCode %lu\n", ErrorCode); - RtlFreeUnicodeString(&ValueName); - - if (ErrorCode == ERROR_SUCCESS || - ErrorCode == ERROR_MORE_DATA) - { - if (lpType != NULL) - { - *lpType = Type; - } - - if ((Type == REG_SZ) || (Type == REG_MULTI_SZ) || (Type == REG_EXPAND_SZ)) - { - if (ErrorCode == ERROR_SUCCESS && ValueData.Buffer != NULL) - { - RtlInitAnsiString(&AnsiString, NULL); - AnsiString.Buffer = (LPSTR)lpData; - AnsiString.MaximumLength = *lpcbData; - ValueData.Length = Length; - ValueData.MaximumLength = ValueData.Length + sizeof(WCHAR); - RtlUnicodeStringToAnsiString(&AnsiString, &ValueData, FALSE); - } - Length = Length / sizeof(WCHAR); - } - else if (ErrorCode == ERROR_SUCCESS && ValueData.Buffer != NULL) - { - if (*lpcbData < Length) - { - ErrorCode = ERROR_MORE_DATA; - } - else - { - RtlMoveMemory(lpData, ValueData.Buffer, Length); - } - } - - if (lpcbData != NULL) - { - *lpcbData = Length; - } - } - - if (ValueData.Buffer != NULL) - { - RtlFreeHeap(ProcessHeap, 0, ValueData.Buffer); - } - - return ErrorCode; -} - - /************************************************************************ * RegQueryValueA * * @implemented */ LONG STDCALL -RegQueryValueA (HKEY hKey, - LPCSTR lpSubKey, - LPSTR lpValue, - PLONG lpcbValue) +RegQueryValueA(HKEY hKey, + LPCSTR lpSubKey, + LPSTR lpValue, + PLONG lpcbValue) { - WCHAR SubKeyNameBuffer[MAX_PATH+1]; - UNICODE_STRING SubKeyName; - UNICODE_STRING Value; - ANSI_STRING AnsiString; - LONG ValueSize; - LONG ErrorCode; + WCHAR SubKeyNameBuffer[MAX_PATH+1]; + UNICODE_STRING SubKeyName; + UNICODE_STRING Value; + ANSI_STRING AnsiString; + LONG ValueSize; + LONG ErrorCode; - TRACE("hKey 0x%X lpSubKey %s lpValue %p lpcbValue %d\n", - hKey, lpSubKey, lpValue, lpcbValue ? *lpcbValue : 0); + TRACE("hKey 0x%X lpSubKey %s lpValue %p lpcbValue %d\n", + hKey, lpSubKey, lpValue, lpcbValue ? *lpcbValue : 0); - if (lpValue != NULL && - lpcbValue == NULL) + if (lpValue != NULL && + lpcbValue == NULL) { - return ERROR_INVALID_PARAMETER; + return ERROR_INVALID_PARAMETER; } - RtlInitUnicodeString (&SubKeyName, - NULL); - RtlInitUnicodeString (&Value, - NULL); - if (lpSubKey != NULL && - strlen(lpSubKey) != 0) + RtlInitUnicodeString(&SubKeyName, + NULL); + RtlInitUnicodeString(&Value, + NULL); + if (lpSubKey != NULL && + strlen(lpSubKey) != 0) { - RtlInitAnsiString (&AnsiString, - (LPSTR)lpSubKey); + RtlInitAnsiString(&AnsiString, + (LPSTR)lpSubKey); SubKeyName.Buffer = &SubKeyNameBuffer[0]; SubKeyName.MaximumLength = sizeof(SubKeyNameBuffer); - RtlAnsiStringToUnicodeString (&SubKeyName, - &AnsiString, - FALSE); + RtlAnsiStringToUnicodeString(&SubKeyName, + &AnsiString, + FALSE); } - if (lpValue != NULL) + if (lpValue != NULL) { - ValueSize = *lpcbValue * sizeof(WCHAR); - Value.MaximumLength = ValueSize; - Value.Buffer = RtlAllocateHeap (ProcessHeap, - 0, - ValueSize); - if (Value.Buffer == NULL) - { - return ERROR_OUTOFMEMORY; - } + ValueSize = *lpcbValue * sizeof(WCHAR); + Value.MaximumLength = ValueSize; + Value.Buffer = RtlAllocateHeap(ProcessHeap, + 0, + ValueSize); + if (Value.Buffer == NULL) + { + return ERROR_OUTOFMEMORY; + } } - else + else { - ValueSize = 0; + ValueSize = 0; } - ErrorCode = RegQueryValueW (hKey, - (LPCWSTR)SubKeyName.Buffer, - Value.Buffer, - &ValueSize); - if (ErrorCode == ERROR_SUCCESS) + ErrorCode = RegQueryValueW(hKey, + (LPCWSTR)SubKeyName.Buffer, + Value.Buffer, + &ValueSize); + if (ErrorCode == ERROR_SUCCESS) { - if (lpValue != NULL) - { - Value.Length = ValueSize; - RtlInitAnsiString (&AnsiString, - NULL); - AnsiString.Buffer = lpValue; - AnsiString.MaximumLength = *lpcbValue; - RtlUnicodeStringToAnsiString (&AnsiString, - &Value, - FALSE); - *lpcbValue = ValueSize; - } - else if (lpcbValue != NULL) - { - *lpcbValue = ValueSize; - } + if (lpValue != NULL) + { + Value.Length = ValueSize; + RtlInitAnsiString(&AnsiString, + NULL); + AnsiString.Buffer = lpValue; + AnsiString.MaximumLength = *lpcbValue; + RtlUnicodeStringToAnsiString(&AnsiString, + &Value, + FALSE); + *lpcbValue = ValueSize; + } + else if (lpcbValue != NULL) + { + *lpcbValue = ValueSize; + } } - if (Value.Buffer != NULL) + if (Value.Buffer != NULL) { - RtlFreeHeap (ProcessHeap, - 0, - Value.Buffer); + RtlFreeHeap(ProcessHeap, + 0, + Value.Buffer); } - return ErrorCode; + return ErrorCode; } @@ -4183,70 +4250,71 @@ RegQueryValueA (HKEY hKey, * @implemented */ LONG STDCALL -RegQueryValueW (HKEY hKey, - LPCWSTR lpSubKey, - LPWSTR lpValue, - PLONG lpcbValue) +RegQueryValueW(HKEY hKey, + LPCWSTR lpSubKey, + LPWSTR lpValue, + PLONG lpcbValue) { - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING SubKeyString; - HANDLE KeyHandle; - HANDLE RealKey; - LONG ErrorCode; - BOOL CloseRealKey; - NTSTATUS Status; + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING SubKeyString; + HANDLE KeyHandle; + HANDLE RealKey; + LONG ErrorCode; + BOOL CloseRealKey; + NTSTATUS Status; - TRACE("hKey 0x%X lpSubKey %S lpValue %p lpcbValue %d\n", - hKey, lpSubKey, lpValue, lpcbValue ? *lpcbValue : 0); + TRACE("hKey 0x%X lpSubKey %S lpValue %p lpcbValue %d\n", + hKey, lpSubKey, lpValue, lpcbValue ? *lpcbValue : 0); - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - if (lpSubKey != NULL && - wcslen(lpSubKey) != 0) + if (lpSubKey != NULL && + wcslen(lpSubKey) != 0) { - RtlInitUnicodeString (&SubKeyString, - (LPWSTR)lpSubKey); - InitializeObjectAttributes (&ObjectAttributes, - &SubKeyString, - OBJ_CASE_INSENSITIVE, - KeyHandle, - NULL); - Status = NtOpenKey (&RealKey, - KEY_QUERY_VALUE, - &ObjectAttributes); - if (!NT_SUCCESS(Status)) - { - ErrorCode = RtlNtStatusToDosError (Status); - goto Cleanup; - } - CloseRealKey = TRUE; + RtlInitUnicodeString(&SubKeyString, + (LPWSTR)lpSubKey); + InitializeObjectAttributes(&ObjectAttributes, + &SubKeyString, + OBJ_CASE_INSENSITIVE, + KeyHandle, + NULL); + Status = NtOpenKey(&RealKey, + KEY_QUERY_VALUE, + &ObjectAttributes); + if (!NT_SUCCESS(Status)) + { + ErrorCode = RtlNtStatusToDosError(Status); + goto Cleanup; + } + + CloseRealKey = TRUE; } - else + else { - RealKey = hKey; - CloseRealKey = FALSE; + RealKey = hKey; + CloseRealKey = FALSE; } - ErrorCode = RegQueryValueExW (RealKey, - NULL, - NULL, - NULL, - (LPBYTE)lpValue, - (LPDWORD)lpcbValue); - if (CloseRealKey) + ErrorCode = RegQueryValueExW(RealKey, + NULL, + NULL, + NULL, + (LPBYTE)lpValue, + (LPDWORD)lpcbValue); + if (CloseRealKey) { - NtClose (RealKey); + NtClose(RealKey); } Cleanup: - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - return ErrorCode; + return ErrorCode; } @@ -4256,33 +4324,33 @@ Cleanup: * @implemented */ LONG STDCALL -RegReplaceKeyA (HKEY hKey, - LPCSTR lpSubKey, - LPCSTR lpNewFile, - LPCSTR lpOldFile) +RegReplaceKeyA(HKEY hKey, + LPCSTR lpSubKey, + LPCSTR lpNewFile, + LPCSTR lpOldFile) { - UNICODE_STRING SubKey; - UNICODE_STRING NewFile; - UNICODE_STRING OldFile; - LONG ErrorCode; - - RtlCreateUnicodeStringFromAsciiz (&SubKey, - (PCSZ)lpSubKey); - RtlCreateUnicodeStringFromAsciiz (&OldFile, - (PCSZ)lpOldFile); - RtlCreateUnicodeStringFromAsciiz (&NewFile, - (PCSZ)lpNewFile); - - ErrorCode = RegReplaceKeyW (hKey, - SubKey.Buffer, - NewFile.Buffer, - OldFile.Buffer); - - RtlFreeUnicodeString (&OldFile); - RtlFreeUnicodeString (&NewFile); - RtlFreeUnicodeString (&SubKey); - - return ErrorCode; + UNICODE_STRING SubKey; + UNICODE_STRING NewFile; + UNICODE_STRING OldFile; + LONG ErrorCode; + + RtlCreateUnicodeStringFromAsciiz(&SubKey, + (PCSZ)lpSubKey); + RtlCreateUnicodeStringFromAsciiz(&OldFile, + (PCSZ)lpOldFile); + RtlCreateUnicodeStringFromAsciiz(&NewFile, + (PCSZ)lpNewFile); + + ErrorCode = RegReplaceKeyW(hKey, + SubKey.Buffer, + NewFile.Buffer, + OldFile.Buffer); + + RtlFreeUnicodeString(&OldFile); + RtlFreeUnicodeString(&NewFile); + RtlFreeUnicodeString(&SubKey); + + return ErrorCode; } @@ -4292,129 +4360,132 @@ RegReplaceKeyA (HKEY hKey, * @unimplemented */ LONG STDCALL -RegReplaceKeyW (HKEY hKey, - LPCWSTR lpSubKey, - LPCWSTR lpNewFile, - LPCWSTR lpOldFile) +RegReplaceKeyW(HKEY hKey, + LPCWSTR lpSubKey, + LPCWSTR lpNewFile, + LPCWSTR lpOldFile) { - 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) + 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; + return ERROR_INVALID_HANDLE; } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - /* Open the real key */ - if (lpSubKey != NULL && *lpSubKey != (WCHAR)0) + /* Open the real key */ + if (lpSubKey != NULL && *lpSubKey != (WCHAR)0) { - RtlInitUnicodeString (&SubKeyName, - (PWSTR)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; + RtlInitUnicodeString(&SubKeyName, + (PWSTR)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 + else { - RealKeyHandle = KeyHandle; - CloseRealKey = FALSE; + RealKeyHandle = KeyHandle; + CloseRealKey = FALSE; } - /* Convert new file name */ - if (!RtlDosPathNameToNtPathName_U (lpNewFile, - &NewFileName, - NULL, - NULL)) + /* Convert new file name */ + if (!RtlDosPathNameToNtPathName_U(lpNewFile, + &NewFileName, + NULL, + NULL)) { - if (CloseRealKey) - { - NtClose (RealKeyHandle); - } - ErrorCode = ERROR_INVALID_PARAMETER; - goto Cleanup; + 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(&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); + InitializeObjectAttributes(&OldObjectAttributes, + &OldFileName, + OBJ_CASE_INSENSITIVE, + NULL, + NULL); - Status = NtReplaceKey (&NewObjectAttributes, - RealKeyHandle, - &OldObjectAttributes); + Status = NtReplaceKey(&NewObjectAttributes, + RealKeyHandle, + &OldObjectAttributes); - RtlFreeHeap (RtlGetProcessHeap (), - 0, - OldFileName.Buffer); - RtlFreeHeap (RtlGetProcessHeap (), - 0, - NewFileName.Buffer); + RtlFreeHeap(RtlGetProcessHeap(), + 0, + OldFileName.Buffer); + RtlFreeHeap(RtlGetProcessHeap(), + 0, + NewFileName.Buffer); - if (CloseRealKey) + if (CloseRealKey) { - NtClose (RealKeyHandle); + NtClose(RealKeyHandle); } - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } Cleanup: - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - return ErrorCode; + return ErrorCode; } @@ -4424,23 +4495,23 @@ Cleanup: * @implemented */ LONG STDCALL -RegRestoreKeyA (HKEY hKey, - LPCSTR lpFile, - DWORD dwFlags) +RegRestoreKeyA(HKEY hKey, + LPCSTR lpFile, + DWORD dwFlags) { - UNICODE_STRING FileName; - LONG ErrorCode; + UNICODE_STRING FileName; + LONG ErrorCode; - RtlCreateUnicodeStringFromAsciiz (&FileName, - (PCSZ)lpFile); + RtlCreateUnicodeStringFromAsciiz(&FileName, + (PCSZ)lpFile); - ErrorCode = RegRestoreKeyW (hKey, - FileName.Buffer, - dwFlags); + ErrorCode = RegRestoreKeyW(hKey, + FileName.Buffer, + dwFlags); - RtlFreeUnicodeString (&FileName); + RtlFreeUnicodeString(&FileName); - return ErrorCode; + return ErrorCode; } @@ -4450,72 +4521,72 @@ RegRestoreKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegRestoreKeyW (HKEY hKey, - LPCWSTR lpFile, - DWORD dwFlags) +RegRestoreKeyW(HKEY hKey, + LPCWSTR lpFile, + DWORD dwFlags) { - OBJECT_ATTRIBUTES ObjectAttributes; - IO_STATUS_BLOCK IoStatusBlock; - UNICODE_STRING FileName; - HANDLE FileHandle; - HANDLE KeyHandle; - NTSTATUS Status; + OBJECT_ATTRIBUTES ObjectAttributes; + IO_STATUS_BLOCK IoStatusBlock; + UNICODE_STRING FileName; + HANDLE FileHandle; + HANDLE KeyHandle; + NTSTATUS Status; - if (hKey == HKEY_PERFORMANCE_DATA) + if (hKey == HKEY_PERFORMANCE_DATA) { - return ERROR_INVALID_HANDLE; + return ERROR_INVALID_HANDLE; } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - if (!RtlDosPathNameToNtPathName_U (lpFile, - &FileName, - NULL, - NULL)) + if (!RtlDosPathNameToNtPathName_U(lpFile, + &FileName, + NULL, + NULL)) { - Status = STATUS_INVALID_PARAMETER; - goto Cleanup; + Status = STATUS_INVALID_PARAMETER; + goto Cleanup; } - InitializeObjectAttributes (&ObjectAttributes, - &FileName, - OBJ_CASE_INSENSITIVE, - NULL, - NULL); + 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)) + 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; + goto Cleanup; } - Status = NtRestoreKey (KeyHandle, - FileHandle, - (ULONG)dwFlags); - NtClose (FileHandle); + Status = NtRestoreKey(KeyHandle, + FileHandle, + (ULONG)dwFlags); + NtClose (FileHandle); Cleanup: - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -4525,21 +4596,21 @@ Cleanup: * @implemented */ LONG STDCALL -RegSaveKeyA (HKEY hKey, - LPCSTR lpFile, - LPSECURITY_ATTRIBUTES lpSecurityAttributes) +RegSaveKeyA(HKEY hKey, + LPCSTR lpFile, + LPSECURITY_ATTRIBUTES lpSecurityAttributes) { - UNICODE_STRING FileName; - LONG ErrorCode; + UNICODE_STRING FileName; + LONG ErrorCode; - RtlCreateUnicodeStringFromAsciiz (&FileName, - (LPSTR)lpFile); - ErrorCode = RegSaveKeyW (hKey, - FileName.Buffer, - lpSecurityAttributes); - RtlFreeUnicodeString (&FileName); + RtlCreateUnicodeStringFromAsciiz(&FileName, + (LPSTR)lpFile); + ErrorCode = RegSaveKeyW(hKey, + FileName.Buffer, + lpSecurityAttributes); + RtlFreeUnicodeString(&FileName); - return ErrorCode; + return ErrorCode; } @@ -4549,76 +4620,76 @@ RegSaveKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegSaveKeyW (HKEY hKey, - LPCWSTR lpFile, - LPSECURITY_ATTRIBUTES lpSecurityAttributes) +RegSaveKeyW(HKEY hKey, + LPCWSTR lpFile, + LPSECURITY_ATTRIBUTES lpSecurityAttributes) { - PSECURITY_DESCRIPTOR SecurityDescriptor = NULL; - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING FileName; - IO_STATUS_BLOCK IoStatusBlock; - HANDLE FileHandle; - HANDLE KeyHandle; - NTSTATUS Status; + 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); + } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + if (!RtlDosPathNameToNtPathName_U(lpFile, + &FileName, + NULL, + NULL)) { - return RtlNtStatusToDosError (Status); + Status = STATUS_INVALID_PARAMETER; + goto Cleanup; } - if (!RtlDosPathNameToNtPathName_U (lpFile, - &FileName, - NULL, - NULL)) + if (lpSecurityAttributes != NULL) { - Status = STATUS_INVALID_PARAMETER; - goto Cleanup; + SecurityDescriptor = lpSecurityAttributes->lpSecurityDescriptor; } - 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)) + 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; + goto Cleanup; } - Status = NtSaveKey (KeyHandle, - FileHandle); - NtClose (FileHandle); + Status = NtSaveKey(KeyHandle, + FileHandle); + NtClose (FileHandle); Cleanup: - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -4628,37 +4699,37 @@ Cleanup: * @implemented */ LONG STDCALL -RegSetKeySecurity (HKEY hKey, - SECURITY_INFORMATION SecurityInformation, - PSECURITY_DESCRIPTOR pSecurityDescriptor) +RegSetKeySecurity(HKEY hKey, + SECURITY_INFORMATION SecurityInformation, + PSECURITY_DESCRIPTOR pSecurityDescriptor) { - HANDLE KeyHandle; - NTSTATUS Status; + HANDLE KeyHandle; + NTSTATUS Status; - if (hKey == HKEY_PERFORMANCE_DATA) + if (hKey == HKEY_PERFORMANCE_DATA) { - return ERROR_INVALID_HANDLE; + return ERROR_INVALID_HANDLE; } - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - Status = NtSetSecurityObject (KeyHandle, - SecurityInformation, - pSecurityDescriptor); + Status = NtSetSecurityObject(KeyHandle, + SecurityInformation, + pSecurityDescriptor); - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -4668,85 +4739,85 @@ RegSetKeySecurity (HKEY hKey, * @implemented */ LONG STDCALL -RegSetValueExA (HKEY hKey, - LPCSTR lpValueName, - DWORD Reserved, - DWORD dwType, - CONST BYTE* lpData, - DWORD cbData) +RegSetValueExA(HKEY hKey, + LPCSTR lpValueName, + DWORD Reserved, + DWORD dwType, + CONST BYTE* lpData, + DWORD cbData) { - UNICODE_STRING ValueName; - LPWSTR pValueName; - ANSI_STRING AnsiString; - UNICODE_STRING Data; - LONG ErrorCode; - LPBYTE pData; - DWORD DataSize; + UNICODE_STRING ValueName; + LPWSTR pValueName; + ANSI_STRING AnsiString; + UNICODE_STRING Data; + LONG ErrorCode; + LPBYTE pData; + DWORD DataSize; - if (lpValueName != NULL && - strlen(lpValueName) != 0) + if (lpValueName != NULL && + strlen(lpValueName) != 0) { - RtlCreateUnicodeStringFromAsciiz (&ValueName, - (PSTR)lpValueName); + RtlCreateUnicodeStringFromAsciiz(&ValueName, + (PSTR)lpValueName); } - else + else { - ValueName.Buffer = NULL; + ValueName.Buffer = NULL; } - pValueName = (LPWSTR)ValueName.Buffer; + pValueName = (LPWSTR)ValueName.Buffer; - if (((dwType == REG_SZ) || - (dwType == REG_MULTI_SZ) || - (dwType == REG_EXPAND_SZ)) && - (cbData != 0)) + if (((dwType == REG_SZ) || + (dwType == REG_MULTI_SZ) || + (dwType == REG_EXPAND_SZ)) && + (cbData != 0)) { - /* NT adds one if the caller forgot the NULL-termination character */ - if (lpData[cbData - 1] != '\0') - { - cbData++; - } + /* NT adds one if the caller forgot the NULL-termination character */ + if (lpData[cbData - 1] != '\0') + { + cbData++; + } - RtlInitAnsiString (&AnsiString, - NULL); - AnsiString.Buffer = (PSTR)lpData; - AnsiString.Length = cbData - 1; - AnsiString.MaximumLength = cbData; - RtlAnsiStringToUnicodeString (&Data, - &AnsiString, - TRUE); - pData = (LPBYTE)Data.Buffer; - DataSize = cbData * sizeof(WCHAR); + RtlInitAnsiString(&AnsiString, + NULL); + AnsiString.Buffer = (PSTR)lpData; + AnsiString.Length = cbData - 1; + AnsiString.MaximumLength = cbData; + RtlAnsiStringToUnicodeString(&Data, + &AnsiString, + TRUE); + pData = (LPBYTE)Data.Buffer; + DataSize = cbData * sizeof(WCHAR); } - else + else { - RtlInitUnicodeString (&Data, - NULL); - pData = (LPBYTE)lpData; - DataSize = cbData; + RtlInitUnicodeString(&Data, + NULL); + pData = (LPBYTE)lpData; + DataSize = cbData; } - ErrorCode = RegSetValueExW (hKey, - pValueName, - Reserved, - dwType, - pData, - DataSize); - if (pValueName != NULL) + ErrorCode = RegSetValueExW(hKey, + pValueName, + Reserved, + dwType, + pData, + DataSize); + if (pValueName != NULL) { - RtlFreeHeap (ProcessHeap, - 0, - ValueName.Buffer); + RtlFreeHeap(ProcessHeap, + 0, + ValueName.Buffer); } - if (Data.Buffer != NULL) + if (Data.Buffer != NULL) { - RtlFreeHeap (ProcessHeap, - 0, - Data.Buffer); + RtlFreeHeap(ProcessHeap, + 0, + Data.Buffer); } - return ErrorCode; + return ErrorCode; } @@ -4756,60 +4827,60 @@ RegSetValueExA (HKEY hKey, * @implemented */ LONG STDCALL -RegSetValueExW (HKEY hKey, - LPCWSTR lpValueName, - DWORD Reserved, - DWORD dwType, - CONST BYTE* lpData, - DWORD cbData) +RegSetValueExW(HKEY hKey, + LPCWSTR lpValueName, + DWORD Reserved, + DWORD dwType, + CONST BYTE* lpData, + DWORD cbData) { - UNICODE_STRING ValueName; - PUNICODE_STRING pValueName; - HANDLE KeyHandle; - NTSTATUS Status; + UNICODE_STRING ValueName; + PUNICODE_STRING pValueName; + HANDLE KeyHandle; + NTSTATUS Status; - Status = MapDefaultKey (&KeyHandle, - hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, + hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - if (lpValueName != NULL) + if (lpValueName != NULL) { - RtlInitUnicodeString (&ValueName, - lpValueName); + RtlInitUnicodeString(&ValueName, + lpValueName); } - else + else { - RtlInitUnicodeString (&ValueName, L""); + RtlInitUnicodeString(&ValueName, L""); } - pValueName = &ValueName; + pValueName = &ValueName; - if (((dwType == REG_SZ) || - (dwType == REG_MULTI_SZ) || - (dwType == REG_EXPAND_SZ)) && - (cbData != 0) && (*(((PWCHAR)lpData) + (cbData / sizeof(WCHAR)) - 1) != L'\0')) + if (((dwType == REG_SZ) || + (dwType == REG_MULTI_SZ) || + (dwType == REG_EXPAND_SZ)) && + (cbData != 0) && (*(((PWCHAR)lpData) + (cbData / sizeof(WCHAR)) - 1) != L'\0')) { - /* NT adds one if the caller forgot the NULL-termination character */ - cbData += sizeof(WCHAR); + /* NT adds one if the caller forgot the NULL-termination character */ + cbData += sizeof(WCHAR); } - Status = NtSetValueKey (KeyHandle, - pValueName, - 0, - dwType, - (PVOID)lpData, - (ULONG)cbData); + Status = NtSetValueKey(KeyHandle, + pValueName, + 0, + dwType, + (PVOID)lpData, + (ULONG)cbData); - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } @@ -4819,11 +4890,11 @@ RegSetValueExW (HKEY hKey, * @implemented */ LONG STDCALL -RegSetValueA (HKEY hKeyOriginal, - LPCSTR lpSubKey, - DWORD dwType, - LPCSTR lpData, - DWORD cbData) +RegSetValueA(HKEY hKeyOriginal, + LPCSTR lpSubKey, + DWORD dwType, + LPCSTR lpData, + DWORD cbData) { HKEY subkey; HANDLE hKey; @@ -4843,10 +4914,14 @@ RegSetValueA (HKEY hKeyOriginal, if (lpSubKey && lpSubKey[0]) /* need to create the subkey */ { - if ((ret = RegCreateKeyA( hKey, lpSubKey, &subkey )) != ERROR_SUCCESS) goto Cleanup; + 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 ); + if (subkey != hKey) + RegCloseKey(subkey); Cleanup: ClosePredefKey(hKey); @@ -4861,11 +4936,11 @@ Cleanup: * @implemented */ LONG STDCALL -RegSetValueW (HKEY hKeyOriginal, - LPCWSTR lpSubKey, - DWORD dwType, - LPCWSTR lpData, - DWORD cbData) +RegSetValueW(HKEY hKeyOriginal, + LPCWSTR lpSubKey, + DWORD dwType, + LPCWSTR lpData, + DWORD cbData) { HKEY subkey; HANDLE hKey; @@ -4874,23 +4949,28 @@ RegSetValueW (HKEY hKeyOriginal, 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; + if (dwType != REG_SZ || !lpData) + return ERROR_INVALID_PARAMETER; - Status = MapDefaultKey(&hKey, hKeyOriginal); + Status = MapDefaultKey(&hKey, + hKeyOriginal); if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } subkey = hKey; if (lpSubKey && lpSubKey[0]) /* need to create the subkey */ { - if ((ret = RegCreateKeyW( hKey, lpSubKey, &subkey )) != ERROR_SUCCESS) goto Cleanup; + 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 ); + if (subkey != hKey) + RegCloseKey(subkey); Cleanup: ClosePredefKey(hKey); @@ -4905,21 +4985,21 @@ Cleanup: * @implemented */ LONG STDCALL -RegUnLoadKeyA (HKEY hKey, - LPCSTR lpSubKey) +RegUnLoadKeyA(HKEY hKey, + LPCSTR lpSubKey) { - UNICODE_STRING KeyName; - DWORD ErrorCode; + UNICODE_STRING KeyName; + DWORD ErrorCode; - RtlCreateUnicodeStringFromAsciiz (&KeyName, - (LPSTR)lpSubKey); + RtlCreateUnicodeStringFromAsciiz(&KeyName, + (LPSTR)lpSubKey); - ErrorCode = RegUnLoadKeyW (hKey, - KeyName.Buffer); + ErrorCode = RegUnLoadKeyW(hKey, + KeyName.Buffer); - RtlFreeUnicodeString (&KeyName); + RtlFreeUnicodeString (&KeyName); - return ErrorCode; + return ErrorCode; } @@ -4929,46 +5009,47 @@ RegUnLoadKeyA (HKEY hKey, * @implemented */ LONG STDCALL -RegUnLoadKeyW (HKEY hKey, - LPCWSTR lpSubKey) +RegUnLoadKeyW(HKEY hKey, + LPCWSTR lpSubKey) { - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING KeyName; - HANDLE KeyHandle; - NTSTATUS Status; + OBJECT_ATTRIBUTES ObjectAttributes; + UNICODE_STRING KeyName; + HANDLE KeyHandle; + NTSTATUS Status; - if (hKey == HKEY_PERFORMANCE_DATA) + if (hKey == HKEY_PERFORMANCE_DATA) { return ERROR_INVALID_HANDLE; } - Status = MapDefaultKey (&KeyHandle, hKey); - if (!NT_SUCCESS(Status)) + Status = MapDefaultKey(&KeyHandle, hKey); + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - RtlInitUnicodeString (&KeyName, - (LPWSTR)lpSubKey); + RtlInitUnicodeString(&KeyName, + (LPWSTR)lpSubKey); - InitializeObjectAttributes (&ObjectAttributes, - &KeyName, - OBJ_CASE_INSENSITIVE, - KeyHandle, - NULL); + InitializeObjectAttributes(&ObjectAttributes, + &KeyName, + OBJ_CASE_INSENSITIVE, + KeyHandle, + NULL); - Status = NtUnloadKey (&ObjectAttributes); + Status = NtUnloadKey(&ObjectAttributes); - ClosePredefKey(KeyHandle); + ClosePredefKey(KeyHandle); - if (!NT_SUCCESS(Status)) + if (!NT_SUCCESS(Status)) { - return RtlNtStatusToDosError (Status); + return RtlNtStatusToDosError(Status); } - return ERROR_SUCCESS; + return ERROR_SUCCESS; } + /****************************************************************************** * load_string [Internal] * @@ -5003,7 +5084,8 @@ static int load_string(HINSTANCE hModule, UINT resId, LPWSTR pwszBuffer, INT cMa /* Else copy over the string, respecting the buffer size. */ cMaxChars = (*pString < cMaxChars) ? *pString : (cMaxChars - 1); - if (cMaxChars >= 0) { + if (cMaxChars >= 0) + { memcpy(pwszBuffer, pString+1, cMaxChars * sizeof(WCHAR)); pwszBuffer[cMaxChars] = L'\0'; } @@ -5034,7 +5116,8 @@ RegLoadMUIStringW(IN HKEY hKey, if (!hKey || !pszOutBuf) return ERROR_INVALID_PARAMETER; - if (pszDirectory && *pszDirectory) { + if (pszDirectory && *pszDirectory) + { FIXME("BaseDir parameter not yet supported!\n"); return ERROR_INVALID_PARAMETER; } @@ -5042,12 +5125,14 @@ RegLoadMUIStringW(IN HKEY hKey, /* 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) { + if (!(dwValueType == REG_SZ || dwValueType == REG_EXPAND_SZ) || !cbData) + { result = ERROR_FILE_NOT_FOUND; goto cleanup; } pwszTempBuffer = HeapAlloc(GetProcessHeap(), 0, cbData); - if (!pwszTempBuffer) { + if (!pwszTempBuffer) + { result = ERROR_NOT_ENOUGH_MEMORY; goto cleanup; } @@ -5055,16 +5140,20 @@ RegLoadMUIStringW(IN HKEY hKey, if (result != ERROR_SUCCESS) goto cleanup; /* Expand environment variables, if appropriate, or copy the original string over. */ - if (dwValueType == REG_EXPAND_SZ) { + if (dwValueType == REG_EXPAND_SZ) + { cbData = ExpandEnvironmentStringsW(pwszTempBuffer, NULL, 0) * sizeof(WCHAR); if (!cbData) goto cleanup; pwszExpandedBuffer = HeapAlloc(GetProcessHeap(), 0, cbData); - if (!pwszExpandedBuffer) { + if (!pwszExpandedBuffer) + { result = ERROR_NOT_ENOUGH_MEMORY; goto cleanup; } ExpandEnvironmentStringsW(pwszTempBuffer, pwszExpandedBuffer, cbData); - } else { + } + else + { pwszExpandedBuffer = HeapAlloc(GetProcessHeap(), 0, cbData); memcpy(pwszExpandedBuffer, pwszTempBuffer, cbData); } @@ -5072,15 +5161,19 @@ RegLoadMUIStringW(IN HKEY hKey, /* 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. */ + if (*pwszExpandedBuffer != L'@') /* '@' is the prefix for resource based string entries. */ + { lstrcpynW(pszOutBuf, pwszExpandedBuffer, cbOutBuf / sizeof(WCHAR)); - } else { + } + 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'-') { + if (!pComma || pComma[1] != L'-') + { result = ERROR_BADKEY; goto cleanup; } @@ -5132,7 +5225,8 @@ RegLoadMUIStringA(IN HKEY hKey, result = RegLoadMUIStringW(hKey, valueW.Buffer, pwszBuffer, cbData, NULL, Flags, baseDirW.Buffer); - if (result == ERROR_SUCCESS) { + if (result == ERROR_SUCCESS) + { cbData = WideCharToMultiByte(CP_ACP, 0, pwszBuffer, -1, pszOutBuf, cbOutBuf, NULL, NULL); if (pcbData) *pcbData = cbData; @@ -5146,5 +5240,4 @@ cleanup: return result; } - /* EOF */