git.oblomov.eu Git - wine/blob - dlls/ntdll/tests/reg.c

   1 /* Unit test suite for Rtl* Registry API functions
   2  *
   3  * Copyright 2003 Thomas Mertes
   4  * Copyright 2005 Brad DeMorrow
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * NOTE: I don't test every RelativeTo value because it would be redundant, all calls go through
  21  * helper function RTL_GetKeyHandle().--Brad DeMorrow
  22  *
  23  */
  24
  25 #include "ntdll_test.h"
  26 #include "winternl.h"
  27 #include "stdio.h"
  28 #include "winnt.h"
  29 #include "winnls.h"
  30 #include "stdlib.h"
  31
  32 /* A test string */
  33 static const WCHAR stringW[] = {'s', 't', 'r', 'i', 'n', 'g', 'W', 0};
  34 /* A size, in bytes, short enough to cause truncation of the above */
  35 #define STR_TRUNC_SIZE (sizeof(stringW)-2*sizeof(*stringW))
  36
  37 #ifndef __WINE_WINTERNL_H
  38
  39 /* RtlQueryRegistryValues structs and defines */
  40 #define RTL_REGISTRY_ABSOLUTE             0
  41 #define RTL_REGISTRY_SERVICES             1
  42 #define RTL_REGISTRY_CONTROL              2
  43 #define RTL_REGISTRY_WINDOWS_NT           3
  44 #define RTL_REGISTRY_DEVICEMAP            4
  45 #define RTL_REGISTRY_USER                 5
  46
  47 #define RTL_REGISTRY_HANDLE       0x40000000
  48 #define RTL_REGISTRY_OPTIONAL     0x80000000
  49
  50 #define RTL_QUERY_REGISTRY_SUBKEY         0x00000001
  51 #define RTL_QUERY_REGISTRY_TOPKEY         0x00000002
  52 #define RTL_QUERY_REGISTRY_REQUIRED       0x00000004
  53 #define RTL_QUERY_REGISTRY_NOVALUE        0x00000008
  54 #define RTL_QUERY_REGISTRY_NOEXPAND       0x00000010
  55 #define RTL_QUERY_REGISTRY_DIRECT         0x00000020
  56 #define RTL_QUERY_REGISTRY_DELETE         0x00000040
  57
  58 typedef NTSTATUS (WINAPI *PRTL_QUERY_REGISTRY_ROUTINE)( PCWSTR  ValueName,
  59                                                         ULONG  ValueType,
  60                                                         PVOID  ValueData,
  61                                                         ULONG  ValueLength,
  62                                                         PVOID  Context,
  63                                                         PVOID  EntryContext);
  64
  65 typedef struct _RTL_QUERY_REGISTRY_TABLE {
  66   PRTL_QUERY_REGISTRY_ROUTINE  QueryRoutine;
  67   ULONG  Flags;
  68   PWSTR  Name;
  69   PVOID  EntryContext;
  70   ULONG  DefaultType;
  71   PVOID  DefaultData;
  72   ULONG  DefaultLength;
  73 } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE;
  74
  75 typedef struct _KEY_VALUE_BASIC_INFORMATION {
  76     ULONG TitleIndex;
  77     ULONG Type;
  78     ULONG NameLength;
  79     WCHAR Name[1];
  80 } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
  81
  82 typedef struct _KEY_VALUE_PARTIAL_INFORMATION {
  83     ULONG TitleIndex;
  84     ULONG Type;
  85     ULONG DataLength;
  86     UCHAR Data[1];
  87 } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
  88
  89 typedef struct _KEY_VALUE_FULL_INFORMATION {
  90     ULONG TitleIndex;
  91     ULONG Type;
  92     ULONG DataOffset;
  93     ULONG DataLength;
  94     ULONG NameLength;
  95     WCHAR Name[1];
  96 } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
  97
  98 typedef enum _KEY_VALUE_INFORMATION_CLASS {
  99     KeyValueBasicInformation,
 100     KeyValueFullInformation,
 101     KeyValuePartialInformation,
 102     KeyValueFullInformationAlign64,
 103     KeyValuePartialInformationAlign64
 104 } KEY_VALUE_INFORMATION_CLASS;
 105
 106 #define InitializeObjectAttributes(p,n,a,r,s) \
 107     do { \
 108         (p)->Length = sizeof(OBJECT_ATTRIBUTES); \
 109         (p)->RootDirectory = r; \
 110         (p)->Attributes = a; \
 111         (p)->ObjectName = n; \
 112         (p)->SecurityDescriptor = s; \
 113         (p)->SecurityQualityOfService = NULL; \
 114     } while (0)
 115
 116 #endif
 117
 118 static NTSTATUS (WINAPI * pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR);
 119 static void     (WINAPI * pRtlInitUnicodeString)(PUNICODE_STRING,PCWSTR);
 120 static NTSTATUS (WINAPI * pRtlFreeUnicodeString)(PUNICODE_STRING);
 121 static NTSTATUS (WINAPI * pNtDeleteValueKey)(IN HANDLE, IN PUNICODE_STRING);
 122 static NTSTATUS (WINAPI * pRtlQueryRegistryValues)(IN ULONG, IN PCWSTR,IN PRTL_QUERY_REGISTRY_TABLE, IN PVOID,IN PVOID);
 123 static NTSTATUS (WINAPI * pRtlCheckRegistryKey)(IN ULONG,IN PWSTR);
 124 static NTSTATUS (WINAPI * pRtlOpenCurrentUser)(IN ACCESS_MASK, PHANDLE);
 125 static NTSTATUS (WINAPI * pNtOpenKey)(PHANDLE, IN ACCESS_MASK, IN POBJECT_ATTRIBUTES);
 126 static NTSTATUS (WINAPI * pNtClose)(IN HANDLE);
 127 static NTSTATUS (WINAPI * pNtDeleteValueKey)(IN HANDLE, IN PUNICODE_STRING);
 128 static NTSTATUS (WINAPI * pNtFlushKey)(HANDLE);
 129 static NTSTATUS (WINAPI * pNtDeleteKey)(HANDLE);
 130 static NTSTATUS (WINAPI * pNtCreateKey)( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 131                              ULONG TitleIndex, const UNICODE_STRING *class, ULONG options,
 132                              PULONG dispos );
 133 static NTSTATUS (WINAPI * pNtQueryValueKey)(HANDLE,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
 134 static NTSTATUS (WINAPI * pNtSetValueKey)(HANDLE, const PUNICODE_STRING, ULONG,
 135                                ULONG, const void*, ULONG  );
 136 static NTSTATUS (WINAPI * pNtQueryInformationProcess)(HANDLE,PROCESSINFOCLASS,PVOID,ULONG,PULONG);
 137 static NTSTATUS (WINAPI * pRtlFormatCurrentUserKeyPath)(PUNICODE_STRING);
 138 static NTSTATUS (WINAPI * pRtlCreateUnicodeString)( PUNICODE_STRING, LPCWSTR);
 139 static LPVOID   (WINAPI * pRtlReAllocateHeap)(IN PVOID, IN ULONG, IN PVOID, IN ULONG);
 140 static NTSTATUS (WINAPI * pRtlAppendUnicodeToString)(PUNICODE_STRING, PCWSTR);
 141 static NTSTATUS (WINAPI * pRtlUnicodeStringToAnsiString)(PSTRING, PUNICODE_STRING, BOOL);
 142 static NTSTATUS (WINAPI * pRtlFreeHeap)(PVOID, ULONG, PVOID);
 143 static LPVOID   (WINAPI * pRtlAllocateHeap)(PVOID,ULONG,ULONG);
 144 static NTSTATUS (WINAPI * pRtlZeroMemory)(PVOID, ULONG);
 145 static NTSTATUS (WINAPI * pRtlpNtQueryValueKey)(HANDLE,ULONG*,PBYTE,DWORD*,void *);
 146 static NTSTATUS (WINAPI * pRtlOpenCurrentUser)(ACCESS_MASK,HANDLE*);
 147
 148 static HMODULE hntdll = 0;
 149 static int CurrentTest = 0;
 150 static UNICODE_STRING winetestpath;
 151
 152 #define NTDLL_GET_PROC(func) \
 153     p ## func = (void*)GetProcAddress(hntdll, #func); \
 154     if(!p ## func) { \
 155         trace("GetProcAddress(%s) failed\n", #func); \
 156         FreeLibrary(hntdll); \
 157         return FALSE; \
 158     }
 159
 160 static BOOL InitFunctionPtrs(void)
 161 {
 162     hntdll = LoadLibraryA("ntdll.dll");
 163     if(!hntdll) {
 164         trace("Could not load ntdll.dll\n");
 165         return FALSE;
 166     }
 167     NTDLL_GET_PROC(RtlInitUnicodeString)
 168     NTDLL_GET_PROC(RtlCreateUnicodeStringFromAsciiz)
 169     NTDLL_GET_PROC(RtlCreateUnicodeString)
 170     NTDLL_GET_PROC(RtlFreeUnicodeString)
 171     NTDLL_GET_PROC(NtDeleteValueKey)
 172     NTDLL_GET_PROC(RtlQueryRegistryValues)
 173     NTDLL_GET_PROC(RtlCheckRegistryKey)
 174     NTDLL_GET_PROC(RtlOpenCurrentUser)
 175     NTDLL_GET_PROC(NtClose)
 176     NTDLL_GET_PROC(NtDeleteValueKey)
 177     NTDLL_GET_PROC(NtCreateKey)
 178     NTDLL_GET_PROC(NtFlushKey)
 179     NTDLL_GET_PROC(NtDeleteKey)
 180     NTDLL_GET_PROC(NtQueryValueKey)
 181     NTDLL_GET_PROC(NtQueryInformationProcess)
 182     NTDLL_GET_PROC(NtSetValueKey)
 183     NTDLL_GET_PROC(NtOpenKey)
 184     NTDLL_GET_PROC(RtlFormatCurrentUserKeyPath)
 185     NTDLL_GET_PROC(RtlReAllocateHeap)
 186     NTDLL_GET_PROC(RtlAppendUnicodeToString)
 187     NTDLL_GET_PROC(RtlUnicodeStringToAnsiString)
 188     NTDLL_GET_PROC(RtlFreeHeap)
 189     NTDLL_GET_PROC(RtlAllocateHeap)
 190     NTDLL_GET_PROC(RtlZeroMemory)
 191     NTDLL_GET_PROC(RtlpNtQueryValueKey)
 192     NTDLL_GET_PROC(RtlOpenCurrentUser)
 193     return TRUE;
 194 }
 195 #undef NTDLL_GET_PROC
 196
 197 static NTSTATUS WINAPI QueryRoutine (IN PCWSTR ValueName, IN ULONG ValueType, IN PVOID ValueData,
 198                               IN ULONG ValueLength, IN PVOID Context, IN PVOID EntryContext)
 199 {
 200     NTSTATUS ret = STATUS_SUCCESS;
 201     int ValueNameLength = 0;
 202     LPSTR ValName = 0;
 203     trace("**Test %d**\n", CurrentTest);
 204
 205     if(ValueName)
 206     {
 207         ValueNameLength = lstrlenW(ValueName);
 208
 209         ValName = pRtlAllocateHeap(GetProcessHeap(), 0, ValueNameLength);
 210
 211         WideCharToMultiByte(0, 0, ValueName, ValueNameLength+1,ValName, ValueNameLength, 0, 0);
 212
 213         trace("ValueName: %s\n", ValName);
 214     }
 215     else
 216         trace("ValueName: (null)\n");
 217
 218     switch(ValueType)
 219     {
 220             case REG_NONE:
 221                 trace("ValueType: REG_NONE\n");
 222                 trace("ValueData: %p\n", ValueData);
 223                 break;
 224
 225             case REG_BINARY:
 226                 trace("ValueType: REG_BINARY\n");
 227                 trace("ValueData: %p\n", ValueData);
 228                 break;
 229
 230             case REG_SZ:
 231                 trace("ValueType: REG_SZ\n");
 232                 trace("ValueData: %s\n", (char*)ValueData);
 233                 break;
 234
 235             case REG_MULTI_SZ:
 236                 trace("ValueType: REG_MULTI_SZ\n");
 237                 trace("ValueData: %s\n", (char*)ValueData);
 238                 break;
 239
 240             case REG_EXPAND_SZ:
 241                 trace("ValueType: REG_EXPAND_SZ\n");
 242                 trace("ValueData: %s\n", (char*)ValueData);
 243                 break;
 244
 245             case REG_DWORD:
 246                 trace("ValueType: REG_DWORD\n");
 247                 trace("ValueData: %p\n", ValueData);
 248                 break;
 249     };
 250     trace("ValueLength: %d\n", (int)ValueLength);
 251
 252     if(CurrentTest == 0)
 253         ok(1, "\n"); /*checks that QueryRoutine is called*/
 254     if(CurrentTest > 7)
 255         ok(!1, "Invalid Test Specified!\n");
 256
 257     CurrentTest++;
 258
 259     if(ValName)
 260         pRtlFreeHeap(GetProcessHeap(), 0, ValName);
 261
 262     return ret;
 263 }
 264
 265 static void test_RtlQueryRegistryValues(void)
 266 {
 267
 268     /*
 269     ******************************
 270     *       QueryTable Flags     *
 271     ******************************
 272     *RTL_QUERY_REGISTRY_SUBKEY   * Name is the name of a subkey relative to Path
 273     *RTL_QUERY_REGISTRY_TOPKEY   * Resets location to original RelativeTo and Path
 274     *RTL_QUERY_REGISTRY_REQUIRED * Key required. returns STATUS_OBJECT_NAME_NOT_FOUND if not present
 275     *RTL_QUERY_REGISTRY_NOVALUE  * We just want a call-back
 276     *RTL_QUERY_REGISTRY_NOEXPAND * Don't expand the variables!
 277     *RTL_QUERY_REGISTRY_DIRECT   * Results of query will be stored in EntryContext(QueryRoutine ignored)
 278     *RTL_QUERY_REGISTRY_DELETE   * Delete value key after query
 279     ******************************
 280
 281
 282     **Test layout(numbered according to CurrentTest value)**
 283     0)NOVALUE           Just make sure call-back works
 284     1)Null Name         See if QueryRoutine is called for every value in current key
 285     2)SUBKEY            See if we can use SUBKEY to change the current path on the fly
 286     3)REQUIRED          Test for value that's not there
 287     4)NOEXPAND          See if it will return multiple strings(no expand should split strings up)
 288     5)DIRECT            Make it store data directly in EntryContext and not call QueryRoutine
 289     6)DefaultType       Test return values when key isn't present
 290     7)DefaultValue      Test Default Value returned with key isn't present(and no REQUIRED flag set)
 291     8)DefaultLength     Test Default Length with DefaultType = REG_SZ
 292    9)DefaultLength      Test Default Length with DefaultType = REG_MULTI_SZ
 293    10)DefaultLength     Test Default Length with DefaultType = REG_EXPAND_SZ
 294    11)DefaultData       Test whether DefaultData is used while DefaultType = REG_NONE(shouldn't be)
 295    12)Delete            Try to delete value key
 296
 297     */
 298     NTSTATUS status;
 299     ULONG RelativeTo;
 300
 301     PRTL_QUERY_REGISTRY_TABLE QueryTable = NULL;
 302     RelativeTo = RTL_REGISTRY_ABSOLUTE;/*Only using absolute - no need to test all relativeto variables*/
 303
 304     QueryTable = pRtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_QUERY_REGISTRY_TABLE)*26);
 305
 306     pRtlZeroMemory( QueryTable, sizeof(RTL_QUERY_REGISTRY_TABLE) * 26);
 307
 308     QueryTable[0].QueryRoutine = QueryRoutine;
 309     QueryTable[0].Flags = RTL_QUERY_REGISTRY_NOVALUE;
 310     QueryTable[0].Name = NULL;
 311     QueryTable[0].EntryContext = NULL;
 312     QueryTable[0].DefaultType = REG_BINARY;
 313     QueryTable[0].DefaultData = NULL;
 314     QueryTable[0].DefaultLength = 100;
 315
 316     QueryTable[1].QueryRoutine = QueryRoutine;
 317     QueryTable[1].Flags = 0;
 318     QueryTable[1].Name = NULL;
 319     QueryTable[1].EntryContext = 0;
 320     QueryTable[1].DefaultType = REG_NONE;
 321     QueryTable[1].DefaultData = NULL;
 322     QueryTable[1].DefaultLength = 0;
 323
 324     QueryTable[2].QueryRoutine = NULL;
 325     QueryTable[2].Flags = 0;
 326     QueryTable[2].Name = NULL;
 327     QueryTable[2].EntryContext = 0;
 328     QueryTable[2].DefaultType = REG_NONE;
 329     QueryTable[2].DefaultData = NULL;
 330     QueryTable[2].DefaultLength = 0;
 331
 332     status = pRtlQueryRegistryValues(RelativeTo, winetestpath.Buffer, QueryTable, 0, 0);
 333     ok(status == STATUS_SUCCESS, "RtlQueryRegistryValues return: 0x%08x\n", status);
 334
 335     pRtlFreeHeap(GetProcessHeap(), 0, QueryTable);
 336 }
 337
 338 static void test_NtOpenKey(void)
 339 {
 340     HANDLE key;
 341     NTSTATUS status;
 342     OBJECT_ATTRIBUTES attr;
 343     ACCESS_MASK am = KEY_READ;
 344
 345     /* All NULL */
 346     status = pNtOpenKey(NULL, 0, NULL);
 347     ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got: 0x%08x\n", status);
 348
 349     /* NULL attributes */
 350     status = pNtOpenKey(&key, 0, NULL);
 351     ok(status == STATUS_ACCESS_VIOLATION /* W2K3/XP/W2K */ || status == STATUS_INVALID_PARAMETER /* NT4 */,
 352         "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER(NT4), got: 0x%08x\n", status);
 353
 354     InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
 355
 356     /* NULL key */
 357     status = pNtOpenKey(NULL, am, &attr);
 358     ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got: 0x%08x\n", status);
 359
 360     /* Length > sizeof(OBJECT_ATTRIBUTES) */
 361     attr.Length *= 2;
 362     status = pNtOpenKey(&key, am, &attr);
 363     ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got: 0x%08x\n", status);
 364 }
 365
 366 static void test_NtCreateKey(void)
 367 {
 368     /*Create WineTest*/
 369     OBJECT_ATTRIBUTES attr;
 370     HANDLE key, subkey;
 371     ACCESS_MASK am = GENERIC_ALL;
 372     NTSTATUS status;
 373     UNICODE_STRING str;
 374
 375     /* All NULL */
 376     status = pNtCreateKey(NULL, 0, NULL, 0, 0, 0, 0);
 377     ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
 378        "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER, got: 0x%08x\n", status);
 379
 380     /* Only the key */
 381     status = pNtCreateKey(&key, 0, NULL, 0, 0, 0, 0);
 382     ok(status == STATUS_ACCESS_VIOLATION /* W2K3/XP/W2K */ || status == STATUS_INVALID_PARAMETER /* NT4 */,
 383         "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER(NT4), got: 0x%08x\n", status);
 384
 385     /* Only accessmask */
 386     status = pNtCreateKey(NULL, am, NULL, 0, 0, 0, 0);
 387     ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
 388        "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER, got: 0x%08x\n", status);
 389
 390     /* Key and accessmask */
 391     status = pNtCreateKey(&key, am, NULL, 0, 0, 0, 0);
 392     ok(status == STATUS_ACCESS_VIOLATION /* W2K3/XP/W2K */ || status == STATUS_INVALID_PARAMETER /* NT4 */,
 393         "Expected STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER(NT4), got: 0x%08x\n", status);
 394
 395     InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
 396
 397     /* Only attributes */
 398     status = pNtCreateKey(NULL, 0, &attr, 0, 0, 0, 0);
 399     ok(status == STATUS_ACCESS_VIOLATION, "Expected STATUS_ACCESS_VIOLATION, got: 0x%08x\n", status);
 400
 401     /* Length > sizeof(OBJECT_ATTRIBUTES) */
 402     attr.Length *= 2;
 403     status = pNtCreateKey(&key, am, &attr, 0, 0, 0, 0);
 404     ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got: 0x%08x\n", status);
 405
 406     attr.Length = sizeof(attr);
 407     status = pNtCreateKey(&key, am, &attr, 0, 0, 0, 0);
 408     ok(status == STATUS_SUCCESS, "NtCreateKey Failed: 0x%08x\n", status);
 409
 410     attr.RootDirectory = key;
 411     attr.ObjectName = &str;
 412
 413     pRtlCreateUnicodeStringFromAsciiz( &str, "test\\sub\\key" );
 414     status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
 415     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
 416     pRtlFreeUnicodeString( &str );
 417
 418     pRtlCreateUnicodeStringFromAsciiz( &str, "test\\subkey" );
 419     status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
 420     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
 421     pRtlFreeUnicodeString( &str );
 422
 423     pRtlCreateUnicodeStringFromAsciiz( &str, "test\\subkey\\" );
 424     status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
 425     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtCreateKey failed: 0x%08x\n", status );
 426     pRtlFreeUnicodeString( &str );
 427
 428     pRtlCreateUnicodeStringFromAsciiz( &str, "test_subkey\\" );
 429     status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
 430     ok( status == STATUS_SUCCESS || broken(status == STATUS_OBJECT_NAME_NOT_FOUND), /* nt4 */
 431         "NtCreateKey failed: 0x%08x\n", status );
 432     if (status == STATUS_SUCCESS)
 433     {
 434         pNtDeleteKey( subkey );
 435         pNtClose( subkey );
 436     }
 437     pRtlFreeUnicodeString( &str );
 438
 439     pRtlCreateUnicodeStringFromAsciiz( &str, "test_subkey" );
 440     status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 );
 441     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 442     pRtlFreeUnicodeString( &str );
 443     pNtDeleteKey( subkey );
 444     pNtClose( subkey );
 445
 446     pNtClose(key);
 447 }
 448
 449 static void test_NtSetValueKey(void)
 450 {
 451     HANDLE key;
 452     NTSTATUS status;
 453     OBJECT_ATTRIBUTES attr;
 454     ACCESS_MASK am = KEY_WRITE;
 455     UNICODE_STRING ValName;
 456     DWORD data = 711;
 457
 458     InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
 459     status = pNtOpenKey(&key, am, &attr);
 460     ok(status == STATUS_SUCCESS, "NtOpenKey Failed: 0x%08x\n", status);
 461
 462     pRtlCreateUnicodeStringFromAsciiz(&ValName, "deletetest");
 463     status = pNtSetValueKey(key, &ValName, 0, REG_DWORD, &data, sizeof(data));
 464     ok(status == STATUS_SUCCESS, "NtSetValueKey Failed: 0x%08x\n", status);
 465     pRtlFreeUnicodeString(&ValName);
 466
 467     pRtlCreateUnicodeStringFromAsciiz(&ValName, "stringtest");
 468     status = pNtSetValueKey(key, &ValName, 0, REG_SZ, (VOID*)stringW, STR_TRUNC_SIZE);
 469     ok(status == STATUS_SUCCESS, "NtSetValueKey Failed: 0x%08x\n", status);
 470     pRtlFreeUnicodeString(&ValName);
 471
 472     pNtClose(key);
 473 }
 474
 475 static void test_RtlOpenCurrentUser(void)
 476 {
 477     NTSTATUS status;
 478     HANDLE handle;
 479     status=pRtlOpenCurrentUser(KEY_READ, &handle);
 480     ok(status == STATUS_SUCCESS, "RtlOpenCurrentUser Failed: 0x%08x\n", status);
 481     pNtClose(handle);
 482 }
 483
 484 static void test_RtlCheckRegistryKey(void)
 485 {
 486     NTSTATUS status;
 487
 488     status = pRtlCheckRegistryKey(RTL_REGISTRY_ABSOLUTE, winetestpath.Buffer);
 489     ok(status == STATUS_SUCCESS, "RtlCheckRegistryKey with RTL_REGISTRY_ABSOLUTE: 0x%08x\n", status);
 490
 491     status = pRtlCheckRegistryKey((RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL), winetestpath.Buffer);
 492     ok(status == STATUS_SUCCESS, "RtlCheckRegistryKey with RTL_REGISTRY_ABSOLUTE and RTL_REGISTRY_OPTIONAL: 0x%08x\n", status);
 493 }
 494
 495 static void test_NtFlushKey(void)
 496 {
 497     NTSTATUS status;
 498     HANDLE hkey;
 499     OBJECT_ATTRIBUTES attr;
 500     ACCESS_MASK am = KEY_ALL_ACCESS;
 501
 502     status = pNtFlushKey(NULL);
 503     ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got: 0x%08x\n", status);
 504
 505     InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
 506     pNtOpenKey(&hkey, am, &attr);
 507
 508     status = pNtFlushKey(hkey);
 509     ok(status == STATUS_SUCCESS, "NtDeleteKey Failed: 0x%08x\n", status);
 510
 511     pNtClose(hkey);
 512 }
 513
 514 static void test_NtQueryValueKey(void)
 515 {
 516     HANDLE key;
 517     NTSTATUS status;
 518     OBJECT_ATTRIBUTES attr;
 519     UNICODE_STRING ValName;
 520     KEY_VALUE_BASIC_INFORMATION *basic_info;
 521     KEY_VALUE_PARTIAL_INFORMATION *partial_info;
 522     KEY_VALUE_FULL_INFORMATION *full_info;
 523     DWORD len, expected;
 524
 525     pRtlCreateUnicodeStringFromAsciiz(&ValName, "deletetest");
 526
 527     InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
 528     status = pNtOpenKey(&key, KEY_READ, &attr);
 529     ok(status == STATUS_SUCCESS, "NtOpenKey Failed: 0x%08x\n", status);
 530
 531     len = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name[0]);
 532     basic_info = HeapAlloc(GetProcessHeap(), 0, len);
 533     status = pNtQueryValueKey(key, &ValName, KeyValueBasicInformation, basic_info, len, &len);
 534     ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey should have returned STATUS_BUFFER_OVERFLOW instead of 0x%08x\n", status);
 535     ok(basic_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", basic_info->TitleIndex);
 536     ok(basic_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", basic_info->Type);
 537     ok(basic_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", basic_info->NameLength);
 538     ok(len == FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name[basic_info->NameLength/sizeof(WCHAR)]), "NtQueryValueKey returned wrong len %d\n", len);
 539
 540     basic_info = HeapReAlloc(GetProcessHeap(), 0, basic_info, len);
 541     status = pNtQueryValueKey(key, &ValName, KeyValueBasicInformation, basic_info, len, &len);
 542     ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
 543     ok(basic_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", basic_info->TitleIndex);
 544     ok(basic_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", basic_info->Type);
 545     ok(basic_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", basic_info->NameLength);
 546     ok(len == FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name[basic_info->NameLength/sizeof(WCHAR)]), "NtQueryValueKey returned wrong len %d\n", len);
 547     ok(!memcmp(basic_info->Name, ValName.Buffer, ValName.Length), "incorrect Name returned\n");
 548     HeapFree(GetProcessHeap(), 0, basic_info);
 549
 550     len = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]);
 551     partial_info = HeapAlloc(GetProcessHeap(), 0, len);
 552     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, len, &len);
 553     ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey should have returned STATUS_BUFFER_OVERFLOW instead of 0x%08x\n", status);
 554     ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->TitleIndex);
 555     ok(partial_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", partial_info->Type);
 556     ok(partial_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", partial_info->DataLength);
 557     ok(len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[partial_info->DataLength]), "NtQueryValueKey returned wrong len %d\n", len);
 558
 559     partial_info = HeapReAlloc(GetProcessHeap(), 0, partial_info, len);
 560     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, len, &len);
 561     ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
 562     ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->TitleIndex);
 563     ok(partial_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", partial_info->Type);
 564     ok(partial_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", partial_info->DataLength);
 565     ok(len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[partial_info->DataLength]), "NtQueryValueKey returned wrong len %d\n", len);
 566     ok(*(DWORD *)partial_info->Data == 711, "incorrect Data returned: 0x%x\n", *(DWORD *)partial_info->Data);
 567     HeapFree(GetProcessHeap(), 0, partial_info);
 568
 569     len = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name[0]);
 570     full_info = HeapAlloc(GetProcessHeap(), 0, len);
 571     status = pNtQueryValueKey(key, &ValName, KeyValueFullInformation, full_info, len, &len);
 572     ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey should have returned STATUS_BUFFER_OVERFLOW instead of 0x%08x\n", status);
 573     ok(full_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", full_info->TitleIndex);
 574     ok(full_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", full_info->Type);
 575     ok(full_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", full_info->DataLength);
 576     ok(full_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", full_info->NameLength);
 577     ok(len == FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name[0]) + full_info->DataLength + full_info->NameLength,
 578         "NtQueryValueKey returned wrong len %d\n", len);
 579     len = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name[0]) + full_info->DataLength + full_info->NameLength;
 580
 581     full_info = HeapReAlloc(GetProcessHeap(), 0, full_info, len);
 582     status = pNtQueryValueKey(key, &ValName, KeyValueFullInformation, full_info, len, &len);
 583     ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
 584     ok(full_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", full_info->TitleIndex);
 585     ok(full_info->Type == REG_DWORD, "NtQueryValueKey returned wrong Type %d\n", full_info->Type);
 586     ok(full_info->DataLength == 4, "NtQueryValueKey returned wrong DataLength %d\n", full_info->DataLength);
 587     ok(full_info->NameLength == 20, "NtQueryValueKey returned wrong NameLength %d\n", full_info->NameLength);
 588     ok(!memcmp(full_info->Name, ValName.Buffer, ValName.Length), "incorrect Name returned\n");
 589     ok(*(DWORD *)((char *)full_info + full_info->DataOffset) == 711, "incorrect Data returned: 0x%x\n",
 590         *(DWORD *)((char *)full_info + full_info->DataOffset));
 591     HeapFree(GetProcessHeap(), 0, full_info);
 592
 593     pRtlFreeUnicodeString(&ValName);
 594     pRtlCreateUnicodeStringFromAsciiz(&ValName, "stringtest");
 595
 596     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, NULL, 0, &len);
 597     ok(status == STATUS_BUFFER_TOO_SMALL, "NtQueryValueKey should have returned STATUS_BUFFER_TOO_SMALL instead of 0x%08x\n", status);
 598     partial_info = HeapAlloc(GetProcessHeap(), 0, len+1);
 599     memset(partial_info, 0xbd, len+1);
 600     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, len, &len);
 601     ok(status == STATUS_SUCCESS, "NtQueryValueKey should have returned STATUS_SUCCESS instead of 0x%08x\n", status);
 602     ok(partial_info->TitleIndex == 0, "NtQueryValueKey returned wrong TitleIndex %d\n", partial_info->TitleIndex);
 603     ok(partial_info->Type == REG_SZ, "NtQueryValueKey returned wrong Type %d\n", partial_info->Type);
 604     ok(partial_info->DataLength == STR_TRUNC_SIZE, "NtQueryValueKey returned wrong DataLength %d\n", partial_info->DataLength);
 605     ok(!memcmp(partial_info->Data, stringW, STR_TRUNC_SIZE), "incorrect Data returned\n");
 606     ok(*(partial_info->Data+STR_TRUNC_SIZE) == 0xbd, "string overflowed %02x\n", *(partial_info->Data+STR_TRUNC_SIZE));
 607
 608     expected = len;
 609     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, 0, &len);
 610     ok(status == STATUS_BUFFER_TOO_SMALL, "NtQueryValueKey wrong status 0x%08x\n", status);
 611     ok(len == expected, "NtQueryValueKey wrong len %u\n", len);
 612     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, 1, &len);
 613     ok(status == STATUS_BUFFER_TOO_SMALL, "NtQueryValueKey wrong status 0x%08x\n", status);
 614     ok(len == expected, "NtQueryValueKey wrong len %u\n", len);
 615     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) - 1, &len);
 616     ok(status == STATUS_BUFFER_TOO_SMALL, "NtQueryValueKey wrong status 0x%08x\n", status);
 617     ok(len == expected, "NtQueryValueKey wrong len %u\n", len);
 618     status = pNtQueryValueKey(key, &ValName, KeyValuePartialInformation, partial_info, FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data), &len);
 619     ok(status == STATUS_BUFFER_OVERFLOW, "NtQueryValueKey wrong status 0x%08x\n", status);
 620     ok(len == expected, "NtQueryValueKey wrong len %u\n", len);
 621
 622     HeapFree(GetProcessHeap(), 0, partial_info);
 623
 624     pRtlFreeUnicodeString(&ValName);
 625     pNtClose(key);
 626 }
 627
 628 static void test_NtDeleteKey(void)
 629 {
 630     NTSTATUS status;
 631     HANDLE hkey;
 632     OBJECT_ATTRIBUTES attr;
 633     ACCESS_MASK am = KEY_ALL_ACCESS;
 634
 635     status = pNtDeleteKey(NULL);
 636     ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got: 0x%08x\n", status);
 637
 638     InitializeObjectAttributes(&attr, &winetestpath, 0, 0, 0);
 639     status = pNtOpenKey(&hkey, am, &attr);
 640
 641     status = pNtDeleteKey(hkey);
 642     ok(status == STATUS_SUCCESS, "NtDeleteKey Failed: 0x%08x\n", status);
 643 }
 644
 645 static void test_RtlpNtQueryValueKey(void)
 646 {
 647     NTSTATUS status;
 648
 649     status = pRtlpNtQueryValueKey(NULL, NULL, NULL, NULL, NULL);
 650     ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got: 0x%08x\n", status);
 651 }
 652
 653 static void test_symlinks(void)
 654 {
 655     static const WCHAR linkW[] = {'l','i','n','k',0};
 656     static const WCHAR valueW[] = {'v','a','l','u','e',0};
 657     static const WCHAR symlinkW[] = {'S','y','m','b','o','l','i','c','L','i','n','k','V','a','l','u','e',0};
 658     static const WCHAR targetW[] = {'\\','t','a','r','g','e','t',0};
 659     static UNICODE_STRING null_str;
 660     char buffer[1024];
 661     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
 662     WCHAR *target;
 663     UNICODE_STRING symlink_str, link_str, target_str, value_str;
 664     HANDLE root, key, link;
 665     OBJECT_ATTRIBUTES attr;
 666     NTSTATUS status;
 667     DWORD target_len, len, dw;
 668
 669     pRtlInitUnicodeString( &link_str, linkW );
 670     pRtlInitUnicodeString( &symlink_str, symlinkW );
 671     pRtlInitUnicodeString( &target_str, targetW + 1 );
 672     pRtlInitUnicodeString( &value_str, valueW );
 673
 674     target_len = winetestpath.Length + sizeof(targetW);
 675     target = pRtlAllocateHeap( GetProcessHeap(), 0, target_len + sizeof(targetW) /*for loop test*/ );
 676     memcpy( target, winetestpath.Buffer, winetestpath.Length );
 677     memcpy( target + winetestpath.Length/sizeof(WCHAR), targetW, sizeof(targetW) );
 678
 679     attr.Length = sizeof(attr);
 680     attr.RootDirectory = 0;
 681     attr.Attributes = 0;
 682     attr.ObjectName = &winetestpath;
 683     attr.SecurityDescriptor = NULL;
 684     attr.SecurityQualityOfService = NULL;
 685
 686     status = pNtCreateKey( &root, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 687     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 688
 689     attr.RootDirectory = root;
 690     attr.ObjectName = &link_str;
 691     status = pNtCreateKey( &link, KEY_ALL_ACCESS, &attr, 0, 0, REG_OPTION_CREATE_LINK, 0 );
 692     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 693
 694     /* REG_SZ is not allowed */
 695     status = pNtSetValueKey( link, &symlink_str, 0, REG_SZ, target, target_len );
 696     ok( status == STATUS_ACCESS_DENIED, "NtSetValueKey wrong status 0x%08x\n", status );
 697     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK, target, target_len - sizeof(WCHAR) );
 698     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 699     /* other values are not allowed */
 700     status = pNtSetValueKey( link, &link_str, 0, REG_LINK, target, target_len - sizeof(WCHAR) );
 701     ok( status == STATUS_ACCESS_DENIED, "NtSetValueKey wrong status 0x%08x\n", status );
 702
 703     /* try opening the target through the link */
 704
 705     attr.ObjectName = &link_str;
 706     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 707     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtOpenKey wrong status 0x%08x\n", status );
 708
 709     attr.ObjectName = &target_str;
 710     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 711     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 712
 713     dw = 0xbeef;
 714     status = pNtSetValueKey( key, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
 715     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 716     pNtClose( key );
 717
 718     attr.ObjectName = &link_str;
 719     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 720     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 721
 722     len = sizeof(buffer);
 723     status = pNtQueryValueKey( key, &value_str, KeyValuePartialInformation, info, len, &len );
 724     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 725     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + sizeof(DWORD), "wrong len %u\n", len );
 726
 727     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 728     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 729
 730     /* REG_LINK can be created in non-link keys */
 731     status = pNtSetValueKey( key, &symlink_str, 0, REG_LINK, target, target_len - sizeof(WCHAR) );
 732     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 733     len = sizeof(buffer);
 734     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 735     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 736     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 737         "wrong len %u\n", len );
 738     status = pNtDeleteValueKey( key, &symlink_str );
 739     ok( status == STATUS_SUCCESS, "NtDeleteValueKey failed: 0x%08x\n", status );
 740
 741     pNtClose( key );
 742
 743     attr.Attributes = 0;
 744     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 745     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 746
 747     len = sizeof(buffer);
 748     status = pNtQueryValueKey( key, &value_str, KeyValuePartialInformation, info, len, &len );
 749     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 750     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + sizeof(DWORD), "wrong len %u\n", len );
 751
 752     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 753     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 754     pNtClose( key );
 755
 756     /* now open the symlink itself */
 757
 758     attr.RootDirectory = root;
 759     attr.Attributes = OBJ_OPENLINK;
 760     attr.ObjectName = &link_str;
 761     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 762     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 763
 764     len = sizeof(buffer);
 765     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 766     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 767     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 768         "wrong len %u\n", len );
 769     pNtClose( key );
 770
 771     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 772     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 773     len = sizeof(buffer);
 774     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 775     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 776     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 777         "wrong len %u\n", len );
 778     pNtClose( key );
 779
 780     if (0)  /* crashes the Windows kernel on some Vista systems */
 781     {
 782         /* reopen the link from itself */
 783
 784         attr.RootDirectory = link;
 785         attr.Attributes = OBJ_OPENLINK;
 786         attr.ObjectName = &null_str;
 787         status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 788         ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 789         len = sizeof(buffer);
 790         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 791         ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 792         ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 793             "wrong len %u\n", len );
 794         pNtClose( key );
 795
 796         status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 797         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 798         len = sizeof(buffer);
 799         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 800         ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 801         ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 802             "wrong len %u\n", len );
 803         pNtClose( key );
 804     }
 805
 806     if (0)  /* crashes the Windows kernel in most versions */
 807     {
 808         attr.RootDirectory = link;
 809         attr.Attributes = 0;
 810         attr.ObjectName = &null_str;
 811         status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 812         ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 813         len = sizeof(buffer);
 814         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 815         ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 816         pNtClose( key );
 817
 818         status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 819         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 820         len = sizeof(buffer);
 821         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 822         ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 823         pNtClose( key );
 824     }
 825
 826     /* target with terminating null doesn't work */
 827     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK, target, target_len );
 828     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 829     attr.RootDirectory = root;
 830     attr.Attributes = 0;
 831     attr.ObjectName = &link_str;
 832     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 833     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtOpenKey wrong status 0x%08x\n", status );
 834
 835     /* relative symlink, works only on win2k */
 836     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK, targetW+1, sizeof(targetW)-2*sizeof(WCHAR) );
 837     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 838     attr.ObjectName = &link_str;
 839     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 840     ok( status == STATUS_SUCCESS || status == STATUS_OBJECT_NAME_NOT_FOUND,
 841         "NtOpenKey wrong status 0x%08x\n", status );
 842
 843     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, REG_OPTION_CREATE_LINK, 0 );
 844     ok( status == STATUS_OBJECT_NAME_COLLISION, "NtCreateKey failed: 0x%08x\n", status );
 845
 846     status = pNtDeleteKey( link );
 847     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 848     pNtClose( link );
 849
 850     attr.ObjectName = &target_str;
 851     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 852     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 853     status = pNtDeleteKey( key );
 854     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 855     pNtClose( key );
 856
 857     /* symlink loop */
 858
 859     status = pNtCreateKey( &link, KEY_ALL_ACCESS, &attr, 0, 0, REG_OPTION_CREATE_LINK, 0 );
 860     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 861     memcpy( target + target_len/sizeof(WCHAR) - 1, targetW, sizeof(targetW) );
 862     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK,
 863         target, target_len + sizeof(targetW) - sizeof(WCHAR) );
 864     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 865
 866     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 867     ok( status == STATUS_OBJECT_NAME_NOT_FOUND || status == STATUS_NAME_TOO_LONG,
 868         "NtOpenKey failed: 0x%08x\n", status );
 869
 870     attr.Attributes = OBJ_OPENLINK;
 871     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 872     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 873     pNtClose( key );
 874
 875     status = pNtDeleteKey( link );
 876     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 877     pNtClose( link );
 878
 879     status = pNtDeleteKey( root );
 880     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 881     pNtClose( root );
 882
 883     pRtlFreeHeap(GetProcessHeap(), 0, target);
 884 }
 885
 886 static WCHAR valueW[] = {'v','a','l','u','e'};
 887 static UNICODE_STRING value_str = { sizeof(valueW), sizeof(valueW), valueW };
 888 static const DWORD ptr_size = 8 * sizeof(void*);
 889
 890 static DWORD get_key_value( HANDLE root, const char *name, DWORD flags )
 891 {
 892     char tmp[32];
 893     NTSTATUS status;
 894     OBJECT_ATTRIBUTES attr;
 895     UNICODE_STRING str;
 896     HANDLE key;
 897     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
 898     DWORD dw, len = sizeof(tmp);
 899
 900     attr.Length = sizeof(attr);
 901     attr.RootDirectory = root;
 902     attr.Attributes = OBJ_CASE_INSENSITIVE;
 903     attr.ObjectName = &str;
 904     attr.SecurityDescriptor = NULL;
 905     attr.SecurityQualityOfService = NULL;
 906     pRtlCreateUnicodeStringFromAsciiz( &str, name );
 907
 908     status = pNtCreateKey( &key, flags | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 909     if (status == STATUS_OBJECT_NAME_NOT_FOUND) return 0;
 910     ok( status == STATUS_SUCCESS, "%08x: NtCreateKey failed: 0x%08x\n", flags, status );
 911
 912     status = pNtQueryValueKey( key, &value_str, KeyValuePartialInformation, info, len, &len );
 913     if (status == STATUS_OBJECT_NAME_NOT_FOUND)
 914         dw = 0;
 915     else
 916     {
 917         ok( status == STATUS_SUCCESS, "%08x: NtQueryValueKey failed: 0x%08x\n", flags, status );
 918         dw = *(DWORD *)info->Data;
 919     }
 920     pNtClose( key );
 921     pRtlFreeUnicodeString( &str );
 922     return dw;
 923 }
 924
 925 static void _check_key_value( int line, HANDLE root, const char *name, DWORD flags, DWORD expect )
 926 {
 927     DWORD dw = get_key_value( root, name, flags );
 928     ok_(__FILE__,line)( dw == expect, "%08x: wrong value %u/%u\n", flags, dw, expect );
 929 }
 930 #define check_key_value(root,name,flags,expect) _check_key_value( __LINE__, root, name, flags, expect )
 931
 932 static void test_redirection(void)
 933 {
 934     static const WCHAR softwareW[] = {'\\','R','e','g','i','s','t','r','y','\\',
 935                                       'M','a','c','h','i','n','e','\\',
 936                                       'S','o','f','t','w','a','r','e',0};
 937     static const WCHAR wownodeW[] = {'\\','R','e','g','i','s','t','r','y','\\',
 938                                      'M','a','c','h','i','n','e','\\',
 939                                      'S','o','f','t','w','a','r','e','\\',
 940                                      'W','o','w','6','4','3','2','N','o','d','e',0};
 941     static const WCHAR wine64W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 942                                     'M','a','c','h','i','n','e','\\',
 943                                     'S','o','f','t','w','a','r','e','\\',
 944                                     'W','i','n','e',0};
 945     static const WCHAR wine32W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 946                                     'M','a','c','h','i','n','e','\\',
 947                                     'S','o','f','t','w','a','r','e','\\',
 948                                     'W','o','w','6','4','3','2','N','o','d','e','\\',
 949                                     'W','i','n','e',0};
 950     static const WCHAR key64W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 951                                    'M','a','c','h','i','n','e','\\',
 952                                    'S','o','f','t','w','a','r','e','\\',
 953                                    'W','i','n','e','\\','W','i','n','e','t','e','s','t',0};
 954     static const WCHAR key32W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 955                                    'M','a','c','h','i','n','e','\\',
 956                                    'S','o','f','t','w','a','r','e','\\',
 957                                    'W','o','w','6','4','3','2','N','o','d','e','\\',
 958                                    'W','i','n','e','\\', 'W','i','n','e','t','e','s','t',0};
 959     static const WCHAR classes64W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 960                                        'M','a','c','h','i','n','e','\\',
 961                                        'S','o','f','t','w','a','r','e','\\',
 962                                        'C','l','a','s','s','e','s','\\',
 963                                        'W','i','n','e',0};
 964     static const WCHAR classes32W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 965                                        'M','a','c','h','i','n','e','\\',
 966                                        'S','o','f','t','w','a','r','e','\\',
 967                                        'C','l','a','s','s','e','s','\\',
 968                                        'W','o','w','6','4','3','2','N','o','d','e','\\',
 969                                        'W','i','n','e',0};
 970     NTSTATUS status;
 971     OBJECT_ATTRIBUTES attr;
 972     UNICODE_STRING str;
 973     char buffer[1024];
 974     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
 975     DWORD dw, len;
 976     HANDLE key, root32, root64, key32, key64;
 977     BOOL is_vista = FALSE;
 978
 979     if (ptr_size != 64)
 980     {
 981         ULONG is_wow64, len;
 982         if (pNtQueryInformationProcess( GetCurrentProcess(), ProcessWow64Information,
 983                                         &is_wow64, sizeof(is_wow64), &len ) ||
 984             !is_wow64)
 985         {
 986             trace( "Not on Wow64, no redirection\n" );
 987             return;
 988         }
 989     }
 990
 991     attr.Length = sizeof(attr);
 992     attr.RootDirectory = 0;
 993     attr.Attributes = OBJ_CASE_INSENSITIVE;
 994     attr.ObjectName = &str;
 995     attr.SecurityDescriptor = NULL;
 996     attr.SecurityQualityOfService = NULL;
 997
 998     pRtlInitUnicodeString( &str, wine64W );
 999     status = pNtCreateKey( &root64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1000     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1001
1002     pRtlInitUnicodeString( &str, wine32W );
1003     status = pNtCreateKey( &root32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1004     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1005
1006     pRtlInitUnicodeString( &str, key64W );
1007     status = pNtCreateKey( &key64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1008     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1009
1010     pRtlInitUnicodeString( &str, key32W );
1011     status = pNtCreateKey( &key32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1012     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1013
1014     dw = 64;
1015     status = pNtSetValueKey( key64, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1016     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1017
1018     dw = 32;
1019     status = pNtSetValueKey( key32, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1020     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1021
1022     len = sizeof(buffer);
1023     status = pNtQueryValueKey( key32, &value_str, KeyValuePartialInformation, info, len, &len );
1024     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1025     dw = *(DWORD *)info->Data;
1026     ok( dw == 32, "wrong value %u\n", dw );
1027
1028     len = sizeof(buffer);
1029     status = pNtQueryValueKey( key64, &value_str, KeyValuePartialInformation, info, len, &len );
1030     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1031     dw = *(DWORD *)info->Data;
1032     ok( dw == 64, "wrong value %u\n", dw );
1033
1034     pRtlInitUnicodeString( &str, softwareW );
1035     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1036     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1037
1038     if (ptr_size == 32)
1039     {
1040         /* the Vista mechanism allows opening Wow6432Node from a 32-bit key too */
1041         /* the new (and simpler) Win7 mechanism doesn't */
1042         if (get_key_value( key, "Wow6432Node\\Wine\\Winetest", 0 ) == 32)
1043         {
1044             trace( "using Vista-style Wow6432Node handling\n" );
1045             is_vista = TRUE;
1046         }
1047         check_key_value( key, "Wine\\Winetest", 0, 32 );
1048         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1049         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1050         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, is_vista ? 32 : 0 );
1051         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 0 );
1052         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, is_vista ? 32 : 0 );
1053     }
1054     else
1055     {
1056         check_key_value( key, "Wine\\Winetest", 0, 64 );
1057         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, 32 );
1058     }
1059     pNtClose( key );
1060
1061     if (ptr_size == 32)
1062     {
1063         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1064         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1065         dw = get_key_value( key, "Wine\\Winetest", 0 );
1066         ok( dw == 64 || broken(dw == 32) /* xp64 */, "wrong value %u\n", dw );
1067         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 64 );
1068         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1069         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, 32 );
1070         dw = get_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY );
1071         ok( dw == 32 || broken(dw == 64) /* xp64 */, "wrong value %u\n", dw );
1072         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1073         pNtClose( key );
1074
1075         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1076         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1077         check_key_value( key, "Wine\\Winetest", 0, 32 );
1078         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1079         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1080         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, is_vista ? 32 : 0 );
1081         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 0 );
1082         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, is_vista ? 32 : 0 );
1083         pNtClose( key );
1084     }
1085
1086     check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", 0, ptr_size );
1087     check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", 0, 32 );
1088     if (ptr_size == 64)
1089     {
1090         /* KEY_WOW64 flags have no effect on 64-bit */
1091         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_64KEY, 64 );
1092         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_32KEY, 64 );
1093         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, 32 );
1094         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1095     }
1096     else
1097     {
1098         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_64KEY, 64 );
1099         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1100         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1101         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1102     }
1103
1104     pRtlInitUnicodeString( &str, wownodeW );
1105     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1106     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1107     check_key_value( key, "Wine\\Winetest", 0, 32 );
1108     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, (ptr_size == 64) ? 32 : (is_vista ? 64 : 32) );
1109     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1110     pNtClose( key );
1111
1112     if (ptr_size == 32)
1113     {
1114         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1115         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1116         dw = get_key_value( key, "Wine\\Winetest", 0 );
1117         ok( dw == (is_vista ? 64 : 32) || broken(dw == 32) /* xp64 */, "wrong value %u\n", dw );
1118         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1119         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1120         pNtClose( key );
1121
1122         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1123         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1124         check_key_value( key, "Wine\\Winetest", 0, 32 );
1125         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1126         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1127         pNtClose( key );
1128     }
1129
1130     pRtlInitUnicodeString( &str, wine32W );
1131     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1132     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1133     check_key_value( key, "Winetest", 0, 32 );
1134     check_key_value( key, "Winetest", KEY_WOW64_64KEY, (ptr_size == 32 && is_vista) ? 64 : 32 );
1135     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1136     pNtClose( key );
1137
1138     if (ptr_size == 32)
1139     {
1140         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1141         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1142         dw = get_key_value( key, "Winetest", 0 );
1143         ok( dw == 32 || (is_vista && dw == 64), "wrong value %u\n", dw );
1144         check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1145         check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1146         pNtClose( key );
1147
1148         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1149         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1150         check_key_value( key, "Winetest", 0, 32 );
1151         check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1152         check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1153         pNtClose( key );
1154     }
1155
1156     pRtlInitUnicodeString( &str, wine64W );
1157     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1158     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1159     check_key_value( key, "Winetest", 0, ptr_size );
1160     check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : ptr_size );
1161     check_key_value( key, "Winetest", KEY_WOW64_32KEY, ptr_size );
1162     pNtClose( key );
1163
1164     if (ptr_size == 32)
1165     {
1166         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1167         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1168         dw = get_key_value( key, "Winetest", 0 );
1169         ok( dw == 64 || broken(dw == 32) /* xp64 */, "wrong value %u\n", dw );
1170         check_key_value( key, "Winetest", KEY_WOW64_64KEY, 64 );
1171         dw = get_key_value( key, "Winetest", KEY_WOW64_32KEY );
1172         todo_wine ok( dw == 32, "wrong value %u\n", dw );
1173         pNtClose( key );
1174
1175         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1176         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1177         check_key_value( key, "Winetest", 0, 32 );
1178         check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1179         check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1180         pNtClose( key );
1181     }
1182
1183     status = pNtDeleteKey( key32 );
1184     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
1185     pNtClose( key32 );
1186
1187     status = pNtDeleteKey( key64 );
1188     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
1189     pNtClose( key64 );
1190
1191     pNtDeleteKey( root32 );
1192     pNtClose( root32 );
1193     pNtDeleteKey( root64 );
1194     pNtClose( root64 );
1195
1196     /* Software\Classes is shared/reflected so behavior is different */
1197
1198     pRtlInitUnicodeString( &str, classes64W );
1199     status = pNtCreateKey( &key64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1200     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1201
1202     pRtlInitUnicodeString( &str, classes32W );
1203     status = pNtCreateKey( &key32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1204     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1205
1206     dw = 64;
1207     status = pNtSetValueKey( key64, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1208     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1209     pNtClose( key64 );
1210
1211     dw = 32;
1212     status = pNtSetValueKey( key32, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1213     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1214     pNtClose( key32 );
1215
1216     pRtlInitUnicodeString( &str, classes64W );
1217     status = pNtCreateKey( &key64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1218     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1219     len = sizeof(buffer);
1220     status = pNtQueryValueKey( key64, &value_str, KeyValuePartialInformation, info, len, &len );
1221     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1222     dw = *(DWORD *)info->Data;
1223     ok( dw == ptr_size, "wrong value %u\n", dw );
1224
1225     pRtlInitUnicodeString( &str, classes32W );
1226     status = pNtCreateKey( &key32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1227     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1228     len = sizeof(buffer);
1229     status = pNtQueryValueKey( key32, &value_str, KeyValuePartialInformation, info, len, &len );
1230     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1231     dw = *(DWORD *)info->Data;
1232     ok( dw == 32, "wrong value %u\n", dw );
1233
1234     pNtDeleteKey( key32 );
1235     pNtClose( key32 );
1236     pNtDeleteKey( key64 );
1237     pNtClose( key64 );
1238 }
1239
1240 START_TEST(reg)
1241 {
1242     static const WCHAR winetest[] = {'\\','W','i','n','e','T','e','s','t',0};
1243     if(!InitFunctionPtrs())
1244         return;
1245     pRtlFormatCurrentUserKeyPath(&winetestpath);
1246     winetestpath.Buffer = pRtlReAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, winetestpath.Buffer,
1247                            winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR));
1248     winetestpath.MaximumLength = winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR);
1249
1250     pRtlAppendUnicodeToString(&winetestpath, winetest);
1251
1252     test_NtCreateKey();
1253     test_NtOpenKey();
1254     test_NtSetValueKey();
1255     test_RtlCheckRegistryKey();
1256     test_RtlOpenCurrentUser();
1257     test_RtlQueryRegistryValues();
1258     test_RtlpNtQueryValueKey();
1259     test_NtFlushKey();
1260     test_NtQueryValueKey();
1261     test_NtDeleteKey();
1262     test_symlinks();
1263     test_redirection();
1264
1265     pRtlFreeUnicodeString(&winetestpath);
1266
1267     FreeLibrary(hntdll);
1268 }