4 * Copyright (C) 1999 Juergen Schmied
5 * Copyright (C) 2000 Alexandre Julliard
6 * Copyright 2005 Ivan Leo Puoti, Laurent Pinchart
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 * HKEY_LOCAL_MACHINE \\REGISTRY\\MACHINE
24 * HKEY_USERS \\REGISTRY\\USER
25 * HKEY_CURRENT_CONFIG \\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\HARDWARE PROFILES\\CURRENT
26 * HKEY_CLASSES \\REGISTRY\\MACHINE\\SOFTWARE\\CLASSES
30 #include "wine/port.h"
37 #define WIN32_NO_STATUS
38 #include "wine/library.h"
39 #include "ntdll_misc.h"
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(reg
);
45 /* maximum length of a key/value name in bytes (without terminating null) */
46 #define MAX_NAME_LENGTH ((MAX_PATH-1) * sizeof(WCHAR))
48 /******************************************************************************
49 * NtCreateKey [NTDLL.@]
50 * ZwCreateKey [NTDLL.@]
52 NTSTATUS WINAPI
NtCreateKey( PHANDLE retkey
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
,
53 ULONG TitleIndex
, const UNICODE_STRING
*class, ULONG options
,
58 if (!retkey
|| !attr
) return STATUS_ACCESS_VIOLATION
;
59 if (attr
->Length
> sizeof(OBJECT_ATTRIBUTES
)) return STATUS_INVALID_PARAMETER
;
60 if (attr
->ObjectName
->Length
> MAX_NAME_LENGTH
) return STATUS_BUFFER_OVERFLOW
;
62 TRACE( "(%p,%s,%s,%x,%x,%p)\n", attr
->RootDirectory
, debugstr_us(attr
->ObjectName
),
63 debugstr_us(class), options
, access
, retkey
);
65 SERVER_START_REQ( create_key
)
67 req
->parent
= wine_server_obj_handle( attr
->RootDirectory
);
69 req
->attributes
= attr
->Attributes
;
70 req
->options
= options
;
71 req
->namelen
= attr
->ObjectName
->Length
;
72 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
73 if (class) wine_server_add_data( req
, class->Buffer
, class->Length
);
74 if (!(ret
= wine_server_call( req
)))
76 *retkey
= wine_server_ptr_handle( reply
->hkey
);
77 if (dispos
) *dispos
= reply
->created
? REG_CREATED_NEW_KEY
: REG_OPENED_EXISTING_KEY
;
81 TRACE("<- %p\n", *retkey
);
85 /******************************************************************************
86 * RtlpNtCreateKey [NTDLL.@]
90 NTSTATUS WINAPI
RtlpNtCreateKey( PHANDLE retkey
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
,
91 ULONG TitleIndex
, const UNICODE_STRING
*class, ULONG options
,
99 oa
.Attributes
&= ~(OBJ_PERMANENT
|OBJ_EXCLUSIVE
);
103 return NtCreateKey(retkey
, access
, attr
, 0, NULL
, 0, dispos
);
106 /******************************************************************************
107 * NtOpenKey [NTDLL.@]
108 * ZwOpenKey [NTDLL.@]
110 * OUT HANDLE retkey (returns 0 when failure)
111 * IN ACCESS_MASK access
112 * IN POBJECT_ATTRIBUTES attr
114 NTSTATUS WINAPI
NtOpenKey( PHANDLE retkey
, ACCESS_MASK access
, const OBJECT_ATTRIBUTES
*attr
)
119 if (!attr
) return STATUS_ACCESS_VIOLATION
;
120 len
= attr
->ObjectName
->Length
;
121 TRACE( "(%p,%s,%x,%p)\n", attr
->RootDirectory
,
122 debugstr_us(attr
->ObjectName
), access
, retkey
);
124 if (len
> MAX_NAME_LENGTH
) return STATUS_BUFFER_OVERFLOW
;
125 if (!retkey
) return STATUS_INVALID_PARAMETER
;
127 SERVER_START_REQ( open_key
)
129 req
->parent
= wine_server_obj_handle( attr
->RootDirectory
);
130 req
->access
= access
;
131 req
->attributes
= attr
->Attributes
;
132 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, len
);
133 ret
= wine_server_call( req
);
134 *retkey
= wine_server_ptr_handle( reply
->hkey
);
137 TRACE("<- %p\n", *retkey
);
141 /******************************************************************************
142 * RtlpNtOpenKey [NTDLL.@]
146 NTSTATUS WINAPI
RtlpNtOpenKey( PHANDLE retkey
, ACCESS_MASK access
, OBJECT_ATTRIBUTES
*attr
)
149 attr
->Attributes
&= ~(OBJ_PERMANENT
|OBJ_EXCLUSIVE
);
150 return NtOpenKey(retkey
, access
, attr
);
153 /******************************************************************************
154 * NtDeleteKey [NTDLL.@]
155 * ZwDeleteKey [NTDLL.@]
157 NTSTATUS WINAPI
NtDeleteKey( HANDLE hkey
)
161 TRACE( "(%p)\n", hkey
);
163 SERVER_START_REQ( delete_key
)
165 req
->hkey
= wine_server_obj_handle( hkey
);
166 ret
= wine_server_call( req
);
172 /******************************************************************************
173 * RtlpNtMakeTemporaryKey [NTDLL.@]
177 NTSTATUS WINAPI
RtlpNtMakeTemporaryKey( HANDLE hkey
)
179 return NtDeleteKey(hkey
);
182 /******************************************************************************
183 * NtDeleteValueKey [NTDLL.@]
184 * ZwDeleteValueKey [NTDLL.@]
186 NTSTATUS WINAPI
NtDeleteValueKey( HANDLE hkey
, const UNICODE_STRING
*name
)
190 TRACE( "(%p,%s)\n", hkey
, debugstr_us(name
) );
191 if (name
->Length
> MAX_NAME_LENGTH
) return STATUS_BUFFER_OVERFLOW
;
193 SERVER_START_REQ( delete_key_value
)
195 req
->hkey
= wine_server_obj_handle( hkey
);
196 wine_server_add_data( req
, name
->Buffer
, name
->Length
);
197 ret
= wine_server_call( req
);
204 /******************************************************************************
207 * Implementation of NtQueryKey and NtEnumerateKey
209 static NTSTATUS
enumerate_key( HANDLE handle
, int index
, KEY_INFORMATION_CLASS info_class
,
210 void *info
, DWORD length
, DWORD
*result_len
)
219 case KeyBasicInformation
: data_ptr
= ((KEY_BASIC_INFORMATION
*)info
)->Name
; break;
220 case KeyFullInformation
: data_ptr
= ((KEY_FULL_INFORMATION
*)info
)->Class
; break;
221 case KeyNodeInformation
: data_ptr
= ((KEY_NODE_INFORMATION
*)info
)->Name
; break;
222 case KeyNameInformation
: data_ptr
= ((KEY_NAME_INFORMATION
*)info
)->Name
; break;
224 FIXME( "Information class %d not implemented\n", info_class
);
225 return STATUS_INVALID_PARAMETER
;
227 fixed_size
= (char *)data_ptr
- (char *)info
;
229 SERVER_START_REQ( enum_key
)
231 req
->hkey
= wine_server_obj_handle( handle
);
233 req
->info_class
= info_class
;
234 if (length
> fixed_size
) wine_server_set_reply( req
, data_ptr
, length
- fixed_size
);
235 if (!(ret
= wine_server_call( req
)))
239 case KeyBasicInformation
:
241 KEY_BASIC_INFORMATION keyinfo
;
242 fixed_size
= (char *)keyinfo
.Name
- (char *)&keyinfo
;
243 keyinfo
.LastWriteTime
.QuadPart
= reply
->modif
;
244 keyinfo
.TitleIndex
= 0;
245 keyinfo
.NameLength
= reply
->namelen
;
246 memcpy( info
, &keyinfo
, min( length
, fixed_size
) );
249 case KeyFullInformation
:
251 KEY_FULL_INFORMATION keyinfo
;
252 fixed_size
= (char *)keyinfo
.Class
- (char *)&keyinfo
;
253 keyinfo
.LastWriteTime
.QuadPart
= reply
->modif
;
254 keyinfo
.TitleIndex
= 0;
255 keyinfo
.ClassLength
= wine_server_reply_size(reply
);
256 keyinfo
.ClassOffset
= keyinfo
.ClassLength
? fixed_size
: -1;
257 keyinfo
.SubKeys
= reply
->subkeys
;
258 keyinfo
.MaxNameLen
= reply
->max_subkey
;
259 keyinfo
.MaxClassLen
= reply
->max_class
;
260 keyinfo
.Values
= reply
->values
;
261 keyinfo
.MaxValueNameLen
= reply
->max_value
;
262 keyinfo
.MaxValueDataLen
= reply
->max_data
;
263 memcpy( info
, &keyinfo
, min( length
, fixed_size
) );
266 case KeyNodeInformation
:
268 KEY_NODE_INFORMATION keyinfo
;
269 fixed_size
= (char *)keyinfo
.Name
- (char *)&keyinfo
;
270 keyinfo
.LastWriteTime
.QuadPart
= reply
->modif
;
271 keyinfo
.TitleIndex
= 0;
272 if (reply
->namelen
< wine_server_reply_size(reply
))
274 keyinfo
.ClassLength
= wine_server_reply_size(reply
) - reply
->namelen
;
275 keyinfo
.ClassOffset
= fixed_size
+ reply
->namelen
;
279 keyinfo
.ClassLength
= 0;
280 keyinfo
.ClassOffset
= -1;
282 keyinfo
.NameLength
= reply
->namelen
;
283 memcpy( info
, &keyinfo
, min( length
, fixed_size
) );
286 case KeyNameInformation
:
288 KEY_NAME_INFORMATION keyinfo
;
289 fixed_size
= (char *)keyinfo
.Name
- (char *)&keyinfo
;
290 keyinfo
.NameLength
= reply
->namelen
;
291 memcpy( info
, &keyinfo
, min( length
, fixed_size
) );
295 *result_len
= fixed_size
+ reply
->total
;
296 if (length
< *result_len
) ret
= STATUS_BUFFER_OVERFLOW
;
305 /******************************************************************************
306 * NtEnumerateKey [NTDLL.@]
307 * ZwEnumerateKey [NTDLL.@]
310 * the name copied into the buffer is NOT 0-terminated
312 NTSTATUS WINAPI
NtEnumerateKey( HANDLE handle
, ULONG index
, KEY_INFORMATION_CLASS info_class
,
313 void *info
, DWORD length
, DWORD
*result_len
)
315 /* -1 means query key, so avoid it here */
316 if (index
== (ULONG
)-1) return STATUS_NO_MORE_ENTRIES
;
317 return enumerate_key( handle
, index
, info_class
, info
, length
, result_len
);
321 /******************************************************************************
322 * RtlpNtEnumerateSubKey [NTDLL.@]
325 NTSTATUS WINAPI
RtlpNtEnumerateSubKey( HANDLE handle
, UNICODE_STRING
*out
, ULONG index
)
327 KEY_BASIC_INFORMATION
*info
;
328 DWORD dwLen
, dwResultLen
;
333 dwLen
= out
->Length
+ sizeof(KEY_BASIC_INFORMATION
);
334 info
= RtlAllocateHeap( GetProcessHeap(), 0, dwLen
);
336 return STATUS_NO_MEMORY
;
344 ret
= NtEnumerateKey( handle
, index
, KeyBasicInformation
, info
, dwLen
, &dwResultLen
);
345 dwResultLen
-= sizeof(KEY_BASIC_INFORMATION
);
347 if (ret
== STATUS_BUFFER_OVERFLOW
)
348 out
->Length
= dwResultLen
;
351 if (out
->Length
< info
->NameLength
)
353 out
->Length
= dwResultLen
;
354 ret
= STATUS_BUFFER_OVERFLOW
;
358 out
->Length
= info
->NameLength
;
359 memcpy(out
->Buffer
, info
->Name
, info
->NameLength
);
363 RtlFreeHeap( GetProcessHeap(), 0, info
);
367 /******************************************************************************
368 * NtQueryKey [NTDLL.@]
369 * ZwQueryKey [NTDLL.@]
371 NTSTATUS WINAPI
NtQueryKey( HANDLE handle
, KEY_INFORMATION_CLASS info_class
,
372 void *info
, DWORD length
, DWORD
*result_len
)
374 return enumerate_key( handle
, -1, info_class
, info
, length
, result_len
);
378 /* fill the key value info structure for a specific info class */
379 static void copy_key_value_info( KEY_VALUE_INFORMATION_CLASS info_class
, void *info
,
380 DWORD length
, int type
, int name_len
, int data_len
)
384 case KeyValueBasicInformation
:
386 KEY_VALUE_BASIC_INFORMATION keyinfo
;
387 keyinfo
.TitleIndex
= 0;
389 keyinfo
.NameLength
= name_len
;
390 length
= min( length
, (char *)keyinfo
.Name
- (char *)&keyinfo
);
391 memcpy( info
, &keyinfo
, length
);
394 case KeyValueFullInformation
:
396 KEY_VALUE_FULL_INFORMATION keyinfo
;
397 keyinfo
.TitleIndex
= 0;
399 keyinfo
.DataOffset
= (char *)keyinfo
.Name
- (char *)&keyinfo
+ name_len
;
400 keyinfo
.DataLength
= data_len
;
401 keyinfo
.NameLength
= name_len
;
402 length
= min( length
, (char *)keyinfo
.Name
- (char *)&keyinfo
);
403 memcpy( info
, &keyinfo
, length
);
406 case KeyValuePartialInformation
:
408 KEY_VALUE_PARTIAL_INFORMATION keyinfo
;
409 keyinfo
.TitleIndex
= 0;
411 keyinfo
.DataLength
= data_len
;
412 length
= min( length
, (char *)keyinfo
.Data
- (char *)&keyinfo
);
413 memcpy( info
, &keyinfo
, length
);
422 /******************************************************************************
423 * NtEnumerateValueKey [NTDLL.@]
424 * ZwEnumerateValueKey [NTDLL.@]
426 NTSTATUS WINAPI
NtEnumerateValueKey( HANDLE handle
, ULONG index
,
427 KEY_VALUE_INFORMATION_CLASS info_class
,
428 void *info
, DWORD length
, DWORD
*result_len
)
434 TRACE( "(%p,%u,%d,%p,%d)\n", handle
, index
, info_class
, info
, length
);
436 /* compute the length we want to retrieve */
439 case KeyValueBasicInformation
: ptr
= ((KEY_VALUE_BASIC_INFORMATION
*)info
)->Name
; break;
440 case KeyValueFullInformation
: ptr
= ((KEY_VALUE_FULL_INFORMATION
*)info
)->Name
; break;
441 case KeyValuePartialInformation
: ptr
= ((KEY_VALUE_PARTIAL_INFORMATION
*)info
)->Data
; break;
443 FIXME( "Information class %d not implemented\n", info_class
);
444 return STATUS_INVALID_PARAMETER
;
446 fixed_size
= (char *)ptr
- (char *)info
;
448 SERVER_START_REQ( enum_key_value
)
450 req
->hkey
= wine_server_obj_handle( handle
);
452 req
->info_class
= info_class
;
453 if (length
> fixed_size
) wine_server_set_reply( req
, ptr
, length
- fixed_size
);
454 if (!(ret
= wine_server_call( req
)))
456 copy_key_value_info( info_class
, info
, length
, reply
->type
, reply
->namelen
,
457 wine_server_reply_size(reply
) - reply
->namelen
);
458 *result_len
= fixed_size
+ reply
->total
;
459 if (length
< *result_len
) ret
= STATUS_BUFFER_OVERFLOW
;
467 /******************************************************************************
468 * NtQueryValueKey [NTDLL.@]
469 * ZwQueryValueKey [NTDLL.@]
472 * the name in the KeyValueInformation is never set
474 NTSTATUS WINAPI
NtQueryValueKey( HANDLE handle
, const UNICODE_STRING
*name
,
475 KEY_VALUE_INFORMATION_CLASS info_class
,
476 void *info
, DWORD length
, DWORD
*result_len
)
480 unsigned int fixed_size
= 0;
482 TRACE( "(%p,%s,%d,%p,%d)\n", handle
, debugstr_us(name
), info_class
, info
, length
);
484 if (name
->Length
> MAX_NAME_LENGTH
) return STATUS_BUFFER_OVERFLOW
;
486 /* compute the length we want to retrieve */
489 case KeyValueBasicInformation
:
491 KEY_VALUE_BASIC_INFORMATION
*basic_info
= info
;
492 if (FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION
, Name
) < length
)
494 memcpy(basic_info
->Name
, name
->Buffer
,
495 min(length
- FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION
, Name
), name
->Length
));
497 fixed_size
= FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION
, Name
) + name
->Length
;
501 case KeyValueFullInformation
:
503 KEY_VALUE_FULL_INFORMATION
*full_info
= info
;
504 if (FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION
, Name
) < length
)
506 memcpy(full_info
->Name
, name
->Buffer
,
507 min(length
- FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION
, Name
), name
->Length
));
509 data_ptr
= (UCHAR
*)full_info
->Name
+ name
->Length
;
510 fixed_size
= (char *)data_ptr
- (char *)info
;
513 case KeyValuePartialInformation
:
514 data_ptr
= ((KEY_VALUE_PARTIAL_INFORMATION
*)info
)->Data
;
515 fixed_size
= (char *)data_ptr
- (char *)info
;
518 FIXME( "Information class %d not implemented\n", info_class
);
519 return STATUS_INVALID_PARAMETER
;
522 SERVER_START_REQ( get_key_value
)
524 req
->hkey
= wine_server_obj_handle( handle
);
525 wine_server_add_data( req
, name
->Buffer
, name
->Length
);
526 if (length
> fixed_size
&& data_ptr
) wine_server_set_reply( req
, data_ptr
, length
- fixed_size
);
527 if (!(ret
= wine_server_call( req
)))
529 copy_key_value_info( info_class
, info
, length
, reply
->type
,
530 name
->Length
, reply
->total
);
531 *result_len
= fixed_size
+ (info_class
== KeyValueBasicInformation
? 0 : reply
->total
);
532 if (length
< *result_len
) ret
= STATUS_BUFFER_OVERFLOW
;
539 /******************************************************************************
540 * RtlpNtQueryValueKey [NTDLL.@]
543 NTSTATUS WINAPI
RtlpNtQueryValueKey( HANDLE handle
, ULONG
*result_type
, PBYTE dest
,
544 DWORD
*result_len
, void *unknown
)
546 KEY_VALUE_PARTIAL_INFORMATION
*info
;
550 DWORD dwLen
= sizeof (KEY_VALUE_PARTIAL_INFORMATION
) + (result_len
? *result_len
: 0);
552 info
= RtlAllocateHeap( GetProcessHeap(), 0, dwLen
);
554 return STATUS_NO_MEMORY
;
557 ret
= NtQueryValueKey( handle
, &name
, KeyValuePartialInformation
, info
, dwLen
, &dwResultLen
);
559 if (!ret
|| ret
== STATUS_BUFFER_OVERFLOW
)
562 *result_len
= info
->DataLength
;
565 *result_type
= info
->Type
;
567 if (ret
!= STATUS_BUFFER_OVERFLOW
)
568 memcpy( dest
, info
->Data
, info
->DataLength
);
571 RtlFreeHeap( GetProcessHeap(), 0, info
);
575 /******************************************************************************
576 * NtFlushKey [NTDLL.@]
577 * ZwFlushKey [NTDLL.@]
579 NTSTATUS WINAPI
NtFlushKey(HANDLE key
)
583 TRACE("key=%p\n", key
);
585 SERVER_START_REQ( flush_key
)
587 req
->hkey
= wine_server_obj_handle( key
);
588 ret
= wine_server_call( req
);
595 /******************************************************************************
596 * NtLoadKey [NTDLL.@]
597 * ZwLoadKey [NTDLL.@]
599 NTSTATUS WINAPI
NtLoadKey( const OBJECT_ATTRIBUTES
*attr
, OBJECT_ATTRIBUTES
*file
)
605 TRACE("(%p,%p)\n", attr
, file
);
607 ret
= NtCreateFile(&hive
, GENERIC_READ
, file
, &io
, NULL
, FILE_ATTRIBUTE_NORMAL
, 0,
608 FILE_OPEN
, 0, NULL
, 0);
611 SERVER_START_REQ( load_registry
)
613 req
->hkey
= wine_server_obj_handle( attr
->RootDirectory
);
614 req
->file
= wine_server_obj_handle( hive
);
615 wine_server_add_data(req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
616 ret
= wine_server_call( req
);
625 /******************************************************************************
626 * NtNotifyChangeKey [NTDLL.@]
627 * ZwNotifyChangeKey [NTDLL.@]
629 NTSTATUS WINAPI
NtNotifyChangeKey(
632 IN PIO_APC_ROUTINE ApcRoutine OPTIONAL
,
633 IN PVOID ApcContext OPTIONAL
,
634 OUT PIO_STATUS_BLOCK IoStatusBlock
,
635 IN ULONG CompletionFilter
,
636 IN BOOLEAN Asynchronous
,
637 OUT PVOID ChangeBuffer
,
639 IN BOOLEAN WatchSubtree
)
643 TRACE("(%p,%p,%p,%p,%p,0x%08x, 0x%08x,%p,0x%08x,0x%08x)\n",
644 KeyHandle
, Event
, ApcRoutine
, ApcContext
, IoStatusBlock
, CompletionFilter
,
645 Asynchronous
, ChangeBuffer
, Length
, WatchSubtree
);
647 if (ApcRoutine
|| ApcContext
|| ChangeBuffer
|| Length
)
648 FIXME("Unimplemented optional parameter\n");
652 OBJECT_ATTRIBUTES attr
;
653 InitializeObjectAttributes( &attr
, NULL
, 0, NULL
, NULL
);
654 ret
= NtCreateEvent( &Event
, EVENT_ALL_ACCESS
, &attr
, SynchronizationEvent
, FALSE
);
655 if (ret
!= STATUS_SUCCESS
)
659 SERVER_START_REQ( set_registry_notification
)
661 req
->hkey
= wine_server_obj_handle( KeyHandle
);
662 req
->event
= wine_server_obj_handle( Event
);
663 req
->subtree
= WatchSubtree
;
664 req
->filter
= CompletionFilter
;
665 ret
= wine_server_call( req
);
671 if (ret
== STATUS_SUCCESS
)
672 NtWaitForSingleObject( Event
, FALSE
, NULL
);
676 return STATUS_SUCCESS
;
679 /******************************************************************************
680 * NtQueryMultipleValueKey [NTDLL]
681 * ZwQueryMultipleValueKey
684 NTSTATUS WINAPI
NtQueryMultipleValueKey(
686 PKEY_MULTIPLE_VALUE_INFORMATION ListOfValuesToQuery
,
688 PVOID MultipleValueInformation
,
692 FIXME("(%p,%p,0x%08x,%p,0x%08x,%p) stub!\n",
693 KeyHandle
, ListOfValuesToQuery
, NumberOfItems
, MultipleValueInformation
,
694 Length
,ReturnLength
);
695 return STATUS_SUCCESS
;
698 /******************************************************************************
699 * NtReplaceKey [NTDLL.@]
700 * ZwReplaceKey [NTDLL.@]
702 NTSTATUS WINAPI
NtReplaceKey(
703 IN POBJECT_ATTRIBUTES ObjectAttributes
,
705 IN POBJECT_ATTRIBUTES ReplacedObjectAttributes
)
707 FIXME("(%s,%p,%s),stub!\n", debugstr_ObjectAttributes(ObjectAttributes
), Key
,
708 debugstr_ObjectAttributes(ReplacedObjectAttributes
) );
709 return STATUS_SUCCESS
;
711 /******************************************************************************
712 * NtRestoreKey [NTDLL.@]
713 * ZwRestoreKey [NTDLL.@]
715 NTSTATUS WINAPI
NtRestoreKey(
720 FIXME("(%p,%p,0x%08x) stub\n",
721 KeyHandle
, FileHandle
, RestoreFlags
);
722 return STATUS_SUCCESS
;
724 /******************************************************************************
725 * NtSaveKey [NTDLL.@]
726 * ZwSaveKey [NTDLL.@]
728 NTSTATUS WINAPI
NtSaveKey(IN HANDLE KeyHandle
, IN HANDLE FileHandle
)
732 TRACE("(%p,%p)\n", KeyHandle
, FileHandle
);
734 SERVER_START_REQ( save_registry
)
736 req
->hkey
= wine_server_obj_handle( KeyHandle
);
737 req
->file
= wine_server_obj_handle( FileHandle
);
738 ret
= wine_server_call( req
);
744 /******************************************************************************
745 * NtSetInformationKey [NTDLL.@]
746 * ZwSetInformationKey [NTDLL.@]
748 NTSTATUS WINAPI
NtSetInformationKey(
750 IN
const int KeyInformationClass
,
751 IN PVOID KeyInformation
,
752 IN ULONG KeyInformationLength
)
754 FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
755 KeyHandle
, KeyInformationClass
, KeyInformation
, KeyInformationLength
);
756 return STATUS_SUCCESS
;
760 /******************************************************************************
761 * NtSetValueKey [NTDLL.@]
762 * ZwSetValueKey [NTDLL.@]
765 * win95 does not care about count for REG_SZ and finds out the len by itself (js)
766 * NT does definitely care (aj)
768 NTSTATUS WINAPI
NtSetValueKey( HANDLE hkey
, const UNICODE_STRING
*name
, ULONG TitleIndex
,
769 ULONG type
, const void *data
, ULONG count
)
773 TRACE( "(%p,%s,%d,%p,%d)\n", hkey
, debugstr_us(name
), type
, data
, count
);
775 if (name
->Length
> MAX_NAME_LENGTH
) return STATUS_BUFFER_OVERFLOW
;
777 SERVER_START_REQ( set_key_value
)
779 req
->hkey
= wine_server_obj_handle( hkey
);
781 req
->namelen
= name
->Length
;
782 wine_server_add_data( req
, name
->Buffer
, name
->Length
);
783 wine_server_add_data( req
, data
, count
);
784 ret
= wine_server_call( req
);
790 /******************************************************************************
791 * RtlpNtSetValueKey [NTDLL.@]
794 NTSTATUS WINAPI
RtlpNtSetValueKey( HANDLE hkey
, ULONG type
, const void *data
,
800 return NtSetValueKey( hkey
, &name
, 0, type
, data
, count
);
803 /******************************************************************************
804 * NtUnloadKey [NTDLL.@]
805 * ZwUnloadKey [NTDLL.@]
807 NTSTATUS WINAPI
NtUnloadKey(IN POBJECT_ATTRIBUTES attr
)
811 TRACE("(%p)\n", attr
);
813 SERVER_START_REQ( unload_registry
)
815 req
->hkey
= wine_server_obj_handle( attr
->RootDirectory
);
816 ret
= wine_server_call(req
);
823 /******************************************************************************
824 * RtlFormatCurrentUserKeyPath [NTDLL.@]
827 NTSTATUS WINAPI
RtlFormatCurrentUserKeyPath( IN OUT PUNICODE_STRING KeyPath
)
829 static const WCHAR pathW
[] = {'\\','R','e','g','i','s','t','r','y','\\','U','s','e','r','\\'};
833 status
= NtOpenThreadToken(GetCurrentThread(), TOKEN_READ
, TRUE
, &token
);
834 if (status
== STATUS_NO_TOKEN
)
835 status
= NtOpenProcessToken(GetCurrentProcess(), TOKEN_READ
, &token
);
836 if (status
== STATUS_SUCCESS
)
838 char buffer
[sizeof(TOKEN_USER
) + sizeof(SID
) + sizeof(DWORD
)*SID_MAX_SUB_AUTHORITIES
];
839 DWORD len
= sizeof(buffer
);
841 status
= NtQueryInformationToken(token
, TokenUser
, buffer
, len
, &len
);
842 if (status
== STATUS_SUCCESS
)
844 KeyPath
->MaximumLength
= 0;
845 status
= RtlConvertSidToUnicodeString(KeyPath
, ((TOKEN_USER
*)buffer
)->User
.Sid
, FALSE
);
846 if (status
== STATUS_BUFFER_OVERFLOW
)
848 PWCHAR buf
= RtlAllocateHeap(GetProcessHeap(), 0,
849 sizeof(pathW
) + KeyPath
->Length
+ sizeof(WCHAR
));
852 memcpy(buf
, pathW
, sizeof(pathW
));
853 KeyPath
->MaximumLength
= KeyPath
->Length
+ sizeof(WCHAR
);
854 KeyPath
->Buffer
= (PWCHAR
)((LPBYTE
)buf
+ sizeof(pathW
));
855 status
= RtlConvertSidToUnicodeString(KeyPath
,
856 ((TOKEN_USER
*)buffer
)->User
.Sid
, FALSE
);
857 KeyPath
->Buffer
= buf
;
858 KeyPath
->Length
+= sizeof(pathW
);
859 KeyPath
->MaximumLength
+= sizeof(pathW
);
862 status
= STATUS_NO_MEMORY
;
870 /******************************************************************************
871 * RtlOpenCurrentUser [NTDLL.@]
874 * If we return just HKEY_CURRENT_USER the advapi tries to find a remote
875 * registry (odd handle) and fails.
877 NTSTATUS WINAPI
RtlOpenCurrentUser(
878 IN ACCESS_MASK DesiredAccess
, /* [in] */
879 OUT PHANDLE KeyHandle
) /* [out] handle of HKEY_CURRENT_USER */
881 OBJECT_ATTRIBUTES ObjectAttributes
;
882 UNICODE_STRING ObjectName
;
885 TRACE("(0x%08x, %p)\n",DesiredAccess
, KeyHandle
);
887 if ((ret
= RtlFormatCurrentUserKeyPath(&ObjectName
))) return ret
;
888 InitializeObjectAttributes(&ObjectAttributes
,&ObjectName
,OBJ_CASE_INSENSITIVE
,0, NULL
);
889 ret
= NtCreateKey(KeyHandle
, DesiredAccess
, &ObjectAttributes
, 0, NULL
, 0, NULL
);
890 RtlFreeUnicodeString(&ObjectName
);
895 static NTSTATUS
RTL_ReportRegistryValue(PKEY_VALUE_FULL_INFORMATION pInfo
,
896 PRTL_QUERY_REGISTRY_TABLE pQuery
, PVOID pContext
, PVOID pEnvironment
)
899 UNICODE_STRING src
, dst
;
904 NTSTATUS status
= STATUS_SUCCESS
;
911 if (pQuery
->Flags
& RTL_QUERY_REGISTRY_DIRECT
)
912 return STATUS_INVALID_PARAMETER
;
915 status
= pQuery
->QueryRoutine(pQuery
->Name
, pQuery
->DefaultType
, pQuery
->DefaultData
,
916 pQuery
->DefaultLength
, pContext
, pQuery
->EntryContext
);
920 len
= pInfo
->DataLength
;
922 if (pQuery
->Flags
& RTL_QUERY_REGISTRY_DIRECT
)
924 str
= pQuery
->EntryContext
;
929 if (!(pQuery
->Flags
& RTL_QUERY_REGISTRY_NOEXPAND
))
931 RtlInitUnicodeString(&src
, (WCHAR
*)(((CHAR
*)pInfo
) + pInfo
->DataOffset
));
933 dst
.MaximumLength
= 0;
934 RtlExpandEnvironmentStrings_U(pEnvironment
, &src
, &dst
, &res
);
936 dst
.MaximumLength
= res
;
937 dst
.Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, res
* sizeof(WCHAR
));
938 RtlExpandEnvironmentStrings_U(pEnvironment
, &src
, &dst
, &res
);
939 status
= pQuery
->QueryRoutine(pQuery
->Name
, pInfo
->Type
, dst
.Buffer
,
940 dst
.Length
, pContext
, pQuery
->EntryContext
);
941 RtlFreeHeap(GetProcessHeap(), 0, dst
.Buffer
);
946 if (str
->Buffer
== NULL
)
947 RtlCreateUnicodeString(str
, (WCHAR
*)(((CHAR
*)pInfo
) + pInfo
->DataOffset
));
949 RtlAppendUnicodeToString(str
, (WCHAR
*)(((CHAR
*)pInfo
) + pInfo
->DataOffset
));
953 if (!(pQuery
->Flags
& RTL_QUERY_REGISTRY_NOEXPAND
))
954 return STATUS_INVALID_PARAMETER
;
956 if (str
->Buffer
== NULL
)
958 str
->Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, len
);
959 str
->MaximumLength
= len
;
961 len
= min(len
, str
->MaximumLength
);
962 memcpy(str
->Buffer
, ((CHAR
*)pInfo
) + pInfo
->DataOffset
, len
);
967 bin
= pQuery
->EntryContext
;
968 if (pInfo
->DataLength
<= sizeof(ULONG
))
969 memcpy(bin
, ((CHAR
*)pInfo
) + pInfo
->DataOffset
,
973 if (bin
[0] <= sizeof(ULONG
))
975 memcpy(&bin
[1], ((CHAR
*)pInfo
) + pInfo
->DataOffset
,
976 min(-bin
[0], pInfo
->DataLength
));
980 len
= min(bin
[0], pInfo
->DataLength
);
982 bin
[2] = pInfo
->Type
;
983 memcpy(&bin
[3], ((CHAR
*)pInfo
) + pInfo
->DataOffset
, len
);
991 if((pQuery
->Flags
& RTL_QUERY_REGISTRY_NOEXPAND
) ||
992 (pInfo
->Type
!= REG_EXPAND_SZ
&& pInfo
->Type
!= REG_MULTI_SZ
))
994 status
= pQuery
->QueryRoutine(pQuery
->Name
, pInfo
->Type
,
995 ((CHAR
*)pInfo
) + pInfo
->DataOffset
, pInfo
->DataLength
,
996 pContext
, pQuery
->EntryContext
);
998 else if (pInfo
->Type
== REG_EXPAND_SZ
)
1000 RtlInitUnicodeString(&src
, (WCHAR
*)(((CHAR
*)pInfo
) + pInfo
->DataOffset
));
1002 dst
.MaximumLength
= 0;
1003 RtlExpandEnvironmentStrings_U(pEnvironment
, &src
, &dst
, &res
);
1005 dst
.MaximumLength
= res
;
1006 dst
.Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, res
* sizeof(WCHAR
));
1007 RtlExpandEnvironmentStrings_U(pEnvironment
, &src
, &dst
, &res
);
1008 status
= pQuery
->QueryRoutine(pQuery
->Name
, pInfo
->Type
, dst
.Buffer
,
1009 dst
.Length
, pContext
, pQuery
->EntryContext
);
1010 RtlFreeHeap(GetProcessHeap(), 0, dst
.Buffer
);
1012 else /* REG_MULTI_SZ */
1014 if(pQuery
->Flags
& RTL_QUERY_REGISTRY_NOEXPAND
)
1016 for (offset
= 0; offset
<= pInfo
->DataLength
; offset
+= len
+ sizeof(WCHAR
))
1018 wstr
= (WCHAR
*)(((CHAR
*)pInfo
) + offset
);
1019 len
= strlenW(wstr
) * sizeof(WCHAR
);
1020 status
= pQuery
->QueryRoutine(pQuery
->Name
, pInfo
->Type
, wstr
, len
,
1021 pContext
, pQuery
->EntryContext
);
1022 if(status
!= STATUS_SUCCESS
&& status
!= STATUS_BUFFER_TOO_SMALL
)
1028 while(count
<=pInfo
->DataLength
)
1030 String
= (WCHAR
*)(((CHAR
*)pInfo
) + pInfo
->DataOffset
)+count
;
1031 count
+=strlenW(String
)+1;
1032 RtlInitUnicodeString(&src
, (WCHAR
*)(((CHAR
*)pInfo
) + pInfo
->DataOffset
));
1034 dst
.MaximumLength
= 0;
1035 RtlExpandEnvironmentStrings_U(pEnvironment
, &src
, &dst
, &res
);
1037 dst
.MaximumLength
= res
;
1038 dst
.Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, res
* sizeof(WCHAR
));
1039 RtlExpandEnvironmentStrings_U(pEnvironment
, &src
, &dst
, &res
);
1040 status
= pQuery
->QueryRoutine(pQuery
->Name
, pInfo
->Type
, dst
.Buffer
,
1041 dst
.Length
, pContext
, pQuery
->EntryContext
);
1042 RtlFreeHeap(GetProcessHeap(), 0, dst
.Buffer
);
1043 if(status
!= STATUS_SUCCESS
&& status
!= STATUS_BUFFER_TOO_SMALL
)
1053 static NTSTATUS
RTL_GetKeyHandle(ULONG RelativeTo
, PCWSTR Path
, PHANDLE handle
)
1055 UNICODE_STRING KeyString
;
1056 OBJECT_ATTRIBUTES regkey
;
1061 static const WCHAR empty
[] = {0};
1062 static const WCHAR control
[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e',
1063 '\\','S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1064 'C','o','n','t','r','o','l','\\',0};
1066 static const WCHAR devicemap
[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
1067 'H','a','r','d','w','a','r','e','\\','D','e','v','i','c','e','M','a','p','\\',0};
1069 static const WCHAR services
[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
1070 'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1071 'S','e','r','v','i','c','e','s','\\',0};
1073 static const WCHAR user
[] = {'\\','R','e','g','i','s','t','r','y','\\','U','s','e','r','\\',
1074 'C','u','r','r','e','n','t','U','s','e','r','\\',0};
1076 static const WCHAR windows_nt
[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
1077 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1078 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',0};
1080 switch (RelativeTo
& 0xff)
1082 case RTL_REGISTRY_ABSOLUTE
:
1086 case RTL_REGISTRY_CONTROL
:
1090 case RTL_REGISTRY_DEVICEMAP
:
1094 case RTL_REGISTRY_SERVICES
:
1098 case RTL_REGISTRY_USER
:
1102 case RTL_REGISTRY_WINDOWS_NT
:
1107 return STATUS_INVALID_PARAMETER
;
1110 len
= (strlenW(base
) + strlenW(Path
) + 1) * sizeof(WCHAR
);
1111 KeyString
.Buffer
= RtlAllocateHeap(GetProcessHeap(), 0, len
);
1112 if (KeyString
.Buffer
== NULL
)
1113 return STATUS_NO_MEMORY
;
1115 strcpyW(KeyString
.Buffer
, base
);
1116 strcatW(KeyString
.Buffer
, Path
);
1117 KeyString
.Length
= len
- sizeof(WCHAR
);
1118 KeyString
.MaximumLength
= len
;
1119 InitializeObjectAttributes(®key
, &KeyString
, OBJ_CASE_INSENSITIVE
, NULL
, NULL
);
1120 status
= NtOpenKey(handle
, KEY_ALL_ACCESS
, ®key
);
1121 RtlFreeHeap(GetProcessHeap(), 0, KeyString
.Buffer
);
1125 /*************************************************************************
1126 * RtlQueryRegistryValues [NTDLL.@]
1128 * Query multiple registry values with a signle call.
1131 * RelativeTo [I] Registry path that Path refers to
1132 * Path [I] Path to key
1133 * QueryTable [I] Table of key values to query
1134 * Context [I] Parameter to pass to the application defined QueryRoutine function
1135 * Environment [I] Optional parameter to use when performing expansion
1138 * STATUS_SUCCESS or an appropriate NTSTATUS error code.
1140 NTSTATUS WINAPI
RtlQueryRegistryValues(IN ULONG RelativeTo
, IN PCWSTR Path
,
1141 IN PRTL_QUERY_REGISTRY_TABLE QueryTable
, IN PVOID Context
,
1142 IN PVOID Environment OPTIONAL
)
1144 UNICODE_STRING Value
;
1145 HANDLE handle
, topkey
;
1146 PKEY_VALUE_FULL_INFORMATION pInfo
= NULL
;
1147 ULONG len
, buflen
= 0;
1148 NTSTATUS status
=STATUS_SUCCESS
, ret
= STATUS_SUCCESS
;
1151 TRACE("(%d, %s, %p, %p, %p)\n", RelativeTo
, debugstr_w(Path
), QueryTable
, Context
, Environment
);
1154 return STATUS_INVALID_PARAMETER
;
1156 /* get a valid handle */
1157 if (RelativeTo
& RTL_REGISTRY_HANDLE
)
1158 topkey
= handle
= (HANDLE
)Path
;
1161 status
= RTL_GetKeyHandle(RelativeTo
, Path
, &topkey
);
1164 if(status
!= STATUS_SUCCESS
)
1167 /* Process query table entries */
1168 for (; QueryTable
->QueryRoutine
!= NULL
|| QueryTable
->Name
!= NULL
; ++QueryTable
)
1170 if (QueryTable
->Flags
&
1171 (RTL_QUERY_REGISTRY_SUBKEY
| RTL_QUERY_REGISTRY_TOPKEY
))
1173 /* topkey must be kept open just in case we will reuse it later */
1174 if (handle
!= topkey
)
1177 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_SUBKEY
)
1180 status
= RTL_GetKeyHandle(PtrToUlong(QueryTable
->Name
), Path
, &handle
);
1181 if(status
!= STATUS_SUCCESS
)
1191 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_NOVALUE
)
1193 QueryTable
->QueryRoutine(QueryTable
->Name
, REG_NONE
, NULL
, 0,
1194 Context
, QueryTable
->EntryContext
);
1200 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_REQUIRED
)
1202 ret
= STATUS_OBJECT_NAME_NOT_FOUND
;
1208 if (QueryTable
->Name
== NULL
)
1210 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_DIRECT
)
1212 ret
= STATUS_INVALID_PARAMETER
;
1216 /* Report all subkeys */
1219 status
= NtEnumerateValueKey(handle
, i
,
1220 KeyValueFullInformation
, pInfo
, buflen
, &len
);
1221 if (status
== STATUS_NO_MORE_ENTRIES
)
1223 if (status
== STATUS_BUFFER_OVERFLOW
||
1224 status
== STATUS_BUFFER_TOO_SMALL
)
1227 RtlFreeHeap(GetProcessHeap(), 0, pInfo
);
1228 pInfo
= RtlAllocateHeap(GetProcessHeap(), 0, buflen
);
1229 NtEnumerateValueKey(handle
, i
, KeyValueFullInformation
,
1230 pInfo
, buflen
, &len
);
1233 status
= RTL_ReportRegistryValue(pInfo
, QueryTable
, Context
, Environment
);
1234 if(status
!= STATUS_SUCCESS
&& status
!= STATUS_BUFFER_TOO_SMALL
)
1239 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_DELETE
)
1241 RtlInitUnicodeString(&Value
, pInfo
->Name
);
1242 NtDeleteValueKey(handle
, &Value
);
1246 if (i
== 0 && (QueryTable
->Flags
& RTL_QUERY_REGISTRY_REQUIRED
))
1248 ret
= STATUS_OBJECT_NAME_NOT_FOUND
;
1254 RtlInitUnicodeString(&Value
, QueryTable
->Name
);
1255 status
= NtQueryValueKey(handle
, &Value
, KeyValueFullInformation
,
1256 pInfo
, buflen
, &len
);
1257 if (status
== STATUS_BUFFER_OVERFLOW
||
1258 status
== STATUS_BUFFER_TOO_SMALL
)
1261 RtlFreeHeap(GetProcessHeap(), 0, pInfo
);
1262 pInfo
= RtlAllocateHeap(GetProcessHeap(), 0, buflen
);
1263 status
= NtQueryValueKey(handle
, &Value
,
1264 KeyValueFullInformation
, pInfo
, buflen
, &len
);
1266 if (status
!= STATUS_SUCCESS
)
1268 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_REQUIRED
)
1270 ret
= STATUS_OBJECT_NAME_NOT_FOUND
;
1273 status
= RTL_ReportRegistryValue(NULL
, QueryTable
, Context
, Environment
);
1274 if(status
!= STATUS_SUCCESS
&& status
!= STATUS_BUFFER_TOO_SMALL
)
1282 status
= RTL_ReportRegistryValue(pInfo
, QueryTable
, Context
, Environment
);
1283 if(status
!= STATUS_SUCCESS
&& status
!= STATUS_BUFFER_TOO_SMALL
)
1288 if (QueryTable
->Flags
& RTL_QUERY_REGISTRY_DELETE
)
1289 NtDeleteValueKey(handle
, &Value
);
1295 RtlFreeHeap(GetProcessHeap(), 0, pInfo
);
1296 if (handle
!= topkey
)
1302 /*************************************************************************
1303 * RtlCheckRegistryKey [NTDLL.@]
1305 * Query multiple registry values with a signle call.
1308 * RelativeTo [I] Registry path that Path refers to
1309 * Path [I] Path to key
1312 * STATUS_SUCCESS if the specified key exists, or an NTSTATUS error code.
1314 NTSTATUS WINAPI
RtlCheckRegistryKey(IN ULONG RelativeTo
, IN PWSTR Path
)
1319 TRACE("(%d, %s)\n", RelativeTo
, debugstr_w(Path
));
1321 if((!RelativeTo
) && Path
== NULL
)
1322 return STATUS_OBJECT_PATH_SYNTAX_BAD
;
1323 if(RelativeTo
& RTL_REGISTRY_HANDLE
)
1324 return STATUS_SUCCESS
;
1326 status
= RTL_GetKeyHandle(RelativeTo
, Path
, &handle
);
1327 if (handle
) NtClose(handle
);
1328 if (status
== STATUS_INVALID_HANDLE
) status
= STATUS_OBJECT_NAME_NOT_FOUND
;
1332 /*************************************************************************
1333 * RtlDeleteRegistryValue [NTDLL.@]
1335 * Query multiple registry values with a signle call.
1338 * RelativeTo [I] Registry path that Path refers to
1339 * Path [I] Path to key
1340 * ValueName [I] Name of the value to delete
1343 * STATUS_SUCCESS if the specified key is successfully deleted, or an NTSTATUS error code.
1345 NTSTATUS WINAPI
RtlDeleteRegistryValue(IN ULONG RelativeTo
, IN PCWSTR Path
, IN PCWSTR ValueName
)
1349 UNICODE_STRING Value
;
1351 TRACE("(%d, %s, %s)\n", RelativeTo
, debugstr_w(Path
), debugstr_w(ValueName
));
1353 RtlInitUnicodeString(&Value
, ValueName
);
1354 if(RelativeTo
== RTL_REGISTRY_HANDLE
)
1356 return NtDeleteValueKey((HANDLE
)Path
, &Value
);
1358 status
= RTL_GetKeyHandle(RelativeTo
, Path
, &handle
);
1359 if (status
) return status
;
1360 status
= NtDeleteValueKey(handle
, &Value
);
1365 /*************************************************************************
1366 * RtlWriteRegistryValue [NTDLL.@]
1368 * Sets the registry value with provided data.
1371 * RelativeTo [I] Registry path that path parameter refers to
1372 * path [I] Path to the key (or handle - see RTL_GetKeyHandle)
1373 * name [I] Name of the registry value to set
1374 * type [I] Type of the registry key to set
1375 * data [I] Pointer to the user data to be set
1376 * length [I] Length of the user data pointed by data
1379 * STATUS_SUCCESS if the specified key is successfully set,
1380 * or an NTSTATUS error code.
1382 NTSTATUS WINAPI
RtlWriteRegistryValue( ULONG RelativeTo
, PCWSTR path
, PCWSTR name
,
1383 ULONG type
, PVOID data
, ULONG length
)
1389 TRACE( "(%d, %s, %s) -> %d: %p [%d]\n", RelativeTo
, debugstr_w(path
), debugstr_w(name
),
1390 type
, data
, length
);
1392 RtlInitUnicodeString( &str
, name
);
1394 if (RelativeTo
== RTL_REGISTRY_HANDLE
)
1395 return NtSetValueKey( (HANDLE
)path
, &str
, 0, type
, data
, length
);
1397 status
= RTL_GetKeyHandle( RelativeTo
, path
, &hkey
);
1398 if (status
!= STATUS_SUCCESS
) return status
;
1400 status
= NtSetValueKey( hkey
, &str
, 0, type
, data
, length
);