ws2_32: Only enable FD_WRITE on short sends.
[wine] / dlls / ntdll / reg.c
1 /*
2  * Registry functions
3  *
4  * Copyright (C) 1999 Juergen Schmied
5  * Copyright (C) 2000 Alexandre Julliard
6  * Copyright 2005 Ivan Leo Puoti, Laurent Pinchart
7  *
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.
12  *
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.
17  *
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
21  *
22  * NOTES:
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
27  */
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <string.h>
35
36 #include "ntstatus.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"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(reg);
44
45 /* maximum length of a key/value name in bytes (without terminating null) */
46 #define MAX_NAME_LENGTH ((MAX_PATH-1) * sizeof(WCHAR))
47
48 /******************************************************************************
49  * NtCreateKey [NTDLL.@]
50  * ZwCreateKey [NTDLL.@]
51  */
52 NTSTATUS WINAPI NtCreateKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
53                              ULONG TitleIndex, const UNICODE_STRING *class, ULONG options,
54                              PULONG dispos )
55 {
56     NTSTATUS ret;
57
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;
61
62     TRACE( "(%p,%s,%s,%x,%x,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName),
63            debugstr_us(class), options, access, retkey );
64
65     SERVER_START_REQ( create_key )
66     {
67         req->parent     = attr->RootDirectory;
68         req->access     = access;
69         req->attributes = attr->Attributes;
70         req->options    = options;
71         req->modif      = 0;
72         req->namelen    = attr->ObjectName->Length;
73         wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
74         if (class) wine_server_add_data( req, class->Buffer, class->Length );
75         if (!(ret = wine_server_call( req )))
76         {
77             *retkey = reply->hkey;
78             if (dispos) *dispos = reply->created ? REG_CREATED_NEW_KEY : REG_OPENED_EXISTING_KEY;
79         }
80     }
81     SERVER_END_REQ;
82     TRACE("<- %p\n", *retkey);
83     return ret;
84 }
85
86 /******************************************************************************
87  *  RtlpNtCreateKey [NTDLL.@]
88  *
89  *  See NtCreateKey.
90  */
91 NTSTATUS WINAPI RtlpNtCreateKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
92                                  ULONG TitleIndex, const UNICODE_STRING *class, ULONG options,
93                                  PULONG dispos )
94 {
95     OBJECT_ATTRIBUTES oa;
96
97     if (attr)
98     {
99         oa = *attr;
100         oa.Attributes &= ~(OBJ_PERMANENT|OBJ_EXCLUSIVE);
101         attr = &oa;
102     }
103
104     return NtCreateKey(retkey, access, attr, 0, NULL, 0, dispos);
105 }
106
107 /******************************************************************************
108  * NtOpenKey [NTDLL.@]
109  * ZwOpenKey [NTDLL.@]
110  *
111  *   OUT        HANDLE                  retkey (returns 0 when failure)
112  *   IN         ACCESS_MASK             access
113  *   IN         POBJECT_ATTRIBUTES      attr
114  */
115 NTSTATUS WINAPI NtOpenKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
116 {
117     NTSTATUS ret;
118     DWORD len = attr->ObjectName->Length;
119
120     TRACE( "(%p,%s,%x,%p)\n", attr->RootDirectory,
121            debugstr_us(attr->ObjectName), access, retkey );
122
123     if (len > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
124     if (!retkey) return STATUS_INVALID_PARAMETER;
125
126     SERVER_START_REQ( open_key )
127     {
128         req->parent     = attr->RootDirectory;
129         req->access     = access;
130         req->attributes = attr->Attributes;
131         wine_server_add_data( req, attr->ObjectName->Buffer, len );
132         ret = wine_server_call( req );
133         *retkey = reply->hkey;
134     }
135     SERVER_END_REQ;
136     TRACE("<- %p\n", *retkey);
137     return ret;
138 }
139
140 /******************************************************************************
141  * RtlpNtOpenKey [NTDLL.@]
142  *
143  * See NtOpenKey.
144  */
145 NTSTATUS WINAPI RtlpNtOpenKey( PHANDLE retkey, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr )
146 {
147     if (attr)
148         attr->Attributes &= ~(OBJ_PERMANENT|OBJ_EXCLUSIVE);
149     return NtOpenKey(retkey, access, attr);
150 }
151
152 /******************************************************************************
153  * NtDeleteKey [NTDLL.@]
154  * ZwDeleteKey [NTDLL.@]
155  */
156 NTSTATUS WINAPI NtDeleteKey( HANDLE hkey )
157 {
158     NTSTATUS ret;
159
160     TRACE( "(%p)\n", hkey );
161
162     SERVER_START_REQ( delete_key )
163     {
164         req->hkey = hkey;
165         ret = wine_server_call( req );
166     }
167     SERVER_END_REQ;
168     return ret;
169 }
170
171 /******************************************************************************
172  * RtlpNtMakeTemporaryKey [NTDLL.@]
173  *
174  *  See NtDeleteKey.
175  */
176 NTSTATUS WINAPI RtlpNtMakeTemporaryKey( HANDLE hkey )
177 {
178     return NtDeleteKey(hkey);
179 }
180
181 /******************************************************************************
182  * NtDeleteValueKey [NTDLL.@]
183  * ZwDeleteValueKey [NTDLL.@]
184  */
185 NTSTATUS WINAPI NtDeleteValueKey( HANDLE hkey, const UNICODE_STRING *name )
186 {
187     NTSTATUS ret;
188
189     TRACE( "(%p,%s)\n", hkey, debugstr_us(name) );
190     if (name->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
191
192     SERVER_START_REQ( delete_key_value )
193     {
194         req->hkey = hkey;
195         wine_server_add_data( req, name->Buffer, name->Length );
196         ret = wine_server_call( req );
197     }
198     SERVER_END_REQ;
199     return ret;
200 }
201
202
203 /******************************************************************************
204  *     enumerate_key
205  *
206  * Implementation of NtQueryKey and NtEnumerateKey
207  */
208 static NTSTATUS enumerate_key( HANDLE handle, int index, KEY_INFORMATION_CLASS info_class,
209                                void *info, DWORD length, DWORD *result_len )
210
211 {
212     NTSTATUS ret;
213     void *data_ptr;
214     size_t fixed_size;
215
216     switch(info_class)
217     {
218     case KeyBasicInformation: data_ptr = ((KEY_BASIC_INFORMATION *)info)->Name; break;
219     case KeyFullInformation:  data_ptr = ((KEY_FULL_INFORMATION *)info)->Class; break;
220     case KeyNodeInformation:  data_ptr = ((KEY_NODE_INFORMATION *)info)->Name;  break;
221     default:
222         FIXME( "Information class %d not implemented\n", info_class );
223         return STATUS_INVALID_PARAMETER;
224     }
225     fixed_size = (char *)data_ptr - (char *)info;
226
227     SERVER_START_REQ( enum_key )
228     {
229         req->hkey       = handle;
230         req->index      = index;
231         req->info_class = info_class;
232         if (length > fixed_size) wine_server_set_reply( req, data_ptr, length - fixed_size );
233         if (!(ret = wine_server_call( req )))
234         {
235             LARGE_INTEGER modif;
236
237             RtlSecondsSince1970ToTime( reply->modif, &modif );
238
239             switch(info_class)
240             {
241             case KeyBasicInformation:
242                 {
243                     KEY_BASIC_INFORMATION keyinfo;
244                     fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
245                     keyinfo.LastWriteTime = modif;
246                     keyinfo.TitleIndex = 0;
247                     keyinfo.NameLength = reply->namelen;
248                     memcpy( info, &keyinfo, min( length, fixed_size ) );
249                 }
250                 break;
251             case KeyFullInformation:
252                 {
253                     KEY_FULL_INFORMATION keyinfo;
254                     fixed_size = (char *)keyinfo.Class - (char *)&keyinfo;
255                     keyinfo.LastWriteTime = modif;
256                     keyinfo.TitleIndex = 0;
257                     keyinfo.ClassLength = wine_server_reply_size(reply);
258                     keyinfo.ClassOffset = keyinfo.ClassLength ? fixed_size : -1;
259                     keyinfo.SubKeys = reply->subkeys;
260                     keyinfo.MaxNameLen = reply->max_subkey;
261                     keyinfo.MaxClassLen = reply->max_class;
262                     keyinfo.Values = reply->values;
263                     keyinfo.MaxValueNameLen = reply->max_value;
264                     keyinfo.MaxValueDataLen = reply->max_data;
265                     memcpy( info, &keyinfo, min( length, fixed_size ) );
266                 }
267                 break;
268             case KeyNodeInformation:
269                 {
270                     KEY_NODE_INFORMATION keyinfo;
271                     fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
272                     keyinfo.LastWriteTime = modif;
273                     keyinfo.TitleIndex = 0;
274                     if (reply->namelen < wine_server_reply_size(reply))
275                     {
276                         keyinfo.ClassLength = wine_server_reply_size(reply) - reply->namelen;
277                         keyinfo.ClassOffset = fixed_size + reply->namelen;
278                     }
279                     else
280                     {
281                         keyinfo.ClassLength = 0;
282                         keyinfo.ClassOffset = -1;
283                     }
284                     keyinfo.NameLength = reply->namelen;
285                     memcpy( info, &keyinfo, min( length, fixed_size ) );
286                 }
287                 break;
288             }
289             *result_len = fixed_size + reply->total;
290             if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
291         }
292     }
293     SERVER_END_REQ;
294     return ret;
295 }
296
297
298
299 /******************************************************************************
300  * NtEnumerateKey [NTDLL.@]
301  * ZwEnumerateKey [NTDLL.@]
302  *
303  * NOTES
304  *  the name copied into the buffer is NOT 0-terminated
305  */
306 NTSTATUS WINAPI NtEnumerateKey( HANDLE handle, ULONG index, KEY_INFORMATION_CLASS info_class,
307                                 void *info, DWORD length, DWORD *result_len )
308 {
309     /* -1 means query key, so avoid it here */
310     if (index == (ULONG)-1) return STATUS_NO_MORE_ENTRIES;
311     return enumerate_key( handle, index, info_class, info, length, result_len );
312 }
313
314
315 /******************************************************************************
316  * RtlpNtEnumerateSubKey [NTDLL.@]
317  *
318  */
319 NTSTATUS WINAPI RtlpNtEnumerateSubKey( HANDLE handle, UNICODE_STRING *out, ULONG index )
320 {
321   KEY_BASIC_INFORMATION *info;
322   DWORD dwLen, dwResultLen;
323   NTSTATUS ret;
324
325   if (out->Length)
326   {
327     dwLen = out->Length + sizeof(KEY_BASIC_INFORMATION);
328     info = (KEY_BASIC_INFORMATION*)RtlAllocateHeap( GetProcessHeap(), 0, dwLen );
329     if (!info)
330       return STATUS_NO_MEMORY;
331   }
332   else
333   {
334     dwLen = 0;
335     info = NULL;
336   }
337
338   ret = NtEnumerateKey( handle, index, KeyBasicInformation, info, dwLen, &dwResultLen );
339   dwResultLen -= sizeof(KEY_BASIC_INFORMATION);
340
341   if (ret == STATUS_BUFFER_OVERFLOW)
342     out->Length = dwResultLen;
343   else if (!ret)
344   {
345     if (out->Length < info->NameLength)
346     {
347       out->Length = dwResultLen;
348       ret = STATUS_BUFFER_OVERFLOW;
349     }
350     else
351     {
352       out->Length = info->NameLength;
353       memcpy(out->Buffer, info->Name, info->NameLength);
354     }
355   }
356
357   RtlFreeHeap( GetProcessHeap(), 0, info );
358   return ret;
359 }
360
361 /******************************************************************************
362  * NtQueryKey [NTDLL.@]
363  * ZwQueryKey [NTDLL.@]
364  */
365 NTSTATUS WINAPI NtQueryKey( HANDLE handle, KEY_INFORMATION_CLASS info_class,
366                             void *info, DWORD length, DWORD *result_len )
367 {
368     return enumerate_key( handle, -1, info_class, info, length, result_len );
369 }
370
371
372 /* fill the key value info structure for a specific info class */
373 static void copy_key_value_info( KEY_VALUE_INFORMATION_CLASS info_class, void *info,
374                                  DWORD length, int type, int name_len, int data_len )
375 {
376     switch(info_class)
377     {
378     case KeyValueBasicInformation:
379         {
380             KEY_VALUE_BASIC_INFORMATION keyinfo;
381             keyinfo.TitleIndex = 0;
382             keyinfo.Type       = type;
383             keyinfo.NameLength = name_len;
384             length = min( length, (char *)keyinfo.Name - (char *)&keyinfo );
385             memcpy( info, &keyinfo, length );
386             break;
387         }
388     case KeyValueFullInformation:
389         {
390             KEY_VALUE_FULL_INFORMATION keyinfo;
391             keyinfo.TitleIndex = 0;
392             keyinfo.Type       = type;
393             keyinfo.DataOffset = (char *)keyinfo.Name - (char *)&keyinfo + name_len;
394             keyinfo.DataLength = data_len;
395             keyinfo.NameLength = name_len;
396             length = min( length, (char *)keyinfo.Name - (char *)&keyinfo );
397             memcpy( info, &keyinfo, length );
398             break;
399         }
400     case KeyValuePartialInformation:
401         {
402             KEY_VALUE_PARTIAL_INFORMATION keyinfo;
403             keyinfo.TitleIndex = 0;
404             keyinfo.Type       = type;
405             keyinfo.DataLength = data_len;
406             length = min( length, (char *)keyinfo.Data - (char *)&keyinfo );
407             memcpy( info, &keyinfo, length );
408             break;
409         }
410     default:
411         break;
412     }
413 }
414
415
416 /******************************************************************************
417  *  NtEnumerateValueKey [NTDLL.@]
418  *  ZwEnumerateValueKey [NTDLL.@]
419  */
420 NTSTATUS WINAPI NtEnumerateValueKey( HANDLE handle, ULONG index,
421                                      KEY_VALUE_INFORMATION_CLASS info_class,
422                                      void *info, DWORD length, DWORD *result_len )
423 {
424     NTSTATUS ret;
425     void *ptr;
426     size_t fixed_size;
427
428     TRACE( "(%p,%u,%d,%p,%d)\n", handle, index, info_class, info, length );
429
430     /* compute the length we want to retrieve */
431     switch(info_class)
432     {
433     case KeyValueBasicInformation:   ptr = ((KEY_VALUE_BASIC_INFORMATION *)info)->Name; break;
434     case KeyValueFullInformation:    ptr = ((KEY_VALUE_FULL_INFORMATION *)info)->Name; break;
435     case KeyValuePartialInformation: ptr = ((KEY_VALUE_PARTIAL_INFORMATION *)info)->Data; break;
436     default:
437         FIXME( "Information class %d not implemented\n", info_class );
438         return STATUS_INVALID_PARAMETER;
439     }
440     fixed_size = (char *)ptr - (char *)info;
441
442     SERVER_START_REQ( enum_key_value )
443     {
444         req->hkey       = handle;
445         req->index      = index;
446         req->info_class = info_class;
447         if (length > fixed_size) wine_server_set_reply( req, ptr, length - fixed_size );
448         if (!(ret = wine_server_call( req )))
449         {
450             copy_key_value_info( info_class, info, length, reply->type, reply->namelen,
451                                  wine_server_reply_size(reply) - reply->namelen );
452             *result_len = fixed_size + reply->total;
453             if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
454         }
455     }
456     SERVER_END_REQ;
457     return ret;
458 }
459
460
461 /******************************************************************************
462  * NtQueryValueKey [NTDLL.@]
463  * ZwQueryValueKey [NTDLL.@]
464  *
465  * NOTES
466  *  the name in the KeyValueInformation is never set
467  */
468 NTSTATUS WINAPI NtQueryValueKey( HANDLE handle, const UNICODE_STRING *name,
469                                  KEY_VALUE_INFORMATION_CLASS info_class,
470                                  void *info, DWORD length, DWORD *result_len )
471 {
472     NTSTATUS ret;
473     UCHAR *data_ptr;
474     unsigned int fixed_size = 0;
475
476     TRACE( "(%p,%s,%d,%p,%d)\n", handle, debugstr_us(name), info_class, info, length );
477
478     if (name->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
479
480     /* compute the length we want to retrieve */
481     switch(info_class)
482     {
483     case KeyValueBasicInformation:
484     {
485         KEY_VALUE_BASIC_INFORMATION *basic_info = info;
486         if (FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) < length)
487         {
488             memcpy(basic_info->Name, name->Buffer,
489                    min(length - FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name), name->Length));
490         }
491         fixed_size = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) + name->Length;
492         data_ptr = NULL;
493         break;
494     }
495     case KeyValueFullInformation:
496     {
497         KEY_VALUE_FULL_INFORMATION *full_info = info;
498         if (FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name) < length)
499         {
500             memcpy(full_info->Name, name->Buffer,
501                    min(length - FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name), name->Length));
502         }
503         data_ptr = (UCHAR *)full_info->Name + name->Length;
504         fixed_size = (char *)data_ptr - (char *)info;
505         break;
506     }
507     case KeyValuePartialInformation:
508         data_ptr = ((KEY_VALUE_PARTIAL_INFORMATION *)info)->Data;
509         fixed_size = (char *)data_ptr - (char *)info;
510         break;
511     default:
512         FIXME( "Information class %d not implemented\n", info_class );
513         return STATUS_INVALID_PARAMETER;
514     }
515
516     SERVER_START_REQ( get_key_value )
517     {
518         req->hkey = handle;
519         wine_server_add_data( req, name->Buffer, name->Length );
520         if (length > fixed_size && data_ptr) wine_server_set_reply( req, data_ptr, length - fixed_size );
521         if (!(ret = wine_server_call( req )))
522         {
523             copy_key_value_info( info_class, info, length, reply->type,
524                                  name->Length, reply->total );
525             *result_len = fixed_size + (info_class == KeyValueBasicInformation ? 0 : reply->total);
526             if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
527         }
528     }
529     SERVER_END_REQ;
530     return ret;
531 }
532
533 /******************************************************************************
534  * RtlpNtQueryValueKey [NTDLL.@]
535  *
536  */
537 NTSTATUS WINAPI RtlpNtQueryValueKey( HANDLE handle, ULONG *result_type, PBYTE dest,
538                                      DWORD *result_len )
539 {
540     KEY_VALUE_PARTIAL_INFORMATION *info;
541     UNICODE_STRING name;
542     NTSTATUS ret;
543     DWORD dwResultLen;
544     DWORD dwLen = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + (result_len ? *result_len : 0);
545
546     info = (KEY_VALUE_PARTIAL_INFORMATION*)RtlAllocateHeap( GetProcessHeap(), 0, dwLen );
547     if (!info)
548       return STATUS_NO_MEMORY;
549
550     name.Length = 0;
551     ret = NtQueryValueKey( handle, &name, KeyValuePartialInformation, info, dwLen, &dwResultLen );
552
553     if (!ret || ret == STATUS_BUFFER_OVERFLOW)
554     {
555         if (result_len)
556             *result_len = info->DataLength;
557
558         if (result_type)
559             *result_type = info->Type;
560
561         if (ret != STATUS_BUFFER_OVERFLOW)
562             memcpy( dest, info->Data, info->DataLength );
563     }
564
565     RtlFreeHeap( GetProcessHeap(), 0, info );
566     return ret;
567 }
568
569 /******************************************************************************
570  *  NtFlushKey  [NTDLL.@]
571  *  ZwFlushKey  [NTDLL.@]
572  */
573 NTSTATUS WINAPI NtFlushKey(HANDLE key)
574 {
575     NTSTATUS ret;
576
577     TRACE("key=%p\n", key);
578
579     SERVER_START_REQ( flush_key )
580     {
581         req->hkey = key;
582         ret = wine_server_call( req );
583     }
584     SERVER_END_REQ;
585     
586     return ret;
587 }
588
589 /******************************************************************************
590  *  NtLoadKey   [NTDLL.@]
591  *  ZwLoadKey   [NTDLL.@]
592  */
593 NTSTATUS WINAPI NtLoadKey( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file )
594 {
595     NTSTATUS ret;
596     HANDLE hive;
597     IO_STATUS_BLOCK io;
598
599     TRACE("(%p,%p)\n", attr, file);
600
601     ret = NtCreateFile(&hive, GENERIC_READ, file, &io, NULL, FILE_ATTRIBUTE_NORMAL, 0,
602                        FILE_OPEN, 0, NULL, 0);
603     if (ret) return ret;
604
605     SERVER_START_REQ( load_registry )
606     {
607         req->hkey = attr->RootDirectory;
608         req->file = hive;
609         wine_server_add_data(req, attr->ObjectName->Buffer, attr->ObjectName->Length);
610         ret = wine_server_call( req );
611     }
612     SERVER_END_REQ;
613
614     NtClose(hive);
615    
616     return ret;
617 }
618
619 /******************************************************************************
620  *  NtNotifyChangeKey   [NTDLL.@]
621  *  ZwNotifyChangeKey   [NTDLL.@]
622  */
623 NTSTATUS WINAPI NtNotifyChangeKey(
624         IN HANDLE KeyHandle,
625         IN HANDLE Event,
626         IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
627         IN PVOID ApcContext OPTIONAL,
628         OUT PIO_STATUS_BLOCK IoStatusBlock,
629         IN ULONG CompletionFilter,
630         IN BOOLEAN Asynchronous,
631         OUT PVOID ChangeBuffer,
632         IN ULONG Length,
633         IN BOOLEAN WatchSubtree)
634 {
635     NTSTATUS ret;
636
637     TRACE("(%p,%p,%p,%p,%p,0x%08x, 0x%08x,%p,0x%08x,0x%08x)\n",
638         KeyHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, CompletionFilter,
639         Asynchronous, ChangeBuffer, Length, WatchSubtree);
640
641     if (ApcRoutine || ApcContext || ChangeBuffer || Length)
642         FIXME("Unimplemented optional parameter\n");
643
644     if (!Asynchronous)
645     {
646         OBJECT_ATTRIBUTES attr;
647         InitializeObjectAttributes( &attr, NULL, 0, NULL, NULL );
648         ret = NtCreateEvent( &Event, EVENT_ALL_ACCESS, &attr, FALSE, FALSE );
649         if (ret != STATUS_SUCCESS)
650             return ret;
651     }
652
653     SERVER_START_REQ( set_registry_notification )
654     {
655         req->hkey    = KeyHandle;
656         req->event   = Event;
657         req->subtree = WatchSubtree;
658         req->filter  = CompletionFilter;
659         ret = wine_server_call( req );
660     }
661     SERVER_END_REQ;
662  
663     if (!Asynchronous)
664     {
665         if (ret == STATUS_SUCCESS)
666             NtWaitForSingleObject( Event, FALSE, NULL );
667         NtClose( Event );
668     }
669
670     return STATUS_SUCCESS;
671 }
672
673 /******************************************************************************
674  * NtQueryMultipleValueKey [NTDLL]
675  * ZwQueryMultipleValueKey
676  */
677
678 NTSTATUS WINAPI NtQueryMultipleValueKey(
679         HANDLE KeyHandle,
680         PKEY_MULTIPLE_VALUE_INFORMATION ListOfValuesToQuery,
681         ULONG NumberOfItems,
682         PVOID MultipleValueInformation,
683         ULONG Length,
684         PULONG  ReturnLength)
685 {
686         FIXME("(%p,%p,0x%08x,%p,0x%08x,%p) stub!\n",
687         KeyHandle, ListOfValuesToQuery, NumberOfItems, MultipleValueInformation,
688         Length,ReturnLength);
689         return STATUS_SUCCESS;
690 }
691
692 /******************************************************************************
693  * NtReplaceKey [NTDLL.@]
694  * ZwReplaceKey [NTDLL.@]
695  */
696 NTSTATUS WINAPI NtReplaceKey(
697         IN POBJECT_ATTRIBUTES ObjectAttributes,
698         IN HANDLE Key,
699         IN POBJECT_ATTRIBUTES ReplacedObjectAttributes)
700 {
701         FIXME("(%p),stub!\n", Key);
702         dump_ObjectAttributes(ObjectAttributes);
703         dump_ObjectAttributes(ReplacedObjectAttributes);
704         return STATUS_SUCCESS;
705 }
706 /******************************************************************************
707  * NtRestoreKey [NTDLL.@]
708  * ZwRestoreKey [NTDLL.@]
709  */
710 NTSTATUS WINAPI NtRestoreKey(
711         HANDLE KeyHandle,
712         HANDLE FileHandle,
713         ULONG RestoreFlags)
714 {
715         FIXME("(%p,%p,0x%08x) stub\n",
716         KeyHandle, FileHandle, RestoreFlags);
717         return STATUS_SUCCESS;
718 }
719 /******************************************************************************
720  * NtSaveKey [NTDLL.@]
721  * ZwSaveKey [NTDLL.@]
722  */
723 NTSTATUS WINAPI NtSaveKey(IN HANDLE KeyHandle, IN HANDLE FileHandle)
724 {
725     NTSTATUS ret;
726
727     TRACE("(%p,%p)\n", KeyHandle, FileHandle);
728
729     SERVER_START_REQ( save_registry )
730     {
731         req->hkey = KeyHandle;
732         req->file = FileHandle;
733         ret = wine_server_call( req );
734     }
735     SERVER_END_REQ;
736
737     return ret;
738 }
739 /******************************************************************************
740  * NtSetInformationKey [NTDLL.@]
741  * ZwSetInformationKey [NTDLL.@]
742  */
743 NTSTATUS WINAPI NtSetInformationKey(
744         IN HANDLE KeyHandle,
745         IN const int KeyInformationClass,
746         IN PVOID KeyInformation,
747         IN ULONG KeyInformationLength)
748 {
749         FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
750         KeyHandle, KeyInformationClass, KeyInformation, KeyInformationLength);
751         return STATUS_SUCCESS;
752 }
753
754
755 /******************************************************************************
756  * NtSetValueKey [NTDLL.@]
757  * ZwSetValueKey [NTDLL.@]
758  *
759  * NOTES
760  *   win95 does not care about count for REG_SZ and finds out the len by itself (js)
761  *   NT does definitely care (aj)
762  */
763 NTSTATUS WINAPI NtSetValueKey( HANDLE hkey, const UNICODE_STRING *name, ULONG TitleIndex,
764                                ULONG type, const void *data, ULONG count )
765 {
766     NTSTATUS ret;
767
768     TRACE( "(%p,%s,%d,%p,%d)\n", hkey, debugstr_us(name), type, data, count );
769
770     if (name->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
771
772     SERVER_START_REQ( set_key_value )
773     {
774         req->hkey    = hkey;
775         req->type    = type;
776         req->namelen = name->Length;
777         wine_server_add_data( req, name->Buffer, name->Length );
778         wine_server_add_data( req, data, count );
779         ret = wine_server_call( req );
780     }
781     SERVER_END_REQ;
782     return ret;
783 }
784
785 /******************************************************************************
786  * RtlpNtSetValueKey [NTDLL.@]
787  *
788  */
789 NTSTATUS WINAPI RtlpNtSetValueKey( HANDLE hkey, ULONG type, const void *data,
790                                    ULONG count )
791 {
792     UNICODE_STRING name;
793
794     name.Length = 0;
795     return NtSetValueKey( hkey, &name, 0, type, data, count );
796 }
797
798 /******************************************************************************
799  * NtUnloadKey [NTDLL.@]
800  * ZwUnloadKey [NTDLL.@]
801  */
802 NTSTATUS WINAPI NtUnloadKey(IN POBJECT_ATTRIBUTES attr)
803 {
804     NTSTATUS ret;
805
806     TRACE("(%p)\n", attr);
807
808     SERVER_START_REQ( unload_registry )
809     {
810         req->hkey = attr->RootDirectory;
811         ret = wine_server_call(req);
812     }
813     SERVER_END_REQ;
814
815     return ret;
816 }
817
818 /******************************************************************************
819  *  RtlFormatCurrentUserKeyPath         [NTDLL.@]
820  *
821  */
822 NTSTATUS WINAPI RtlFormatCurrentUserKeyPath( IN OUT PUNICODE_STRING KeyPath)
823 {
824     static const WCHAR pathW[] = {'\\','R','e','g','i','s','t','r','y','\\','U','s','e','r','\\'};
825     HANDLE token;
826     NTSTATUS status;
827
828     status = NtOpenThreadToken(GetCurrentThread(), TOKEN_READ, TRUE, &token);
829     if (status == STATUS_NO_TOKEN)
830         status = NtOpenProcessToken(GetCurrentProcess(), TOKEN_READ, &token);
831     if (status == STATUS_SUCCESS)
832     {
833         char buffer[sizeof(TOKEN_USER) + sizeof(SID) + sizeof(DWORD)*SID_MAX_SUB_AUTHORITIES];
834         DWORD len = sizeof(buffer);
835
836         status = NtQueryInformationToken(token, TokenUser, buffer, len, &len);
837         if (status == STATUS_SUCCESS)
838         {
839             KeyPath->MaximumLength = 0;
840             status = RtlConvertSidToUnicodeString(KeyPath, ((TOKEN_USER *)buffer)->User.Sid, FALSE);
841             if (status == STATUS_BUFFER_OVERFLOW)
842             {
843                 PWCHAR buf = RtlAllocateHeap(GetProcessHeap(), 0,
844                                              sizeof(pathW) + KeyPath->Length + sizeof(WCHAR));
845                 if (buf)
846                 {
847                     memcpy(buf, pathW, sizeof(pathW));
848                     KeyPath->MaximumLength = KeyPath->Length + sizeof(WCHAR);
849                     KeyPath->Buffer = (PWCHAR)((LPBYTE)buf + sizeof(pathW));
850                     status = RtlConvertSidToUnicodeString(KeyPath,
851                                                           ((TOKEN_USER *)buffer)->User.Sid, FALSE);
852                     KeyPath->Buffer = buf;
853                     KeyPath->Length += sizeof(pathW);
854                     KeyPath->MaximumLength += sizeof(pathW);
855                 }
856                 else
857                     status = STATUS_NO_MEMORY;
858             }
859         }
860         NtClose(token);
861     }
862     return status;
863 }
864
865 /******************************************************************************
866  *  RtlOpenCurrentUser          [NTDLL.@]
867  *
868  * NOTES
869  *  If we return just HKEY_CURRENT_USER the advapi tries to find a remote
870  *  registry (odd handle) and fails.
871  */
872 NTSTATUS WINAPI RtlOpenCurrentUser(
873         IN ACCESS_MASK DesiredAccess, /* [in] */
874         OUT PHANDLE KeyHandle)        /* [out] handle of HKEY_CURRENT_USER */
875 {
876         OBJECT_ATTRIBUTES ObjectAttributes;
877         UNICODE_STRING ObjectName;
878         NTSTATUS ret;
879
880         TRACE("(0x%08x, %p)\n",DesiredAccess, KeyHandle);
881
882         if ((ret = RtlFormatCurrentUserKeyPath(&ObjectName))) return ret;
883         InitializeObjectAttributes(&ObjectAttributes,&ObjectName,OBJ_CASE_INSENSITIVE,0, NULL);
884         ret = NtCreateKey(KeyHandle, DesiredAccess, &ObjectAttributes, 0, NULL, 0, NULL);
885         RtlFreeUnicodeString(&ObjectName);
886         return ret;
887 }
888
889
890 static NTSTATUS RTL_ReportRegistryValue(PKEY_VALUE_FULL_INFORMATION pInfo,
891                                         PRTL_QUERY_REGISTRY_TABLE pQuery, PVOID pContext, PVOID pEnvironment)
892 {
893     PUNICODE_STRING str;
894     UNICODE_STRING src, dst;
895     LONG *bin;
896     ULONG offset;
897     PWSTR wstr;
898     DWORD res;
899     NTSTATUS status = STATUS_SUCCESS;
900     ULONG len;
901     LPWSTR String;
902     INT count = 0;
903
904     if (pInfo == NULL)
905     {
906         if (pQuery->Flags & RTL_QUERY_REGISTRY_DIRECT)
907             return STATUS_INVALID_PARAMETER;
908         else
909         {
910             status = pQuery->QueryRoutine(pQuery->Name, pQuery->DefaultType, pQuery->DefaultData,
911                                           pQuery->DefaultLength, pContext, pQuery->EntryContext);
912         }
913         return status;
914     }
915     len = pInfo->DataLength;
916
917     if (pQuery->Flags & RTL_QUERY_REGISTRY_DIRECT)
918     {
919         str = (PUNICODE_STRING)pQuery->EntryContext;
920  
921         switch(pInfo->Type)
922         {
923         case REG_EXPAND_SZ:
924             if (!(pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND))
925             {
926                 RtlInitUnicodeString(&src, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
927                 res = 0;
928                 dst.MaximumLength = 0;
929                 RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
930                 dst.Length = 0;
931                 dst.MaximumLength = res;
932                 dst.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, res * sizeof(WCHAR));
933                 RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
934                 status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, dst.Buffer,
935                                      dst.Length, pContext, pQuery->EntryContext);
936                 RtlFreeHeap(GetProcessHeap(), 0, dst.Buffer);
937             }
938
939         case REG_SZ:
940         case REG_LINK:
941             if (str->Buffer == NULL)
942                 RtlCreateUnicodeString(str, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
943             else
944                 RtlAppendUnicodeToString(str, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
945             break;
946
947         case REG_MULTI_SZ:
948             if (!(pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND))
949                 return STATUS_INVALID_PARAMETER;
950
951             if (str->Buffer == NULL)
952             {
953                 str->Buffer = RtlAllocateHeap(GetProcessHeap(), 0, len);
954                 str->MaximumLength = len;
955             }
956             len = min(len, str->MaximumLength);
957             memcpy(str->Buffer, ((CHAR*)pInfo) + pInfo->DataOffset, len);
958             str->Length = len;
959             break;
960
961         default:
962             bin = (LONG*)pQuery->EntryContext;
963             if (pInfo->DataLength <= sizeof(ULONG))
964                 memcpy(bin, ((CHAR*)pInfo) + pInfo->DataOffset,
965                     pInfo->DataLength);
966             else
967             {
968                 if (bin[0] <= sizeof(ULONG))
969                 {
970                     memcpy(&bin[1], ((CHAR*)pInfo) + pInfo->DataOffset,
971                     min(-bin[0], pInfo->DataLength));
972                 }
973                 else
974                 {
975                    len = min(bin[0], pInfo->DataLength);
976                     bin[1] = len;
977                     bin[2] = pInfo->Type;
978                     memcpy(&bin[3], ((CHAR*)pInfo) + pInfo->DataOffset, len);
979                 }
980            }
981            break;
982         }
983     }
984     else
985     {
986         if((pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND) ||
987            (pInfo->Type != REG_EXPAND_SZ && pInfo->Type != REG_MULTI_SZ))
988         {
989             status = pQuery->QueryRoutine(pInfo->Name, pInfo->Type,
990                 ((CHAR*)pInfo) + pInfo->DataOffset, pInfo->DataLength,
991                 pContext, pQuery->EntryContext);
992         }
993         else if (pInfo->Type == REG_EXPAND_SZ)
994         {
995             RtlInitUnicodeString(&src, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
996             res = 0;
997             dst.MaximumLength = 0;
998             RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
999             dst.Length = 0;
1000             dst.MaximumLength = res;
1001             dst.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, res * sizeof(WCHAR));
1002             RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
1003             status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, dst.Buffer,
1004                                           dst.Length, pContext, pQuery->EntryContext);
1005             RtlFreeHeap(GetProcessHeap(), 0, dst.Buffer);
1006         }
1007         else /* REG_MULTI_SZ */
1008         {
1009             if(pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND)
1010             {
1011                 for (offset = 0; offset <= pInfo->DataLength; offset += len + sizeof(WCHAR))
1012                     {
1013                     wstr = (WCHAR*)(((CHAR*)pInfo) + offset);
1014                     len = strlenW(wstr) * sizeof(WCHAR);
1015                     status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, wstr, len,
1016                         pContext, pQuery->EntryContext);
1017                     if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
1018                         return status;
1019                     }
1020             }
1021             else
1022             {
1023                 while(count<=pInfo->DataLength)
1024                 {
1025                     String = (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset)+count;
1026                     count+=strlenW(String)+1;
1027                     RtlInitUnicodeString(&src, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
1028                     res = 0;
1029                     dst.MaximumLength = 0;
1030                     RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
1031                     dst.Length = 0;
1032                     dst.MaximumLength = res;
1033                     dst.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, res * sizeof(WCHAR));
1034                     RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
1035                     status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, dst.Buffer,
1036                                                   dst.Length, pContext, pQuery->EntryContext);
1037                     RtlFreeHeap(GetProcessHeap(), 0, dst.Buffer);
1038                     if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
1039                         return status;
1040                 }
1041             }
1042         }
1043     }
1044     return status;
1045 }
1046
1047
1048 static NTSTATUS RTL_GetKeyHandle(ULONG RelativeTo, PCWSTR Path, PHANDLE handle)
1049 {
1050     UNICODE_STRING KeyString;
1051     OBJECT_ATTRIBUTES regkey;
1052     PCWSTR base;
1053     INT len;
1054     NTSTATUS status;
1055
1056     static const WCHAR empty[] = {0};
1057     static const WCHAR control[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e',
1058     '\\','S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1059     'C','o','n','t','r','o','l','\\',0};
1060
1061     static const WCHAR devicemap[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
1062     'H','a','r','d','w','a','r','e','\\','D','e','v','i','c','e','M','a','p','\\',0};
1063
1064     static const WCHAR services[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
1065     'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1066     'S','e','r','v','i','c','e','s','\\',0};
1067
1068     static const WCHAR user[] = {'\\','R','e','g','i','s','t','r','y','\\','U','s','e','r','\\',
1069     'C','u','r','r','e','n','t','U','s','e','r','\\',0};
1070
1071     static const WCHAR windows_nt[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
1072     'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1073     'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',0};
1074
1075     switch (RelativeTo & 0xff)
1076     {
1077     case RTL_REGISTRY_ABSOLUTE:
1078         base = empty;
1079         break;
1080
1081     case RTL_REGISTRY_CONTROL:
1082         base = control;
1083         break;
1084
1085     case RTL_REGISTRY_DEVICEMAP:
1086         base = devicemap;
1087         break;
1088
1089     case RTL_REGISTRY_SERVICES:
1090         base = services;
1091         break;
1092
1093     case RTL_REGISTRY_USER:
1094         base = user;
1095         break;
1096
1097     case RTL_REGISTRY_WINDOWS_NT:
1098         base = windows_nt;
1099         break;
1100
1101     default:
1102         return STATUS_INVALID_PARAMETER;
1103     }
1104
1105     len = (strlenW(base) + strlenW(Path) + 1) * sizeof(WCHAR);
1106     KeyString.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, len);
1107     if (KeyString.Buffer == NULL)
1108         return STATUS_NO_MEMORY;
1109
1110     strcpyW(KeyString.Buffer, base);
1111     strcatW(KeyString.Buffer, Path);
1112     KeyString.Length = len - sizeof(WCHAR);
1113     KeyString.MaximumLength = len;
1114     InitializeObjectAttributes(&regkey, &KeyString, OBJ_CASE_INSENSITIVE, NULL, NULL);
1115     status = NtOpenKey(handle, KEY_ALL_ACCESS, &regkey);
1116     RtlFreeHeap(GetProcessHeap(), 0, KeyString.Buffer);
1117     return status;
1118 }
1119
1120 /*************************************************************************
1121  * RtlQueryRegistryValues   [NTDLL.@]
1122  *
1123  * Query multiple registry values with a signle call.
1124  *
1125  * PARAMS
1126  *  RelativeTo  [I] Registry path that Path refers to
1127  *  Path        [I] Path to key
1128  *  QueryTable  [I] Table of key values to query
1129  *  Context     [I] Parameter to pass to the application defined QueryRoutine function
1130  *  Environment [I] Optional parameter to use when performing expansion
1131  *
1132  * RETURNS
1133  *  STATUS_SUCCESS or an appropriate NTSTATUS error code.
1134  */
1135 NTSTATUS WINAPI RtlQueryRegistryValues(IN ULONG RelativeTo, IN PCWSTR Path,
1136                                        IN PRTL_QUERY_REGISTRY_TABLE QueryTable, IN PVOID Context,
1137                                        IN PVOID Environment OPTIONAL)
1138 {
1139     UNICODE_STRING Value;
1140     HANDLE handle, topkey;
1141     PKEY_VALUE_FULL_INFORMATION pInfo = NULL;
1142     ULONG len, buflen = 0;
1143     NTSTATUS status=STATUS_SUCCESS, ret = STATUS_SUCCESS;
1144     INT i;
1145
1146     TRACE("(%d, %s, %p, %p, %p)\n", RelativeTo, debugstr_w(Path), QueryTable, Context, Environment);
1147
1148     if(Path == NULL)
1149         return STATUS_INVALID_PARAMETER;
1150
1151     /* get a valid handle */
1152     if (RelativeTo & RTL_REGISTRY_HANDLE)
1153         topkey = handle = (HANDLE)Path;
1154     else
1155     {
1156         status = RTL_GetKeyHandle(RelativeTo, Path, &topkey);
1157         handle = topkey;
1158     }
1159     if(status != STATUS_SUCCESS)
1160         return status;
1161
1162     /* Process query table entries */
1163     for (; QueryTable->QueryRoutine != NULL || QueryTable->Name != NULL; ++QueryTable)
1164     {
1165         if (QueryTable->Flags &
1166             (RTL_QUERY_REGISTRY_SUBKEY | RTL_QUERY_REGISTRY_TOPKEY))
1167         {
1168             /* topkey must be kept open just in case we will reuse it later */
1169             if (handle != topkey)
1170                 NtClose(handle);
1171
1172             if (QueryTable->Flags & RTL_QUERY_REGISTRY_SUBKEY)
1173             {
1174                 handle = 0;
1175                 status = RTL_GetKeyHandle(PtrToUlong(QueryTable->Name), Path, &handle);
1176                 if(status != STATUS_SUCCESS)
1177                 {
1178                     ret = status;
1179                     goto out;
1180                 }
1181             }
1182             else
1183                 handle = topkey;
1184         }
1185
1186         if (QueryTable->Flags & RTL_QUERY_REGISTRY_NOVALUE)
1187         {
1188             QueryTable->QueryRoutine(QueryTable->Name, REG_NONE, NULL, 0,
1189                 Context, QueryTable->EntryContext);
1190             continue;
1191         }
1192
1193         if (!handle)
1194         {
1195             if (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED)
1196             {
1197                 ret = STATUS_OBJECT_NAME_NOT_FOUND;
1198                 goto out;
1199             }
1200             continue;
1201         }
1202
1203         if (QueryTable->Name == NULL)
1204         {
1205             if (QueryTable->Flags & RTL_QUERY_REGISTRY_DIRECT)
1206             {
1207                 ret = STATUS_INVALID_PARAMETER;
1208                 goto out;
1209             }
1210
1211             /* Report all subkeys */
1212             for (i = 0;; ++i)
1213             {
1214                 status = NtEnumerateValueKey(handle, i,
1215                     KeyValueFullInformation, pInfo, buflen, &len);
1216                 if (status == STATUS_NO_MORE_ENTRIES)
1217                     break;
1218                 if (status == STATUS_BUFFER_OVERFLOW ||
1219                     status == STATUS_BUFFER_TOO_SMALL)
1220                 {
1221                     buflen = len;
1222                     RtlFreeHeap(GetProcessHeap(), 0, pInfo);
1223                     pInfo = (KEY_VALUE_FULL_INFORMATION*)RtlAllocateHeap(
1224                         GetProcessHeap(), 0, buflen);
1225                     NtEnumerateValueKey(handle, i, KeyValueFullInformation,
1226                         pInfo, buflen, &len);
1227                 }
1228
1229                 status = RTL_ReportRegistryValue(pInfo, QueryTable, Context, Environment);
1230                 if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
1231                 {
1232                     ret = status;
1233                     goto out;
1234                 }
1235                 if (QueryTable->Flags & RTL_QUERY_REGISTRY_DELETE)
1236                 {
1237                     RtlInitUnicodeString(&Value, pInfo->Name);
1238                     NtDeleteValueKey(handle, &Value);
1239                 }
1240             }
1241
1242             if (i == 0  && (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED))
1243             {
1244                 ret = STATUS_OBJECT_NAME_NOT_FOUND;
1245                 goto out;
1246             }
1247         }
1248         else
1249         {
1250             RtlInitUnicodeString(&Value, QueryTable->Name);
1251             status = NtQueryValueKey(handle, &Value, KeyValueFullInformation,
1252                 pInfo, buflen, &len);
1253             if (status == STATUS_BUFFER_OVERFLOW ||
1254                 status == STATUS_BUFFER_TOO_SMALL)
1255             {
1256                 buflen = len;
1257                 RtlFreeHeap(GetProcessHeap(), 0, pInfo);
1258                 pInfo = (KEY_VALUE_FULL_INFORMATION*)RtlAllocateHeap(
1259                     GetProcessHeap(), 0, buflen);
1260                 status = NtQueryValueKey(handle, &Value,
1261                     KeyValueFullInformation, pInfo, buflen, &len);
1262             }
1263             if (status != STATUS_SUCCESS)
1264             {
1265                 if (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED)
1266                 {
1267                     ret = STATUS_OBJECT_NAME_NOT_FOUND;
1268                     goto out;
1269                 }
1270                 status = RTL_ReportRegistryValue(NULL, QueryTable, Context, Environment);
1271                 if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
1272                 {
1273                     ret = status;
1274                     goto out;
1275                 }
1276             }
1277             else
1278             {
1279                 status = RTL_ReportRegistryValue(pInfo, QueryTable, Context, Environment);
1280                 if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
1281                 {
1282                     ret = status;
1283                     goto out;
1284                 }
1285                 if (QueryTable->Flags & RTL_QUERY_REGISTRY_DELETE)
1286                     NtDeleteValueKey(handle, &Value);
1287             }
1288         }
1289     }
1290
1291 out:
1292     RtlFreeHeap(GetProcessHeap(), 0, pInfo);
1293     if (handle != topkey)
1294         NtClose(handle);
1295     NtClose(topkey);
1296     return ret;
1297 }
1298
1299 /*************************************************************************
1300  * RtlCheckRegistryKey   [NTDLL.@]
1301  *
1302  * Query multiple registry values with a signle call.
1303  *
1304  * PARAMS
1305  *  RelativeTo [I] Registry path that Path refers to
1306  *  Path       [I] Path to key
1307  *
1308  * RETURNS
1309  *  STATUS_SUCCESS if the specified key exists, or an NTSTATUS error code.
1310  */
1311 NTSTATUS WINAPI RtlCheckRegistryKey(IN ULONG RelativeTo, IN PWSTR Path)
1312 {
1313     HANDLE handle;
1314     NTSTATUS status;
1315
1316     TRACE("(%d, %s)\n", RelativeTo, debugstr_w(Path));
1317
1318     if((!RelativeTo) && Path == NULL)
1319         return STATUS_OBJECT_PATH_SYNTAX_BAD;
1320     if(RelativeTo & RTL_REGISTRY_HANDLE)
1321         return STATUS_SUCCESS;
1322
1323     status = RTL_GetKeyHandle(RelativeTo, Path, &handle);
1324     if (handle) NtClose(handle);
1325     if (status == STATUS_INVALID_HANDLE) status = STATUS_OBJECT_NAME_NOT_FOUND;
1326     return status;
1327 }
1328
1329 /*************************************************************************
1330  * RtlDeleteRegistryValue   [NTDLL.@]
1331  *
1332  * Query multiple registry values with a signle call.
1333  *
1334  * PARAMS
1335  *  RelativeTo [I] Registry path that Path refers to
1336  *  Path       [I] Path to key
1337  *  ValueName  [I] Name of the value to delete
1338  *
1339  * RETURNS
1340  *  STATUS_SUCCESS if the specified key is successfully deleted, or an NTSTATUS error code.
1341  */
1342 NTSTATUS WINAPI RtlDeleteRegistryValue(IN ULONG RelativeTo, IN PCWSTR Path, IN PCWSTR ValueName)
1343 {
1344     NTSTATUS status;
1345     HANDLE handle;
1346     UNICODE_STRING Value;
1347
1348     TRACE("(%d, %s, %s)\n", RelativeTo, debugstr_w(Path), debugstr_w(ValueName));
1349
1350     RtlInitUnicodeString(&Value, ValueName);
1351     if(RelativeTo == RTL_REGISTRY_HANDLE)
1352     {
1353         return NtDeleteValueKey((HANDLE)Path, &Value);
1354     }
1355     status = RTL_GetKeyHandle(RelativeTo, Path, &handle);
1356     if (status) return status;
1357     status = NtDeleteValueKey(handle, &Value);
1358     NtClose(handle);
1359     return status;
1360 }
1361
1362 /*************************************************************************
1363  * RtlWriteRegistryValue   [NTDLL.@]
1364  *
1365  * Sets the registry value with provided data.
1366  *
1367  * PARAMS
1368  *  RelativeTo [I] Registry path that path parameter refers to
1369  *  path       [I] Path to the key (or handle - see RTL_GetKeyHandle)
1370  *  name       [I] Name of the registry value to set
1371  *  type       [I] Type of the registry key to set
1372  *  data       [I] Pointer to the user data to be set
1373  *  length     [I] Length of the user data pointed by data
1374  *
1375  * RETURNS
1376  *  STATUS_SUCCESS if the specified key is successfully set,
1377  *  or an NTSTATUS error code.
1378  */
1379 NTSTATUS WINAPI RtlWriteRegistryValue( ULONG RelativeTo, PCWSTR path, PCWSTR name,
1380                                        ULONG type, PVOID data, ULONG length )
1381 {
1382     HANDLE hkey;
1383     NTSTATUS status;
1384     UNICODE_STRING str;
1385
1386     TRACE( "(%d, %s, %s) -> %d: %p [%d]\n", RelativeTo, debugstr_w(path), debugstr_w(name),
1387            type, data, length );
1388
1389     RtlInitUnicodeString( &str, name );
1390
1391     if (RelativeTo == RTL_REGISTRY_HANDLE)
1392         return NtSetValueKey( (HANDLE)path, &str, 0, type, data, length );
1393
1394     status = RTL_GetKeyHandle( RelativeTo, path, &hkey );
1395     if (status != STATUS_SUCCESS) return status;
1396
1397     status = NtSetValueKey( hkey, &str, 0, type, data, length );
1398     NtClose( hkey );
1399
1400     return status;
1401 }