lib/advapi32/reg/reg.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/advapi32/reg/reg.c
   6  * PURPOSE:         Registry functions
   7  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   8  * UPDATE HISTORY:
   9  *                  Created 01/11/98
  10  *                  19990309 EA Stubs
  11  */
  12 #include <ddk/ntddk.h>
  13 #include <ntdll/rtl.h>
  14 #include <windows.h>
  15 #include <wchar.h>
  16
  17 #define NDEBUG
  18 #include <debug.h>
  19
  20 #define CHECK_STATUS \
  21 { \
  22         if (!NT_SUCCESS(Status)) \
  23         { \
  24                 LONG _ErrorCode = RtlNtStatusToDosError(Status); \
  25                 SetLastError(_ErrorCode); \
  26                 return _ErrorCode; \
  27         } \
  28 }
  29
  30 /* GLOBALS *******************************************************************/
  31
  32 #define MAX_DEFAULT_HANDLES   6
  33
  34 static CRITICAL_SECTION HandleTableCS;
  35 static HANDLE DefaultHandleTable[MAX_DEFAULT_HANDLES];
  36
  37
  38 /* PROTOTYPES ****************************************************************/
  39
  40 static NTSTATUS MapDefaultKey (PHKEY ParentKey, HKEY Key);
  41 static VOID CloseDefaultKeys(VOID);
  42
  43 static NTSTATUS OpenClassesRootKey(PHANDLE KeyHandle);
  44 static NTSTATUS OpenLocalMachineKey (PHANDLE KeyHandle);
  45 static NTSTATUS OpenUsersKey (PHANDLE KeyHandle);
  46 static NTSTATUS OpenCurrentConfigKey(PHANDLE KeyHandle);
  47
  48
  49 /* FUNCTIONS *****************************************************************/
  50
  51 inline RegiTerminateWideString(LPWSTR String, DWORD Length)
  52 {
  53   LPWSTR AfterString = String + Length;
  54   *AfterString = 0;
  55 }
  56
  57 /************************************************************************
  58  *      RegInitDefaultHandles
  59  */
  60
  61 BOOL
  62 RegInitialize (VOID)
  63 {
  64    DPRINT("RegInitialize()\n");
  65
  66    RtlZeroMemory (DefaultHandleTable,
  67                   MAX_DEFAULT_HANDLES * sizeof(HANDLE));
  68
  69    RtlInitializeCriticalSection(&HandleTableCS);
  70    return TRUE;
  71 }
  72
  73
  74 /************************************************************************
  75  *      RegInit
  76  */
  77 BOOL
  78 RegCleanup(VOID)
  79 {
  80    DPRINT("RegCleanup()\n");
  81
  82    CloseDefaultKeys();
  83    RtlDeleteCriticalSection(&HandleTableCS);
  84    return TRUE;
  85 }
  86
  87
  88 static NTSTATUS
  89 MapDefaultKey(PHKEY RealKey,
  90               HKEY Key)
  91 {
  92    PHANDLE Handle;
  93    ULONG Index;
  94    NTSTATUS Status = STATUS_SUCCESS;
  95
  96    DPRINT("MapDefaultKey (Key %x)\n", Key);
  97
  98    if (((ULONG)Key & 0xF0000000) != 0x80000000)
  99      {
 100         *RealKey = Key;
 101         return STATUS_SUCCESS;
 102      }
 103
 104    /* Handle special cases here */
 105    Index = (ULONG)Key & 0x0FFFFFFF;
 106
 107    if (Index >= MAX_DEFAULT_HANDLES)
 108      return STATUS_INVALID_PARAMETER;
 109
 110    RtlEnterCriticalSection(&HandleTableCS);
 111
 112    Handle = &DefaultHandleTable[Index];
 113    if (*Handle == NULL)
 114      {
 115         /* create/open the default handle */
 116         switch (Index)
 117           {
 118             case 0: /* HKEY_CLASSES_ROOT */
 119               Status = OpenClassesRootKey(Handle);
 120               break;
 121
 122             case 1: /* HKEY_CURRENT_USER */
 123               Status = RtlOpenCurrentUser(KEY_ALL_ACCESS,
 124                                           Handle);
 125               break;
 126
 127             case 2: /* HKEY_LOCAL_MACHINE */
 128               Status = OpenLocalMachineKey(Handle);
 129               break;
 130
 131             case 3: /* HKEY_USERS */
 132               Status = OpenUsersKey(Handle);
 133               break;
 134 #if 0
 135             case 4: /* HKEY_PERFORMANCE_DATA */
 136               Status = OpenPerformanceDataKey(Handle);
 137               break;
 138 #endif
 139             case 5: /* HKEY_CURRENT_CONFIG */
 140               Status = OpenCurrentConfigKey(Handle);
 141               break;
 142
 143             default:
 144               DPRINT("MapDefaultHandle() no handle creator\n");
 145               Status = STATUS_INVALID_PARAMETER;
 146           }
 147      }
 148
 149    RtlLeaveCriticalSection(&HandleTableCS);
 150
 151    if (NT_SUCCESS(Status))
 152      {
 153         *RealKey = (HKEY)*Handle;
 154      }
 155
 156    return Status;
 157 }
 158
 159
 160 static VOID
 161 CloseDefaultKeys(VOID)
 162 {
 163    ULONG i;
 164
 165    RtlEnterCriticalSection(&HandleTableCS);
 166
 167    for (i = 0; i < MAX_DEFAULT_HANDLES; i++)
 168      {
 169         if (DefaultHandleTable[i] != NULL)
 170           {
 171              NtClose (DefaultHandleTable[i]);
 172              DefaultHandleTable[i] = NULL;
 173           }
 174      }
 175
 176    RtlLeaveCriticalSection(&HandleTableCS);
 177 }
 178
 179
 180 static NTSTATUS
 181 OpenClassesRootKey(PHANDLE KeyHandle)
 182 {
 183   OBJECT_ATTRIBUTES Attributes;
 184   UNICODE_STRING KeyName = UNICODE_STRING_INITIALIZER(L"\\Registry\\Machine\\Software\\CLASSES");
 185
 186   DPRINT("OpenClassesRootKey()\n");
 187
 188   InitializeObjectAttributes(&Attributes,
 189                              &KeyName,
 190                              OBJ_CASE_INSENSITIVE,
 191                              NULL,
 192                              NULL);
 193
 194   return(NtOpenKey(KeyHandle,
 195                    KEY_ALL_ACCESS,
 196                    &Attributes));
 197 }
 198
 199
 200 static NTSTATUS
 201 OpenLocalMachineKey(PHANDLE KeyHandle)
 202 {
 203   OBJECT_ATTRIBUTES Attributes;
 204   UNICODE_STRING KeyName = UNICODE_STRING_INITIALIZER(L"\\Registry\\Machine");
 205
 206   DPRINT("OpenLocalMachineKey()\n");
 207
 208   InitializeObjectAttributes(&Attributes,
 209                              &KeyName,
 210                              OBJ_CASE_INSENSITIVE,
 211                              NULL,
 212                              NULL);
 213
 214   return(NtOpenKey(KeyHandle,
 215                    KEY_ALL_ACCESS,
 216                    &Attributes));
 217 }
 218
 219
 220 static NTSTATUS
 221 OpenUsersKey(PHANDLE KeyHandle)
 222 {
 223   OBJECT_ATTRIBUTES Attributes;
 224   UNICODE_STRING KeyName = UNICODE_STRING_INITIALIZER(L"\\Registry\\User");
 225
 226   DPRINT("OpenUsersKey()\n");
 227
 228   InitializeObjectAttributes(&Attributes,
 229                              &KeyName,
 230                              OBJ_CASE_INSENSITIVE,
 231                              NULL,
 232                              NULL);
 233
 234   return(NtOpenKey(KeyHandle,
 235                    KEY_ALL_ACCESS,
 236                    &Attributes));
 237 }
 238
 239
 240 static NTSTATUS
 241 OpenCurrentConfigKey(PHANDLE KeyHandle)
 242 {
 243   OBJECT_ATTRIBUTES Attributes;
 244   UNICODE_STRING KeyName =
 245    UNICODE_STRING_INITIALIZER(L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\Current");
 246
 247   DPRINT("OpenCurrentConfigKey()\n");
 248
 249   InitializeObjectAttributes(&Attributes,
 250                              &KeyName,
 251                              OBJ_CASE_INSENSITIVE,
 252                              NULL,
 253                              NULL);
 254
 255   return(NtOpenKey(KeyHandle,
 256                    KEY_ALL_ACCESS,
 257                    &Attributes));
 258 }
 259
 260 /************************************************************************
 261  *      RegCloseKey
 262  */
 263 LONG STDCALL
 264 RegCloseKey(HKEY hKey)
 265 {
 266   NTSTATUS Status;
 267
 268   /* don't close null handle or a pseudo handle */
 269   if ((!hKey) || (((ULONG)hKey & 0xF0000000) == 0x80000000))
 270     return ERROR_INVALID_HANDLE;
 271
 272   Status = NtClose (hKey);
 273   if (!NT_SUCCESS(Status))
 274     {
 275       LONG ErrorCode = RtlNtStatusToDosError(Status);
 276
 277       SetLastError (ErrorCode);
 278       return ErrorCode;
 279     }
 280
 281   return ERROR_SUCCESS;
 282 }
 283
 284
 285 /************************************************************************
 286  *      RegConnectRegistryA
 287  */
 288 LONG STDCALL
 289 RegConnectRegistryA(LPCSTR lpMachineName,
 290                     HKEY hKey,
 291                     PHKEY phkResult)
 292 {
 293   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 294   return ERROR_CALL_NOT_IMPLEMENTED;
 295 }
 296
 297
 298 /************************************************************************
 299  *      RegConnectRegistryW
 300  */
 301 LONG STDCALL
 302 RegConnectRegistryW(LPCWSTR lpMachineName,
 303                     HKEY hKey,
 304                     PHKEY phkResult)
 305 {
 306   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 307   return ERROR_CALL_NOT_IMPLEMENTED;
 308 }
 309
 310
 311 /************************************************************************
 312  *      RegCreateKeyA
 313  */
 314 LONG STDCALL
 315 RegCreateKeyA(HKEY hKey,
 316               LPCSTR lpSubKey,
 317               PHKEY phkResult)
 318 {
 319   return(RegCreateKeyExA(hKey,
 320                          lpSubKey,
 321                          0,
 322                          NULL,
 323                          0,
 324                          KEY_ALL_ACCESS,
 325                          NULL,
 326                          phkResult,
 327                          NULL));
 328 }
 329
 330
 331 /************************************************************************
 332  *      RegCreateKeyW
 333  */
 334 LONG STDCALL
 335 RegCreateKeyW(HKEY hKey,
 336               LPCWSTR lpSubKey,
 337               PHKEY phkResult)
 338 {
 339   return(RegCreateKeyExW(hKey,
 340                          lpSubKey,
 341                          0,
 342                          NULL,
 343                          0,
 344                          KEY_ALL_ACCESS,
 345                          NULL,
 346                          phkResult,
 347                          NULL));
 348 }
 349
 350
 351 /************************************************************************
 352  *      RegCreateKeyExA
 353  */
 354 LONG STDCALL
 355 RegCreateKeyExA(HKEY hKey,
 356                 LPCSTR lpSubKey,
 357                 DWORD Reserved,
 358                 LPSTR lpClass,
 359                 DWORD dwOptions,
 360                 REGSAM samDesired,
 361                 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
 362                 PHKEY phkResult,
 363                 LPDWORD lpdwDisposition)
 364 {
 365   UNICODE_STRING SubKeyString;
 366   UNICODE_STRING ClassString;
 367   OBJECT_ATTRIBUTES Attributes;
 368   NTSTATUS Status;
 369   HKEY ParentKey;
 370
 371   DPRINT("RegCreateKeyExW() called\n");
 372
 373   /* get the real parent key */
 374   Status = MapDefaultKey(&ParentKey,
 375                          hKey);
 376   if (!NT_SUCCESS(Status))
 377     {
 378       LONG ErrorCode = RtlNtStatusToDosError(Status);
 379
 380       SetLastError(ErrorCode);
 381       return(ErrorCode);
 382     }
 383
 384   DPRINT("ParentKey %x\n", (ULONG)ParentKey);
 385
 386   if (lpClass != NULL)
 387     RtlCreateUnicodeStringFromAsciiz(&ClassString,
 388                                      lpClass);
 389   RtlCreateUnicodeStringFromAsciiz(&SubKeyString,
 390                                    (LPSTR)lpSubKey);
 391
 392   InitializeObjectAttributes(&Attributes,
 393                              &SubKeyString,
 394                              OBJ_CASE_INSENSITIVE,
 395                              (HANDLE)ParentKey,
 396                              (PSECURITY_DESCRIPTOR)lpSecurityAttributes);
 397
 398   Status = NtCreateKey(phkResult,
 399                        samDesired,
 400                        &Attributes,
 401                        0,
 402                        (lpClass == NULL)? NULL : &ClassString,
 403                        dwOptions,
 404                        (PULONG)lpdwDisposition);
 405
 406   RtlFreeUnicodeString(&SubKeyString);
 407   if (lpClass != NULL)
 408     RtlFreeUnicodeString(&ClassString);
 409
 410   DPRINT("Status %x\n", Status);
 411   if (!NT_SUCCESS(Status))
 412     {
 413       LONG ErrorCode = RtlNtStatusToDosError(Status);
 414
 415       SetLastError (ErrorCode);
 416       return ErrorCode;
 417     }
 418
 419   return(ERROR_SUCCESS);
 420 }
 421
 422
 423 /************************************************************************
 424  *      RegCreateKeyExW
 425  */
 426 LONG STDCALL
 427 RegCreateKeyExW(HKEY                    hKey,
 428                 LPCWSTR                 lpSubKey,
 429                 DWORD                   Reserved,
 430                 LPWSTR                  lpClass,
 431                 DWORD                   dwOptions,
 432                 REGSAM                  samDesired,
 433                 LPSECURITY_ATTRIBUTES   lpSecurityAttributes,
 434                 PHKEY                   phkResult,
 435                 LPDWORD                 lpdwDisposition)
 436 {
 437         UNICODE_STRING SubKeyString;
 438         UNICODE_STRING ClassString;
 439         OBJECT_ATTRIBUTES Attributes;
 440         NTSTATUS Status;
 441         HKEY ParentKey;
 442
 443         DPRINT("RegCreateKeyExW() called\n");
 444
 445         /* get the real parent key */
 446         Status = MapDefaultKey (&ParentKey, hKey);
 447         if (!NT_SUCCESS(Status))
 448         {
 449                 LONG ErrorCode = RtlNtStatusToDosError(Status);
 450
 451                 SetLastError (ErrorCode);
 452                 return ErrorCode;
 453         }
 454
 455         DPRINT("ParentKey %x\n", (ULONG)ParentKey);
 456         RtlInitUnicodeString (&ClassString, lpClass);
 457         RtlInitUnicodeString (&SubKeyString, lpSubKey);
 458
 459         InitializeObjectAttributes (&Attributes,
 460                                     &SubKeyString,
 461                                     OBJ_CASE_INSENSITIVE,
 462                                     (HANDLE)ParentKey,
 463                                     (PSECURITY_DESCRIPTOR)lpSecurityAttributes);
 464
 465         Status = NtCreateKey (phkResult,
 466                               samDesired,
 467                               &Attributes,
 468                               0,
 469                               (lpClass == NULL)? NULL : &ClassString,
 470                               dwOptions,
 471                               (PULONG)lpdwDisposition);
 472         DPRINT("Status %x\n", Status);
 473         if (!NT_SUCCESS(Status))
 474         {
 475                 LONG ErrorCode = RtlNtStatusToDosError(Status);
 476
 477                 SetLastError (ErrorCode);
 478                 return ErrorCode;
 479         }
 480
 481         return ERROR_SUCCESS;
 482 }
 483
 484
 485 /************************************************************************
 486  *      RegDeleteKeyA
 487  */
 488 LONG
 489 STDCALL
 490 RegDeleteKeyA(
 491         HKEY    hKey,
 492         LPCSTR  lpSubKey
 493         )
 494 {
 495         OBJECT_ATTRIBUTES ObjectAttributes;
 496         UNICODE_STRING SubKeyStringW;
 497         ANSI_STRING SubKeyStringA;
 498 //      HANDLE ParentKey;
 499         HKEY ParentKey;
 500         HANDLE TargetKey;
 501         NTSTATUS Status;
 502         LONG ErrorCode;
 503
 504         Status = MapDefaultKey(&ParentKey,
 505                                hKey);
 506         if (!NT_SUCCESS(Status))
 507         {
 508                 ErrorCode = RtlNtStatusToDosError(Status);
 509
 510                 SetLastError (ErrorCode);
 511                 return ErrorCode;
 512         }
 513
 514         RtlInitAnsiString(&SubKeyStringA,
 515                           (LPSTR)lpSubKey);
 516         RtlAnsiStringToUnicodeString(&SubKeyStringW,
 517                                      &SubKeyStringA,
 518                                      TRUE);
 519
 520         InitializeObjectAttributes (&ObjectAttributes,
 521                                     &SubKeyStringW,
 522                                     OBJ_CASE_INSENSITIVE,
 523                                     (HANDLE)ParentKey,
 524                                     NULL);
 525
 526         Status = NtOpenKey (&TargetKey,
 527                             DELETE,
 528                             &ObjectAttributes);
 529
 530         RtlFreeUnicodeString (&SubKeyStringW);
 531
 532         if (!NT_SUCCESS(Status))
 533         {
 534                 ErrorCode = RtlNtStatusToDosError(Status);
 535
 536                 SetLastError (ErrorCode);
 537                 return ErrorCode;
 538         }
 539
 540         Status = NtDeleteKey(TargetKey);
 541
 542         NtClose(TargetKey);
 543
 544         if (!NT_SUCCESS(Status))
 545         {
 546                 ErrorCode = RtlNtStatusToDosError(Status);
 547
 548                 SetLastError (ErrorCode);
 549                 return ErrorCode;
 550         }
 551         return ERROR_SUCCESS;
 552 }
 553
 554
 555 /************************************************************************
 556  *      RegDeleteKeyW
 557  */
 558 LONG
 559 STDCALL
 560 RegDeleteKeyW(
 561         HKEY    hKey,
 562         LPCWSTR lpSubKey
 563         )
 564 {
 565         OBJECT_ATTRIBUTES ObjectAttributes;
 566         UNICODE_STRING SubKeyString;
 567         HKEY ParentKey;
 568         HANDLE TargetKey;
 569         NTSTATUS Status;
 570         LONG ErrorCode;
 571
 572         Status = MapDefaultKey(&ParentKey,
 573                                hKey);
 574         if (!NT_SUCCESS(Status))
 575         {
 576                 ErrorCode = RtlNtStatusToDosError(Status);
 577
 578                 SetLastError (ErrorCode);
 579                 return ErrorCode;
 580         }
 581
 582         RtlInitUnicodeString(&SubKeyString,
 583                              (LPWSTR)lpSubKey);
 584
 585         InitializeObjectAttributes (&ObjectAttributes,
 586                                     &SubKeyString,
 587                                     OBJ_CASE_INSENSITIVE,
 588                                     (HANDLE)ParentKey,
 589                                     NULL);
 590
 591         Status = NtOpenKey (&TargetKey,
 592                             DELETE,
 593                             &ObjectAttributes);
 594         if (!NT_SUCCESS(Status))
 595         {
 596                 ErrorCode = RtlNtStatusToDosError(Status);
 597
 598                 SetLastError (ErrorCode);
 599                 return ErrorCode;
 600         }
 601
 602         Status = NtDeleteKey(TargetKey);
 603
 604         NtClose(TargetKey);
 605
 606         if (!NT_SUCCESS(Status))
 607         {
 608                 ErrorCode = RtlNtStatusToDosError(Status);
 609
 610                 SetLastError (ErrorCode);
 611                 return ErrorCode;
 612         }
 613         return ERROR_SUCCESS;
 614 }
 615
 616
 617 /************************************************************************
 618  *      RegDeleteValueA
 619  */
 620 LONG
 621 STDCALL
 622 RegDeleteValueA(
 623         HKEY    hKey,
 624         LPCSTR  lpValueName
 625         )
 626 {
 627         UNICODE_STRING ValueNameW;
 628         ANSI_STRING ValueNameA;
 629         NTSTATUS Status;
 630         LONG ErrorCode;
 631         HKEY KeyHandle;
 632
 633         Status = MapDefaultKey(&KeyHandle,
 634                                hKey);
 635         if (!NT_SUCCESS(Status))
 636         {
 637                 ErrorCode = RtlNtStatusToDosError(Status);
 638
 639                 SetLastError (ErrorCode);
 640                 return ErrorCode;
 641         }
 642
 643         RtlInitAnsiString(&ValueNameA,
 644                           (LPSTR)lpValueName);
 645         RtlAnsiStringToUnicodeString(&ValueNameW,
 646                                      &ValueNameA,
 647                                      TRUE);
 648
 649         Status = NtDeleteValueKey(KeyHandle,
 650                                   &ValueNameW);
 651
 652         RtlFreeUnicodeString (&ValueNameW);
 653
 654         if (!NT_SUCCESS(Status))
 655         {
 656                 ErrorCode = RtlNtStatusToDosError(Status);
 657
 658                 SetLastError (ErrorCode);
 659                 return ErrorCode;
 660         }
 661
 662         return ERROR_SUCCESS;
 663 }
 664
 665
 666 /************************************************************************
 667  *      RegDeleteValueW
 668  */
 669 LONG
 670 STDCALL
 671 RegDeleteValueW(
 672         HKEY    hKey,
 673         LPCWSTR lpValueName
 674         )
 675 {
 676         UNICODE_STRING ValueName;
 677         NTSTATUS Status;
 678         LONG ErrorCode;
 679         HKEY KeyHandle;
 680
 681         Status = MapDefaultKey(&KeyHandle,
 682                                hKey);
 683         if (!NT_SUCCESS(Status))
 684         {
 685                 ErrorCode = RtlNtStatusToDosError(Status);
 686
 687                 SetLastError (ErrorCode);
 688                 return ErrorCode;
 689         }
 690
 691         RtlInitUnicodeString(&ValueName,
 692                              (LPWSTR)lpValueName);
 693
 694         Status = NtDeleteValueKey(KeyHandle,
 695                                   &ValueName);
 696         if (!NT_SUCCESS(Status))
 697         {
 698                 ErrorCode = RtlNtStatusToDosError(Status);
 699
 700                 SetLastError (ErrorCode);
 701                 return ErrorCode;
 702         }
 703
 704         return ERROR_SUCCESS;
 705 }
 706
 707
 708 /************************************************************************
 709  *      RegEnumKeyA
 710  */
 711 LONG
 712 STDCALL
 713 RegEnumKeyA(
 714         HKEY    hKey,
 715         DWORD   dwIndex,
 716         LPSTR   lpName,
 717         DWORD   cbName
 718         )
 719 {
 720         DWORD dwLength = cbName;
 721
 722         return RegEnumKeyExA(hKey,
 723                              dwIndex,
 724                              lpName,
 725                              &dwLength,
 726                              NULL,
 727                              NULL,
 728                              NULL,
 729                              NULL);
 730 }
 731
 732
 733 /************************************************************************
 734  *      RegEnumKeyExA
 735  */
 736 LONG
 737 STDCALL
 738 RegEnumKeyExA(
 739         HKEY            hKey,
 740         DWORD           dwIndex,
 741         LPSTR           lpName,
 742         LPDWORD         lpcbName,
 743         LPDWORD         lpReserved,
 744         LPSTR           lpClass,
 745         LPDWORD         lpcbClass,
 746         PFILETIME       lpftLastWriteTime
 747         )
 748 {
 749   WCHAR Name[MAX_PATH+1];
 750   UNICODE_STRING UnicodeStringName;
 751   WCHAR Class[MAX_PATH+1];
 752   UNICODE_STRING UnicodeStringClass;
 753   ANSI_STRING AnsiString;
 754   LONG ErrorCode;
 755   DWORD NameLength;
 756   DWORD ClassLength;
 757
 758   DPRINT("hKey 0x%x  dwIndex %d  lpName 0x%x  *lpcbName %d  lpClass 0x%x  lpcbClass %d\n",
 759     hKey, dwIndex, lpName, *lpcbName, lpClass, lpcbClass);
 760
 761   if ((lpClass) && (!lpcbClass))
 762   {
 763     SetLastError(ERROR_INVALID_PARAMETER);
 764     return ERROR_INVALID_PARAMETER;
 765   }
 766
 767   RtlInitUnicodeString(&UnicodeStringName, NULL);
 768   UnicodeStringName.Buffer = &Name[0];
 769   UnicodeStringName.MaximumLength = sizeof(Name);
 770
 771   RtlInitUnicodeString(&UnicodeStringClass, NULL);
 772
 773   if (lpClass)
 774   {
 775     UnicodeStringClass.Buffer = &Class[0];
 776     UnicodeStringClass.MaximumLength = sizeof(Class);
 777     ClassLength = *lpcbClass;
 778   }
 779   else
 780   {
 781     ClassLength = 0;
 782   }
 783
 784   NameLength = *lpcbName;
 785
 786   ErrorCode = RegEnumKeyExW(
 787           hKey,
 788           dwIndex,
 789           UnicodeStringName.Buffer,
 790           &NameLength,
 791     lpReserved,
 792           UnicodeStringClass.Buffer,
 793           &ClassLength,
 794           lpftLastWriteTime);
 795
 796   if (ErrorCode != ERROR_SUCCESS)
 797     return ErrorCode;
 798
 799   UnicodeStringName.Length = NameLength * sizeof(WCHAR);
 800   UnicodeStringClass.Length = ClassLength * sizeof(WCHAR);
 801
 802   RtlInitAnsiString(&AnsiString, NULL);
 803   AnsiString.Buffer = lpName;
 804   AnsiString.MaximumLength = *lpcbName;
 805   RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeStringName, FALSE);
 806   *lpcbName = AnsiString.Length;
 807
 808   DPRINT("Key Namea0 Length %d\n", UnicodeStringName.Length);
 809   DPRINT("Key Namea1 Length %d\n", NameLength);
 810   DPRINT("Key Namea Length %d\n", *lpcbName);
 811   DPRINT("Key Namea %s\n", lpName);
 812
 813   if (lpClass)
 814   {
 815     RtlInitAnsiString(&AnsiString, NULL);
 816     AnsiString.Buffer = lpClass;
 817     AnsiString.MaximumLength = *lpcbClass;
 818     RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeStringClass, FALSE);
 819     *lpcbClass = AnsiString.Length;
 820   }
 821
 822   return ERROR_SUCCESS;
 823 }
 824
 825
 826 /************************************************************************
 827  *      RegEnumKeyExW
 828  */
 829 LONG
 830 STDCALL
 831 RegEnumKeyExW(
 832         HKEY            hKey,
 833         DWORD           dwIndex,
 834         LPWSTR          lpName,
 835         LPDWORD         lpcbName,
 836         LPDWORD         lpReserved,
 837         LPWSTR          lpClass,
 838         LPDWORD         lpcbClass,
 839         PFILETIME       lpftLastWriteTime
 840         )
 841 {
 842   PKEY_NODE_INFORMATION KeyInfo;
 843         NTSTATUS Status;
 844         DWORD dwError = ERROR_SUCCESS;
 845         ULONG BufferSize;
 846         ULONG ResultSize;
 847     HKEY KeyHandle;
 848
 849   Status = MapDefaultKey(&KeyHandle, hKey);
 850         if (!NT_SUCCESS(Status))
 851         {
 852                 dwError = RtlNtStatusToDosError(Status);
 853                 SetLastError (dwError);
 854                 return dwError;
 855         }
 856
 857         BufferSize = sizeof (KEY_NODE_INFORMATION) + *lpcbName * sizeof(WCHAR);
 858         if (lpClass)
 859                 BufferSize += *lpcbClass;
 860
 861     //
 862     // I think this is a memory leak, always allocated again below ???
 863     //
 864     // KeyInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferSize);
 865     //
 866
 867   /* We don't know the exact size of the data returned, so call
 868      NtEnumerateKey() with a buffer size determined from parameters
 869      to this function. If that call fails with a status code of
 870      STATUS_BUFFER_OVERFLOW, allocate a new buffer and try again */
 871   while (TRUE) {
 872     KeyInfo = RtlAllocateHeap(
 873       RtlGetProcessHeap(),
 874                 0,
 875                 BufferSize);
 876           if (KeyInfo == NULL)
 877     {
 878       SetLastError(ERROR_OUTOFMEMORY);
 879       return ERROR_OUTOFMEMORY;
 880     }
 881
 882     Status = NtEnumerateKey(
 883       KeyHandle,
 884                 (ULONG)dwIndex,
 885                 KeyNodeInformation,
 886                 KeyInfo,
 887                 BufferSize,
 888                 &ResultSize);
 889
 890     DPRINT("NtEnumerateKey() returned status 0x%X\n", Status);
 891
 892     if (Status == STATUS_BUFFER_OVERFLOW)
 893     {
 894       RtlFreeHeap(RtlGetProcessHeap(), 0, KeyInfo);
 895       BufferSize = ResultSize;
 896       continue;
 897     }
 898
 899     if (!NT_SUCCESS(Status))
 900           {
 901                 dwError = RtlNtStatusToDosError(Status);
 902                 SetLastError(dwError);
 903       break;
 904           }
 905           else
 906           {
 907       if ((lpClass) && (*lpcbClass != 0) && (KeyInfo->ClassLength > *lpcbClass))
 908       {
 909                   dwError = ERROR_MORE_DATA;
 910                   SetLastError(dwError);
 911         break;
 912       }
 913
 914       RtlMoveMemory(lpName, KeyInfo->Name, KeyInfo->NameLength);
 915                   *lpcbName = (DWORD)(KeyInfo->NameLength / sizeof(WCHAR));
 916       RegiTerminateWideString(lpName, *lpcbName);
 917
 918                   if (lpClass)
 919                   {
 920                         RtlMoveMemory(lpClass,
 921                                 (PVOID)((ULONG_PTR)KeyInfo->Name + KeyInfo->ClassOffset),
 922                                 KeyInfo->ClassLength);
 923                         *lpcbClass = (DWORD)(KeyInfo->ClassLength / sizeof(WCHAR));
 924                   }
 925
 926                   if (lpftLastWriteTime)
 927                   {
 928         /* FIXME: Fill lpftLastWriteTime */
 929                   }
 930
 931       break;
 932         }
 933   }
 934
 935   RtlFreeHeap (RtlGetProcessHeap(), 0, KeyInfo);
 936
 937         return dwError;
 938 }
 939
 940
 941 /************************************************************************
 942  *      RegEnumKeyW
 943  */
 944 LONG
 945 STDCALL
 946 RegEnumKeyW(
 947         HKEY    hKey,
 948         DWORD   dwIndex,
 949         LPWSTR  lpName,
 950         DWORD   cbName
 951         )
 952 {
 953         DWORD dwLength = cbName;
 954
 955         return RegEnumKeyExW(hKey,
 956                              dwIndex,
 957                              lpName,
 958                              &dwLength,
 959                              NULL,
 960                              NULL,
 961                              NULL,
 962                              NULL);
 963 }
 964
 965
 966 /************************************************************************
 967  *      RegEnumValueA
 968  */
 969 LONG
 970 STDCALL
 971 RegEnumValueA(
 972         HKEY    hKey,
 973         DWORD   dwIndex,
 974         LPSTR   lpValueName,
 975         LPDWORD lpcbValueName,
 976         LPDWORD lpReserved,
 977         LPDWORD lpType,
 978         LPBYTE  lpData,
 979         LPDWORD lpcbData
 980         )
 981 {
 982   WCHAR ValueName[MAX_PATH+1];
 983   UNICODE_STRING UnicodeString;
 984   ANSI_STRING AnsiString;
 985   LONG ErrorCode;
 986   DWORD ValueNameLength;
 987
 988   RtlInitUnicodeString(&UnicodeString, NULL);
 989   UnicodeString.Buffer = &ValueName[0];
 990   UnicodeString.MaximumLength = sizeof(ValueName);
 991
 992   ValueNameLength = *lpcbValueName;
 993
 994   ErrorCode = RegEnumValueW(
 995           hKey,
 996           dwIndex,
 997           UnicodeString.Buffer,
 998           &ValueNameLength,
 999           lpReserved,
1000           lpType,
1001           lpData,
1002           lpcbData);
1003
1004   if (ErrorCode != ERROR_SUCCESS)
1005     return ErrorCode;
1006
1007   UnicodeString.Length = ValueNameLength * sizeof(WCHAR);
1008
1009   RtlInitAnsiString(&AnsiString, NULL);
1010   AnsiString.Buffer = lpValueName;
1011   AnsiString.MaximumLength = *lpcbValueName;
1012   RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
1013   *lpcbValueName = AnsiString.Length;
1014
1015   return ERROR_SUCCESS;
1016 }
1017
1018
1019 /************************************************************************
1020  *      RegEnumValueW
1021  */
1022 LONG
1023 STDCALL
1024 RegEnumValueW(
1025         HKEY    hKey,
1026         DWORD   dwIndex,
1027         LPWSTR  lpValueName,
1028         LPDWORD lpcbValueName,
1029         LPDWORD lpReserved,
1030         LPDWORD lpType,
1031         LPBYTE  lpData,
1032         LPDWORD lpcbData
1033         )
1034 {
1035         PKEY_VALUE_FULL_INFORMATION ValueInfo;
1036         NTSTATUS Status;
1037         DWORD dwError = ERROR_SUCCESS;
1038         ULONG BufferSize;
1039         ULONG ResultSize;
1040     HKEY KeyHandle;
1041
1042   Status = MapDefaultKey(&KeyHandle, hKey);
1043   if (!NT_SUCCESS(Status))
1044     {
1045       dwError = RtlNtStatusToDosError(Status);
1046       SetLastError(dwError);
1047       return(dwError);
1048     }
1049
1050   BufferSize = sizeof (KEY_VALUE_FULL_INFORMATION) +
1051                 *lpcbValueName * sizeof(WCHAR);
1052   if (lpcbData)
1053     BufferSize += *lpcbData;
1054
1055   /* We don't know the exact size of the data returned, so call
1056      NtEnumerateValueKey() with a buffer size determined from parameters
1057      to this function. If that call fails with a status code of
1058      STATUS_BUFFER_OVERFLOW, allocate a new buffer and try again */
1059   while (TRUE) {
1060     ValueInfo = RtlAllocateHeap(
1061       RtlGetProcessHeap(),
1062                 0,
1063                 BufferSize);
1064           if (ValueInfo == NULL)
1065     {
1066       SetLastError(ERROR_OUTOFMEMORY);
1067                 return ERROR_OUTOFMEMORY;
1068     }
1069
1070           Status = NtEnumerateValueKey(
1071                 KeyHandle,
1072                 (ULONG)dwIndex,
1073                 KeyValueFullInformation,
1074                 ValueInfo,
1075                 BufferSize,
1076                 &ResultSize);
1077
1078     DPRINT("NtEnumerateValueKey() returned status 0x%X\n", Status);
1079
1080     if (Status == STATUS_BUFFER_OVERFLOW)
1081     {
1082           RtlFreeHeap(RtlGetProcessHeap(), 0, ValueInfo);
1083       BufferSize = ResultSize;
1084       continue;
1085     }
1086
1087     if (!NT_SUCCESS(Status))
1088           {
1089                 dwError = RtlNtStatusToDosError(Status);
1090                 SetLastError(dwError);
1091       break;
1092           }
1093           else
1094           {
1095       if ((lpData) && (*lpcbData != 0) && (ValueInfo->DataLength > *lpcbData))
1096       {
1097                   dwError = ERROR_MORE_DATA;
1098                   SetLastError(dwError);
1099         break;
1100       }
1101
1102       memcpy(lpValueName, ValueInfo->Name, ValueInfo->NameLength);
1103                 *lpcbValueName = (DWORD)(ValueInfo->NameLength / sizeof(WCHAR));
1104       RegiTerminateWideString(lpValueName, *lpcbValueName);
1105
1106                 if (lpType)
1107                         *lpType = ValueInfo->Type;
1108
1109                 if (lpData)
1110                 {
1111                         memcpy(lpData,
1112                                 (PVOID)((ULONG_PTR)ValueInfo + ValueInfo->DataOffset),
1113                                 ValueInfo->DataLength);
1114                         *lpcbData = (DWORD)ValueInfo->DataLength;
1115                 }
1116
1117       break;
1118         }
1119   }
1120
1121   RtlFreeHeap (RtlGetProcessHeap(), 0, ValueInfo);
1122
1123         return dwError;
1124 }
1125
1126
1127 /************************************************************************
1128  *      RegFlushKey
1129  */
1130 LONG STDCALL
1131 RegFlushKey(HKEY hKey)
1132 {
1133   HKEY KeyHandle;
1134   NTSTATUS Status;
1135   LONG ErrorCode;
1136
1137   if (hKey == HKEY_PERFORMANCE_DATA)
1138     return(ERROR_SUCCESS);
1139
1140   Status = MapDefaultKey(&KeyHandle,
1141                          hKey);
1142   if (!NT_SUCCESS(Status))
1143     {
1144       ErrorCode = RtlNtStatusToDosError(Status);
1145
1146       SetLastError(ErrorCode);
1147       return(ErrorCode);
1148     }
1149
1150   Status = NtFlushKey(KeyHandle);
1151   if (!NT_SUCCESS(Status))
1152     {
1153       ErrorCode = RtlNtStatusToDosError(Status);
1154
1155       SetLastError(ErrorCode);
1156       return(ErrorCode);
1157     }
1158
1159   return(ERROR_SUCCESS);
1160 }
1161
1162
1163 /************************************************************************
1164  *      RegGetKeySecurity
1165  */
1166 LONG
1167 STDCALL
1168 RegGetKeySecurity (
1169         HKEY                    hKey,
1170         SECURITY_INFORMATION    SecurityInformation,
1171         PSECURITY_DESCRIPTOR    pSecurityDescriptor,
1172         LPDWORD                 lpcbSecurityDescriptor
1173         )
1174 {
1175   UNIMPLEMENTED;
1176         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1177         return ERROR_CALL_NOT_IMPLEMENTED;
1178 }
1179
1180
1181 /************************************************************************
1182  *      RegLoadKeyA
1183  */
1184 LONG
1185 STDCALL
1186 RegLoadKey(
1187         HKEY    hKey,
1188         LPCSTR  lpSubKey,
1189         LPCSTR  lpFile
1190         )
1191 {
1192   UNIMPLEMENTED;
1193         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194         return ERROR_CALL_NOT_IMPLEMENTED;
1195 }
1196
1197
1198 /************************************************************************
1199  *      RegLoadKeyW
1200  */
1201 LONG
1202 STDCALL
1203 RegLoadKeyW(
1204         HKEY    hKey,
1205         LPCWSTR lpSubKey,
1206         LPCWSTR lpFile
1207         )
1208 {
1209         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1210         return ERROR_CALL_NOT_IMPLEMENTED;
1211 }
1212
1213
1214 /************************************************************************
1215  *      RegNotifyChangeKeyValue
1216  */
1217 LONG
1218 STDCALL
1219 RegNotifyChangeKeyValue(
1220         HKEY    hKey,
1221         BOOL    bWatchSubtree,
1222         DWORD   dwNotifyFilter,
1223         HANDLE  hEvent,
1224         BOOL    fAsynchronous
1225         )
1226 {
1227   UNIMPLEMENTED;
1228         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1229         return ERROR_CALL_NOT_IMPLEMENTED;
1230 }
1231
1232
1233
1234 /************************************************************************
1235  *      RegOpenKeyA
1236  */
1237 LONG STDCALL
1238 RegOpenKeyA(HKEY hKey,
1239             LPCSTR lpSubKey,
1240             PHKEY phkResult)
1241 {
1242   OBJECT_ATTRIBUTES ObjectAttributes;
1243   UNICODE_STRING SubKeyString;
1244   HKEY KeyHandle;
1245   LONG ErrorCode;
1246   NTSTATUS Status;
1247
1248   Status = MapDefaultKey(&KeyHandle,
1249                          hKey);
1250   if (!NT_SUCCESS(Status))
1251     {
1252       ErrorCode = RtlNtStatusToDosError(Status);
1253
1254       SetLastError(ErrorCode);
1255       return(ErrorCode);
1256     }
1257
1258   RtlCreateUnicodeStringFromAsciiz(&SubKeyString,
1259                                    (LPSTR)lpSubKey);
1260
1261   InitializeObjectAttributes(&ObjectAttributes,
1262                              &SubKeyString,
1263                              OBJ_CASE_INSENSITIVE,
1264                              KeyHandle,
1265                              NULL);
1266
1267   Status = NtOpenKey(phkResult,
1268                      KEY_ALL_ACCESS,
1269                      &ObjectAttributes);
1270
1271   RtlFreeUnicodeString(&SubKeyString);
1272
1273   if (!NT_SUCCESS(Status))
1274     {
1275       ErrorCode = RtlNtStatusToDosError(Status);
1276
1277       SetLastError(ErrorCode);
1278       return(ErrorCode);
1279     }
1280   return(ERROR_SUCCESS);
1281 }
1282
1283
1284 /************************************************************************
1285  *      RegOpenKeyW
1286  *
1287  *      19981101 Ariadne
1288  *      19990525 EA
1289  */
1290 LONG
1291 STDCALL
1292 RegOpenKeyW (
1293         HKEY    hKey,
1294         LPCWSTR lpSubKey,
1295         PHKEY   phkResult
1296         )
1297 {
1298         NTSTATUS                errCode;
1299         UNICODE_STRING          SubKeyString;
1300         OBJECT_ATTRIBUTES       ObjectAttributes;
1301         HKEY                    KeyHandle;
1302         LONG                    ErrorCode;
1303
1304         errCode = MapDefaultKey(&KeyHandle,
1305                                 hKey);
1306         if (!NT_SUCCESS(errCode))
1307         {
1308                 ErrorCode = RtlNtStatusToDosError(errCode);
1309
1310                 SetLastError (ErrorCode);
1311                 return ErrorCode;
1312         }
1313
1314         RtlInitUnicodeString(&SubKeyString,
1315                              (LPWSTR)lpSubKey);
1316
1317         InitializeObjectAttributes(&ObjectAttributes,
1318                                    &SubKeyString,
1319                                    OBJ_CASE_INSENSITIVE,
1320                                    KeyHandle,
1321                                    NULL);
1322
1323         errCode = NtOpenKey(
1324                         phkResult,
1325                         KEY_ALL_ACCESS,
1326                         & ObjectAttributes
1327                         );
1328         if ( !NT_SUCCESS(errCode) )
1329         {
1330                 ErrorCode = RtlNtStatusToDosError(errCode);
1331
1332                 SetLastError(ErrorCode);
1333                 return ErrorCode;
1334         }
1335         return ERROR_SUCCESS;
1336 }
1337
1338
1339 /************************************************************************
1340  *      RegOpenKeyExA
1341  */
1342 LONG STDCALL
1343 RegOpenKeyExA(HKEY hKey,
1344               LPCSTR lpSubKey,
1345               DWORD ulOptions,
1346               REGSAM samDesired,
1347               PHKEY phkResult)
1348 {
1349   OBJECT_ATTRIBUTES ObjectAttributes;
1350   UNICODE_STRING SubKeyString;
1351   HKEY KeyHandle;
1352   LONG ErrorCode;
1353   NTSTATUS Status;
1354
1355   Status = MapDefaultKey(&KeyHandle,
1356                          hKey);
1357   if (!NT_SUCCESS(Status))
1358     {
1359       ErrorCode = RtlNtStatusToDosError(Status);
1360
1361       SetLastError(ErrorCode);
1362       return(ErrorCode);
1363     }
1364
1365   RtlCreateUnicodeStringFromAsciiz(&SubKeyString,
1366                                    (LPSTR)lpSubKey);
1367
1368   InitializeObjectAttributes(&ObjectAttributes,
1369                              &SubKeyString,
1370                              OBJ_CASE_INSENSITIVE,
1371                              KeyHandle,
1372                              NULL);
1373
1374   Status = NtOpenKey(phkResult,
1375                      samDesired,
1376                      &ObjectAttributes);
1377
1378   RtlFreeUnicodeString(&SubKeyString);
1379
1380   if (!NT_SUCCESS(Status))
1381     {
1382       ErrorCode = RtlNtStatusToDosError(Status);
1383
1384       SetLastError(ErrorCode);
1385       return(ErrorCode);
1386     }
1387
1388   return(ERROR_SUCCESS);
1389 }
1390
1391
1392 /************************************************************************
1393  *      RegOpenKeyExW
1394  */
1395 LONG STDCALL
1396 RegOpenKeyExW(HKEY hKey,
1397               LPCWSTR lpSubKey,
1398               DWORD ulOptions,
1399               REGSAM samDesired,
1400               PHKEY phkResult)
1401 {
1402   OBJECT_ATTRIBUTES ObjectAttributes;
1403   UNICODE_STRING SubKeyString;
1404   HKEY KeyHandle;
1405   LONG ErrorCode;
1406   NTSTATUS Status;
1407
1408   Status = MapDefaultKey(&KeyHandle,
1409                          hKey);
1410   if (!NT_SUCCESS(Status))
1411     {
1412       ErrorCode = RtlNtStatusToDosError(Status);
1413
1414       SetLastError (ErrorCode);
1415       return(ErrorCode);
1416     }
1417
1418   RtlInitUnicodeString(&SubKeyString,
1419                        (LPWSTR)lpSubKey);
1420
1421   InitializeObjectAttributes(&ObjectAttributes,
1422                              &SubKeyString,
1423                              OBJ_CASE_INSENSITIVE,
1424                              KeyHandle,
1425                              NULL);
1426
1427   Status = NtOpenKey(phkResult,
1428                      samDesired,
1429                      &ObjectAttributes);
1430   if (!NT_SUCCESS(Status))
1431     {
1432       ErrorCode = RtlNtStatusToDosError(Status);
1433
1434       SetLastError(ErrorCode);
1435       return(ErrorCode);
1436     }
1437   return(ERROR_SUCCESS);
1438 }
1439
1440
1441 /************************************************************************
1442  *      RegQueryInfoKeyA
1443  */
1444 LONG
1445 STDCALL
1446 RegQueryInfoKeyA(
1447         HKEY            hKey,
1448         LPSTR           lpClass,
1449         LPDWORD         lpcbClass,
1450         LPDWORD         lpReserved,
1451         LPDWORD         lpcSubKeys,
1452         LPDWORD         lpcbMaxSubKeyLen,
1453         LPDWORD         lpcbMaxClassLen,
1454         LPDWORD         lpcValues,
1455         LPDWORD         lpcbMaxValueNameLen,
1456         LPDWORD         lpcbMaxValueLen,
1457         LPDWORD         lpcbSecurityDescriptor,
1458         PFILETIME       lpftLastWriteTime
1459         )
1460 {
1461   WCHAR ClassName[MAX_PATH];
1462   UNICODE_STRING UnicodeString;
1463   ANSI_STRING AnsiString;
1464   LONG ErrorCode;
1465
1466   RtlInitUnicodeString(&UnicodeString, NULL);
1467
1468   if (lpClass)
1469   {
1470     UnicodeString.Buffer = &ClassName[0];
1471     UnicodeString.MaximumLength = sizeof(ClassName);
1472   }
1473
1474   ErrorCode = RegQueryInfoKeyW(
1475           hKey,
1476           UnicodeString.Buffer,
1477           lpcbClass,
1478           lpReserved,
1479           lpcSubKeys,
1480           lpcbMaxSubKeyLen,
1481           lpcbMaxClassLen,
1482           lpcValues,
1483           lpcbMaxValueNameLen,
1484           lpcbMaxValueLen,
1485           lpcbSecurityDescriptor,
1486           lpftLastWriteTime);
1487
1488   if ((ErrorCode == ERROR_SUCCESS) && (lpClass))
1489   {
1490     RtlInitAnsiString(&AnsiString, NULL);
1491     AnsiString.Buffer = lpClass;
1492     AnsiString.MaximumLength = *lpcbClass;
1493     RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
1494     *lpcbClass = AnsiString.Length;
1495   }
1496
1497   return ErrorCode;
1498 }
1499
1500
1501 /************************************************************************
1502  *      RegQueryInfoKeyW
1503  */
1504 LONG
1505 STDCALL
1506 RegQueryInfoKeyW(
1507         HKEY            hKey,
1508         LPWSTR          lpClass,
1509         LPDWORD         lpcbClass,
1510         LPDWORD         lpReserved,
1511         LPDWORD         lpcSubKeys,
1512         LPDWORD         lpcbMaxSubKeyLen,
1513         LPDWORD         lpcbMaxClassLen,
1514         LPDWORD         lpcValues,
1515         LPDWORD         lpcbMaxValueNameLen,
1516         LPDWORD         lpcbMaxValueLen,
1517         LPDWORD         lpcbSecurityDescriptor,
1518         PFILETIME       lpftLastWriteTime
1519         )
1520 {
1521   KEY_FULL_INFORMATION FullInfoBuffer;
1522   PKEY_FULL_INFORMATION FullInfo;
1523   ULONG FullInfoSize;
1524   HKEY KeyHandle;
1525   NTSTATUS Status;
1526   LONG ErrorCode;
1527   ULONG Length;
1528
1529   if ((lpClass) && (!lpcbClass))
1530   {
1531         SetLastError(ERROR_INVALID_PARAMETER);
1532           return ERROR_INVALID_PARAMETER;
1533   }
1534
1535   Status = MapDefaultKey(&KeyHandle, hKey);
1536   CHECK_STATUS;
1537
1538   if (lpClass)
1539   {
1540     FullInfoSize = sizeof(KEY_FULL_INFORMATION) + *lpcbClass;
1541     FullInfo = RtlAllocateHeap(RtlGetProcessHeap(), 0, FullInfoSize);
1542     if (!FullInfo)
1543     {
1544                   SetLastError(ERROR_OUTOFMEMORY);
1545                   return ERROR_OUTOFMEMORY;
1546         }
1547
1548     FullInfo->ClassLength = *lpcbClass;
1549   }
1550   else
1551   {
1552     FullInfoSize = sizeof(KEY_FULL_INFORMATION);
1553     FullInfo = &FullInfoBuffer;
1554     FullInfo->ClassLength = 1;
1555   }
1556
1557   FullInfo->ClassOffset = FIELD_OFFSET(KEY_FULL_INFORMATION, Class);
1558
1559   Status = NtQueryKey(
1560     KeyHandle,
1561     KeyFullInformation,
1562     FullInfo,
1563     FullInfoSize,
1564     &Length);
1565
1566   if (!NT_SUCCESS(Status))
1567         {
1568     if (lpClass)
1569     {
1570       RtlFreeHeap(RtlGetProcessHeap(), 0, FullInfo);
1571     }
1572
1573                 ErrorCode = RtlNtStatusToDosError(Status);
1574                 SetLastError(ErrorCode);
1575                 return ErrorCode;
1576         }
1577
1578   if (lpcSubKeys)
1579   {
1580     *lpcSubKeys = FullInfo->SubKeys;
1581   }
1582
1583   if (lpcbMaxSubKeyLen)
1584   {
1585     *lpcbMaxSubKeyLen = FullInfo->MaxNameLen;
1586   }
1587
1588   if (lpcbMaxClassLen)
1589   {
1590     *lpcbMaxClassLen = FullInfo->MaxClassLen;
1591   }
1592
1593   if (lpcValues)
1594   {
1595     *lpcValues = FullInfo->Values;
1596   }
1597
1598   if (lpcbMaxValueNameLen)
1599   {
1600     *lpcbMaxValueNameLen = FullInfo->MaxValueNameLen;
1601   }
1602
1603   if (lpcbMaxValueLen)
1604   {
1605     *lpcbMaxValueLen = FullInfo->MaxValueDataLen;
1606   }
1607
1608   if (lpcbSecurityDescriptor)
1609   {
1610     *lpcbSecurityDescriptor = 0;
1611     /* FIXME */
1612   }
1613
1614   if (lpftLastWriteTime != NULL)
1615   {
1616     lpftLastWriteTime->dwLowDateTime = FullInfo->LastWriteTime.u.LowPart;
1617     lpftLastWriteTime->dwHighDateTime = FullInfo->LastWriteTime.u.HighPart;
1618   }
1619
1620   if (lpClass)
1621   {
1622     wcsncpy(lpClass, FullInfo->Class, *lpcbClass);
1623     RtlFreeHeap(RtlGetProcessHeap(), 0, FullInfo);
1624   }
1625
1626   SetLastError(ERROR_SUCCESS);
1627         return ERROR_SUCCESS;
1628 }
1629
1630
1631 /************************************************************************
1632  *      RegQueryMultipleValuesA
1633  */
1634 LONG
1635 STDCALL
1636 RegQueryMultipleValuesA(
1637         HKEY    hKey,
1638         PVALENTA val_list,
1639         DWORD   num_vals,
1640         LPSTR   lpValueBuf,
1641         LPDWORD ldwTotsize
1642         )
1643 {
1644   UNIMPLEMENTED;
1645         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1646         return ERROR_CALL_NOT_IMPLEMENTED;
1647 }
1648
1649
1650 /************************************************************************
1651  *      RegQueryMultipleValuesW
1652  */
1653 LONG
1654 STDCALL
1655 RegQueryMultipleValuesW(
1656         HKEY    hKey,
1657         PVALENTW val_list,
1658         DWORD   num_vals,
1659         LPWSTR  lpValueBuf,
1660         LPDWORD ldwTotsize
1661         )
1662 {
1663   UNIMPLEMENTED;
1664         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1665         return ERROR_CALL_NOT_IMPLEMENTED;
1666 }
1667
1668
1669 /************************************************************************
1670  *      RegQueryValueA
1671  */
1672 LONG
1673 STDCALL
1674 RegQueryValueA(
1675         HKEY    hKey,
1676         LPCSTR  lpSubKey,
1677         LPSTR   lpValue,
1678         PLONG   lpcbValue
1679         )
1680 {
1681   WCHAR SubKeyNameBuffer[MAX_PATH+1];
1682   UNICODE_STRING SubKeyName;
1683   UNICODE_STRING Value;
1684   ANSI_STRING AnsiString;
1685   LONG ValueSize;
1686   LONG ErrorCode;
1687
1688   if ((lpValue) && (!lpcbValue))
1689   {
1690         SetLastError(ERROR_INVALID_PARAMETER);
1691           return ERROR_INVALID_PARAMETER;
1692   }
1693
1694   RtlInitUnicodeString(&SubKeyName, NULL);
1695   RtlInitUnicodeString(&Value, NULL);
1696
1697   if ((lpSubKey) && (strlen(lpSubKey) != 0))
1698   {
1699     RtlInitAnsiString(&AnsiString, (LPSTR)lpSubKey);
1700     SubKeyName.Buffer = &SubKeyNameBuffer[0];
1701     SubKeyName.MaximumLength = sizeof(SubKeyNameBuffer);
1702     RtlAnsiStringToUnicodeString(&SubKeyName, &AnsiString, FALSE);
1703   }
1704
1705   if (lpValue)
1706   {
1707     ValueSize = *lpcbValue * sizeof(WCHAR);
1708     Value.MaximumLength = ValueSize;
1709     Value.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, ValueSize);
1710     if (!Value.Buffer)
1711     {
1712             SetLastError(ERROR_OUTOFMEMORY);
1713             return ERROR_OUTOFMEMORY;
1714     }
1715   }
1716   else
1717   {
1718     ValueSize = 0;
1719   }
1720
1721   ErrorCode = RegQueryValueW(
1722         hKey,
1723         (LPCWSTR)SubKeyName.Buffer,
1724         Value.Buffer,
1725         &ValueSize);
1726
1727   if (ErrorCode == ERROR_SUCCESS)
1728   {
1729     Value.Length = ValueSize;
1730     RtlInitAnsiString(&AnsiString, NULL);
1731     AnsiString.Buffer = lpValue;
1732     AnsiString.MaximumLength = *lpcbValue;
1733     RtlUnicodeStringToAnsiString(&AnsiString, &Value, FALSE);
1734   }
1735
1736   *lpcbValue = ValueSize;
1737
1738   if (Value.Buffer)
1739   {
1740     RtlFreeHeap(RtlGetProcessHeap(), 0, Value.Buffer);
1741   }
1742
1743   return ErrorCode;
1744 }
1745
1746
1747 /************************************************************************
1748  *      RegQueryValueExA
1749  */
1750 LONG
1751 STDCALL
1752 RegQueryValueExA(
1753         HKEY    hKey,
1754         LPCSTR  lpValueName,
1755         LPDWORD lpReserved,
1756         LPDWORD lpType,
1757         LPBYTE  lpData,
1758         LPDWORD lpcbData
1759         )
1760 {
1761   WCHAR ValueNameBuffer[MAX_PATH+1];
1762   UNICODE_STRING ValueName;
1763   UNICODE_STRING ValueData;
1764   ANSI_STRING AnsiString;
1765   LONG ErrorCode;
1766   DWORD ResultSize;
1767   DWORD Type;
1768
1769   /* FIXME: HKEY_PERFORMANCE_DATA is special, see MS SDK */
1770
1771   if ((lpData) && (!lpcbData))
1772   {
1773         SetLastError(ERROR_INVALID_PARAMETER);
1774           return ERROR_INVALID_PARAMETER;
1775   }
1776
1777   RtlInitUnicodeString(&ValueData, NULL);
1778
1779   if (lpData)
1780   {
1781     ValueData.MaximumLength = *lpcbData * sizeof(WCHAR);
1782           ValueData.Buffer = RtlAllocateHeap(
1783       RtlGetProcessHeap(),
1784       0,
1785       ValueData.MaximumLength);
1786           if (!ValueData.Buffer)
1787     {
1788       SetLastError(ERROR_OUTOFMEMORY);
1789                 return ERROR_OUTOFMEMORY;
1790     }
1791   }
1792
1793   RtlInitAnsiString(&AnsiString, (LPSTR)lpValueName);
1794   RtlInitUnicodeString(&ValueName, NULL);
1795   ValueName.Buffer = &ValueNameBuffer[0];
1796   ValueName.MaximumLength = sizeof(ValueNameBuffer);
1797   RtlAnsiStringToUnicodeString(&ValueName, &AnsiString, FALSE);
1798
1799   if (lpcbData)
1800   {
1801     ResultSize = *lpcbData;
1802   }
1803   else
1804   {
1805     ResultSize = 0;
1806   }
1807
1808   ErrorCode = RegQueryValueExW(
1809           hKey,
1810           ValueName.Buffer,
1811           lpReserved,
1812           &Type,
1813           (LPBYTE)ValueData.Buffer,
1814           &ResultSize);
1815
1816   if ((ErrorCode == ERROR_SUCCESS) && (ValueData.Buffer != NULL))
1817   {
1818     if (lpType)
1819     {
1820       *lpType = Type;
1821     }
1822
1823     if ((Type == REG_SZ) || (Type == REG_MULTI_SZ) || (Type == REG_EXPAND_SZ))
1824     {
1825       ValueData.Length = ResultSize;
1826       RtlInitAnsiString(&AnsiString, NULL);
1827       AnsiString.Buffer = lpData;
1828       AnsiString.MaximumLength = *lpcbData;
1829       RtlUnicodeStringToAnsiString(&AnsiString, &ValueData, FALSE);
1830     }
1831     else
1832     {
1833       RtlMoveMemory(lpData, ValueData.Buffer, ResultSize);
1834     }
1835   }
1836
1837   if (lpcbData)
1838   {
1839     *lpcbData = ResultSize;
1840   }
1841
1842   if (ValueData.Buffer)
1843   {
1844     RtlFreeHeap(RtlGetProcessHeap(), 0, ValueData.Buffer);
1845   }
1846
1847   return ErrorCode;
1848 }
1849
1850
1851 /************************************************************************
1852  *      RegQueryValueExW
1853  */
1854 LONG
1855 STDCALL
1856 RegQueryValueExW(
1857         HKEY    hKey,
1858         LPCWSTR lpValueName,
1859         LPDWORD lpReserved,
1860         LPDWORD lpType,
1861         LPBYTE  lpData,
1862         LPDWORD lpcbData
1863         )
1864 {
1865         PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
1866         UNICODE_STRING ValueName;
1867         NTSTATUS Status;
1868         DWORD dwError = ERROR_SUCCESS;
1869         ULONG BufferSize;
1870         ULONG ResultSize;
1871     HKEY KeyHandle;
1872
1873   DPRINT("hKey 0x%X  lpValueName %S  lpData 0x%X  lpcbData %d\n",
1874     hKey, lpValueName, lpData, lpcbData ? *lpcbData : 0);
1875
1876   Status = MapDefaultKey(&KeyHandle, hKey);
1877   if (!NT_SUCCESS(Status))
1878     {
1879       dwError = RtlNtStatusToDosError(Status);
1880       SetLastError(dwError);
1881       return(dwError);
1882     }
1883
1884   if ((lpData) && (!lpcbData))
1885   {
1886         SetLastError(ERROR_INVALID_PARAMETER);
1887           return ERROR_INVALID_PARAMETER;
1888   }
1889
1890         RtlInitUnicodeString (&ValueName,
1891                               lpValueName);
1892
1893         BufferSize = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + *lpcbData;
1894         ValueInfo = RtlAllocateHeap (RtlGetProcessHeap(),
1895                                      0,
1896                                      BufferSize);
1897         if (ValueInfo == NULL)
1898   {
1899     SetLastError(ERROR_OUTOFMEMORY);
1900                 return ERROR_OUTOFMEMORY;
1901   }
1902
1903         Status = NtQueryValueKey (hKey,
1904                                   &ValueName,
1905                                   KeyValuePartialInformation,
1906                                   ValueInfo,
1907                                   BufferSize,
1908                                   &ResultSize);
1909
1910   DPRINT("Status 0x%X\n", Status);
1911
1912   if (Status == STATUS_BUFFER_TOO_SMALL)
1913   {
1914     /* Return ERROR_SUCCESS and the buffer space needed for a successful call */
1915     dwError = ERROR_SUCCESS;
1916   }
1917   else if (!NT_SUCCESS(Status))
1918         {
1919                 dwError = RtlNtStatusToDosError(Status);
1920                 SetLastError(dwError);
1921         }
1922         else
1923         {
1924     if (lpType)
1925     {
1926             *lpType = ValueInfo->Type;
1927     }
1928
1929                 RtlMoveMemory(lpData, ValueInfo->Data, ValueInfo->DataLength);
1930     if ((ValueInfo->Type == REG_SZ) ||
1931       (ValueInfo->Type == REG_MULTI_SZ) ||
1932       (ValueInfo->Type == REG_EXPAND_SZ))
1933     {
1934                         ((PWSTR)lpData)[ValueInfo->DataLength / sizeof(WCHAR)] = 0;
1935     }
1936         }
1937
1938   DPRINT("Type %d  ResultSize %d\n", ValueInfo->Type, ResultSize);
1939
1940         *lpcbData = (DWORD)ResultSize;
1941
1942         RtlFreeHeap(RtlGetProcessHeap(), 0, ValueInfo);
1943
1944         return dwError;
1945 }
1946
1947
1948 /************************************************************************
1949  *      RegQueryValueW
1950  */
1951 LONG
1952 STDCALL
1953 RegQueryValueW(
1954         HKEY    hKey,
1955         LPCWSTR lpSubKey,
1956         LPWSTR  lpValue,
1957         PLONG   lpcbValue
1958         )
1959 {
1960         NTSTATUS                errCode;
1961         UNICODE_STRING          SubKeyString;
1962         OBJECT_ATTRIBUTES       ObjectAttributes;
1963         HKEY                    KeyHandle;
1964   HANDLE                        RealKey;
1965         LONG                      ErrorCode;
1966   BOOL        CloseRealKey;
1967
1968         errCode = MapDefaultKey(&KeyHandle, hKey);
1969         if (!NT_SUCCESS(errCode))
1970         {
1971                 ErrorCode = RtlNtStatusToDosError(errCode);
1972                 SetLastError (ErrorCode);
1973                 return ErrorCode;
1974         }
1975
1976   if ((lpSubKey) && (wcslen(lpSubKey) != 0))
1977   {
1978
1979           RtlInitUnicodeString(&SubKeyString,
1980                              (LPWSTR)lpSubKey);
1981
1982           InitializeObjectAttributes(&ObjectAttributes,
1983                                    &SubKeyString,
1984                                    OBJ_CASE_INSENSITIVE,
1985                                    KeyHandle,
1986                                    NULL);
1987
1988           errCode = NtOpenKey(
1989                         &RealKey,
1990                         KEY_ALL_ACCESS,
1991                         & ObjectAttributes
1992                         );
1993           if ( !NT_SUCCESS(errCode) )
1994           {
1995                 ErrorCode = RtlNtStatusToDosError(errCode);
1996                 SetLastError(ErrorCode);
1997                 return ErrorCode;
1998           }
1999     CloseRealKey = TRUE;
2000   }
2001   else
2002   {
2003     RealKey = hKey;
2004     CloseRealKey = FALSE;
2005   }
2006
2007   ErrorCode = RegQueryValueExW(
2008           RealKey,
2009           NULL,
2010           NULL,
2011           NULL,
2012           (LPBYTE)lpValue,
2013           (LPDWORD)lpcbValue);
2014
2015   if (CloseRealKey)
2016   {
2017     NtClose(RealKey);
2018   }
2019
2020   return ErrorCode;
2021 }
2022
2023
2024 /************************************************************************
2025  *      RegReplaceKeyA
2026  */
2027 LONG
2028 STDCALL
2029 RegReplaceKeyA(
2030         HKEY    hKey,
2031         LPCSTR  lpSubKey,
2032         LPCSTR  lpNewFile,
2033         LPCSTR  lpOldFile
2034         )
2035 {
2036   UNIMPLEMENTED;
2037         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2038         return ERROR_CALL_NOT_IMPLEMENTED;
2039 }
2040
2041
2042 /************************************************************************
2043  *      RegReplaceKeyW
2044  */
2045 LONG
2046 STDCALL
2047 RegReplaceKeyW(
2048         HKEY    hKey,
2049         LPCWSTR lpSubKey,
2050         LPCWSTR lpNewFile,
2051         LPCWSTR lpOldFile
2052         )
2053 {
2054   UNIMPLEMENTED;
2055         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2056         return ERROR_CALL_NOT_IMPLEMENTED;
2057 }
2058
2059
2060 /************************************************************************
2061  *      RegRestoreKeyA
2062  */
2063 LONG
2064 STDCALL
2065 RegRestoreKeyA(
2066         HKEY    hKey,
2067         LPCSTR  lpFile,
2068         DWORD   dwFlags
2069         )
2070 {
2071   UNIMPLEMENTED;
2072         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2073         return ERROR_CALL_NOT_IMPLEMENTED;
2074 }
2075
2076
2077 /************************************************************************
2078  *      RegRestoreKeyW
2079  */
2080 LONG
2081 STDCALL
2082 RegRestoreKeyW(
2083         HKEY    hKey,
2084         LPCWSTR lpFile,
2085         DWORD   dwFlags
2086         )
2087 {
2088   UNIMPLEMENTED;
2089         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2090         return ERROR_CALL_NOT_IMPLEMENTED;
2091 }
2092
2093
2094 /************************************************************************
2095  *      RegSaveKeyA
2096  */
2097 LONG STDCALL
2098 RegSaveKeyA(HKEY hKey,
2099             LPCSTR lpFile,
2100             LPSECURITY_ATTRIBUTES lpSecurityAttributes)
2101 {
2102   UNICODE_STRING FileName;
2103   LONG ErrorCode;
2104
2105   RtlCreateUnicodeStringFromAsciiz(&FileName,
2106                                    (LPSTR)lpFile);
2107   ErrorCode = RegSaveKeyW(hKey,
2108                           FileName.Buffer,
2109                           lpSecurityAttributes);
2110   RtlFreeUnicodeString(&FileName);
2111
2112   return(ErrorCode);
2113 }
2114
2115
2116 /************************************************************************
2117  *      RegSaveKeyW
2118  */
2119 LONG STDCALL
2120 RegSaveKeyW(HKEY hKey,
2121             LPCWSTR lpFile,
2122             LPSECURITY_ATTRIBUTES lpSecurityAttributes)
2123 {
2124   PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
2125   OBJECT_ATTRIBUTES ObjectAttributes;
2126   UNICODE_STRING NtName;
2127   IO_STATUS_BLOCK IoStatusBlock;
2128   HANDLE FileHandle;
2129   HKEY KeyHandle;
2130   NTSTATUS Status;
2131   LONG ErrorCode;
2132
2133   Status = MapDefaultKey(&KeyHandle,
2134                          hKey);
2135   if (!NT_SUCCESS(Status))
2136     {
2137       ErrorCode = RtlNtStatusToDosError(Status);
2138       SetLastError(ErrorCode);
2139       return(ErrorCode);
2140     }
2141
2142   if (!RtlDosPathNameToNtPathName_U((LPWSTR)lpFile,
2143                                     &NtName,
2144                                     NULL,
2145                                     NULL))
2146     {
2147       SetLastError(ERROR_INVALID_PARAMETER);
2148       return(ERROR_INVALID_PARAMETER);
2149     }
2150
2151   if (lpSecurityAttributes != NULL)
2152     SecurityDescriptor = lpSecurityAttributes->lpSecurityDescriptor;
2153
2154   InitializeObjectAttributes(&ObjectAttributes,
2155                              &NtName,
2156                              OBJ_CASE_INSENSITIVE,
2157                              NULL,
2158                              SecurityDescriptor);
2159
2160   Status = NtCreateFile(&FileHandle,
2161                         GENERIC_WRITE | SYNCHRONIZE,
2162                         &ObjectAttributes,
2163                         &IoStatusBlock,
2164                         NULL,
2165                         FILE_ATTRIBUTE_NORMAL,
2166                         FILE_SHARE_READ,
2167                         FILE_CREATE,
2168                         FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
2169                         NULL,
2170                         0);
2171   RtlFreeUnicodeString(&NtName);
2172   if (!NT_SUCCESS(Status))
2173     {
2174       ErrorCode = RtlNtStatusToDosError(Status);
2175       SetLastError(ErrorCode);
2176       return(ErrorCode);
2177     }
2178
2179   Status = NtSaveKey(KeyHandle,
2180                      FileHandle);
2181   NtClose(FileHandle);
2182   if (!NT_SUCCESS(Status))
2183     {
2184       ErrorCode = RtlNtStatusToDosError(Status);
2185       SetLastError(ErrorCode);
2186       return(ErrorCode);
2187     }
2188
2189   return(ERROR_SUCCESS);
2190 }
2191
2192
2193 /************************************************************************
2194  *      RegSetKeySecurity
2195  */
2196 LONG
2197 STDCALL
2198 RegSetKeySecurity(
2199         HKEY                    hKey,
2200         SECURITY_INFORMATION    SecurityInformation,    /* FIXME: ULONG? */
2201         PSECURITY_DESCRIPTOR    pSecurityDescriptor
2202         )
2203 {
2204   UNIMPLEMENTED;
2205         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2206         return ERROR_CALL_NOT_IMPLEMENTED;
2207 }
2208
2209
2210 /************************************************************************
2211  *      RegSetValueA
2212  */
2213 LONG
2214 STDCALL
2215 RegSetValueA(
2216         HKEY    hKey,
2217         LPCSTR  lpSubKey,
2218         DWORD   dwType,
2219         LPCSTR  lpData,
2220         DWORD   cbData
2221         )
2222 {
2223   WCHAR SubKeyNameBuffer[MAX_PATH+1];
2224   UNICODE_STRING SubKeyName;
2225   UNICODE_STRING Data;
2226   ANSI_STRING AnsiString;
2227   LONG DataSize;
2228   LONG ErrorCode;
2229
2230   if (!lpData)
2231   {
2232         SetLastError(ERROR_INVALID_PARAMETER);
2233           return ERROR_INVALID_PARAMETER;
2234   }
2235
2236   RtlInitUnicodeString(&SubKeyName, NULL);
2237   RtlInitUnicodeString(&Data, NULL);
2238
2239   if ((lpSubKey) && (strlen(lpSubKey) != 0))
2240   {
2241     RtlInitAnsiString(&AnsiString, (LPSTR)lpSubKey);
2242     SubKeyName.Buffer = &SubKeyNameBuffer[0];
2243     SubKeyName.MaximumLength = sizeof(SubKeyNameBuffer);
2244     RtlAnsiStringToUnicodeString(&SubKeyName, &AnsiString, FALSE);
2245   }
2246
2247   DataSize = cbData * sizeof(WCHAR);
2248   Data.MaximumLength = DataSize;
2249   Data.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, DataSize);
2250   if (!Data.Buffer)
2251   {
2252           SetLastError(ERROR_OUTOFMEMORY);
2253           return ERROR_OUTOFMEMORY;
2254   }
2255
2256   ErrorCode = RegSetValueW(
2257           hKey,
2258           (LPCWSTR)SubKeyName.Buffer,
2259           dwType,
2260           Data.Buffer,
2261           DataSize);
2262
2263   RtlFreeHeap(RtlGetProcessHeap(), 0, Data.Buffer);
2264
2265   return ErrorCode;
2266 }
2267
2268
2269 /************************************************************************
2270  *      RegSetValueExA
2271  */
2272 LONG
2273 STDCALL
2274 RegSetValueExA(
2275         HKEY            hKey,
2276         LPCSTR          lpValueName,
2277         DWORD           Reserved,
2278         DWORD           dwType,
2279         CONST BYTE      *lpData,
2280         DWORD           cbData
2281         )
2282 {
2283   UNICODE_STRING ValueName;
2284   LPWSTR pValueName;
2285   ANSI_STRING AnsiString;
2286   UNICODE_STRING Data;
2287   LONG ErrorCode;
2288   LPBYTE pData;
2289   DWORD DataSize;
2290
2291   if (!lpData)
2292   {
2293         SetLastError(ERROR_INVALID_PARAMETER);
2294           return ERROR_INVALID_PARAMETER;
2295   }
2296
2297   if ((lpValueName) && (strlen(lpValueName) != 0))
2298   {
2299     RtlCreateUnicodeStringFromAsciiz(&ValueName, (LPSTR)lpValueName);
2300     pValueName = (LPWSTR)ValueName.Buffer;
2301   }
2302   else
2303   {
2304     pValueName = NULL;
2305   }
2306
2307   if ((dwType == REG_SZ) || (dwType == REG_MULTI_SZ) || (dwType == REG_EXPAND_SZ))
2308   {
2309     RtlInitAnsiString(&AnsiString, NULL);
2310     AnsiString.Buffer = (LPSTR)lpData;
2311     AnsiString.Length = cbData;
2312     AnsiString.MaximumLength = cbData;
2313     RtlAnsiStringToUnicodeString(&Data, &AnsiString, TRUE);
2314     pData = (LPBYTE)Data.Buffer;
2315     DataSize = cbData * sizeof(WCHAR);
2316   }
2317   else
2318   {
2319     RtlInitUnicodeString(&Data, NULL);
2320     pData = (LPBYTE)lpData;
2321     DataSize = cbData;
2322   }
2323
2324   ErrorCode = RegSetValueExW(
2325           hKey,
2326           pValueName,
2327           Reserved,
2328           dwType,
2329     pData,
2330           DataSize);
2331
2332   if (pValueName)
2333   {
2334     RtlFreeHeap(RtlGetProcessHeap(), 0, ValueName.Buffer);
2335   }
2336
2337   if (Data.Buffer)
2338   {
2339     RtlFreeHeap(RtlGetProcessHeap(), 0, Data.Buffer);
2340   }
2341
2342   return ErrorCode;
2343 }
2344
2345
2346 /************************************************************************
2347  *      RegSetValueExW
2348  */
2349 LONG
2350 STDCALL
2351 RegSetValueExW(
2352         HKEY            hKey,
2353         LPCWSTR         lpValueName,
2354         DWORD           Reserved,
2355         DWORD           dwType,
2356         CONST BYTE      *lpData,
2357         DWORD           cbData
2358         )
2359 {
2360         UNICODE_STRING ValueName;
2361   PUNICODE_STRING pValueName;
2362     HKEY KeyHandle;
2363         NTSTATUS Status;
2364   LONG ErrorCode;
2365
2366   Status = MapDefaultKey(&KeyHandle, hKey);
2367         if (!NT_SUCCESS(Status))
2368         {
2369                 ErrorCode = RtlNtStatusToDosError(Status);
2370                 SetLastError(ErrorCode);
2371                 return ErrorCode;
2372         }
2373
2374   if (lpValueName)
2375   {
2376           RtlInitUnicodeString(&ValueName, lpValueName);
2377     pValueName = &ValueName;
2378   }
2379   else
2380   {
2381     pValueName = NULL;
2382   }
2383
2384         Status = NtSetValueKey(
2385     KeyHandle,
2386           pValueName,
2387                 0,
2388                 dwType,
2389                 (PVOID)lpData,
2390                 (ULONG)cbData);
2391         if (!NT_SUCCESS(Status))
2392         {
2393                 LONG ErrorCode = RtlNtStatusToDosError(Status);
2394                 SetLastError (ErrorCode);
2395                 return ErrorCode;
2396         }
2397
2398         return ERROR_SUCCESS;
2399 }
2400
2401
2402 /************************************************************************
2403  *      RegSetValueW
2404  */
2405 LONG
2406 STDCALL
2407 RegSetValueW(
2408         HKEY    hKey,
2409         LPCWSTR lpSubKey,
2410         DWORD   dwType,
2411         LPCWSTR lpData,
2412         DWORD   cbData
2413         )
2414 {
2415         NTSTATUS                errCode;
2416         UNICODE_STRING          SubKeyString;
2417         OBJECT_ATTRIBUTES       ObjectAttributes;
2418         HKEY                    KeyHandle;
2419   HANDLE                        RealKey;
2420         LONG                      ErrorCode;
2421   BOOL        CloseRealKey;
2422
2423         errCode = MapDefaultKey(&KeyHandle, hKey);
2424         if (!NT_SUCCESS(errCode))
2425         {
2426                 ErrorCode = RtlNtStatusToDosError(errCode);
2427                 SetLastError (ErrorCode);
2428                 return ErrorCode;
2429         }
2430
2431   if ((lpSubKey) && (wcslen(lpSubKey) != 0))
2432   {
2433
2434           RtlInitUnicodeString(&SubKeyString,
2435                              (LPWSTR)lpSubKey);
2436
2437           InitializeObjectAttributes(&ObjectAttributes,
2438                                    &SubKeyString,
2439                                    OBJ_CASE_INSENSITIVE,
2440                                    KeyHandle,
2441                                    NULL);
2442
2443           errCode = NtOpenKey(
2444                         &RealKey,
2445                         KEY_ALL_ACCESS,
2446                         & ObjectAttributes
2447                         );
2448           if ( !NT_SUCCESS(errCode) )
2449           {
2450                 ErrorCode = RtlNtStatusToDosError(errCode);
2451                 SetLastError(ErrorCode);
2452                 return ErrorCode;
2453           }
2454     CloseRealKey = TRUE;
2455   }
2456   else
2457   {
2458     RealKey = hKey;
2459     CloseRealKey = FALSE;
2460   }
2461
2462   ErrorCode = RegSetValueExW(
2463           RealKey,
2464           NULL,
2465           0,
2466           dwType,
2467     (LPBYTE)lpData,
2468           cbData);
2469
2470   if (CloseRealKey)
2471   {
2472     NtClose(RealKey);
2473   }
2474
2475   return ErrorCode;
2476 }
2477
2478
2479 /************************************************************************
2480  *      RegUnLoadKeyA
2481  */
2482 LONG
2483 STDCALL
2484 RegUnLoadKeyA(
2485         HKEY    hKey,
2486         LPCSTR  lpSubKey
2487         )
2488 {
2489   UNIMPLEMENTED;
2490         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2491         return ERROR_CALL_NOT_IMPLEMENTED;
2492 }
2493
2494
2495 /************************************************************************
2496  *      RegUnLoadKeyW
2497  */
2498 LONG
2499 STDCALL
2500 RegUnLoadKeyW(
2501         HKEY    hKey,
2502         LPCWSTR lpSubKey
2503         )
2504 {
2505   UNIMPLEMENTED;
2506         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2507         return ERROR_CALL_NOT_IMPLEMENTED;
2508 }
2509
2510 /* EOF */