reg.c 46.2 KB
Newer Older
Juergen Schmied's avatar
Juergen Schmied committed
1
/*
2 3 4 5
 * Registry functions
 *
 * Copyright (C) 1999 Juergen Schmied
 * Copyright (C) 2000 Alexandre Julliard
6
 * Copyright 2005 Ivan Leo Puoti, Laurent Pinchart
7
 *
8 9 10 11 12 13 14 15 16 17 18 19
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21
 *
22 23 24 25 26
 * NOTES:
 * 	HKEY_LOCAL_MACHINE	\\REGISTRY\\MACHINE
 *	HKEY_USERS		\\REGISTRY\\USER
 *	HKEY_CURRENT_CONFIG	\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\HARDWARE PROFILES\\CURRENT
  *	HKEY_CLASSES		\\REGISTRY\\MACHINE\\SOFTWARE\\CLASSES
Juergen Schmied's avatar
Juergen Schmied committed
27 28
 */

29 30 31
#include "config.h"
#include "wine/port.h"

32
#include <stdarg.h>
33
#include <stdio.h>
34
#include <string.h>
35

36 37
#include "ntstatus.h"
#define WIN32_NO_STATUS
38
#include "wine/library.h"
39
#include "ntdll_misc.h"
40
#include "wine/debug.h"
41
#include "wine/unicode.h"
42

43
WINE_DEFAULT_DEBUG_CHANNEL(reg);
44

45 46 47 48
/* maximum length of a key name in bytes (without terminating null) */
#define MAX_NAME_LENGTH  (255 * sizeof(WCHAR))
/* maximum length of a value name in bytes (without terminating null) */
#define MAX_VALUE_LENGTH (16383 * sizeof(WCHAR))
49

50
/******************************************************************************
51
 * NtCreateKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
52
 * ZwCreateKey [NTDLL.@]
53
 */
54
NTSTATUS WINAPI NtCreateKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
55 56
                             ULONG TitleIndex, const UNICODE_STRING *class, ULONG options,
                             PULONG dispos )
57
{
58 59
    NTSTATUS ret;

60 61
    if (!retkey || !attr) return STATUS_ACCESS_VIOLATION;
    if (attr->Length > sizeof(OBJECT_ATTRIBUTES)) return STATUS_INVALID_PARAMETER;
62
    if (attr->ObjectName->Length > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
63

64
    TRACE( "(%p,%s,%s,%x,%x,%p)\n", attr->RootDirectory, debugstr_us(attr->ObjectName),
65 66
           debugstr_us(class), options, access, retkey );

67
    SERVER_START_REQ( create_key )
68
    {
69
        req->parent     = wine_server_obj_handle( attr->RootDirectory );
70 71 72 73
        req->access     = access;
        req->attributes = attr->Attributes;
        req->options    = options;
        req->namelen    = attr->ObjectName->Length;
74 75 76
        wine_server_add_data( req, attr->ObjectName->Buffer, attr->ObjectName->Length );
        if (class) wine_server_add_data( req, class->Buffer, class->Length );
        if (!(ret = wine_server_call( req )))
77
        {
78
            *retkey = wine_server_ptr_handle( reply->hkey );
79
            if (dispos) *dispos = reply->created ? REG_CREATED_NEW_KEY : REG_OPENED_EXISTING_KEY;
80
        }
81
    }
82
    SERVER_END_REQ;
Patrik Stridvall's avatar
Patrik Stridvall committed
83
    TRACE("<- %p\n", *retkey);
84
    return ret;
85 86
}

87 88 89 90 91
/******************************************************************************
 *  RtlpNtCreateKey [NTDLL.@]
 *
 *  See NtCreateKey.
 */
92
NTSTATUS WINAPI RtlpNtCreateKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
93 94 95
                                 ULONG TitleIndex, const UNICODE_STRING *class, ULONG options,
                                 PULONG dispos )
{
96 97
    OBJECT_ATTRIBUTES oa;

98
    if (attr)
99
    {
100
        oa = *attr;
101 102 103
        oa.Attributes &= ~(OBJ_PERMANENT|OBJ_EXCLUSIVE);
        attr = &oa;
    }
104 105 106

    return NtCreateKey(retkey, access, attr, 0, NULL, 0, dispos);
}
107

108
/******************************************************************************
109
 * NtOpenKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
110 111
 * ZwOpenKey [NTDLL.@]
 *
112
 *   OUT	HANDLE			retkey (returns 0 when failure)
113
 *   IN		ACCESS_MASK		access
114
 *   IN		POBJECT_ATTRIBUTES 	attr
115
 */
116
NTSTATUS WINAPI NtOpenKey( PHANDLE retkey, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
117
{
118
    NTSTATUS ret;
119
    DWORD len;
120

121 122
    if (!retkey || !attr) return STATUS_ACCESS_VIOLATION;
    if (attr->Length > sizeof(OBJECT_ATTRIBUTES)) return STATUS_INVALID_PARAMETER;
123
    len = attr->ObjectName->Length;
124
    TRACE( "(%p,%s,%x,%p)\n", attr->RootDirectory,
125
           debugstr_us(attr->ObjectName), access, retkey );
126

127
    if (len > MAX_NAME_LENGTH) return STATUS_BUFFER_OVERFLOW;
128

129
    SERVER_START_REQ( open_key )
130
    {
131
        req->parent     = wine_server_obj_handle( attr->RootDirectory );
132 133
        req->access     = access;
        req->attributes = attr->Attributes;
134 135
        wine_server_add_data( req, attr->ObjectName->Buffer, len );
        ret = wine_server_call( req );
136
        *retkey = wine_server_ptr_handle( reply->hkey );
137
    }
138
    SERVER_END_REQ;
Patrik Stridvall's avatar
Patrik Stridvall committed
139
    TRACE("<- %p\n", *retkey);
140
    return ret;
141 142
}

143 144 145 146 147
/******************************************************************************
 * RtlpNtOpenKey [NTDLL.@]
 *
 * See NtOpenKey.
 */
148
NTSTATUS WINAPI RtlpNtOpenKey( PHANDLE retkey, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr )
149 150 151 152 153
{
    if (attr)
        attr->Attributes &= ~(OBJ_PERMANENT|OBJ_EXCLUSIVE);
    return NtOpenKey(retkey, access, attr);
}
154

155
/******************************************************************************
156
 * NtDeleteKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
157
 * ZwDeleteKey [NTDLL.@]
158
 */
159
NTSTATUS WINAPI NtDeleteKey( HANDLE hkey )
160
{
161
    NTSTATUS ret;
162

163
    TRACE( "(%p)\n", hkey );
164

165
    SERVER_START_REQ( delete_key )
166
    {
167
        req->hkey = wine_server_obj_handle( hkey );
168
        ret = wine_server_call( req );
169 170 171
    }
    SERVER_END_REQ;
    return ret;
172 173
}

174 175 176 177 178
/******************************************************************************
 * RtlpNtMakeTemporaryKey [NTDLL.@]
 *
 *  See NtDeleteKey.
 */
179
NTSTATUS WINAPI RtlpNtMakeTemporaryKey( HANDLE hkey )
180 181 182
{
    return NtDeleteKey(hkey);
}
183

184
/******************************************************************************
185
 * NtDeleteValueKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
186
 * ZwDeleteValueKey [NTDLL.@]
187
 */
188
NTSTATUS WINAPI NtDeleteValueKey( HANDLE hkey, const UNICODE_STRING *name )
189
{
190 191
    NTSTATUS ret;

Patrik Stridvall's avatar
Patrik Stridvall committed
192
    TRACE( "(%p,%s)\n", hkey, debugstr_us(name) );
193
    if (name->Length > MAX_VALUE_LENGTH) return STATUS_BUFFER_OVERFLOW;
194

195
    SERVER_START_REQ( delete_key_value )
196
    {
197
        req->hkey = wine_server_obj_handle( hkey );
198 199
        wine_server_add_data( req, name->Buffer, name->Length );
        ret = wine_server_call( req );
200
    }
201
    SERVER_END_REQ;
202
    return ret;
203
}
204

205

206
/******************************************************************************
207
 *     enumerate_key
208
 *
209
 * Implementation of NtQueryKey and NtEnumerateKey
210
 */
211
static NTSTATUS enumerate_key( HANDLE handle, int index, KEY_INFORMATION_CLASS info_class,
212
                               void *info, DWORD length, DWORD *result_len )
213

214 215 216 217
{
    NTSTATUS ret;
    void *data_ptr;
    size_t fixed_size;
218 219 220

    switch(info_class)
    {
221 222 223
    case KeyBasicInformation: data_ptr = ((KEY_BASIC_INFORMATION *)info)->Name; break;
    case KeyFullInformation:  data_ptr = ((KEY_FULL_INFORMATION *)info)->Class; break;
    case KeyNodeInformation:  data_ptr = ((KEY_NODE_INFORMATION *)info)->Name;  break;
224
    case KeyNameInformation:  data_ptr = ((KEY_NAME_INFORMATION *)info)->Name;  break;
225
    default:
226
        FIXME( "Information class %d not implemented\n", info_class );
227 228
        return STATUS_INVALID_PARAMETER;
    }
229
    fixed_size = (char *)data_ptr - (char *)info;
230

231
    SERVER_START_REQ( enum_key )
232
    {
233
        req->hkey       = wine_server_obj_handle( handle );
234 235 236 237 238 239 240 241 242 243 244
        req->index      = index;
        req->info_class = info_class;
        if (length > fixed_size) wine_server_set_reply( req, data_ptr, length - fixed_size );
        if (!(ret = wine_server_call( req )))
        {
            switch(info_class)
            {
            case KeyBasicInformation:
                {
                    KEY_BASIC_INFORMATION keyinfo;
                    fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
245
                    keyinfo.LastWriteTime.QuadPart = reply->modif;
246 247 248 249 250 251 252 253 254
                    keyinfo.TitleIndex = 0;
                    keyinfo.NameLength = reply->namelen;
                    memcpy( info, &keyinfo, min( length, fixed_size ) );
                }
                break;
            case KeyFullInformation:
                {
                    KEY_FULL_INFORMATION keyinfo;
                    fixed_size = (char *)keyinfo.Class - (char *)&keyinfo;
255
                    keyinfo.LastWriteTime.QuadPart = reply->modif;
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
                    keyinfo.TitleIndex = 0;
                    keyinfo.ClassLength = wine_server_reply_size(reply);
                    keyinfo.ClassOffset = keyinfo.ClassLength ? fixed_size : -1;
                    keyinfo.SubKeys = reply->subkeys;
                    keyinfo.MaxNameLen = reply->max_subkey;
                    keyinfo.MaxClassLen = reply->max_class;
                    keyinfo.Values = reply->values;
                    keyinfo.MaxValueNameLen = reply->max_value;
                    keyinfo.MaxValueDataLen = reply->max_data;
                    memcpy( info, &keyinfo, min( length, fixed_size ) );
                }
                break;
            case KeyNodeInformation:
                {
                    KEY_NODE_INFORMATION keyinfo;
                    fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
272
                    keyinfo.LastWriteTime.QuadPart = reply->modif;
273
                    keyinfo.TitleIndex = 0;
274 275 276 277 278 279 280 281 282 283
                    if (reply->namelen < wine_server_reply_size(reply))
                    {
                        keyinfo.ClassLength = wine_server_reply_size(reply) - reply->namelen;
                        keyinfo.ClassOffset = fixed_size + reply->namelen;
                    }
                    else
                    {
                        keyinfo.ClassLength = 0;
                        keyinfo.ClassOffset = -1;
                    }
284 285 286 287
                    keyinfo.NameLength = reply->namelen;
                    memcpy( info, &keyinfo, min( length, fixed_size ) );
                }
                break;
288 289 290 291 292 293 294 295
            case KeyNameInformation:
                {
                    KEY_NAME_INFORMATION keyinfo;
                    fixed_size = (char *)keyinfo.Name - (char *)&keyinfo;
                    keyinfo.NameLength = reply->namelen;
                    memcpy( info, &keyinfo, min( length, fixed_size ) );
                }
                break;
296 297 298 299
            }
            *result_len = fixed_size + reply->total;
            if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
        }
300
    }
301 302
    SERVER_END_REQ;
    return ret;
303 304 305 306
}



307
/******************************************************************************
308
 * NtEnumerateKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
309
 * ZwEnumerateKey [NTDLL.@]
310 311
 *
 * NOTES
312
 *  the name copied into the buffer is NOT 0-terminated
313
 */
314
NTSTATUS WINAPI NtEnumerateKey( HANDLE handle, ULONG index, KEY_INFORMATION_CLASS info_class,
315
                                void *info, DWORD length, DWORD *result_len )
316
{
317 318
    /* -1 means query key, so avoid it here */
    if (index == (ULONG)-1) return STATUS_NO_MORE_ENTRIES;
319
    return enumerate_key( handle, index, info_class, info, length, result_len );
320 321
}

322

323 324 325 326
/******************************************************************************
 * RtlpNtEnumerateSubKey [NTDLL.@]
 *
 */
327
NTSTATUS WINAPI RtlpNtEnumerateSubKey( HANDLE handle, UNICODE_STRING *out, ULONG index )
328 329 330 331 332 333 334 335
{
  KEY_BASIC_INFORMATION *info;
  DWORD dwLen, dwResultLen;
  NTSTATUS ret;

  if (out->Length)
  {
    dwLen = out->Length + sizeof(KEY_BASIC_INFORMATION);
336
    info = RtlAllocateHeap( GetProcessHeap(), 0, dwLen );
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
    if (!info)
      return STATUS_NO_MEMORY;
  }
  else
  {
    dwLen = 0;
    info = NULL;
  }

  ret = NtEnumerateKey( handle, index, KeyBasicInformation, info, dwLen, &dwResultLen );
  dwResultLen -= sizeof(KEY_BASIC_INFORMATION);

  if (ret == STATUS_BUFFER_OVERFLOW)
    out->Length = dwResultLen;
  else if (!ret)
  {
    if (out->Length < info->NameLength)
    {
      out->Length = dwResultLen;
      ret = STATUS_BUFFER_OVERFLOW;
    }
    else
    {
      out->Length = info->NameLength;
      memcpy(out->Buffer, info->Name, info->NameLength);
    }
  }

365
  RtlFreeHeap( GetProcessHeap(), 0, info );
366 367 368
  return ret;
}

369
/******************************************************************************
370
 * NtQueryKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
371
 * ZwQueryKey [NTDLL.@]
372
 */
373
NTSTATUS WINAPI NtQueryKey( HANDLE handle, KEY_INFORMATION_CLASS info_class,
374
                            void *info, DWORD length, DWORD *result_len )
375
{
376
    return enumerate_key( handle, -1, info_class, info, length, result_len );
377 378 379
}


380 381 382
/* fill the key value info structure for a specific info class */
static void copy_key_value_info( KEY_VALUE_INFORMATION_CLASS info_class, void *info,
                                 DWORD length, int type, int name_len, int data_len )
383
{
384 385 386 387 388 389 390 391
    switch(info_class)
    {
    case KeyValueBasicInformation:
        {
            KEY_VALUE_BASIC_INFORMATION keyinfo;
            keyinfo.TitleIndex = 0;
            keyinfo.Type       = type;
            keyinfo.NameLength = name_len;
392
            length = min( length, (char *)keyinfo.Name - (char *)&keyinfo );
393 394 395 396 397 398 399 400
            memcpy( info, &keyinfo, length );
            break;
        }
    case KeyValueFullInformation:
        {
            KEY_VALUE_FULL_INFORMATION keyinfo;
            keyinfo.TitleIndex = 0;
            keyinfo.Type       = type;
401
            keyinfo.DataOffset = (char *)keyinfo.Name - (char *)&keyinfo + name_len;
402 403
            keyinfo.DataLength = data_len;
            keyinfo.NameLength = name_len;
404
            length = min( length, (char *)keyinfo.Name - (char *)&keyinfo );
405 406 407 408 409 410 411 412 413
            memcpy( info, &keyinfo, length );
            break;
        }
    case KeyValuePartialInformation:
        {
            KEY_VALUE_PARTIAL_INFORMATION keyinfo;
            keyinfo.TitleIndex = 0;
            keyinfo.Type       = type;
            keyinfo.DataLength = data_len;
414
            length = min( length, (char *)keyinfo.Data - (char *)&keyinfo );
415 416 417 418 419 420
            memcpy( info, &keyinfo, length );
            break;
        }
    default:
        break;
    }
421 422 423 424
}


/******************************************************************************
425
 *  NtEnumerateValueKey	[NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
426
 *  ZwEnumerateValueKey [NTDLL.@]
427
 */
428
NTSTATUS WINAPI NtEnumerateValueKey( HANDLE handle, ULONG index,
429 430
                                     KEY_VALUE_INFORMATION_CLASS info_class,
                                     void *info, DWORD length, DWORD *result_len )
431
{
432
    NTSTATUS ret;
433 434
    void *ptr;
    size_t fixed_size;
435

436
    TRACE( "(%p,%u,%d,%p,%d)\n", handle, index, info_class, info, length );
437 438 439 440

    /* compute the length we want to retrieve */
    switch(info_class)
    {
441 442 443
    case KeyValueBasicInformation:   ptr = ((KEY_VALUE_BASIC_INFORMATION *)info)->Name; break;
    case KeyValueFullInformation:    ptr = ((KEY_VALUE_FULL_INFORMATION *)info)->Name; break;
    case KeyValuePartialInformation: ptr = ((KEY_VALUE_PARTIAL_INFORMATION *)info)->Data; break;
444 445 446 447
    default:
        FIXME( "Information class %d not implemented\n", info_class );
        return STATUS_INVALID_PARAMETER;
    }
448
    fixed_size = (char *)ptr - (char *)info;
449

450
    SERVER_START_REQ( enum_key_value )
451
    {
452
        req->hkey       = wine_server_obj_handle( handle );
453 454 455 456
        req->index      = index;
        req->info_class = info_class;
        if (length > fixed_size) wine_server_set_reply( req, ptr, length - fixed_size );
        if (!(ret = wine_server_call( req )))
457
        {
458 459 460 461
            copy_key_value_info( info_class, info, length, reply->type, reply->namelen,
                                 wine_server_reply_size(reply) - reply->namelen );
            *result_len = fixed_size + reply->total;
            if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
462
        }
463 464
    }
    SERVER_END_REQ;
465
    return ret;
466 467
}

468

469
/******************************************************************************
470
 * NtQueryValueKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
471
 * ZwQueryValueKey [NTDLL.@]
472 473 474
 *
 * NOTES
 *  the name in the KeyValueInformation is never set
475
 */
476
NTSTATUS WINAPI NtQueryValueKey( HANDLE handle, const UNICODE_STRING *name,
477 478
                                 KEY_VALUE_INFORMATION_CLASS info_class,
                                 void *info, DWORD length, DWORD *result_len )
479
{
480
    NTSTATUS ret;
481
    UCHAR *data_ptr;
482
    unsigned int fixed_size = 0, min_size = 0;
483

484
    TRACE( "(%p,%s,%d,%p,%d)\n", handle, debugstr_us(name), info_class, info, length );
485

486
    if (name->Length > MAX_VALUE_LENGTH) return STATUS_BUFFER_OVERFLOW;
487

488 489 490 491
    /* compute the length we want to retrieve */
    switch(info_class)
    {
    case KeyValueBasicInformation:
492 493
    {
        KEY_VALUE_BASIC_INFORMATION *basic_info = info;
494 495 496 497
        min_size = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name);
        fixed_size = min_size + name->Length;
        if (min_size < length)
            memcpy(basic_info->Name, name->Buffer, min(length - min_size, name->Length));
498 499
        data_ptr = NULL;
        break;
500
    }
501
    case KeyValueFullInformation:
502 503
    {
        KEY_VALUE_FULL_INFORMATION *full_info = info;
504 505 506 507
        min_size = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name);
        fixed_size = min_size + name->Length;
        if (min_size < length)
            memcpy(full_info->Name, name->Buffer, min(length - min_size, name->Length));
508
        data_ptr = (UCHAR *)full_info->Name + name->Length;
509
        break;
510
    }
511
    case KeyValuePartialInformation:
512
        min_size = fixed_size = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
513
        data_ptr = ((KEY_VALUE_PARTIAL_INFORMATION *)info)->Data;
514 515 516 517 518
        break;
    default:
        FIXME( "Information class %d not implemented\n", info_class );
        return STATUS_INVALID_PARAMETER;
    }
519

520
    SERVER_START_REQ( get_key_value )
521
    {
522
        req->hkey = wine_server_obj_handle( handle );
523
        wine_server_add_data( req, name->Buffer, name->Length );
524
        if (length > fixed_size && data_ptr) wine_server_set_reply( req, data_ptr, length - fixed_size );
525
        if (!(ret = wine_server_call( req )))
526
        {
527
            copy_key_value_info( info_class, info, length, reply->type,
528
                                 name->Length, reply->total );
529
            *result_len = fixed_size + (info_class == KeyValueBasicInformation ? 0 : reply->total);
530 531
            if (length < min_size) ret = STATUS_BUFFER_TOO_SMALL;
            else if (length < *result_len) ret = STATUS_BUFFER_OVERFLOW;
532
        }
533 534
    }
    SERVER_END_REQ;
535
    return ret;
536 537
}

538 539 540 541
/******************************************************************************
 * RtlpNtQueryValueKey [NTDLL.@]
 *
 */
542
NTSTATUS WINAPI RtlpNtQueryValueKey( HANDLE handle, ULONG *result_type, PBYTE dest,
543
                                     DWORD *result_len, void *unknown )
544 545 546 547 548
{
    KEY_VALUE_PARTIAL_INFORMATION *info;
    UNICODE_STRING name;
    NTSTATUS ret;
    DWORD dwResultLen;
549
    DWORD dwLen = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + (result_len ? *result_len : 0);
550

551
    info = RtlAllocateHeap( GetProcessHeap(), 0, dwLen );
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
    if (!info)
      return STATUS_NO_MEMORY;

    name.Length = 0;
    ret = NtQueryValueKey( handle, &name, KeyValuePartialInformation, info, dwLen, &dwResultLen );

    if (!ret || ret == STATUS_BUFFER_OVERFLOW)
    {
        if (result_len)
            *result_len = info->DataLength;

        if (result_type)
            *result_type = info->Type;

        if (ret != STATUS_BUFFER_OVERFLOW)
            memcpy( dest, info->Data, info->DataLength );
    }

570
    RtlFreeHeap( GetProcessHeap(), 0, info );
571 572
    return ret;
}
573 574

/******************************************************************************
575
 *  NtFlushKey	[NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
576
 *  ZwFlushKey  [NTDLL.@]
577
 */
578
NTSTATUS WINAPI NtFlushKey(HANDLE key)
579
{
580 581 582 583 584 585
    NTSTATUS ret;

    TRACE("key=%p\n", key);

    SERVER_START_REQ( flush_key )
    {
586
	req->hkey = wine_server_obj_handle( key );
587 588 589 590 591
	ret = wine_server_call( req );
    }
    SERVER_END_REQ;
    
    return ret;
592 593 594
}

/******************************************************************************
595
 *  NtLoadKey	[NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
596
 *  ZwLoadKey   [NTDLL.@]
597
 */
James Hawkins's avatar
James Hawkins committed
598
NTSTATUS WINAPI NtLoadKey( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file )
599
{
James Hawkins's avatar
James Hawkins committed
600 601 602 603 604 605 606
    NTSTATUS ret;
    HANDLE hive;
    IO_STATUS_BLOCK io;

    TRACE("(%p,%p)\n", attr, file);

    ret = NtCreateFile(&hive, GENERIC_READ, file, &io, NULL, FILE_ATTRIBUTE_NORMAL, 0,
607
                       FILE_OPEN, 0, NULL, 0);
James Hawkins's avatar
James Hawkins committed
608 609 610 611
    if (ret) return ret;

    SERVER_START_REQ( load_registry )
    {
612 613
        req->hkey = wine_server_obj_handle( attr->RootDirectory );
        req->file = wine_server_obj_handle( hive );
James Hawkins's avatar
James Hawkins committed
614 615 616 617 618 619 620 621
        wine_server_add_data(req, attr->ObjectName->Buffer, attr->ObjectName->Length);
        ret = wine_server_call( req );
    }
    SERVER_END_REQ;

    NtClose(hive);
   
    return ret;
622 623 624
}

/******************************************************************************
625
 *  NtNotifyChangeKey	[NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
626
 *  ZwNotifyChangeKey   [NTDLL.@]
627 628
 */
NTSTATUS WINAPI NtNotifyChangeKey(
629
	IN HANDLE KeyHandle,
630 631 632 633 634
	IN HANDLE Event,
	IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
	IN PVOID ApcContext OPTIONAL,
	OUT PIO_STATUS_BLOCK IoStatusBlock,
	IN ULONG CompletionFilter,
635
	IN BOOLEAN Asynchronous,
636 637 638 639
	OUT PVOID ChangeBuffer,
	IN ULONG Length,
	IN BOOLEAN WatchSubtree)
{
640 641
    NTSTATUS ret;

642
    TRACE("(%p,%p,%p,%p,%p,0x%08x, 0x%08x,%p,0x%08x,0x%08x)\n",
643 644 645 646 647 648 649 650 651 652
        KeyHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, CompletionFilter,
        Asynchronous, ChangeBuffer, Length, WatchSubtree);

    if (ApcRoutine || ApcContext || ChangeBuffer || Length)
        FIXME("Unimplemented optional parameter\n");

    if (!Asynchronous)
    {
        OBJECT_ATTRIBUTES attr;
        InitializeObjectAttributes( &attr, NULL, 0, NULL, NULL );
653
        ret = NtCreateEvent( &Event, EVENT_ALL_ACCESS, &attr, SynchronizationEvent, FALSE );
654 655 656 657 658 659
        if (ret != STATUS_SUCCESS)
            return ret;
    }

    SERVER_START_REQ( set_registry_notification )
    {
660 661
        req->hkey    = wine_server_obj_handle( KeyHandle );
        req->event   = wine_server_obj_handle( Event );
662 663 664 665 666 667 668 669 670 671 672 673 674 675
        req->subtree = WatchSubtree;
        req->filter  = CompletionFilter;
        ret = wine_server_call( req );
    }
    SERVER_END_REQ;
 
    if (!Asynchronous)
    {
        if (ret == STATUS_SUCCESS)
            NtWaitForSingleObject( Event, FALSE, NULL );
        NtClose( Event );
    }

    return STATUS_SUCCESS;
676 677 678 679 680 681 682 683
}

/******************************************************************************
 * NtQueryMultipleValueKey [NTDLL]
 * ZwQueryMultipleValueKey
 */

NTSTATUS WINAPI NtQueryMultipleValueKey(
684
	HANDLE KeyHandle,
685
	PKEY_MULTIPLE_VALUE_INFORMATION ListOfValuesToQuery,
686 687 688 689 690
	ULONG NumberOfItems,
	PVOID MultipleValueInformation,
	ULONG Length,
	PULONG  ReturnLength)
{
691
	FIXME("(%p,%p,0x%08x,%p,0x%08x,%p) stub!\n",
692 693 694 695 696
	KeyHandle, ListOfValuesToQuery, NumberOfItems, MultipleValueInformation,
	Length,ReturnLength);
	return STATUS_SUCCESS;
}

697
/******************************************************************************
698
 * NtReplaceKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
699
 * ZwReplaceKey [NTDLL.@]
700 701 702
 */
NTSTATUS WINAPI NtReplaceKey(
	IN POBJECT_ATTRIBUTES ObjectAttributes,
703
	IN HANDLE Key,
704 705
	IN POBJECT_ATTRIBUTES ReplacedObjectAttributes)
{
706 707 708
    FIXME("(%s,%p,%s),stub!\n", debugstr_ObjectAttributes(ObjectAttributes), Key,
          debugstr_ObjectAttributes(ReplacedObjectAttributes) );
    return STATUS_SUCCESS;
709 710
}
/******************************************************************************
711
 * NtRestoreKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
712
 * ZwRestoreKey [NTDLL.@]
713 714
 */
NTSTATUS WINAPI NtRestoreKey(
715
	HANDLE KeyHandle,
716
	HANDLE FileHandle,
717 718
	ULONG RestoreFlags)
{
719
	FIXME("(%p,%p,0x%08x) stub\n",
720
	KeyHandle, FileHandle, RestoreFlags);
721
	return STATUS_SUCCESS;
722 723
}
/******************************************************************************
724
 * NtSaveKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
725
 * ZwSaveKey [NTDLL.@]
726
 */
727
NTSTATUS WINAPI NtSaveKey(IN HANDLE KeyHandle, IN HANDLE FileHandle)
728
{
729 730 731 732 733 734
    NTSTATUS ret;

    TRACE("(%p,%p)\n", KeyHandle, FileHandle);

    SERVER_START_REQ( save_registry )
    {
735 736
        req->hkey = wine_server_obj_handle( KeyHandle );
        req->file = wine_server_obj_handle( FileHandle );
737 738 739 740 741
        ret = wine_server_call( req );
    }
    SERVER_END_REQ;

    return ret;
742 743
}
/******************************************************************************
744
 * NtSetInformationKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
745
 * ZwSetInformationKey [NTDLL.@]
746 747
 */
NTSTATUS WINAPI NtSetInformationKey(
748
	IN HANDLE KeyHandle,
749 750 751 752
	IN const int KeyInformationClass,
	IN PVOID KeyInformation,
	IN ULONG KeyInformationLength)
{
753
	FIXME("(%p,0x%08x,%p,0x%08x) stub\n",
754
	KeyHandle, KeyInformationClass, KeyInformation, KeyInformationLength);
755
	return STATUS_SUCCESS;
756
}
757 758


759
/******************************************************************************
760
 * NtSetValueKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
761
 * ZwSetValueKey [NTDLL.@]
762 763
 *
 * NOTES
764
 *   win95 does not care about count for REG_SZ and finds out the len by itself (js)
765
 *   NT does definitely care (aj)
766
 */
767
NTSTATUS WINAPI NtSetValueKey( HANDLE hkey, const UNICODE_STRING *name, ULONG TitleIndex,
768
                               ULONG type, const void *data, ULONG count )
769
{
770 771
    NTSTATUS ret;

772
    TRACE( "(%p,%s,%d,%p,%d)\n", hkey, debugstr_us(name), type, data, count );
773

774
    if (name->Length > MAX_VALUE_LENGTH) return STATUS_BUFFER_OVERFLOW;
775

776
    SERVER_START_REQ( set_key_value )
777
    {
778
        req->hkey    = wine_server_obj_handle( hkey );
779 780 781 782 783 784 785
        req->type    = type;
        req->namelen = name->Length;
        wine_server_add_data( req, name->Buffer, name->Length );
        wine_server_add_data( req, data, count );
        ret = wine_server_call( req );
    }
    SERVER_END_REQ;
786
    return ret;
787 788
}

789 790 791 792
/******************************************************************************
 * RtlpNtSetValueKey [NTDLL.@]
 *
 */
793
NTSTATUS WINAPI RtlpNtSetValueKey( HANDLE hkey, ULONG type, const void *data,
794 795 796 797 798 799 800 801
                                   ULONG count )
{
    UNICODE_STRING name;

    name.Length = 0;
    return NtSetValueKey( hkey, &name, 0, type, data, count );
}

802
/******************************************************************************
803
 * NtUnloadKey [NTDLL.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
804
 * ZwUnloadKey [NTDLL.@]
805
 */
806
NTSTATUS WINAPI NtUnloadKey(IN POBJECT_ATTRIBUTES attr)
807
{
808 809
    NTSTATUS ret;

810
    TRACE("(%p)\n", attr);
811 812 813

    SERVER_START_REQ( unload_registry )
    {
814
        req->hkey = wine_server_obj_handle( attr->RootDirectory );
815 816 817 818 819
        ret = wine_server_call(req);
    }
    SERVER_END_REQ;

    return ret;
820 821 822
}

/******************************************************************************
823
 *  RtlFormatCurrentUserKeyPath		[NTDLL.@]
824
 *
825
 */
826
NTSTATUS WINAPI RtlFormatCurrentUserKeyPath( IN OUT PUNICODE_STRING KeyPath)
827
{
828
    static const WCHAR pathW[] = {'\\','R','e','g','i','s','t','r','y','\\','U','s','e','r','\\'};
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
    HANDLE token;
    NTSTATUS status;

    status = NtOpenThreadToken(GetCurrentThread(), TOKEN_READ, TRUE, &token);
    if (status == STATUS_NO_TOKEN)
        status = NtOpenProcessToken(GetCurrentProcess(), TOKEN_READ, &token);
    if (status == STATUS_SUCCESS)
    {
        char buffer[sizeof(TOKEN_USER) + sizeof(SID) + sizeof(DWORD)*SID_MAX_SUB_AUTHORITIES];
        DWORD len = sizeof(buffer);

        status = NtQueryInformationToken(token, TokenUser, buffer, len, &len);
        if (status == STATUS_SUCCESS)
        {
            KeyPath->MaximumLength = 0;
            status = RtlConvertSidToUnicodeString(KeyPath, ((TOKEN_USER *)buffer)->User.Sid, FALSE);
            if (status == STATUS_BUFFER_OVERFLOW)
            {
                PWCHAR buf = RtlAllocateHeap(GetProcessHeap(), 0,
                                             sizeof(pathW) + KeyPath->Length + sizeof(WCHAR));
                if (buf)
                {
                    memcpy(buf, pathW, sizeof(pathW));
                    KeyPath->MaximumLength = KeyPath->Length + sizeof(WCHAR);
                    KeyPath->Buffer = (PWCHAR)((LPBYTE)buf + sizeof(pathW));
                    status = RtlConvertSidToUnicodeString(KeyPath,
                                                          ((TOKEN_USER *)buffer)->User.Sid, FALSE);
856
                    KeyPath->Buffer = buf;
857 858 859 860 861 862 863 864 865 866
                    KeyPath->Length += sizeof(pathW);
                    KeyPath->MaximumLength += sizeof(pathW);
                }
                else
                    status = STATUS_NO_MEMORY;
            }
        }
        NtClose(token);
    }
    return status;
867 868 869
}

/******************************************************************************
870
 *  RtlOpenCurrentUser		[NTDLL.@]
871
 *
872 873 874
 * NOTES
 *  If we return just HKEY_CURRENT_USER the advapi tries to find a remote
 *  registry (odd handle) and fails.
875
 */
876
NTSTATUS WINAPI RtlOpenCurrentUser(
877
	IN ACCESS_MASK DesiredAccess, /* [in] */
878
	OUT PHANDLE KeyHandle)	      /* [out] handle of HKEY_CURRENT_USER */
879 880 881 882 883
{
	OBJECT_ATTRIBUTES ObjectAttributes;
	UNICODE_STRING ObjectName;
	NTSTATUS ret;

884
	TRACE("(0x%08x, %p)\n",DesiredAccess, KeyHandle);
885

886
        if ((ret = RtlFormatCurrentUserKeyPath(&ObjectName))) return ret;
887
	InitializeObjectAttributes(&ObjectAttributes,&ObjectName,OBJ_CASE_INSENSITIVE,0, NULL);
888
	ret = NtCreateKey(KeyHandle, DesiredAccess, &ObjectAttributes, 0, NULL, 0, NULL);
889 890
	RtlFreeUnicodeString(&ObjectName);
	return ret;
891
}
892 893 894 895 896 897 898 899 900 901 902 903 904 905


static NTSTATUS RTL_ReportRegistryValue(PKEY_VALUE_FULL_INFORMATION pInfo,
                                        PRTL_QUERY_REGISTRY_TABLE pQuery, PVOID pContext, PVOID pEnvironment)
{
    PUNICODE_STRING str;
    UNICODE_STRING src, dst;
    LONG *bin;
    ULONG offset;
    PWSTR wstr;
    DWORD res;
    NTSTATUS status = STATUS_SUCCESS;
    ULONG len;
    LPWSTR String;
906
    ULONG count = 0;
907 908 909 910

    if (pInfo == NULL)
    {
        if (pQuery->Flags & RTL_QUERY_REGISTRY_DIRECT)
911
            return STATUS_INVALID_PARAMETER;
912 913 914 915 916 917 918 919 920 921 922
        else
        {
            status = pQuery->QueryRoutine(pQuery->Name, pQuery->DefaultType, pQuery->DefaultData,
                                          pQuery->DefaultLength, pContext, pQuery->EntryContext);
        }
        return status;
    }
    len = pInfo->DataLength;

    if (pQuery->Flags & RTL_QUERY_REGISTRY_DIRECT)
    {
923 924
        str = pQuery->EntryContext;

925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
        switch(pInfo->Type)
        {
        case REG_EXPAND_SZ:
            if (!(pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND))
            {
                RtlInitUnicodeString(&src, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
                res = 0;
                dst.MaximumLength = 0;
                RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
                dst.Length = 0;
                dst.MaximumLength = res;
                dst.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, res * sizeof(WCHAR));
                RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
                status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, dst.Buffer,
                                     dst.Length, pContext, pQuery->EntryContext);
                RtlFreeHeap(GetProcessHeap(), 0, dst.Buffer);
            }

        case REG_SZ:
        case REG_LINK:
            if (str->Buffer == NULL)
                RtlCreateUnicodeString(str, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
            else
                RtlAppendUnicodeToString(str, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
            break;

        case REG_MULTI_SZ:
            if (!(pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND))
                return STATUS_INVALID_PARAMETER;

            if (str->Buffer == NULL)
            {
                str->Buffer = RtlAllocateHeap(GetProcessHeap(), 0, len);
                str->MaximumLength = len;
            }
            len = min(len, str->MaximumLength);
            memcpy(str->Buffer, ((CHAR*)pInfo) + pInfo->DataOffset, len);
            str->Length = len;
            break;

        default:
966
            bin = pQuery->EntryContext;
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
            if (pInfo->DataLength <= sizeof(ULONG))
                memcpy(bin, ((CHAR*)pInfo) + pInfo->DataOffset,
                    pInfo->DataLength);
            else
            {
                if (bin[0] <= sizeof(ULONG))
                {
                    memcpy(&bin[1], ((CHAR*)pInfo) + pInfo->DataOffset,
                    min(-bin[0], pInfo->DataLength));
                }
                else
                {
                   len = min(bin[0], pInfo->DataLength);
                    bin[1] = len;
                    bin[2] = pInfo->Type;
                    memcpy(&bin[3], ((CHAR*)pInfo) + pInfo->DataOffset, len);
                }
           }
           break;
        }
    }
    else
    {
        if((pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND) ||
           (pInfo->Type != REG_EXPAND_SZ && pInfo->Type != REG_MULTI_SZ))
        {
993
            status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type,
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
                ((CHAR*)pInfo) + pInfo->DataOffset, pInfo->DataLength,
                pContext, pQuery->EntryContext);
        }
        else if (pInfo->Type == REG_EXPAND_SZ)
        {
            RtlInitUnicodeString(&src, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
            res = 0;
            dst.MaximumLength = 0;
            RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
            dst.Length = 0;
            dst.MaximumLength = res;
            dst.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, res * sizeof(WCHAR));
            RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
            status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, dst.Buffer,
                                          dst.Length, pContext, pQuery->EntryContext);
            RtlFreeHeap(GetProcessHeap(), 0, dst.Buffer);
        }
        else /* REG_MULTI_SZ */
        {
            if(pQuery->Flags & RTL_QUERY_REGISTRY_NOEXPAND)
            {
                for (offset = 0; offset <= pInfo->DataLength; offset += len + sizeof(WCHAR))
                    {
                    wstr = (WCHAR*)(((CHAR*)pInfo) + offset);
                    len = strlenW(wstr) * sizeof(WCHAR);
                    status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, wstr, len,
                        pContext, pQuery->EntryContext);
                    if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
                        return status;
                    }
            }
            else
            {
                while(count<=pInfo->DataLength)
                {
                    String = (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset)+count;
                    count+=strlenW(String)+1;
                    RtlInitUnicodeString(&src, (WCHAR*)(((CHAR*)pInfo) + pInfo->DataOffset));
                    res = 0;
                    dst.MaximumLength = 0;
                    RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
                    dst.Length = 0;
                    dst.MaximumLength = res;
                    dst.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, res * sizeof(WCHAR));
                    RtlExpandEnvironmentStrings_U(pEnvironment, &src, &dst, &res);
                    status = pQuery->QueryRoutine(pQuery->Name, pInfo->Type, dst.Buffer,
                                                  dst.Length, pContext, pQuery->EntryContext);
                    RtlFreeHeap(GetProcessHeap(), 0, dst.Buffer);
                    if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
                        return status;
                }
            }
        }
    }
    return status;
}


1052
static NTSTATUS RTL_GetKeyHandle(ULONG RelativeTo, PCWSTR Path, PHANDLE handle)
1053 1054 1055 1056 1057 1058 1059 1060 1061
{
    UNICODE_STRING KeyString;
    OBJECT_ATTRIBUTES regkey;
    PCWSTR base;
    INT len;
    NTSTATUS status;

    static const WCHAR empty[] = {0};
    static const WCHAR control[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e',
1062
    '\\','S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
    'C','o','n','t','r','o','l','\\',0};

    static const WCHAR devicemap[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
    'H','a','r','d','w','a','r','e','\\','D','e','v','i','c','e','M','a','p','\\',0};

    static const WCHAR services[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
    'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
    'S','e','r','v','i','c','e','s','\\',0};

    static const WCHAR user[] = {'\\','R','e','g','i','s','t','r','y','\\','U','s','e','r','\\',
    'C','u','r','r','e','n','t','U','s','e','r','\\',0};

    static const WCHAR windows_nt[] = {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
    'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
    'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',0};

    switch (RelativeTo & 0xff)
    {
    case RTL_REGISTRY_ABSOLUTE:
        base = empty;
        break;

    case RTL_REGISTRY_CONTROL:
        base = control;
        break;

    case RTL_REGISTRY_DEVICEMAP:
        base = devicemap;
        break;

    case RTL_REGISTRY_SERVICES:
        base = services;
        break;

    case RTL_REGISTRY_USER:
        base = user;
        break;

    case RTL_REGISTRY_WINDOWS_NT:
        base = windows_nt;
        break;

    default:
        return STATUS_INVALID_PARAMETER;
    }

    len = (strlenW(base) + strlenW(Path) + 1) * sizeof(WCHAR);
    KeyString.Buffer = RtlAllocateHeap(GetProcessHeap(), 0, len);
    if (KeyString.Buffer == NULL)
        return STATUS_NO_MEMORY;

    strcpyW(KeyString.Buffer, base);
    strcatW(KeyString.Buffer, Path);
    KeyString.Length = len - sizeof(WCHAR);
    KeyString.MaximumLength = len;
1118
    InitializeObjectAttributes(&regkey, &KeyString, OBJ_CASE_INSENSITIVE, NULL, NULL);
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
    status = NtOpenKey(handle, KEY_ALL_ACCESS, &regkey);
    RtlFreeHeap(GetProcessHeap(), 0, KeyString.Buffer);
    return status;
}

/*************************************************************************
 * RtlQueryRegistryValues   [NTDLL.@]
 *
 * Query multiple registry values with a signle call.
 *
 * PARAMS
 *  RelativeTo  [I] Registry path that Path refers to
 *  Path        [I] Path to key
 *  QueryTable  [I] Table of key values to query
Austin English's avatar
Austin English committed
1133 1134
 *  Context     [I] Parameter to pass to the application defined QueryRoutine function
 *  Environment [I] Optional parameter to use when performing expansion
1135 1136 1137 1138 1139 1140 1141 1142 1143
 *
 * RETURNS
 *  STATUS_SUCCESS or an appropriate NTSTATUS error code.
 */
NTSTATUS WINAPI RtlQueryRegistryValues(IN ULONG RelativeTo, IN PCWSTR Path,
                                       IN PRTL_QUERY_REGISTRY_TABLE QueryTable, IN PVOID Context,
                                       IN PVOID Environment OPTIONAL)
{
    UNICODE_STRING Value;
1144
    HANDLE handle, topkey;
1145 1146 1147 1148 1149
    PKEY_VALUE_FULL_INFORMATION pInfo = NULL;
    ULONG len, buflen = 0;
    NTSTATUS status=STATUS_SUCCESS, ret = STATUS_SUCCESS;
    INT i;

1150
    TRACE("(%d, %s, %p, %p, %p)\n", RelativeTo, debugstr_w(Path), QueryTable, Context, Environment);
1151

1152 1153 1154
    if(Path == NULL)
        return STATUS_INVALID_PARAMETER;

1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
    /* get a valid handle */
    if (RelativeTo & RTL_REGISTRY_HANDLE)
        topkey = handle = (HANDLE)Path;
    else
    {
        status = RTL_GetKeyHandle(RelativeTo, Path, &topkey);
        handle = topkey;
    }
    if(status != STATUS_SUCCESS)
        return status;

    /* Process query table entries */
    for (; QueryTable->QueryRoutine != NULL || QueryTable->Name != NULL; ++QueryTable)
    {
        if (QueryTable->Flags &
            (RTL_QUERY_REGISTRY_SUBKEY | RTL_QUERY_REGISTRY_TOPKEY))
        {
            /* topkey must be kept open just in case we will reuse it later */
            if (handle != topkey)
                NtClose(handle);

            if (QueryTable->Flags & RTL_QUERY_REGISTRY_SUBKEY)
            {
                handle = 0;
1179
                status = RTL_GetKeyHandle(PtrToUlong(QueryTable->Name), Path, &handle);
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
                if(status != STATUS_SUCCESS)
                {
                    ret = status;
                    goto out;
                }
            }
            else
                handle = topkey;
        }

        if (QueryTable->Flags & RTL_QUERY_REGISTRY_NOVALUE)
        {
            QueryTable->QueryRoutine(QueryTable->Name, REG_NONE, NULL, 0,
                Context, QueryTable->EntryContext);
            continue;
        }

        if (!handle)
        {
            if (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED)
            {
                ret = STATUS_OBJECT_NAME_NOT_FOUND;
                goto out;
            }
            continue;
        }

        if (QueryTable->Name == NULL)
        {
            if (QueryTable->Flags & RTL_QUERY_REGISTRY_DIRECT)
            {
                ret = STATUS_INVALID_PARAMETER;
                goto out;
            }

            /* Report all subkeys */
            for (i = 0;; ++i)
            {
                status = NtEnumerateValueKey(handle, i,
                    KeyValueFullInformation, pInfo, buflen, &len);
                if (status == STATUS_NO_MORE_ENTRIES)
                    break;
                if (status == STATUS_BUFFER_OVERFLOW ||
                    status == STATUS_BUFFER_TOO_SMALL)
                {
                    buflen = len;
                    RtlFreeHeap(GetProcessHeap(), 0, pInfo);
1227
                    pInfo = RtlAllocateHeap(GetProcessHeap(), 0, buflen);
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
                    NtEnumerateValueKey(handle, i, KeyValueFullInformation,
                        pInfo, buflen, &len);
                }

                status = RTL_ReportRegistryValue(pInfo, QueryTable, Context, Environment);
                if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
                {
                    ret = status;
                    goto out;
                }
                if (QueryTable->Flags & RTL_QUERY_REGISTRY_DELETE)
                {
                    RtlInitUnicodeString(&Value, pInfo->Name);
                    NtDeleteValueKey(handle, &Value);
                }
            }

            if (i == 0  && (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED))
            {
                ret = STATUS_OBJECT_NAME_NOT_FOUND;
                goto out;
            }
        }
        else
        {
            RtlInitUnicodeString(&Value, QueryTable->Name);
            status = NtQueryValueKey(handle, &Value, KeyValueFullInformation,
                pInfo, buflen, &len);
            if (status == STATUS_BUFFER_OVERFLOW ||
                status == STATUS_BUFFER_TOO_SMALL)
            {
                buflen = len;
                RtlFreeHeap(GetProcessHeap(), 0, pInfo);
1261
                pInfo = RtlAllocateHeap(GetProcessHeap(), 0, buflen);
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
                status = NtQueryValueKey(handle, &Value,
                    KeyValueFullInformation, pInfo, buflen, &len);
            }
            if (status != STATUS_SUCCESS)
            {
                if (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED)
                {
                    ret = STATUS_OBJECT_NAME_NOT_FOUND;
                    goto out;
                }
                status = RTL_ReportRegistryValue(NULL, QueryTable, Context, Environment);
                if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
                {
                    ret = status;
                    goto out;
                }
            }
            else
            {
                status = RTL_ReportRegistryValue(pInfo, QueryTable, Context, Environment);
                if(status != STATUS_SUCCESS && status != STATUS_BUFFER_TOO_SMALL)
                {
                    ret = status;
                    goto out;
                }
                if (QueryTable->Flags & RTL_QUERY_REGISTRY_DELETE)
                    NtDeleteValueKey(handle, &Value);
            }
        }
    }

out:
    RtlFreeHeap(GetProcessHeap(), 0, pInfo);
    if (handle != topkey)
        NtClose(handle);
    NtClose(topkey);
    return ret;
}

/*************************************************************************
 * RtlCheckRegistryKey   [NTDLL.@]
 *
 * Query multiple registry values with a signle call.
 *
 * PARAMS
 *  RelativeTo [I] Registry path that Path refers to
 *  Path       [I] Path to key
 *
 * RETURNS
 *  STATUS_SUCCESS if the specified key exists, or an NTSTATUS error code.
 */
1313
NTSTATUS WINAPI RtlCheckRegistryKey(IN ULONG RelativeTo, IN PWSTR Path)
1314
{
1315
    HANDLE handle;
1316 1317
    NTSTATUS status;

1318
    TRACE("(%d, %s)\n", RelativeTo, debugstr_w(Path));
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341

    if((!RelativeTo) && Path == NULL)
        return STATUS_OBJECT_PATH_SYNTAX_BAD;
    if(RelativeTo & RTL_REGISTRY_HANDLE)
        return STATUS_SUCCESS;

    status = RTL_GetKeyHandle(RelativeTo, Path, &handle);
    if (handle) NtClose(handle);
    if (status == STATUS_INVALID_HANDLE) status = STATUS_OBJECT_NAME_NOT_FOUND;
    return status;
}

/*************************************************************************
 * RtlDeleteRegistryValue   [NTDLL.@]
 *
 * Query multiple registry values with a signle call.
 *
 * PARAMS
 *  RelativeTo [I] Registry path that Path refers to
 *  Path       [I] Path to key
 *  ValueName  [I] Name of the value to delete
 *
 * RETURNS
1342
 *  STATUS_SUCCESS if the specified key is successfully deleted, or an NTSTATUS error code.
1343
 */
1344
NTSTATUS WINAPI RtlDeleteRegistryValue(IN ULONG RelativeTo, IN PCWSTR Path, IN PCWSTR ValueName)
1345 1346
{
    NTSTATUS status;
1347
    HANDLE handle;
1348 1349
    UNICODE_STRING Value;

1350
    TRACE("(%d, %s, %s)\n", RelativeTo, debugstr_w(Path), debugstr_w(ValueName));
1351 1352 1353 1354

    RtlInitUnicodeString(&Value, ValueName);
    if(RelativeTo == RTL_REGISTRY_HANDLE)
    {
1355
        return NtDeleteValueKey((HANDLE)Path, &Value);
1356 1357 1358 1359 1360 1361 1362
    }
    status = RTL_GetKeyHandle(RelativeTo, Path, &handle);
    if (status) return status;
    status = NtDeleteValueKey(handle, &Value);
    NtClose(handle);
    return status;
}
1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403

/*************************************************************************
 * RtlWriteRegistryValue   [NTDLL.@]
 *
 * Sets the registry value with provided data.
 *
 * PARAMS
 *  RelativeTo [I] Registry path that path parameter refers to
 *  path       [I] Path to the key (or handle - see RTL_GetKeyHandle)
 *  name       [I] Name of the registry value to set
 *  type       [I] Type of the registry key to set
 *  data       [I] Pointer to the user data to be set
 *  length     [I] Length of the user data pointed by data
 *
 * RETURNS
 *  STATUS_SUCCESS if the specified key is successfully set,
 *  or an NTSTATUS error code.
 */
NTSTATUS WINAPI RtlWriteRegistryValue( ULONG RelativeTo, PCWSTR path, PCWSTR name,
                                       ULONG type, PVOID data, ULONG length )
{
    HANDLE hkey;
    NTSTATUS status;
    UNICODE_STRING str;

    TRACE( "(%d, %s, %s) -> %d: %p [%d]\n", RelativeTo, debugstr_w(path), debugstr_w(name),
           type, data, length );

    RtlInitUnicodeString( &str, name );

    if (RelativeTo == RTL_REGISTRY_HANDLE)
        return NtSetValueKey( (HANDLE)path, &str, 0, type, data, length );

    status = RTL_GetKeyHandle( RelativeTo, path, &hkey );
    if (status != STATUS_SUCCESS) return status;

    status = NtSetValueKey( hkey, &str, 0, type, data, length );
    NtClose( hkey );

    return status;
}