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     ok(status == STATUS_SUCCESS, "NtOpenKey Failed: 0x%08x\n", status);
 641
 642     status = pNtDeleteKey(hkey);
 643     ok(status == STATUS_SUCCESS, "NtDeleteKey Failed: 0x%08x\n", status);
 644 }
 645
 646 static void test_RtlpNtQueryValueKey(void)
 647 {
 648     NTSTATUS status;
 649
 650     status = pRtlpNtQueryValueKey(NULL, NULL, NULL, NULL, NULL);
 651     ok(status == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got: 0x%08x\n", status);
 652 }
 653
 654 static void test_symlinks(void)
 655 {
 656     static const WCHAR linkW[] = {'l','i','n','k',0};
 657     static const WCHAR valueW[] = {'v','a','l','u','e',0};
 658     static const WCHAR symlinkW[] = {'S','y','m','b','o','l','i','c','L','i','n','k','V','a','l','u','e',0};
 659     static const WCHAR targetW[] = {'\\','t','a','r','g','e','t',0};
 660     static UNICODE_STRING null_str;
 661     char buffer[1024];
 662     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
 663     WCHAR *target;
 664     UNICODE_STRING symlink_str, link_str, target_str, value_str;
 665     HANDLE root, key, link;
 666     OBJECT_ATTRIBUTES attr;
 667     NTSTATUS status;
 668     DWORD target_len, len, dw;
 669
 670     pRtlInitUnicodeString( &link_str, linkW );
 671     pRtlInitUnicodeString( &symlink_str, symlinkW );
 672     pRtlInitUnicodeString( &target_str, targetW + 1 );
 673     pRtlInitUnicodeString( &value_str, valueW );
 674
 675     target_len = winetestpath.Length + sizeof(targetW);
 676     target = pRtlAllocateHeap( GetProcessHeap(), 0, target_len + sizeof(targetW) /*for loop test*/ );
 677     memcpy( target, winetestpath.Buffer, winetestpath.Length );
 678     memcpy( target + winetestpath.Length/sizeof(WCHAR), targetW, sizeof(targetW) );
 679
 680     attr.Length = sizeof(attr);
 681     attr.RootDirectory = 0;
 682     attr.Attributes = 0;
 683     attr.ObjectName = &winetestpath;
 684     attr.SecurityDescriptor = NULL;
 685     attr.SecurityQualityOfService = NULL;
 686
 687     status = pNtCreateKey( &root, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 688     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 689
 690     attr.RootDirectory = root;
 691     attr.ObjectName = &link_str;
 692     status = pNtCreateKey( &link, KEY_ALL_ACCESS, &attr, 0, 0, REG_OPTION_CREATE_LINK, 0 );
 693     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 694
 695     /* REG_SZ is not allowed */
 696     status = pNtSetValueKey( link, &symlink_str, 0, REG_SZ, target, target_len );
 697     ok( status == STATUS_ACCESS_DENIED, "NtSetValueKey wrong status 0x%08x\n", status );
 698     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK, target, target_len - sizeof(WCHAR) );
 699     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 700     /* other values are not allowed */
 701     status = pNtSetValueKey( link, &link_str, 0, REG_LINK, target, target_len - sizeof(WCHAR) );
 702     ok( status == STATUS_ACCESS_DENIED, "NtSetValueKey wrong status 0x%08x\n", status );
 703
 704     /* try opening the target through the link */
 705
 706     attr.ObjectName = &link_str;
 707     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 708     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtOpenKey wrong status 0x%08x\n", status );
 709
 710     attr.ObjectName = &target_str;
 711     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 712     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 713
 714     dw = 0xbeef;
 715     status = pNtSetValueKey( key, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
 716     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 717     pNtClose( key );
 718
 719     attr.ObjectName = &link_str;
 720     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 721     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 722
 723     len = sizeof(buffer);
 724     status = pNtQueryValueKey( key, &value_str, KeyValuePartialInformation, info, len, &len );
 725     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 726     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + sizeof(DWORD), "wrong len %u\n", len );
 727
 728     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 729     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 730
 731     /* REG_LINK can be created in non-link keys */
 732     status = pNtSetValueKey( key, &symlink_str, 0, REG_LINK, target, target_len - sizeof(WCHAR) );
 733     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 734     len = sizeof(buffer);
 735     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 736     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 737     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 738         "wrong len %u\n", len );
 739     status = pNtDeleteValueKey( key, &symlink_str );
 740     ok( status == STATUS_SUCCESS, "NtDeleteValueKey failed: 0x%08x\n", status );
 741
 742     pNtClose( key );
 743
 744     attr.Attributes = 0;
 745     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 746     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 747
 748     len = sizeof(buffer);
 749     status = pNtQueryValueKey( key, &value_str, KeyValuePartialInformation, info, len, &len );
 750     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 751     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + sizeof(DWORD), "wrong len %u\n", len );
 752
 753     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 754     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 755     pNtClose( key );
 756
 757     /* now open the symlink itself */
 758
 759     attr.RootDirectory = root;
 760     attr.Attributes = OBJ_OPENLINK;
 761     attr.ObjectName = &link_str;
 762     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 763     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 764
 765     len = sizeof(buffer);
 766     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 767     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 768     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 769         "wrong len %u\n", len );
 770     pNtClose( key );
 771
 772     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 773     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 774     len = sizeof(buffer);
 775     status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 776     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 777     ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 778         "wrong len %u\n", len );
 779     pNtClose( key );
 780
 781     if (0)  /* crashes the Windows kernel on some Vista systems */
 782     {
 783         /* reopen the link from itself */
 784
 785         attr.RootDirectory = link;
 786         attr.Attributes = OBJ_OPENLINK;
 787         attr.ObjectName = &null_str;
 788         status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 789         ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 790         len = sizeof(buffer);
 791         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 792         ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 793         ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 794             "wrong len %u\n", len );
 795         pNtClose( key );
 796
 797         status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 798         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 799         len = sizeof(buffer);
 800         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 801         ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
 802         ok( len == FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,Data) + target_len - sizeof(WCHAR),
 803             "wrong len %u\n", len );
 804         pNtClose( key );
 805     }
 806
 807     if (0)  /* crashes the Windows kernel in most versions */
 808     {
 809         attr.RootDirectory = link;
 810         attr.Attributes = 0;
 811         attr.ObjectName = &null_str;
 812         status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 813         ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 814         len = sizeof(buffer);
 815         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 816         ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 817         pNtClose( key );
 818
 819         status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 820         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 821         len = sizeof(buffer);
 822         status = pNtQueryValueKey( key, &symlink_str, KeyValuePartialInformation, info, len, &len );
 823         ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtQueryValueKey failed: 0x%08x\n", status );
 824         pNtClose( key );
 825     }
 826
 827     /* target with terminating null doesn't work */
 828     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK, target, target_len );
 829     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 830     attr.RootDirectory = root;
 831     attr.Attributes = 0;
 832     attr.ObjectName = &link_str;
 833     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 834     ok( status == STATUS_OBJECT_NAME_NOT_FOUND, "NtOpenKey wrong status 0x%08x\n", status );
 835
 836     /* relative symlink, works only on win2k */
 837     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK, targetW+1, sizeof(targetW)-2*sizeof(WCHAR) );
 838     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 839     attr.ObjectName = &link_str;
 840     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 841     ok( status == STATUS_SUCCESS || status == STATUS_OBJECT_NAME_NOT_FOUND,
 842         "NtOpenKey wrong status 0x%08x\n", status );
 843
 844     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, REG_OPTION_CREATE_LINK, 0 );
 845     ok( status == STATUS_OBJECT_NAME_COLLISION, "NtCreateKey failed: 0x%08x\n", status );
 846
 847     status = pNtDeleteKey( link );
 848     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 849     pNtClose( link );
 850
 851     attr.ObjectName = &target_str;
 852     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 853     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 854     status = pNtDeleteKey( key );
 855     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 856     pNtClose( key );
 857
 858     /* symlink loop */
 859
 860     status = pNtCreateKey( &link, KEY_ALL_ACCESS, &attr, 0, 0, REG_OPTION_CREATE_LINK, 0 );
 861     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
 862     memcpy( target + target_len/sizeof(WCHAR) - 1, targetW, sizeof(targetW) );
 863     status = pNtSetValueKey( link, &symlink_str, 0, REG_LINK,
 864         target, target_len + sizeof(targetW) - sizeof(WCHAR) );
 865     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
 866
 867     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 868     ok( status == STATUS_OBJECT_NAME_NOT_FOUND || status == STATUS_NAME_TOO_LONG,
 869         "NtOpenKey failed: 0x%08x\n", status );
 870
 871     attr.Attributes = OBJ_OPENLINK;
 872     status = pNtOpenKey( &key, KEY_ALL_ACCESS, &attr );
 873     ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status );
 874     pNtClose( key );
 875
 876     status = pNtDeleteKey( link );
 877     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 878     pNtClose( link );
 879
 880     status = pNtDeleteKey( root );
 881     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
 882     pNtClose( root );
 883
 884     pRtlFreeHeap(GetProcessHeap(), 0, target);
 885 }
 886
 887 static WCHAR valueW[] = {'v','a','l','u','e'};
 888 static UNICODE_STRING value_str = { sizeof(valueW), sizeof(valueW), valueW };
 889 static const DWORD ptr_size = 8 * sizeof(void*);
 890
 891 static DWORD get_key_value( HANDLE root, const char *name, DWORD flags )
 892 {
 893     char tmp[32];
 894     NTSTATUS status;
 895     OBJECT_ATTRIBUTES attr;
 896     UNICODE_STRING str;
 897     HANDLE key;
 898     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
 899     DWORD dw, len = sizeof(tmp);
 900
 901     attr.Length = sizeof(attr);
 902     attr.RootDirectory = root;
 903     attr.Attributes = OBJ_CASE_INSENSITIVE;
 904     attr.ObjectName = &str;
 905     attr.SecurityDescriptor = NULL;
 906     attr.SecurityQualityOfService = NULL;
 907     pRtlCreateUnicodeStringFromAsciiz( &str, name );
 908
 909     status = pNtCreateKey( &key, flags | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
 910     if (status == STATUS_OBJECT_NAME_NOT_FOUND) return 0;
 911     ok( status == STATUS_SUCCESS, "%08x: NtCreateKey failed: 0x%08x\n", flags, status );
 912
 913     status = pNtQueryValueKey( key, &value_str, KeyValuePartialInformation, info, len, &len );
 914     if (status == STATUS_OBJECT_NAME_NOT_FOUND)
 915         dw = 0;
 916     else
 917     {
 918         ok( status == STATUS_SUCCESS, "%08x: NtQueryValueKey failed: 0x%08x\n", flags, status );
 919         dw = *(DWORD *)info->Data;
 920     }
 921     pNtClose( key );
 922     pRtlFreeUnicodeString( &str );
 923     return dw;
 924 }
 925
 926 static void _check_key_value( int line, HANDLE root, const char *name, DWORD flags, DWORD expect )
 927 {
 928     DWORD dw = get_key_value( root, name, flags );
 929     ok_(__FILE__,line)( dw == expect, "%08x: wrong value %u/%u\n", flags, dw, expect );
 930 }
 931 #define check_key_value(root,name,flags,expect) _check_key_value( __LINE__, root, name, flags, expect )
 932
 933 static void test_redirection(void)
 934 {
 935     static const WCHAR softwareW[] = {'\\','R','e','g','i','s','t','r','y','\\',
 936                                       'M','a','c','h','i','n','e','\\',
 937                                       'S','o','f','t','w','a','r','e',0};
 938     static const WCHAR wownodeW[] = {'\\','R','e','g','i','s','t','r','y','\\',
 939                                      'M','a','c','h','i','n','e','\\',
 940                                      'S','o','f','t','w','a','r','e','\\',
 941                                      'W','o','w','6','4','3','2','N','o','d','e',0};
 942     static const WCHAR wine64W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 943                                     'M','a','c','h','i','n','e','\\',
 944                                     'S','o','f','t','w','a','r','e','\\',
 945                                     'W','i','n','e',0};
 946     static const WCHAR wine32W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 947                                     'M','a','c','h','i','n','e','\\',
 948                                     'S','o','f','t','w','a','r','e','\\',
 949                                     'W','o','w','6','4','3','2','N','o','d','e','\\',
 950                                     'W','i','n','e',0};
 951     static const WCHAR key64W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 952                                    'M','a','c','h','i','n','e','\\',
 953                                    'S','o','f','t','w','a','r','e','\\',
 954                                    'W','i','n','e','\\','W','i','n','e','t','e','s','t',0};
 955     static const WCHAR key32W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 956                                    'M','a','c','h','i','n','e','\\',
 957                                    'S','o','f','t','w','a','r','e','\\',
 958                                    'W','o','w','6','4','3','2','N','o','d','e','\\',
 959                                    'W','i','n','e','\\', 'W','i','n','e','t','e','s','t',0};
 960     static const WCHAR classes64W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 961                                        'M','a','c','h','i','n','e','\\',
 962                                        'S','o','f','t','w','a','r','e','\\',
 963                                        'C','l','a','s','s','e','s','\\',
 964                                        'W','i','n','e',0};
 965     static const WCHAR classes32W[] = {'\\','R','e','g','i','s','t','r','y','\\',
 966                                        'M','a','c','h','i','n','e','\\',
 967                                        'S','o','f','t','w','a','r','e','\\',
 968                                        'C','l','a','s','s','e','s','\\',
 969                                        'W','o','w','6','4','3','2','N','o','d','e','\\',
 970                                        'W','i','n','e',0};
 971     NTSTATUS status;
 972     OBJECT_ATTRIBUTES attr;
 973     UNICODE_STRING str;
 974     char buffer[1024];
 975     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
 976     DWORD dw, len;
 977     HANDLE key, root32, root64, key32, key64;
 978     BOOL is_vista = FALSE;
 979
 980     if (ptr_size != 64)
 981     {
 982         ULONG is_wow64, len;
 983         if (pNtQueryInformationProcess( GetCurrentProcess(), ProcessWow64Information,
 984                                         &is_wow64, sizeof(is_wow64), &len ) ||
 985             !is_wow64)
 986         {
 987             trace( "Not on Wow64, no redirection\n" );
 988             return;
 989         }
 990     }
 991
 992     attr.Length = sizeof(attr);
 993     attr.RootDirectory = 0;
 994     attr.Attributes = OBJ_CASE_INSENSITIVE;
 995     attr.ObjectName = &str;
 996     attr.SecurityDescriptor = NULL;
 997     attr.SecurityQualityOfService = NULL;
 998
 999     pRtlInitUnicodeString( &str, wine64W );
1000     status = pNtCreateKey( &root64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1001     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1002
1003     pRtlInitUnicodeString( &str, wine32W );
1004     status = pNtCreateKey( &root32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1005     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1006
1007     pRtlInitUnicodeString( &str, key64W );
1008     status = pNtCreateKey( &key64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1009     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1010
1011     pRtlInitUnicodeString( &str, key32W );
1012     status = pNtCreateKey( &key32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1013     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1014
1015     dw = 64;
1016     status = pNtSetValueKey( key64, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1017     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1018
1019     dw = 32;
1020     status = pNtSetValueKey( key32, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1021     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1022
1023     len = sizeof(buffer);
1024     status = pNtQueryValueKey( key32, &value_str, KeyValuePartialInformation, info, len, &len );
1025     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1026     dw = *(DWORD *)info->Data;
1027     ok( dw == 32, "wrong value %u\n", dw );
1028
1029     len = sizeof(buffer);
1030     status = pNtQueryValueKey( key64, &value_str, KeyValuePartialInformation, info, len, &len );
1031     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1032     dw = *(DWORD *)info->Data;
1033     ok( dw == 64, "wrong value %u\n", dw );
1034
1035     pRtlInitUnicodeString( &str, softwareW );
1036     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1037     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1038
1039     if (ptr_size == 32)
1040     {
1041         /* the Vista mechanism allows opening Wow6432Node from a 32-bit key too */
1042         /* the new (and simpler) Win7 mechanism doesn't */
1043         if (get_key_value( key, "Wow6432Node\\Wine\\Winetest", 0 ) == 32)
1044         {
1045             trace( "using Vista-style Wow6432Node handling\n" );
1046             is_vista = TRUE;
1047         }
1048         check_key_value( key, "Wine\\Winetest", 0, 32 );
1049         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1050         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1051         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, is_vista ? 32 : 0 );
1052         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 0 );
1053         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, is_vista ? 32 : 0 );
1054     }
1055     else
1056     {
1057         check_key_value( key, "Wine\\Winetest", 0, 64 );
1058         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, 32 );
1059     }
1060     pNtClose( key );
1061
1062     if (ptr_size == 32)
1063     {
1064         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1065         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1066         dw = get_key_value( key, "Wine\\Winetest", 0 );
1067         ok( dw == 64 || broken(dw == 32) /* xp64 */, "wrong value %u\n", dw );
1068         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, 64 );
1069         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1070         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, 32 );
1071         dw = get_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY );
1072         ok( dw == 32 || broken(dw == 64) /* xp64 */, "wrong value %u\n", dw );
1073         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1074         pNtClose( key );
1075
1076         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1077         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1078         check_key_value( key, "Wine\\Winetest", 0, 32 );
1079         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1080         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1081         check_key_value( key, "Wow6432Node\\Wine\\Winetest", 0, is_vista ? 32 : 0 );
1082         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 0 );
1083         check_key_value( key, "Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, is_vista ? 32 : 0 );
1084         pNtClose( key );
1085     }
1086
1087     check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", 0, ptr_size );
1088     check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", 0, 32 );
1089     if (ptr_size == 64)
1090     {
1091         /* KEY_WOW64 flags have no effect on 64-bit */
1092         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_64KEY, 64 );
1093         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_32KEY, 64 );
1094         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, 32 );
1095         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1096     }
1097     else
1098     {
1099         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_64KEY, 64 );
1100         check_key_value( 0, "\\Registry\\Machine\\Software\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1101         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1102         check_key_value( 0, "\\Registry\\Machine\\Software\\Wow6432Node\\Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1103     }
1104
1105     pRtlInitUnicodeString( &str, wownodeW );
1106     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1107     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1108     check_key_value( key, "Wine\\Winetest", 0, 32 );
1109     check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, (ptr_size == 64) ? 32 : (is_vista ? 64 : 32) );
1110     check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1111     pNtClose( key );
1112
1113     if (ptr_size == 32)
1114     {
1115         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1116         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1117         dw = get_key_value( key, "Wine\\Winetest", 0 );
1118         ok( dw == (is_vista ? 64 : 32) || broken(dw == 32) /* xp64 */, "wrong value %u\n", dw );
1119         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1120         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1121         pNtClose( key );
1122
1123         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1124         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1125         check_key_value( key, "Wine\\Winetest", 0, 32 );
1126         check_key_value( key, "Wine\\Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1127         check_key_value( key, "Wine\\Winetest", KEY_WOW64_32KEY, 32 );
1128         pNtClose( key );
1129     }
1130
1131     pRtlInitUnicodeString( &str, wine32W );
1132     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1133     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1134     check_key_value( key, "Winetest", 0, 32 );
1135     check_key_value( key, "Winetest", KEY_WOW64_64KEY, (ptr_size == 32 && is_vista) ? 64 : 32 );
1136     check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1137     pNtClose( key );
1138
1139     if (ptr_size == 32)
1140     {
1141         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1142         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1143         dw = get_key_value( key, "Winetest", 0 );
1144         ok( dw == 32 || (is_vista && dw == 64), "wrong value %u\n", dw );
1145         check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1146         check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1147         pNtClose( key );
1148
1149         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1150         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1151         check_key_value( key, "Winetest", 0, 32 );
1152         check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1153         check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1154         pNtClose( key );
1155     }
1156
1157     pRtlInitUnicodeString( &str, wine64W );
1158     status = pNtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1159     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1160     check_key_value( key, "Winetest", 0, ptr_size );
1161     check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : ptr_size );
1162     check_key_value( key, "Winetest", KEY_WOW64_32KEY, ptr_size );
1163     pNtClose( key );
1164
1165     if (ptr_size == 32)
1166     {
1167         status = pNtCreateKey( &key, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1168         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1169         dw = get_key_value( key, "Winetest", 0 );
1170         ok( dw == 64 || broken(dw == 32) /* xp64 */, "wrong value %u\n", dw );
1171         check_key_value( key, "Winetest", KEY_WOW64_64KEY, 64 );
1172         dw = get_key_value( key, "Winetest", KEY_WOW64_32KEY );
1173         todo_wine ok( dw == 32, "wrong value %u\n", dw );
1174         pNtClose( key );
1175
1176         status = pNtCreateKey( &key, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1177         ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1178         check_key_value( key, "Winetest", 0, 32 );
1179         check_key_value( key, "Winetest", KEY_WOW64_64KEY, is_vista ? 64 : 32 );
1180         check_key_value( key, "Winetest", KEY_WOW64_32KEY, 32 );
1181         pNtClose( key );
1182     }
1183
1184     status = pNtDeleteKey( key32 );
1185     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
1186     pNtClose( key32 );
1187
1188     status = pNtDeleteKey( key64 );
1189     ok( status == STATUS_SUCCESS, "NtDeleteKey failed: 0x%08x\n", status );
1190     pNtClose( key64 );
1191
1192     pNtDeleteKey( root32 );
1193     pNtClose( root32 );
1194     pNtDeleteKey( root64 );
1195     pNtClose( root64 );
1196
1197     /* Software\Classes is shared/reflected so behavior is different */
1198
1199     pRtlInitUnicodeString( &str, classes64W );
1200     status = pNtCreateKey( &key64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1201     if (status == STATUS_ACCESS_DENIED)
1202     {
1203         skip("Not authorized to modify the Classes key\n");
1204         return;
1205     }
1206     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1207
1208     pRtlInitUnicodeString( &str, classes32W );
1209     status = pNtCreateKey( &key32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1210     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1211
1212     dw = 64;
1213     status = pNtSetValueKey( key64, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1214     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1215     pNtClose( key64 );
1216
1217     dw = 32;
1218     status = pNtSetValueKey( key32, &value_str, 0, REG_DWORD, &dw, sizeof(dw) );
1219     ok( status == STATUS_SUCCESS, "NtSetValueKey failed: 0x%08x\n", status );
1220     pNtClose( key32 );
1221
1222     pRtlInitUnicodeString( &str, classes64W );
1223     status = pNtCreateKey( &key64, KEY_WOW64_64KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1224     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1225     len = sizeof(buffer);
1226     status = pNtQueryValueKey( key64, &value_str, KeyValuePartialInformation, info, len, &len );
1227     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1228     dw = *(DWORD *)info->Data;
1229     ok( dw == ptr_size, "wrong value %u\n", dw );
1230
1231     pRtlInitUnicodeString( &str, classes32W );
1232     status = pNtCreateKey( &key32, KEY_WOW64_32KEY | KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1233     ok( status == STATUS_SUCCESS, "NtCreateKey failed: 0x%08x\n", status );
1234     len = sizeof(buffer);
1235     status = pNtQueryValueKey( key32, &value_str, KeyValuePartialInformation, info, len, &len );
1236     ok( status == STATUS_SUCCESS, "NtQueryValueKey failed: 0x%08x\n", status );
1237     dw = *(DWORD *)info->Data;
1238     ok( dw == 32, "wrong value %u\n", dw );
1239
1240     pNtDeleteKey( key32 );
1241     pNtClose( key32 );
1242     pNtDeleteKey( key64 );
1243     pNtClose( key64 );
1244 }
1245
1246 START_TEST(reg)
1247 {
1248     static const WCHAR winetest[] = {'\\','W','i','n','e','T','e','s','t',0};
1249     if(!InitFunctionPtrs())
1250         return;
1251     pRtlFormatCurrentUserKeyPath(&winetestpath);
1252     winetestpath.Buffer = pRtlReAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, winetestpath.Buffer,
1253                            winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR));
1254     winetestpath.MaximumLength = winetestpath.MaximumLength + sizeof(winetest)*sizeof(WCHAR);
1255
1256     pRtlAppendUnicodeToString(&winetestpath, winetest);
1257
1258     test_NtCreateKey();
1259     test_NtOpenKey();
1260     test_NtSetValueKey();
1261     test_RtlCheckRegistryKey();
1262     test_RtlOpenCurrentUser();
1263     test_RtlQueryRegistryValues();
1264     test_RtlpNtQueryValueKey();
1265     test_NtFlushKey();
1266     test_NtQueryValueKey();
1267     test_NtDeleteKey();
1268     test_symlinks();
1269     test_redirection();
1270
1271     pRtlFreeUnicodeString(&winetestpath);
1272
1273     FreeLibrary(hntdll);
1274 }