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