Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 16:52:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

Minor cleanup.

Browse source 
Implement RegRestoreKeyW().

svn path=/trunk/; revision=8311
This commit is contained in:
Eric Kohl 2004-02-22 14:26:07 +00:00
parent 2d6b7b1255
commit a1eebee733
1 changed files with 325 additions and 208 deletions
Download patch file Download diff file Expand all files Collapse all files

247
reactos/lib/advapi32/reg/reg.c
View file

@ -1,4 +1,4 @@
/* $Id: reg.c,v 1.42 2003/12/29 23:04:55 gvg Exp $ /* $Id: reg.c,v 1.43 2004/02/22 14:26:07 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -774,6 +774,7 @@ RegEnumKeyExA (HKEY hKey,
SetLastError (ERROR_INVALID_PARAMETER); SetLastError (ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER; return ERROR_INVALID_PARAMETER;
} }
Status = MapDefaultKey(&KeyHandle, Status = MapDefaultKey(&KeyHandle,
hKey); hKey);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -791,6 +792,7 @@ RegEnumKeyExA (HKEY hKey,
{ {
NameLength = 0; NameLength = 0;
} }
if (lpClass) if (lpClass)
{ {
if (*lpcbClass > 0) if (*lpcbClass > 0)
@ -801,6 +803,7 @@ RegEnumKeyExA (HKEY hKey,
{ {
ClassLength = 0; ClassLength = 0;
} }
/* The class name should start at a dword boundary */ /* The class name should start at a dword boundary */
BufferSize = ((sizeof(KEY_NODE_INFORMATION) + NameLength + 3) & ~3) + ClassLength; BufferSize = ((sizeof(KEY_NODE_INFORMATION) + NameLength + 3) & ~3) + ClassLength;
} }
@ -812,7 +815,6 @@ RegEnumKeyExA (HKEY hKey,
KeyInfo = RtlAllocateHeap (ProcessHeap, KeyInfo = RtlAllocateHeap (ProcessHeap,
0, 0,
BufferSize); BufferSize);
if (KeyInfo == NULL) if (KeyInfo == NULL)
{ {
SetLastError (ERROR_OUTOFMEMORY); SetLastError (ERROR_OUTOFMEMORY);
@ -868,6 +870,7 @@ RegEnumKeyExA (HKEY hKey,
StringU.MaximumLength = KeyInfo->Node.NameLength; StringU.MaximumLength = KeyInfo->Node.NameLength;
} }
} }
if (ErrorCode == ERROR_SUCCESS) if (ErrorCode == ERROR_SUCCESS)
{ {
StringA.Buffer = lpName; StringA.Buffer = lpName;
@ -947,6 +950,7 @@ RegEnumKeyExW (HKEY hKey,
SetLastError (ErrorCode); SetLastError (ErrorCode);
return ErrorCode; return ErrorCode;
} }
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);
@ -955,6 +959,7 @@ RegEnumKeyExW (HKEY hKey,
{ {
NameLength = 0; NameLength = 0;
} }
if (lpClass) if (lpClass)
{ {
if (*lpcbClass > 0) if (*lpcbClass > 0)
@ -965,12 +970,14 @@ RegEnumKeyExW (HKEY hKey,
{ {
ClassLength = 0; ClassLength = 0;
} }
BufferSize = ((sizeof(KEY_NODE_INFORMATION) + NameLength + 3) & ~3) + ClassLength; 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, KeyInfo = RtlAllocateHeap (ProcessHeap,
0, 0,
BufferSize); BufferSize);
@ -1029,6 +1036,7 @@ RegEnumKeyExW (HKEY hKey,
lpClass[*lpcbClass] = 0; lpClass[*lpcbClass] = 0;
} }
} }
if (ErrorCode == ERROR_SUCCESS && lpftLastWriteTime != NULL) if (ErrorCode == ERROR_SUCCESS && lpftLastWriteTime != NULL)
{ {
if (lpClass == NULL) if (lpClass == NULL)
@ -1052,6 +1060,7 @@ RegEnumKeyExW (HKEY hKey,
{ {
SetLastError(ErrorCode); SetLastError(ErrorCode);
} }
return ErrorCode; return ErrorCode;
} }
@ -1107,6 +1116,7 @@ RegEnumValueA (HKEY hKey,
{ {
NameLength = 0; NameLength = 0;
} }
if (lpData) if (lpData)
{ {
DataLength = min (*lpcbData * sizeof(WCHAR), REG_MAX_DATA_SIZE); DataLength = min (*lpcbData * sizeof(WCHAR), REG_MAX_DATA_SIZE);
@ -1173,6 +1183,7 @@ RegEnumValueA (HKEY hKey,
ValueInfo->Full.DataLength); ValueInfo->Full.DataLength);
*lpcbData = ValueInfo->Full.DataLength; *lpcbData = ValueInfo->Full.DataLength;
} }
StringU.Buffer = ValueInfo->Full.Name; StringU.Buffer = ValueInfo->Full.Name;
StringU.Length = ValueInfo->Full.NameLength; StringU.Length = ValueInfo->Full.NameLength;
StringU.MaximumLength = NameLength; StringU.MaximumLength = NameLength;
@ -1191,6 +1202,7 @@ RegEnumValueA (HKEY hKey,
StringU.MaximumLength = NameLength; StringU.MaximumLength = NameLength;
} }
} }
if (ErrorCode == ERROR_SUCCESS) if (ErrorCode == ERROR_SUCCESS)
{ {
StringA.Buffer = (PCHAR)lpValueName; StringA.Buffer = (PCHAR)lpValueName;
@ -1207,6 +1219,7 @@ RegEnumValueA (HKEY hKey,
} }
} }
} }
RtlFreeHeap (ProcessHeap, RtlFreeHeap (ProcessHeap,
0, 0,
ValueInfo); ValueInfo);
@ -1214,6 +1227,7 @@ RegEnumValueA (HKEY hKey,
{ {
SetLastError(ErrorCode); SetLastError(ErrorCode);
} }
return ErrorCode; return ErrorCode;
} }
@ -1266,6 +1280,7 @@ RegEnumValueW (HKEY hKey,
{ {
NameLength = 0; NameLength = 0;
} }
if (lpData) if (lpData)
{ {
DataLength = min(*lpcbData, REG_MAX_DATA_SIZE); DataLength = min(*lpcbData, REG_MAX_DATA_SIZE);
@ -1332,18 +1347,22 @@ RegEnumValueW (HKEY hKey,
lpValueName[*lpcbValueName] = 0; lpValueName[*lpcbValueName] = 0;
} }
} }
if (ErrorCode == ERROR_SUCCESS && lpType != NULL) if (ErrorCode == ERROR_SUCCESS && lpType != NULL)
{ {
*lpType = lpData ? ValueInfo->Full.Type : ValueInfo->Basic.Type; *lpType = lpData ? ValueInfo->Full.Type : ValueInfo->Basic.Type;
} }
} }
RtlFreeHeap (ProcessHeap, RtlFreeHeap (ProcessHeap,
0, 0,
ValueInfo); ValueInfo);
if (ErrorCode != ERROR_SUCCESS) if (ErrorCode != ERROR_SUCCESS)
{ {
SetLastError (ErrorCode); SetLastError (ErrorCode);
} }
return ErrorCode; return ErrorCode;
} }
@ -1445,7 +1464,7 @@ RegLoadKeyA (HKEY hKey,
{ {
UNICODE_STRING FileName; UNICODE_STRING FileName;
UNICODE_STRING KeyName; UNICODE_STRING KeyName;
DWORD ErrorCode; LONG ErrorCode;
RtlCreateUnicodeStringFromAsciiz (&KeyName, RtlCreateUnicodeStringFromAsciiz (&KeyName,
(LPSTR)lpSubKey); (LPSTR)lpSubKey);
@ -1478,7 +1497,7 @@ RegLoadKeyW (HKEY hKey,
UNICODE_STRING FileName; UNICODE_STRING FileName;
UNICODE_STRING KeyName; UNICODE_STRING KeyName;
HANDLE KeyHandle; HANDLE KeyHandle;
DWORD ErrorCode; LONG ErrorCode;
NTSTATUS Status; NTSTATUS Status;
if (hKey == HKEY_PERFORMANCE_DATA) if (hKey == HKEY_PERFORMANCE_DATA)
@ -1905,6 +1924,7 @@ RegQueryInfoKeyW (HKEY hKey,
{ {
ClassLength = 0; ClassLength = 0;
} }
FullInfoSize = sizeof(KEY_FULL_INFORMATION) + ((ClassLength + 3) & ~3); FullInfoSize = sizeof(KEY_FULL_INFORMATION) + ((ClassLength + 3) & ~3);
FullInfo = RtlAllocateHeap (ProcessHeap, FullInfo = RtlAllocateHeap (ProcessHeap,
0, 0,
@ -1914,6 +1934,7 @@ RegQueryInfoKeyW (HKEY hKey,
SetLastError (ERROR_OUTOFMEMORY); SetLastError (ERROR_OUTOFMEMORY);
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
FullInfo->ClassLength = ClassLength; FullInfo->ClassLength = ClassLength;
} }
else else
@ -1932,10 +1953,18 @@ RegQueryInfoKeyW (HKEY hKey,
DPRINT("NtQueryKey() returned status 0x%X\n", Status); DPRINT("NtQueryKey() returned status 0x%X\n", Status);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ErrorCode = RtlNtStatusToDosError (Status); if (lpClass != NULL)
}
else
{ {
RtlFreeHeap (ProcessHeap,
0,
FullInfo);
}
ErrorCode = RtlNtStatusToDosError (Status);
SetLastError (ErrorCode);
return ErrorCode;
}
DPRINT("SubKeys %d\n", FullInfo->SubKeys); DPRINT("SubKeys %d\n", FullInfo->SubKeys);
if (lpcSubKeys != NULL) if (lpcSubKeys != NULL)
{ {
@ -1955,27 +1984,27 @@ RegQueryInfoKeyW (HKEY hKey,
} }
DPRINT("Values %lu\n", FullInfo->Values); DPRINT("Values %lu\n", FullInfo->Values);
if (lpcValues) if (lpcValues != NULL)
{ {
*lpcValues = FullInfo->Values; *lpcValues = FullInfo->Values;
} }
DPRINT("MaxValueNameLen %lu\n", FullInfo->MaxValueNameLen); DPRINT("MaxValueNameLen %lu\n", FullInfo->MaxValueNameLen);
if (lpcbMaxValueNameLen) if (lpcbMaxValueNameLen != NULL)
{ {
*lpcbMaxValueNameLen = FullInfo->MaxValueNameLen / sizeof(WCHAR) + 1; *lpcbMaxValueNameLen = FullInfo->MaxValueNameLen / sizeof(WCHAR) + 1;
} }
DPRINT("MaxValueDataLen %lu\n", FullInfo->MaxValueDataLen); DPRINT("MaxValueDataLen %lu\n", FullInfo->MaxValueDataLen);
if (lpcbMaxValueLen) if (lpcbMaxValueLen != NULL)
{ {
*lpcbMaxValueLen = FullInfo->MaxValueDataLen; *lpcbMaxValueLen = FullInfo->MaxValueDataLen;
} }
if (lpcbSecurityDescriptor) if (lpcbSecurityDescriptor != NULL)
{ {
*lpcbSecurityDescriptor = 0;
/* FIXME */ /* FIXME */
*lpcbSecurityDescriptor = 0;
} }
if (lpftLastWriteTime != NULL) if (lpftLastWriteTime != NULL)
@ -1998,14 +2027,12 @@ RegQueryInfoKeyW (HKEY hKey,
*lpcbClass = FullInfo->ClassLength / sizeof(WCHAR); *lpcbClass = FullInfo->ClassLength / sizeof(WCHAR);
lpClass[*lpcbClass] = 0; lpClass[*lpcbClass] = 0;
} }
}
}
if (lpClass != NULL)
{
RtlFreeHeap (ProcessHeap, RtlFreeHeap (ProcessHeap,
0, 0,
FullInfo); FullInfo);
} }
if (ErrorCode != ERROR_SUCCESS) if (ErrorCode != ERROR_SUCCESS)
{ {
SetLastError (ErrorCode); SetLastError (ErrorCode);
@ -2047,32 +2074,42 @@ RegQueryMultipleValuesW (HKEY hKey,
{ {
ULONG i; ULONG i;
DWORD maxBytes = *ldwTotsize; DWORD maxBytes = *ldwTotsize;
HRESULT status;
LPSTR bufptr = (LPSTR)lpValueBuf; LPSTR bufptr = (LPSTR)lpValueBuf;
LONG ErrorCode;
if (maxBytes >= (1024*1024)) if (maxBytes >= (1024*1024))
return ERROR_TRANSFER_TOO_LONG; return ERROR_TRANSFER_TOO_LONG;
*ldwTotsize = 0; *ldwTotsize = 0;
//TRACE("(%p,%p,%ld,%p,%p=%ld)\n", hKey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize); DPRINT ("RegQueryMultipleValuesW(%p,%p,%ld,%p,%p=%ld)\n",
hKey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
for (i = 0; i < num_vals; ++i) for (i = 0; i < num_vals; ++i)
{ {
val_list[i].ve_valuelen = 0; val_list[i].ve_valuelen = 0;
status = RegQueryValueExW(hKey, val_list[i].ve_valuename, NULL, NULL, NULL, &val_list[i].ve_valuelen); ErrorCode = RegQueryValueExW (hKey,
if(status != ERROR_SUCCESS) val_list[i].ve_valuename,
NULL,
NULL,
NULL,
&val_list[i].ve_valuelen);
if(ErrorCode != ERROR_SUCCESS)
{ {
return status; return ErrorCode;
} }
if(lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes) if(lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
{ {
status = RegQueryValueExW(hKey, val_list[i].ve_valuename, NULL, &val_list[i].ve_type, ErrorCode = RegQueryValueExW (hKey,
bufptr, &val_list[i].ve_valuelen); val_list[i].ve_valuename,
if(status != ERROR_SUCCESS) NULL,
&val_list[i].ve_type,
bufptr,
&val_list[i].ve_valuelen);
if (ErrorCode != ERROR_SUCCESS)
{ {
return status; return ErrorCode;
} }
val_list[i].ve_valueptr = (DWORD_PTR)bufptr; val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
@ -2082,7 +2119,8 @@ RegQueryMultipleValuesW (HKEY hKey,
*ldwTotsize += val_list[i].ve_valuelen; *ldwTotsize += val_list[i].ve_valuelen;
} }
return lpValueBuf != NULL && *ldwTotsize <= maxBytes ? ERROR_SUCCESS : ERROR_MORE_DATA;
return (lpValueBuf != NULL && *ldwTotsize <= maxBytes) ? ERROR_SUCCESS : ERROR_MORE_DATA;
} }
@ -2205,10 +2243,8 @@ RegQueryValueExW (HKEY hKey,
* *
* @implemented * @implemented
*/ */
LONG LONG STDCALL
STDCALL RegQueryValueExA (HKEY hKey,
RegQueryValueExA(
HKEY hKey,
LPCSTR lpValueName, LPCSTR lpValueName,
LPDWORD lpReserved, LPDWORD lpReserved,
LPDWORD lpType, LPDWORD lpType,
@ -2232,8 +2268,7 @@ RegQueryValueExA(
{ {
ValueData.Length = *lpcbData * sizeof(WCHAR); ValueData.Length = *lpcbData * sizeof(WCHAR);
ValueData.MaximumLength = ValueData.Length + sizeof(WCHAR); ValueData.MaximumLength = ValueData.Length + sizeof(WCHAR);
ValueData.Buffer = RtlAllocateHeap( ValueData.Buffer = RtlAllocateHeap (ProcessHeap,
ProcessHeap,
0, 0,
ValueData.MaximumLength); ValueData.MaximumLength);
if (!ValueData.Buffer) if (!ValueData.Buffer)
@ -2249,18 +2284,20 @@ RegQueryValueExA(
ValueData.MaximumLength = 0; ValueData.MaximumLength = 0;
} }
RtlCreateUnicodeStringFromAsciiz(&ValueName, (LPSTR)lpValueName); RtlCreateUnicodeStringFromAsciiz (&ValueName,
(LPSTR)lpValueName);
/* Convert length from USHORT to DWORD */ /* Convert length from USHORT to DWORD */
Length = ValueData.Length; Length = ValueData.Length;
ErrorCode = RegQueryValueExW ErrorCode = RegQueryValueExW (hKey,
(hKey,
ValueName.Buffer, ValueName.Buffer,
lpReserved, lpReserved,
&Type, &Type,
(LPBYTE)ValueData.Buffer, (LPBYTE)ValueData.Buffer,
&Length); &Length);
if (lpType) *lpType = Type; if (lpType != NULL)
*lpType = Type;
if ((ErrorCode == ERROR_SUCCESS) && (ValueData.Buffer != NULL)) if ((ErrorCode == ERROR_SUCCESS) && (ValueData.Buffer != NULL))
{ {
if ((Type == REG_SZ) || (Type == REG_MULTI_SZ) || (Type == REG_EXPAND_SZ)) if ((Type == REG_SZ) || (Type == REG_MULTI_SZ) || (Type == REG_EXPAND_SZ))
@ -2272,13 +2309,15 @@ RegQueryValueExA(
ValueData.MaximumLength = ValueData.Length + sizeof(WCHAR); ValueData.MaximumLength = ValueData.Length + sizeof(WCHAR);
RtlUnicodeStringToAnsiString(&AnsiString, &ValueData, FALSE); RtlUnicodeStringToAnsiString(&AnsiString, &ValueData, FALSE);
Length = Length / sizeof(WCHAR); Length = Length / sizeof(WCHAR);
} else { }
else
{
Length = min(*lpcbData, Length); Length = min(*lpcbData, Length);
RtlMoveMemory(lpData, ValueData.Buffer, Length); RtlMoveMemory(lpData, ValueData.Buffer, Length);
} }
} }
if (NULL != lpcbData) if (lpcbData != NULL)
{ {
*lpcbData = Length; *lpcbData = Length;
} }
@ -2460,19 +2499,28 @@ RegReplaceKeyA (HKEY hKey,
LPCSTR lpNewFile, LPCSTR lpNewFile,
LPCSTR lpOldFile) LPCSTR lpOldFile)
{ {
UNICODE_STRING lpSubKeyW; UNICODE_STRING SubKey;
UNICODE_STRING lpNewFileW; UNICODE_STRING NewFile;
UNICODE_STRING lpOldFileW; UNICODE_STRING OldFile;
LONG ret; LONG ErrorCode;
RtlCreateUnicodeStringFromAsciiz( &lpSubKeyW, (PCSZ)lpSubKey ); RtlCreateUnicodeStringFromAsciiz (&SubKey,
RtlCreateUnicodeStringFromAsciiz( &lpOldFileW, (PCSZ)lpOldFile ); (PCSZ)lpSubKey);
RtlCreateUnicodeStringFromAsciiz( &lpNewFileW, (PCSZ)lpNewFile ); RtlCreateUnicodeStringFromAsciiz (&OldFile,
ret = RegReplaceKeyW( hKey, lpSubKeyW.Buffer, lpNewFileW.Buffer, lpOldFileW.Buffer ); (PCSZ)lpOldFile);
RtlFreeUnicodeString( &lpOldFileW ); RtlCreateUnicodeStringFromAsciiz (&NewFile,
RtlFreeUnicodeString( &lpNewFileW ); (PCSZ)lpNewFile);
RtlFreeUnicodeString( &lpSubKeyW );
return ret; ErrorCode = RegReplaceKeyW (hKey,
SubKey.Buffer,
NewFile.Buffer,
OldFile.Buffer);
RtlFreeUnicodeString (&OldFile);
RtlFreeUnicodeString (&NewFile);
RtlFreeUnicodeString (&SubKey);
return ErrorCode;
} }
@ -2503,29 +2551,95 @@ RegRestoreKeyA (HKEY hKey,
LPCSTR lpFile, LPCSTR lpFile,
DWORD dwFlags) DWORD dwFlags)
{ {
UNICODE_STRING lpFileW; UNICODE_STRING FileName;
LONG ret; LONG ErrorCode;
RtlCreateUnicodeStringFromAsciiz( &lpFileW, (PCSZ)lpFile ); RtlCreateUnicodeStringFromAsciiz (&FileName,
ret = RegRestoreKeyW( hKey, lpFileW.Buffer, dwFlags ); (PCSZ)lpFile);
RtlFreeUnicodeString( &lpFileW );
return ret; ErrorCode = RegRestoreKeyW (hKey,
FileName.Buffer,
dwFlags);
RtlFreeUnicodeString (&FileName);
return ErrorCode;
} }
/************************************************************************ /************************************************************************
* RegRestoreKeyW * RegRestoreKeyW
* *
* @unimplemented * @implemented
*/ */
LONG STDCALL LONG STDCALL
RegRestoreKeyW (HKEY hKey, RegRestoreKeyW (HKEY hKey,
LPCWSTR lpFile, LPCWSTR lpFile,
DWORD dwFlags) DWORD dwFlags)
{ {
UNIMPLEMENTED; OBJECT_ATTRIBUTES ObjectAttributes;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); IO_STATUS_BLOCK IoStatusBlock;
return ERROR_CALL_NOT_IMPLEMENTED; UNICODE_STRING FileName;
HANDLE FileHandle;
HANDLE KeyHandle;
LONG ErrorCode;
NTSTATUS Status;
if (hKey == HKEY_PERFORMANCE_DATA)
{
return ERROR_INVALID_HANDLE;
}
Status = MapDefaultKey (&KeyHandle,
hKey);
if (!NT_SUCCESS(Status))
{
ErrorCode = RtlNtStatusToDosError (Status);
SetLastError (ErrorCode);
return ErrorCode;
}
if (!RtlDosPathNameToNtPathName_U ((LPWSTR)lpFile,
&FileName,
NULL,
NULL))
{
SetLastError (ERROR_INVALID_PARAMETER);
return ERROR_INVALID_PARAMETER;
}
InitializeObjectAttributes (&ObjectAttributes,
&FileName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenFile (&FileHandle,
FILE_GENERIC_READ,
&ObjectAttributes,
&IoStatusBlock,
FILE_SHARE_READ,
FILE_SYNCHRONOUS_IO_NONALERT);
RtlFreeUnicodeString (&FileName);
if (!NT_SUCCESS(Status))
{
ErrorCode = RtlNtStatusToDosError (Status);
SetLastError (ErrorCode);
return ErrorCode;
}
Status = NtRestoreKey (KeyHandle,
FileHandle,
(ULONG)dwFlags);
NtClose (FileHandle);
if (!NT_SUCCESS(Status))
{
ErrorCode = RtlNtStatusToDosError (Status);
SetLastError (ErrorCode);
return ErrorCode;
}
return ERROR_SUCCESS;
} }
@ -2565,7 +2679,7 @@ RegSaveKeyW (HKEY hKey,
{ {
PSECURITY_DESCRIPTOR SecurityDescriptor = NULL; PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING NtName; UNICODE_STRING FileName;
IO_STATUS_BLOCK IoStatusBlock; IO_STATUS_BLOCK IoStatusBlock;
HANDLE FileHandle; HANDLE FileHandle;
HKEY KeyHandle; HKEY KeyHandle;
@ -2582,7 +2696,7 @@ RegSaveKeyW (HKEY hKey,
} }
if (!RtlDosPathNameToNtPathName_U ((LPWSTR)lpFile, if (!RtlDosPathNameToNtPathName_U ((LPWSTR)lpFile,
&NtName, &FileName,
NULL, NULL,
NULL)) NULL))
{ {
@ -2596,7 +2710,7 @@ RegSaveKeyW (HKEY hKey,
} }
InitializeObjectAttributes (&ObjectAttributes, InitializeObjectAttributes (&ObjectAttributes,
&NtName, &FileName,
OBJ_CASE_INSENSITIVE, OBJ_CASE_INSENSITIVE,
NULL, NULL,
SecurityDescriptor); SecurityDescriptor);
@ -2611,7 +2725,7 @@ RegSaveKeyW (HKEY hKey,
FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT, FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
NULL, NULL,
0); 0);
RtlFreeUnicodeString (&NtName); RtlFreeUnicodeString (&FileName);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ErrorCode = RtlNtStatusToDosError (Status); ErrorCode = RtlNtStatusToDosError (Status);
@ -2644,11 +2758,13 @@ RegSetKeySecurity (HKEY hKey,
PSECURITY_DESCRIPTOR pSecurityDescriptor) PSECURITY_DESCRIPTOR pSecurityDescriptor)
{ {
HKEY KeyHandle; HKEY KeyHandle;
NTSTATUS Status;
LONG ErrorCode; LONG ErrorCode;
NTSTATUS Status;
if (hKey == HKEY_PERFORMANCE_DATA) if (hKey == HKEY_PERFORMANCE_DATA)
{
return ERROR_INVALID_HANDLE; return ERROR_INVALID_HANDLE;
}
Status = MapDefaultKey (&KeyHandle, Status = MapDefaultKey (&KeyHandle,
hKey); hKey);
@ -2866,6 +2982,7 @@ RegSetValueA (HKEY hKey,
dwType, dwType,
Data.Buffer, Data.Buffer,
DataSize); DataSize);
RtlFreeHeap (ProcessHeap, RtlFreeHeap (ProcessHeap,
0, 0,
Data.Buffer); Data.Buffer);