?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Partially implement RegOpenUserClassesRoot.
[wine/wine-kai.git] / dlls / advapi32 / registry.c
blob45508e0826fa7d8107fc7458eb1d683074c4c294
1 /*
2 * Registry management
3 *
4 * Copyright (C) 1999 Alexandre Julliard
5 *
6 * Based on misc/registry.c code
7 * Copyright (C) 1996 Marcus Meissner
8 * Copyright (C) 1998 Matthew Becker
9 * Copyright (C) 1999 Sylvain St-Germain
10 *
11 * This file is concerned about handle management and interaction with the Wine server.
12 * Registry file I/O is in misc/registry.c.
13 *
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
18 *
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
23 *
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 */
28
29 #include <stdlib.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "winreg.h"
36 #include "winerror.h"
37 #include "ntstatus.h"
38 #include "wine/unicode.h"
39 #include "wine/server.h"
40 #include "wine/debug.h"
41 #include "winternl.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(reg);
44
45 /* allowed bits for access mask */
46 #define KEY_ACCESS_MASK (KEY_ALL_ACCESS | MAXIMUM_ALLOWED)
47
48 #define HKEY_SPECIAL_ROOT_FIRST HKEY_CLASSES_ROOT
49 #define HKEY_SPECIAL_ROOT_LAST HKEY_DYN_DATA
50 #define NB_SPECIAL_ROOT_KEYS ((UINT)HKEY_SPECIAL_ROOT_LAST - (UINT)HKEY_SPECIAL_ROOT_FIRST + 1)
51
52 static HKEY special_root_keys[NB_SPECIAL_ROOT_KEYS];
53
54 static const WCHAR name_CLASSES_ROOT[] =
55 {'M','a','c','h','i','n','e','\\',
56 'S','o','f','t','w','a','r','e','\\',
57 'C','l','a','s','s','e','s',0};
58 static const WCHAR name_LOCAL_MACHINE[] =
59 {'M','a','c','h','i','n','e',0};
60 static const WCHAR name_USERS[] =
61 {'U','s','e','r',0};
62 static const WCHAR name_PERFORMANCE_DATA[] =
63 {'P','e','r','f','D','a','t','a',0};
64 static const WCHAR name_CURRENT_CONFIG[] =
65 {'M','a','c','h','i','n','e','\\',
66 'S','y','s','t','e','m','\\',
67 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
68 'H','a','r','d','w','a','r','e','P','r','o','f','i','l','e','s','\\',
69 'C','u','r','r','e','n','t',0};
70 static const WCHAR name_DYN_DATA[] =
71 {'D','y','n','D','a','t','a',0};
72
73 #define DECL_STR(key) { sizeof(name_##key)-sizeof(WCHAR), sizeof(name_##key), (LPWSTR)name_##key }
74 static UNICODE_STRING root_key_names[NB_SPECIAL_ROOT_KEYS] =
75 {
76 DECL_STR(CLASSES_ROOT),
77 { 0, 0, NULL }, /* HKEY_CURRENT_USER is determined dynamically */
78 DECL_STR(LOCAL_MACHINE),
79 DECL_STR(USERS),
80 DECL_STR(PERFORMANCE_DATA),
81 DECL_STR(CURRENT_CONFIG),
82 DECL_STR(DYN_DATA)
83 };
84 #undef DECL_STR
85
86
87 /* check if value type needs string conversion (Ansi<->Unicode) */
88 inline static int is_string( DWORD type )
89 {
90 return (type == REG_SZ) || (type == REG_EXPAND_SZ) || (type == REG_MULTI_SZ);
91 }
92
93 /* check if current version is NT or Win95 */
94 inline static int is_version_nt(void)
95 {
96 return !(GetVersion() & 0x80000000);
97 }
98
99 /* create one of the HKEY_* special root keys */
100 static HKEY create_special_root_hkey( HKEY hkey, DWORD access )
101 {
102 HKEY ret = 0;
103 int idx = (UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST;
104
105 if (hkey == HKEY_CURRENT_USER)
106 {
107 if (RtlOpenCurrentUser( access, &hkey )) return 0;
108 TRACE( "HKEY_CURRENT_USER -> %p\n", hkey );
109 }
110 else
111 {
112 OBJECT_ATTRIBUTES attr;
113
114 attr.Length = sizeof(attr);
115 attr.RootDirectory = 0;
116 attr.ObjectName = &root_key_names[idx];
117 attr.Attributes = 0;
118 attr.SecurityDescriptor = NULL;
119 attr.SecurityQualityOfService = NULL;
120 if (NtCreateKey( &hkey, access, &attr, 0, NULL, 0, NULL )) return 0;
121 TRACE( "%s -> %p\n", debugstr_w(attr.ObjectName->Buffer), hkey );
122 }
123
124 if (!(ret = InterlockedCompareExchangePointer( (void **)&special_root_keys[idx], hkey, 0 )))
125 ret = hkey;
126 else
127 NtClose( hkey ); /* somebody beat us to it */
128 return ret;
129 }
130
131 /* map the hkey from special root to normal key if necessary */
132 inline static HKEY get_special_root_hkey( HKEY hkey )
133 {
134 HKEY ret = hkey;
135
136 if ((hkey >= HKEY_SPECIAL_ROOT_FIRST) && (hkey <= HKEY_SPECIAL_ROOT_LAST))
137 {
138 if (!(ret = special_root_keys[(UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST]))
139 ret = create_special_root_hkey( hkey, KEY_ALL_ACCESS );
140 }
141 return ret;
142 }
143
144
145 /******************************************************************************
146 * RegCreateKeyExW [ADVAPI32.@]
147 *
148 * PARAMS
149 * hkey [I] Handle of an open key
150 * name [I] Address of subkey name
151 * reserved [I] Reserved - must be 0
152 * class [I] Address of class string
153 * options [I] Special options flag
154 * access [I] Desired security access
155 * sa [I] Address of key security structure
156 * retkey [O] Address of buffer for opened handle
157 * dispos [O] Receives REG_CREATED_NEW_KEY or REG_OPENED_EXISTING_KEY
158 *
159 * NOTES
160 * in case of failing retkey remains untouched
161 *
162 * FIXME MAXIMUM_ALLOWED in access mask not supported by server
163 */
164 DWORD WINAPI RegCreateKeyExW( HKEY hkey, LPCWSTR name, DWORD reserved, LPCWSTR class,
165 DWORD options, REGSAM access, SECURITY_ATTRIBUTES *sa,
166 PHKEY retkey, LPDWORD dispos )
167 {
168 OBJECT_ATTRIBUTES attr;
169 UNICODE_STRING nameW, classW;
170
171 if (reserved) return ERROR_INVALID_PARAMETER;
172 if (!(access & KEY_ACCESS_MASK) || (access & ~KEY_ACCESS_MASK)) return ERROR_ACCESS_DENIED;
173 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
174
175 attr.Length = sizeof(attr);
176 attr.RootDirectory = hkey;
177 attr.ObjectName = &nameW;
178 attr.Attributes = 0;
179 attr.SecurityDescriptor = NULL;
180 attr.SecurityQualityOfService = NULL;
181 RtlInitUnicodeString( &nameW, name );
182 RtlInitUnicodeString( &classW, class );
183
184 return RtlNtStatusToDosError( NtCreateKey( retkey, access, &attr, 0,
185 &classW, options, dispos ) );
186 }
187
188
189 /******************************************************************************
190 * RegCreateKeyExA [ADVAPI32.@]
191 *
192 * FIXME MAXIMUM_ALLOWED in access mask not supported by server
193 */
194 DWORD WINAPI RegCreateKeyExA( HKEY hkey, LPCSTR name, DWORD reserved, LPCSTR class,
195 DWORD options, REGSAM access, SECURITY_ATTRIBUTES *sa,
196 PHKEY retkey, LPDWORD dispos )
197 {
198 OBJECT_ATTRIBUTES attr;
199 UNICODE_STRING classW;
200 ANSI_STRING nameA, classA;
201 NTSTATUS status;
202
203 if (reserved) return ERROR_INVALID_PARAMETER;
204 if (!is_version_nt()) access = KEY_ALL_ACCESS; /* Win95 ignores the access mask */
205 else if (!(access & KEY_ACCESS_MASK) || (access & ~KEY_ACCESS_MASK)) return ERROR_ACCESS_DENIED;
206 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
207
208 attr.Length = sizeof(attr);
209 attr.RootDirectory = hkey;
210 attr.ObjectName = &NtCurrentTeb()->StaticUnicodeString;
211 attr.Attributes = 0;
212 attr.SecurityDescriptor = NULL;
213 attr.SecurityQualityOfService = NULL;
214 RtlInitAnsiString( &nameA, name );
215 RtlInitAnsiString( &classA, class );
216
217 if (!(status = RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString,
218 &nameA, FALSE )))
219 {
220 if (!(status = RtlAnsiStringToUnicodeString( &classW, &classA, TRUE )))
221 {
222 status = NtCreateKey( retkey, access, &attr, 0, &classW, options, dispos );
223 RtlFreeUnicodeString( &classW );
224 }
225 }
226 return RtlNtStatusToDosError( status );
227 }
228
229
230 /******************************************************************************
231 * RegCreateKeyW [ADVAPI32.@]
232 */
233 DWORD WINAPI RegCreateKeyW( HKEY hkey, LPCWSTR name, PHKEY retkey )
234 {
235 /* FIXME: previous implementation converted ERROR_INVALID_HANDLE to ERROR_BADKEY, */
236 /* but at least my version of NT (4.0 SP5) doesn't do this. -- AJ */
237 return RegCreateKeyExW( hkey, name, 0, NULL, REG_OPTION_NON_VOLATILE,
238 KEY_ALL_ACCESS, NULL, retkey, NULL );
239 }
240
241
242 /******************************************************************************
243 * RegCreateKeyA [ADVAPI32.@]
244 */
245 DWORD WINAPI RegCreateKeyA( HKEY hkey, LPCSTR name, PHKEY retkey )
246 {
247 return RegCreateKeyExA( hkey, name, 0, NULL, REG_OPTION_NON_VOLATILE,
248 KEY_ALL_ACCESS, NULL, retkey, NULL );
249 }
250
251
252
253 /******************************************************************************
254 * RegOpenKeyExW [ADVAPI32.@]
255 *
256 * Opens the specified key
257 *
258 * Unlike RegCreateKeyEx, this does not create the key if it does not exist.
259 *
260 * PARAMS
261 * hkey [I] Handle of open key
262 * name [I] Name of subkey to open
263 * reserved [I] Reserved - must be zero
264 * access [I] Security access mask
265 * retkey [O] Handle to open key
266 *
267 * RETURNS
268 * Success: ERROR_SUCCESS
269 * Failure: Error code
270 *
271 * NOTES
272 * in case of failing is retkey = 0
273 */
274 DWORD WINAPI RegOpenKeyExW( HKEY hkey, LPCWSTR name, DWORD reserved, REGSAM access, PHKEY retkey )
275 {
276 OBJECT_ATTRIBUTES attr;
277 UNICODE_STRING nameW;
278
279 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
280
281 attr.Length = sizeof(attr);
282 attr.RootDirectory = hkey;
283 attr.ObjectName = &nameW;
284 attr.Attributes = 0;
285 attr.SecurityDescriptor = NULL;
286 attr.SecurityQualityOfService = NULL;
287 RtlInitUnicodeString( &nameW, name );
288 return RtlNtStatusToDosError( NtOpenKey( retkey, access, &attr ) );
289 }
290
291
292 /******************************************************************************
293 * RegOpenKeyExA [ADVAPI32.@]
294 */
295 DWORD WINAPI RegOpenKeyExA( HKEY hkey, LPCSTR name, DWORD reserved, REGSAM access, PHKEY retkey )
296 {
297 OBJECT_ATTRIBUTES attr;
298 STRING nameA;
299 NTSTATUS status;
300
301 if (!is_version_nt()) access = KEY_ALL_ACCESS; /* Win95 ignores the access mask */
302
303 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
304
305 attr.Length = sizeof(attr);
306 attr.RootDirectory = hkey;
307 attr.ObjectName = &NtCurrentTeb()->StaticUnicodeString;
308 attr.Attributes = 0;
309 attr.SecurityDescriptor = NULL;
310 attr.SecurityQualityOfService = NULL;
311
312 RtlInitAnsiString( &nameA, name );
313 if (!(status = RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString,
314 &nameA, FALSE )))
315 {
316 status = NtOpenKey( retkey, access, &attr );
317 }
318 return RtlNtStatusToDosError( status );
319 }
320
321
322 /******************************************************************************
323 * RegOpenKeyW [ADVAPI32.@]
324 *
325 * PARAMS
326 * hkey [I] Handle of open key
327 * name [I] Address of name of subkey to open
328 * retkey [O] Handle to open key
329 *
330 * RETURNS
331 * Success: ERROR_SUCCESS
332 * Failure: Error code
333 *
334 * NOTES
335 * in case of failing is retkey = 0
336 */
337 DWORD WINAPI RegOpenKeyW( HKEY hkey, LPCWSTR name, PHKEY retkey )
338 {
339 return RegOpenKeyExW( hkey, name, 0, KEY_ALL_ACCESS, retkey );
340 }
341
342
343 /******************************************************************************
344 * RegOpenKeyA [ADVAPI32.@]
345 */
346 DWORD WINAPI RegOpenKeyA( HKEY hkey, LPCSTR name, PHKEY retkey )
347 {
348 return RegOpenKeyExA( hkey, name, 0, KEY_ALL_ACCESS, retkey );
349 }
350
351
352 /******************************************************************************
353 * RegOpenCurrentUser [ADVAPI32.@]
354 * FIXME: This function is supposed to retrieve a handle to the
355 * HKEY_CURRENT_USER for the user the current thread is impersonating.
356 * Since Wine does not currently allow threads to impersonate other users,
357 * this stub should work fine.
358 */
359 DWORD WINAPI RegOpenCurrentUser( REGSAM access, PHKEY retkey )
360 {
361 return RegOpenKeyExA( HKEY_CURRENT_USER, "", 0, access, retkey );
362 }
363
364
365
366 /******************************************************************************
367 * RegEnumKeyExW [ADVAPI32.@]
368 *
369 * PARAMS
370 * hkey [I] Handle to key to enumerate
371 * index [I] Index of subkey to enumerate
372 * name [O] Buffer for subkey name
373 * name_len [O] Size of subkey buffer
374 * reserved [I] Reserved
375 * class [O] Buffer for class string
376 * class_len [O] Size of class buffer
377 * ft [O] Time key last written to
378 */
379 DWORD WINAPI RegEnumKeyExW( HKEY hkey, DWORD index, LPWSTR name, LPDWORD name_len,
380 LPDWORD reserved, LPWSTR class, LPDWORD class_len, FILETIME *ft )
381 {
382 NTSTATUS status;
383 char buffer[256], *buf_ptr = buffer;
384 KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
385 DWORD total_size;
386
387 TRACE( "(%p,%ld,%p,%p(%ld),%p,%p,%p,%p)\n", hkey, index, name, name_len,
388 name_len ? *name_len : -1, reserved, class, class_len, ft );
389
390 if (reserved) return ERROR_INVALID_PARAMETER;
391 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
392
393 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
394 buffer, sizeof(buffer), &total_size );
395
396 while (status == STATUS_BUFFER_OVERFLOW)
397 {
398 /* retry with a dynamically allocated buffer */
399 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
400 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
401 return ERROR_NOT_ENOUGH_MEMORY;
402 info = (KEY_NODE_INFORMATION *)buf_ptr;
403 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
404 buf_ptr, total_size, &total_size );
405 }
406
407 if (!status)
408 {
409 DWORD len = info->NameLength / sizeof(WCHAR);
410 DWORD cls_len = info->ClassLength / sizeof(WCHAR);
411
412 if (ft) *ft = *(FILETIME *)&info->LastWriteTime;
413
414 if (len >= *name_len || (class && class_len && (cls_len >= *class_len)))
415 status = STATUS_BUFFER_OVERFLOW;
416 else
417 {
418 *name_len = len;
419 memcpy( name, info->Name, info->NameLength );
420 name[len] = 0;
421 if (class_len)
422 {
423 *class_len = cls_len;
424 if (class)
425 {
426 memcpy( class, buf_ptr + info->ClassOffset, info->ClassLength );
427 class[cls_len] = 0;
428 }
429 }
430 }
431 }
432
433 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
434 return RtlNtStatusToDosError( status );
435 }
436
437
438 /******************************************************************************
439 * RegEnumKeyExA [ADVAPI32.@]
440 */
441 DWORD WINAPI RegEnumKeyExA( HKEY hkey, DWORD index, LPSTR name, LPDWORD name_len,
442 LPDWORD reserved, LPSTR class, LPDWORD class_len, FILETIME *ft )
443 {
444 NTSTATUS status;
445 char buffer[256], *buf_ptr = buffer;
446 KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
447 DWORD total_size;
448
449 TRACE( "(%p,%ld,%p,%p(%ld),%p,%p,%p,%p)\n", hkey, index, name, name_len,
450 name_len ? *name_len : -1, reserved, class, class_len, ft );
451
452 if (reserved) return ERROR_INVALID_PARAMETER;
453 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
454
455 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
456 buffer, sizeof(buffer), &total_size );
457
458 while (status == STATUS_BUFFER_OVERFLOW)
459 {
460 /* retry with a dynamically allocated buffer */
461 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
462 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
463 return ERROR_NOT_ENOUGH_MEMORY;
464 info = (KEY_NODE_INFORMATION *)buf_ptr;
465 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
466 buf_ptr, total_size, &total_size );
467 }
468
469 if (!status)
470 {
471 DWORD len, cls_len;
472
473 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
474 RtlUnicodeToMultiByteSize( &cls_len, (WCHAR *)(buf_ptr + info->ClassOffset),
475 info->ClassLength );
476 if (ft) *ft = *(FILETIME *)&info->LastWriteTime;
477
478 if (len >= *name_len || (class && class_len && (cls_len >= *class_len)))
479 status = STATUS_BUFFER_OVERFLOW;
480 else
481 {
482 *name_len = len;
483 RtlUnicodeToMultiByteN( name, len, NULL, info->Name, info->NameLength );
484 name[len] = 0;
485 if (class_len)
486 {
487 *class_len = cls_len;
488 if (class)
489 {
490 RtlUnicodeToMultiByteN( class, cls_len, NULL,
491 (WCHAR *)(buf_ptr + info->ClassOffset),
492 info->ClassLength );
493 class[cls_len] = 0;
494 }
495 }
496 }
497 }
498
499 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
500 return RtlNtStatusToDosError( status );
501 }
502
503
504 /******************************************************************************
505 * RegEnumKeyW [ADVAPI32.@]
506 */
507 DWORD WINAPI RegEnumKeyW( HKEY hkey, DWORD index, LPWSTR name, DWORD name_len )
508 {
509 return RegEnumKeyExW( hkey, index, name, &name_len, NULL, NULL, NULL, NULL );
510 }
511
512
513 /******************************************************************************
514 * RegEnumKeyA [ADVAPI32.@]
515 */
516 DWORD WINAPI RegEnumKeyA( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
517 {
518 return RegEnumKeyExA( hkey, index, name, &name_len, NULL, NULL, NULL, NULL );
519 }
520
521
522 /******************************************************************************
523 * RegQueryInfoKeyW [ADVAPI32.@]
524 *
525 * PARAMS
526 * hkey [I] Handle to key to query
527 * class [O] Buffer for class string
528 * class_len [O] Size of class string buffer
529 * reserved [I] Reserved
530 * subkeys [O] Buffer for number of subkeys
531 * max_subkey [O] Buffer for longest subkey name length
532 * max_class [O] Buffer for longest class string length
533 * values [O] Buffer for number of value entries
534 * max_value [O] Buffer for longest value name length
535 * max_data [O] Buffer for longest value data length
536 * security [O] Buffer for security descriptor length
537 * modif [O] Modification time
538 *
539 * - win95 allows class to be valid and class_len to be NULL
540 * - winnt returns ERROR_INVALID_PARAMETER if class is valid and class_len is NULL
541 * - both allow class to be NULL and class_len to be NULL
542 * (it's hard to test validity, so test !NULL instead)
543 */
544 DWORD WINAPI RegQueryInfoKeyW( HKEY hkey, LPWSTR class, LPDWORD class_len, LPDWORD reserved,
545 LPDWORD subkeys, LPDWORD max_subkey, LPDWORD max_class,
546 LPDWORD values, LPDWORD max_value, LPDWORD max_data,
547 LPDWORD security, FILETIME *modif )
548 {
549 NTSTATUS status;
550 char buffer[256], *buf_ptr = buffer;
551 KEY_FULL_INFORMATION *info = (KEY_FULL_INFORMATION *)buffer;
552 DWORD total_size;
553
554 TRACE( "(%p,%p,%ld,%p,%p,%p,%p,%p,%p,%p,%p)\n", hkey, class, class_len ? *class_len : 0,
555 reserved, subkeys, max_subkey, values, max_value, max_data, security, modif );
556
557 if (class && !class_len && is_version_nt()) return ERROR_INVALID_PARAMETER;
558 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
559
560 status = NtQueryKey( hkey, KeyFullInformation, buffer, sizeof(buffer), &total_size );
561 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
562
563 if (class)
564 {
565 /* retry with a dynamically allocated buffer */
566 while (status == STATUS_BUFFER_OVERFLOW)
567 {
568 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
569 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
570 return ERROR_NOT_ENOUGH_MEMORY;
571 info = (KEY_FULL_INFORMATION *)buf_ptr;
572 status = NtQueryKey( hkey, KeyFullInformation, buf_ptr, total_size, &total_size );
573 }
574
575 if (status) goto done;
576
577 if (class_len && (info->ClassLength/sizeof(WCHAR) + 1 > *class_len))
578 {
579 status = STATUS_BUFFER_OVERFLOW;
580 }
581 else
582 {
583 memcpy( class, buf_ptr + info->ClassOffset, info->ClassLength );
584 class[info->ClassLength/sizeof(WCHAR)] = 0;
585 }
586 }
587 else status = STATUS_SUCCESS;
588
589 if (class_len) *class_len = info->ClassLength / sizeof(WCHAR);
590 if (subkeys) *subkeys = info->SubKeys;
591 if (max_subkey) *max_subkey = info->MaxNameLen;
592 if (max_class) *max_class = info->MaxClassLen;
593 if (values) *values = info->Values;
594 if (max_value) *max_value = info->MaxValueNameLen;
595 if (max_data) *max_data = info->MaxValueDataLen;
596 if (modif) *modif = *(FILETIME *)&info->LastWriteTime;
597
598 done:
599 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
600 return RtlNtStatusToDosError( status );
601 }
602
603
604 /******************************************************************************
605 * RegQueryMultipleValuesA [ADVAPI32.@]
606 */
607 DWORD WINAPI RegQueryMultipleValuesA(HKEY hkey, PVALENTA val_list, DWORD num_vals,
608 LPSTR lpValueBuf, LPDWORD ldwTotsize)
609 {
610 int i;
611 DWORD maxBytes = *ldwTotsize;
612 HRESULT status;
613 LPSTR bufptr = lpValueBuf;
614 *ldwTotsize = 0;
615
616 TRACE("(%p,%p,%ld,%p,%p=%ld)\n", hkey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
617
618 for(i=0; i < num_vals; ++i)
619 {
620
621 val_list[i].ve_valuelen=0;
622 status = RegQueryValueExA(hkey, val_list[i].ve_valuename, NULL, NULL, NULL, &val_list[i].ve_valuelen);
623 if(status != ERROR_SUCCESS)
624 {
625 return status;
626 }
627
628 if(lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
629 {
630 status = RegQueryValueExA(hkey, val_list[i].ve_valuename, NULL, &val_list[i].ve_type,
631 bufptr, &val_list[i].ve_valuelen);
632 if(status != ERROR_SUCCESS)
633 {
634 return status;
635 }
636
637 val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
638
639 bufptr += val_list[i].ve_valuelen;
640 }
641
642 *ldwTotsize += val_list[i].ve_valuelen;
643 }
644 return lpValueBuf != NULL && *ldwTotsize <= maxBytes ? ERROR_SUCCESS : ERROR_MORE_DATA;
645 }
646
647
648 /******************************************************************************
649 * RegQueryMultipleValuesW [ADVAPI32.@]
650 */
651 DWORD WINAPI RegQueryMultipleValuesW(HKEY hkey, PVALENTW val_list, DWORD num_vals,
652 LPWSTR lpValueBuf, LPDWORD ldwTotsize)
653 {
654 int i;
655 DWORD maxBytes = *ldwTotsize;
656 HRESULT status;
657 LPSTR bufptr = (LPSTR)lpValueBuf;
658 *ldwTotsize = 0;
659
660 TRACE("(%p,%p,%ld,%p,%p=%ld)\n", hkey, val_list, num_vals, lpValueBuf, ldwTotsize, *ldwTotsize);
661
662 for(i=0; i < num_vals; ++i)
663 {
664 val_list[i].ve_valuelen=0;
665 status = RegQueryValueExW(hkey, val_list[i].ve_valuename, NULL, NULL, NULL, &val_list[i].ve_valuelen);
666 if(status != ERROR_SUCCESS)
667 {
668 return status;
669 }
670
671 if(lpValueBuf != NULL && *ldwTotsize + val_list[i].ve_valuelen <= maxBytes)
672 {
673 status = RegQueryValueExW(hkey, val_list[i].ve_valuename, NULL, &val_list[i].ve_type,
674 bufptr, &val_list[i].ve_valuelen);
675 if(status != ERROR_SUCCESS)
676 {
677 return status;
678 }
679
680 val_list[i].ve_valueptr = (DWORD_PTR)bufptr;
681
682 bufptr += val_list[i].ve_valuelen;
683 }
684
685 *ldwTotsize += val_list[i].ve_valuelen;
686 }
687 return lpValueBuf != NULL && *ldwTotsize <= maxBytes ? ERROR_SUCCESS : ERROR_MORE_DATA;
688 }
689
690 /******************************************************************************
691 * RegQueryInfoKeyA [ADVAPI32.@]
692 */
693 DWORD WINAPI RegQueryInfoKeyA( HKEY hkey, LPSTR class, LPDWORD class_len, LPDWORD reserved,
694 LPDWORD subkeys, LPDWORD max_subkey, LPDWORD max_class,
695 LPDWORD values, LPDWORD max_value, LPDWORD max_data,
696 LPDWORD security, FILETIME *modif )
697 {
698 NTSTATUS status;
699 char buffer[256], *buf_ptr = buffer;
700 KEY_FULL_INFORMATION *info = (KEY_FULL_INFORMATION *)buffer;
701 DWORD total_size, len;
702
703 TRACE( "(%p,%p,%ld,%p,%p,%p,%p,%p,%p,%p,%p)\n", hkey, class, class_len ? *class_len : 0,
704 reserved, subkeys, max_subkey, values, max_value, max_data, security, modif );
705
706 if (class && !class_len && is_version_nt()) return ERROR_INVALID_PARAMETER;
707 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
708
709 status = NtQueryKey( hkey, KeyFullInformation, buffer, sizeof(buffer), &total_size );
710 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
711
712 if (class || class_len)
713 {
714 /* retry with a dynamically allocated buffer */
715 while (status == STATUS_BUFFER_OVERFLOW)
716 {
717 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
718 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
719 return ERROR_NOT_ENOUGH_MEMORY;
720 info = (KEY_FULL_INFORMATION *)buf_ptr;
721 status = NtQueryKey( hkey, KeyFullInformation, buf_ptr, total_size, &total_size );
722 }
723
724 if (status) goto done;
725
726 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info->ClassOffset), info->ClassLength);
727 if (class_len)
728 {
729 if (len + 1 > *class_len) status = STATUS_BUFFER_OVERFLOW;
730 *class_len = len;
731 }
732 if (class && !status)
733 {
734 RtlUnicodeToMultiByteN( class, len, NULL, (WCHAR *)(buf_ptr + info->ClassOffset),
735 info->ClassLength );
736 class[len] = 0;
737 }
738 }
739 else status = STATUS_SUCCESS;
740
741 if (subkeys) *subkeys = info->SubKeys;
742 if (max_subkey) *max_subkey = info->MaxNameLen;
743 if (max_class) *max_class = info->MaxClassLen;
744 if (values) *values = info->Values;
745 if (max_value) *max_value = info->MaxValueNameLen;
746 if (max_data) *max_data = info->MaxValueDataLen;
747 if (modif) *modif = *(FILETIME *)&info->LastWriteTime;
748
749 done:
750 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
751 return RtlNtStatusToDosError( status );
752 }
753
754
755 /******************************************************************************
756 * RegCloseKey [ADVAPI32.@]
757 *
758 * Releases the handle of the specified key
759 *
760 * PARAMS
761 * hkey [I] Handle of key to close
762 *
763 * RETURNS
764 * Success: ERROR_SUCCESS
765 * Failure: Error code
766 */
767 DWORD WINAPI RegCloseKey( HKEY hkey )
768 {
769 if (!hkey || hkey >= (HKEY)0x80000000) return ERROR_SUCCESS;
770 return RtlNtStatusToDosError( NtClose( hkey ) );
771 }
772
773
774 /******************************************************************************
775 * RegDeleteKeyW [ADVAPI32.@]
776 *
777 * PARAMS
778 * hkey [I] Handle to open key
779 * name [I] Name of subkey to delete
780 *
781 * RETURNS
782 * Success: ERROR_SUCCESS
783 * Failure: Error code
784 */
785 DWORD WINAPI RegDeleteKeyW( HKEY hkey, LPCWSTR name )
786 {
787 DWORD ret;
788 HKEY tmp;
789
790 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
791
792 if (!name || !*name)
793 {
794 ret = RtlNtStatusToDosError( NtDeleteKey( hkey ) );
795 }
796 else if (!(ret = RegOpenKeyExW( hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp )))
797 {
798 if (!is_version_nt()) /* win95 does recursive key deletes */
799 {
800 WCHAR name[MAX_PATH];
801
802 while(!RegEnumKeyW(tmp, 0, name, sizeof(name)))
803 {
804 if(RegDeleteKeyW(tmp, name)) /* recurse */
805 break;
806 }
807 }
808 ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
809 RegCloseKey( tmp );
810 }
811 TRACE("%s ret=%08lx\n", debugstr_w(name), ret);
812 return ret;
813 }
814
815
816 /******************************************************************************
817 * RegDeleteKeyA [ADVAPI32.@]
818 */
819 DWORD WINAPI RegDeleteKeyA( HKEY hkey, LPCSTR name )
820 {
821 DWORD ret;
822 HKEY tmp;
823
824 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
825
826 if (!name || !*name)
827 {
828 ret = RtlNtStatusToDosError( NtDeleteKey( hkey ) );
829 }
830 else if (!(ret = RegOpenKeyExA( hkey, name, 0, KEY_ENUMERATE_SUB_KEYS, &tmp )))
831 {
832 if (!is_version_nt()) /* win95 does recursive key deletes */
833 {
834 CHAR name[MAX_PATH];
835
836 while(!RegEnumKeyA(tmp, 0, name, sizeof(name)))
837 {
838 if(RegDeleteKeyA(tmp, name)) /* recurse */
839 break;
840 }
841 }
842 ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
843 RegCloseKey( tmp );
844 }
845 TRACE("%s ret=%08lx\n", debugstr_a(name), ret);
846 return ret;
847 }
848
849
850
851 /******************************************************************************
852 * RegSetValueExW [ADVAPI32.@]
853 *
854 * Sets the data and type of a value under a register key
855 *
856 * PARAMS
857 * hkey [I] Handle of key to set value for
858 * name [I] Name of value to set
859 * reserved [I] Reserved - must be zero
860 * type [I] Flag for value type
861 * data [I] Address of value data
862 * count [I] Size of value data
863 *
864 * RETURNS
865 * Success: ERROR_SUCCESS
866 * Failure: Error code
867 *
868 * NOTES
869 * win95 does not care about count for REG_SZ and finds out the len by itself (js)
870 * NT does definitely care (aj)
871 */
872 DWORD WINAPI RegSetValueExW( HKEY hkey, LPCWSTR name, DWORD reserved,
873 DWORD type, CONST BYTE *data, DWORD count )
874 {
875 UNICODE_STRING nameW;
876
877 if (!is_version_nt()) /* win95 */
878 {
879 if (type == REG_SZ) count = (strlenW( (WCHAR *)data ) + 1) * sizeof(WCHAR);
880 }
881 else if (count && is_string(type))
882 {
883 LPCWSTR str = (LPCWSTR)data;
884 /* if user forgot to count terminating null, add it (yes NT does this) */
885 if (str[count / sizeof(WCHAR) - 1] && !str[count / sizeof(WCHAR)])
886 count += sizeof(WCHAR);
887 }
888 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
889
890 RtlInitUnicodeString( &nameW, name );
891 return RtlNtStatusToDosError( NtSetValueKey( hkey, &nameW, 0, type, data, count ) );
892 }
893
894
895 /******************************************************************************
896 * RegSetValueExA [ADVAPI32.@]
897 */
898 DWORD WINAPI RegSetValueExA( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
899 CONST BYTE *data, DWORD count )
900 {
901 ANSI_STRING nameA;
902 WCHAR *dataW = NULL;
903 NTSTATUS status;
904
905 if (!is_version_nt()) /* win95 */
906 {
907 if (type == REG_SZ) count = strlen(data) + 1;
908 }
909 else if (count && is_string(type))
910 {
911 /* if user forgot to count terminating null, add it (yes NT does this) */
912 if (data[count-1] && !data[count]) count++;
913 }
914
915 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
916
917 if (is_string( type )) /* need to convert to Unicode */
918 {
919 DWORD lenW;
920 RtlMultiByteToUnicodeSize( &lenW, data, count );
921 if (!(dataW = HeapAlloc( GetProcessHeap(), 0, lenW ))) return ERROR_OUTOFMEMORY;
922 RtlMultiByteToUnicodeN( dataW, lenW, NULL, data, count );
923 count = lenW;
924 data = (BYTE *)dataW;
925 }
926
927 RtlInitAnsiString( &nameA, name );
928 if (!(status = RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString,
929 &nameA, FALSE )))
930 {
931 status = NtSetValueKey( hkey, &NtCurrentTeb()->StaticUnicodeString, 0, type, data, count );
932 }
933 if (dataW) HeapFree( GetProcessHeap(), 0, dataW );
934 return RtlNtStatusToDosError( status );
935 }
936
937
938 /******************************************************************************
939 * RegSetValueW [ADVAPI32.@]
940 */
941 DWORD WINAPI RegSetValueW( HKEY hkey, LPCWSTR name, DWORD type, LPCWSTR data, DWORD count )
942 {
943 HKEY subkey = hkey;
944 DWORD ret;
945
946 TRACE("(%p,%s,%ld,%s,%ld)\n", hkey, debugstr_w(name), type, debugstr_w(data), count );
947
948 if (type != REG_SZ) return ERROR_INVALID_PARAMETER;
949
950 if (name && name[0]) /* need to create the subkey */
951 {
952 if ((ret = RegCreateKeyW( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
953 }
954
955 ret = RegSetValueExW( subkey, NULL, 0, REG_SZ, (LPBYTE)data,
956 (strlenW( data ) + 1) * sizeof(WCHAR) );
957 if (subkey != hkey) RegCloseKey( subkey );
958 return ret;
959 }
960
961
962 /******************************************************************************
963 * RegSetValueA [ADVAPI32.@]
964 */
965 DWORD WINAPI RegSetValueA( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
966 {
967 HKEY subkey = hkey;
968 DWORD ret;
969
970 TRACE("(%p,%s,%ld,%s,%ld)\n", hkey, debugstr_a(name), type, debugstr_a(data), count );
971
972 if (type != REG_SZ) return ERROR_INVALID_PARAMETER;
973
974 if (name && name[0]) /* need to create the subkey */
975 {
976 if ((ret = RegCreateKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
977 }
978 ret = RegSetValueExA( subkey, NULL, 0, REG_SZ, (LPBYTE)data, strlen(data)+1 );
979 if (subkey != hkey) RegCloseKey( subkey );
980 return ret;
981 }
982
983
984
985 /******************************************************************************
986 * RegQueryValueExW [ADVAPI32.@]
987 *
988 * Retrieves type and data for a specified name associated with an open key
989 *
990 * PARAMS
991 * hkey [I] Handle of key to query
992 * name [I] Name of value to query
993 * reserved [I] Reserved - must be NULL
994 * type [O] Address of buffer for value type. If NULL, the type
995 * is not required.
996 * data [O] Address of data buffer. If NULL, the actual data is
997 * not required.
998 * count [I/O] Address of data buffer size
999 *
1000 * RETURNS
1001 * ERROR_SUCCESS: Success
1002 * ERROR_MORE_DATA: !!! if the specified buffer is not big enough to hold the data
1003 * buffer is left untouched. The MS-documentation is wrong (js) !!!
1004 */
1005 DWORD WINAPI RegQueryValueExW( HKEY hkey, LPCWSTR name, LPDWORD reserved, LPDWORD type,
1006 LPBYTE data, LPDWORD count )
1007 {
1008 NTSTATUS status;
1009 UNICODE_STRING name_str;
1010 DWORD total_size;
1011 char buffer[256], *buf_ptr = buffer;
1012 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
1013 static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
1014
1015 TRACE("(%p,%s,%p,%p,%p,%p=%ld)\n",
1016 hkey, debugstr_w(name), reserved, type, data, count,
1017 (count && data) ? *count : 0 );
1018
1019 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
1020 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1021
1022 RtlInitUnicodeString( &name_str, name );
1023
1024 if (data) total_size = min( sizeof(buffer), *count + info_size );
1025 else total_size = info_size;
1026
1027 status = NtQueryValueKey( hkey, &name_str, KeyValuePartialInformation,
1028 buffer, total_size, &total_size );
1029 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
1030
1031 if (data)
1032 {
1033 /* retry with a dynamically allocated buffer */
1034 while (status == STATUS_BUFFER_OVERFLOW && total_size - info_size <= *count)
1035 {
1036 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1037 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
1038 return ERROR_NOT_ENOUGH_MEMORY;
1039 info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
1040 status = NtQueryValueKey( hkey, &name_str, KeyValuePartialInformation,
1041 buf_ptr, total_size, &total_size );
1042 }
1043
1044 if (!status)
1045 {
1046 memcpy( data, buf_ptr + info_size, total_size - info_size );
1047 /* if the type is REG_SZ and data is not 0-terminated
1048 * and there is enough space in the buffer NT appends a \0 */
1049 if (total_size - info_size <= *count-sizeof(WCHAR) && is_string(info->Type))
1050 {
1051 WCHAR *ptr = (WCHAR *)(data + total_size - info_size);
1052 if (ptr > (WCHAR *)data && ptr[-1]) *ptr = 0;
1053 }
1054 }
1055 else if (status != STATUS_BUFFER_OVERFLOW) goto done;
1056 }
1057 else status = STATUS_SUCCESS;
1058
1059 if (type) *type = info->Type;
1060 if (count) *count = total_size - info_size;
1061
1062 done:
1063 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1064 return RtlNtStatusToDosError(status);
1065 }
1066
1067
1068 /******************************************************************************
1069 * RegQueryValueExA [ADVAPI32.@]
1070 *
1071 * NOTES:
1072 * the documentation is wrong: if the buffer is too small it remains untouched
1073 */
1074 DWORD WINAPI RegQueryValueExA( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
1075 LPBYTE data, LPDWORD count )
1076 {
1077 NTSTATUS status;
1078 ANSI_STRING nameA;
1079 DWORD total_size;
1080 char buffer[256], *buf_ptr = buffer;
1081 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
1082 static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
1083
1084 TRACE("(%p,%s,%p,%p,%p,%p=%ld)\n",
1085 hkey, debugstr_a(name), reserved, type, data, count, count ? *count : 0 );
1086
1087 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
1088 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1089
1090 RtlInitAnsiString( &nameA, name );
1091 if ((status = RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString,
1092 &nameA, FALSE )))
1093 return RtlNtStatusToDosError(status);
1094
1095 status = NtQueryValueKey( hkey, &NtCurrentTeb()->StaticUnicodeString,
1096 KeyValuePartialInformation, buffer, sizeof(buffer), &total_size );
1097 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
1098
1099 /* we need to fetch the contents for a string type even if not requested,
1100 * because we need to compute the length of the ASCII string. */
1101 if (data || is_string(info->Type))
1102 {
1103 /* retry with a dynamically allocated buffer */
1104 while (status == STATUS_BUFFER_OVERFLOW)
1105 {
1106 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1107 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
1108 {
1109 status = STATUS_NO_MEMORY;
1110 goto done;
1111 }
1112 info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
1113 status = NtQueryValueKey( hkey, &NtCurrentTeb()->StaticUnicodeString,
1114 KeyValuePartialInformation, buf_ptr, total_size, &total_size );
1115 }
1116
1117 if (status) goto done;
1118
1119 if (is_string(info->Type))
1120 {
1121 DWORD len;
1122
1123 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info_size),
1124 total_size - info_size );
1125 if (data && len)
1126 {
1127 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
1128 else
1129 {
1130 RtlUnicodeToMultiByteN( data, len, NULL, (WCHAR *)(buf_ptr + info_size),
1131 total_size - info_size );
1132 /* if the type is REG_SZ and data is not 0-terminated
1133 * and there is enough space in the buffer NT appends a \0 */
1134 if (len < *count && data[len-1]) data[len] = 0;
1135 }
1136 }
1137 total_size = len + info_size;
1138 }
1139 else if (data)
1140 {
1141 if (total_size - info_size > *count) status = STATUS_BUFFER_OVERFLOW;
1142 else memcpy( data, buf_ptr + info_size, total_size - info_size );
1143 }
1144 }
1145 else status = STATUS_SUCCESS;
1146
1147 if (type) *type = info->Type;
1148 if (count) *count = total_size - info_size;
1149
1150 done:
1151 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1152 return RtlNtStatusToDosError(status);
1153 }
1154
1155
1156 /******************************************************************************
1157 * RegQueryValueW [ADVAPI32.@]
1158 */
1159 DWORD WINAPI RegQueryValueW( HKEY hkey, LPCWSTR name, LPWSTR data, LPLONG count )
1160 {
1161 DWORD ret;
1162 HKEY subkey = hkey;
1163
1164 TRACE("(%p,%s,%p,%ld)\n", hkey, debugstr_w(name), data, count ? *count : 0 );
1165
1166 if (name && name[0])
1167 {
1168 if ((ret = RegOpenKeyW( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
1169 }
1170 ret = RegQueryValueExW( subkey, NULL, NULL, NULL, (LPBYTE)data, count );
1171 if (subkey != hkey) RegCloseKey( subkey );
1172 if (ret == ERROR_FILE_NOT_FOUND)
1173 {
1174 /* return empty string if default value not found */
1175 if (data) *data = 0;
1176 if (count) *count = 1;
1177 ret = ERROR_SUCCESS;
1178 }
1179 return ret;
1180 }
1181
1182
1183 /******************************************************************************
1184 * RegQueryValueA [ADVAPI32.@]
1185 */
1186 DWORD WINAPI RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
1187 {
1188 DWORD ret;
1189 HKEY subkey = hkey;
1190
1191 TRACE("(%p,%s,%p,%ld)\n", hkey, debugstr_a(name), data, count ? *count : 0 );
1192
1193 if (name && name[0])
1194 {
1195 if ((ret = RegOpenKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
1196 }
1197 ret = RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, count );
1198 if (subkey != hkey) RegCloseKey( subkey );
1199 if (ret == ERROR_FILE_NOT_FOUND)
1200 {
1201 /* return empty string if default value not found */
1202 if (data) *data = 0;
1203 if (count) *count = 1;
1204 ret = ERROR_SUCCESS;
1205 }
1206 return ret;
1207 }
1208
1209
1210 /******************************************************************************
1211 * RegEnumValueW [ADVAPI32.@]
1212 *
1213 * PARAMS
1214 * hkey [I] Handle to key to query
1215 * index [I] Index of value to query
1216 * value [O] Value string
1217 * val_count [I/O] Size of value buffer (in wchars)
1218 * reserved [I] Reserved
1219 * type [O] Type code
1220 * data [O] Value data
1221 * count [I/O] Size of data buffer (in bytes)
1222 */
1223
1224 DWORD WINAPI RegEnumValueW( HKEY hkey, DWORD index, LPWSTR value, LPDWORD val_count,
1225 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
1226 {
1227 NTSTATUS status;
1228 DWORD total_size;
1229 char buffer[256], *buf_ptr = buffer;
1230 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
1231 static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
1232
1233 TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
1234 hkey, index, value, val_count, reserved, type, data, count );
1235
1236 /* NT only checks count, not val_count */
1237 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
1238 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1239
1240 total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
1241 if (data) total_size += *count;
1242 total_size = min( sizeof(buffer), total_size );
1243
1244 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
1245 buffer, total_size, &total_size );
1246 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
1247
1248 if (value || data)
1249 {
1250 /* retry with a dynamically allocated buffer */
1251 while (status == STATUS_BUFFER_OVERFLOW)
1252 {
1253 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1254 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
1255 return ERROR_NOT_ENOUGH_MEMORY;
1256 info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
1257 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
1258 buf_ptr, total_size, &total_size );
1259 }
1260
1261 if (status) goto done;
1262
1263 if (value)
1264 {
1265 if (info->NameLength/sizeof(WCHAR) >= *val_count)
1266 {
1267 status = STATUS_BUFFER_OVERFLOW;
1268 goto overflow;
1269 }
1270 memcpy( value, info->Name, info->NameLength );
1271 *val_count = info->NameLength / sizeof(WCHAR);
1272 value[*val_count] = 0;
1273 }
1274
1275 if (data)
1276 {
1277 if (total_size - info->DataOffset > *count)
1278 {
1279 status = STATUS_BUFFER_OVERFLOW;
1280 goto overflow;
1281 }
1282 memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
1283 if (total_size - info->DataOffset <= *count-sizeof(WCHAR) && is_string(info->Type))
1284 {
1285 /* if the type is REG_SZ and data is not 0-terminated
1286 * and there is enough space in the buffer NT appends a \0 */
1287 WCHAR *ptr = (WCHAR *)(data + total_size - info->DataOffset);
1288 if (ptr > (WCHAR *)data && ptr[-1]) *ptr = 0;
1289 }
1290 }
1291 }
1292 else status = STATUS_SUCCESS;
1293
1294 overflow:
1295 if (type) *type = info->Type;
1296 if (count) *count = info->DataLength;
1297
1298 done:
1299 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1300 return RtlNtStatusToDosError(status);
1301 }
1302
1303
1304 /******************************************************************************
1305 * RegEnumValueA [ADVAPI32.@]
1306 */
1307 DWORD WINAPI RegEnumValueA( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
1308 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
1309 {
1310 NTSTATUS status;
1311 DWORD total_size;
1312 char buffer[256], *buf_ptr = buffer;
1313 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
1314 static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
1315
1316 TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
1317 hkey, index, value, val_count, reserved, type, data, count );
1318
1319 /* NT only checks count, not val_count */
1320 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
1321 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1322
1323 total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
1324 if (data) total_size += *count;
1325 total_size = min( sizeof(buffer), total_size );
1326
1327 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
1328 buffer, total_size, &total_size );
1329 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
1330
1331 /* we need to fetch the contents for a string type even if not requested,
1332 * because we need to compute the length of the ASCII string. */
1333 if (value || data || is_string(info->Type))
1334 {
1335 /* retry with a dynamically allocated buffer */
1336 while (status == STATUS_BUFFER_OVERFLOW)
1337 {
1338 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1339 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
1340 return ERROR_NOT_ENOUGH_MEMORY;
1341 info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
1342 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
1343 buf_ptr, total_size, &total_size );
1344 }
1345
1346 if (status) goto done;
1347
1348 if (is_string(info->Type))
1349 {
1350 DWORD len;
1351 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info->DataOffset),
1352 total_size - info->DataOffset );
1353 if (data && len)
1354 {
1355 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
1356 else
1357 {
1358 RtlUnicodeToMultiByteN( data, len, NULL, (WCHAR *)(buf_ptr + info->DataOffset),
1359 total_size - info->DataOffset );
1360 /* if the type is REG_SZ and data is not 0-terminated
1361 * and there is enough space in the buffer NT appends a \0 */
1362 if (len < *count && data[len-1]) data[len] = 0;
1363 }
1364 }
1365 info->DataLength = len;
1366 }
1367 else if (data)
1368 {
1369 if (total_size - info->DataOffset > *count) status = STATUS_BUFFER_OVERFLOW;
1370 else memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
1371 }
1372
1373 if (value && !status)
1374 {
1375 DWORD len;
1376
1377 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
1378 if (len >= *val_count)
1379 {
1380 status = STATUS_BUFFER_OVERFLOW;
1381 if (*val_count)
1382 {
1383 len = *val_count - 1;
1384 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
1385 value[len] = 0;
1386 }
1387 }
1388 else
1389 {
1390 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
1391 value[len] = 0;
1392 *val_count = len;
1393 }
1394 }
1395 }
1396 else status = STATUS_SUCCESS;
1397
1398 if (type) *type = info->Type;
1399 if (count) *count = info->DataLength;
1400
1401 done:
1402 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1403 return RtlNtStatusToDosError(status);
1404 }
1405
1406
1407
1408 /******************************************************************************
1409 * RegDeleteValueW [ADVAPI32.@]
1410 *
1411 * See RegDeleteValueA.
1412 */
1413 DWORD WINAPI RegDeleteValueW( HKEY hkey, LPCWSTR name )
1414 {
1415 UNICODE_STRING nameW;
1416
1417 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1418
1419 RtlInitUnicodeString( &nameW, name );
1420 return RtlNtStatusToDosError( NtDeleteValueKey( hkey, &nameW ) );
1421 }
1422
1423
1424 /******************************************************************************
1425 * RegDeleteValueA [ADVAPI32.@]
1426 *
1427 * Delete a value from the registry.
1428 *
1429 * PARAMS
1430 * hkey [I] Registry handle of the key holding the value
1431 * name [I] Name of the value under hkey to delete
1432 *
1433 * RETURNS
1434 * Success: 0
1435 * Failure: A standard Windows error code.
1436 */
1437 DWORD WINAPI RegDeleteValueA( HKEY hkey, LPCSTR name )
1438 {
1439 STRING nameA;
1440 NTSTATUS status;
1441
1442 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1443
1444 RtlInitAnsiString( &nameA, name );
1445 if (!(status = RtlAnsiStringToUnicodeString( &NtCurrentTeb()->StaticUnicodeString,
1446 &nameA, FALSE )))
1447 status = NtDeleteValueKey( hkey, &NtCurrentTeb()->StaticUnicodeString );
1448 return RtlNtStatusToDosError( status );
1449 }
1450
1451
1452 /******************************************************************************
1453 * RegLoadKeyW [ADVAPI32.@]
1454 *
1455 * PARAMS
1456 * hkey [I] Handle of open key
1457 * subkey [I] Address of name of subkey
1458 * filename [I] Address of filename for registry information
1459 */
1460 LONG WINAPI RegLoadKeyW( HKEY hkey, LPCWSTR subkey, LPCWSTR filename )
1461 {
1462 HANDLE file;
1463 DWORD ret, len, err = GetLastError();
1464 HKEY shkey;
1465
1466 TRACE( "(%p,%s,%s)\n", hkey, debugstr_w(subkey), debugstr_w(filename) );
1467
1468 if (!filename || !*filename) return ERROR_INVALID_PARAMETER;
1469 if (!subkey || !*subkey) return ERROR_INVALID_PARAMETER;
1470 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1471
1472 len = strlenW( subkey ) * sizeof(WCHAR);
1473 if (len > MAX_PATH*sizeof(WCHAR)) return ERROR_INVALID_PARAMETER;
1474
1475 if ((file = CreateFileW( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING,
1476 FILE_ATTRIBUTE_NORMAL, 0 )) == INVALID_HANDLE_VALUE)
1477 {
1478 ret = GetLastError();
1479 goto done;
1480 }
1481
1482 RegCreateKeyW(hkey,subkey,&shkey);
1483
1484 SERVER_START_REQ( load_registry )
1485 {
1486 req->hkey = shkey;
1487 req->file = file;
1488 wine_server_add_data( req, subkey, len );
1489 ret = RtlNtStatusToDosError( wine_server_call(req) );
1490 }
1491 SERVER_END_REQ;
1492 CloseHandle( file );
1493 RegCloseKey(shkey);
1494
1495 done:
1496 SetLastError( err ); /* restore the last error code */
1497 return ret;
1498 }
1499
1500
1501 /******************************************************************************
1502 * RegLoadKeyA [ADVAPI32.@]
1503 */
1504 LONG WINAPI RegLoadKeyA( HKEY hkey, LPCSTR subkey, LPCSTR filename )
1505 {
1506 WCHAR buffer[MAX_PATH];
1507 HANDLE file;
1508 DWORD ret, len, err = GetLastError();
1509 HKEY shkey;
1510
1511 TRACE( "(%p,%s,%s)\n", hkey, debugstr_a(subkey), debugstr_a(filename) );
1512
1513 if (!filename || !*filename) return ERROR_INVALID_PARAMETER;
1514 if (!subkey || !*subkey) return ERROR_INVALID_PARAMETER;
1515 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1516
1517 if (!(len = MultiByteToWideChar( CP_ACP, 0, subkey, strlen(subkey), buffer, MAX_PATH )))
1518 return ERROR_INVALID_PARAMETER;
1519
1520 if ((file = CreateFileA( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING,
1521 FILE_ATTRIBUTE_NORMAL, 0 )) == INVALID_HANDLE_VALUE)
1522 {
1523 ret = GetLastError();
1524 goto done;
1525 }
1526
1527 RegCreateKeyA(hkey,subkey,&shkey);
1528
1529 SERVER_START_REQ( load_registry )
1530 {
1531 req->hkey = shkey;
1532 req->file = file;
1533 wine_server_add_data( req, buffer, len * sizeof(WCHAR) );
1534 ret = RtlNtStatusToDosError( wine_server_call(req) );
1535 }
1536 SERVER_END_REQ;
1537 CloseHandle( file );
1538 RegCloseKey(shkey);
1539
1540 done:
1541 SetLastError( err ); /* restore the last error code */
1542 return ret;
1543 }
1544
1545
1546 /******************************************************************************
1547 * RegSaveKeyW [ADVAPI32.@]
1548 *
1549 * PARAMS
1550 * hkey [I] Handle of key where save begins
1551 * lpFile [I] Address of filename to save to
1552 * sa [I] Address of security structure
1553 */
1554 LONG WINAPI RegSaveKeyW( HKEY hkey, LPCWSTR file, LPSECURITY_ATTRIBUTES sa )
1555 {
1556 static const WCHAR format[] =
1557 {'r','e','g','%','0','4','x','.','t','m','p',0};
1558 WCHAR buffer[MAX_PATH];
1559 int count = 0;
1560 LPWSTR nameW;
1561 DWORD ret, err;
1562 HANDLE handle;
1563
1564 TRACE( "(%p,%s,%p)\n", hkey, debugstr_w(file), sa );
1565
1566 if (!file || !*file) return ERROR_INVALID_PARAMETER;
1567 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1568
1569 err = GetLastError();
1570 GetFullPathNameW( file, sizeof(buffer)/sizeof(WCHAR), buffer, &nameW );
1571
1572 for (;;)
1573 {
1574 snprintfW( nameW, 16, format, count++ );
1575 handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
1576 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
1577 if (handle != INVALID_HANDLE_VALUE) break;
1578 if ((ret = GetLastError()) != ERROR_ALREADY_EXISTS) goto done;
1579
1580 /* Something gone haywire ? Please report if this happens abnormally */
1581 if (count >= 100)
1582 MESSAGE("Wow, we are already fiddling with a temp file %s with an ordinal as high as %d !\nYou might want to delete all corresponding temp files in that directory.\n", debugstr_w(buffer), count);
1583 }
1584
1585 SERVER_START_REQ( save_registry )
1586 {
1587 req->hkey = hkey;
1588 req->file = handle;
1589 ret = RtlNtStatusToDosError( wine_server_call( req ) );
1590 }
1591 SERVER_END_REQ;
1592
1593 CloseHandle( handle );
1594 if (!ret)
1595 {
1596 if (!MoveFileExW( buffer, file, MOVEFILE_REPLACE_EXISTING ))
1597 {
1598 ERR( "Failed to move %s to %s\n", debugstr_w(buffer),
1599 debugstr_w(file) );
1600 ret = GetLastError();
1601 }
1602 }
1603 if (ret) DeleteFileW( buffer );
1604
1605 done:
1606 SetLastError( err ); /* restore last error code */
1607 return ret;
1608 }
1609
1610
1611 /******************************************************************************
1612 * RegSaveKeyA [ADVAPI32.@]
1613 */
1614 LONG WINAPI RegSaveKeyA( HKEY hkey, LPCSTR file, LPSECURITY_ATTRIBUTES sa )
1615 {
1616 UNICODE_STRING *fileW = &NtCurrentTeb()->StaticUnicodeString;
1617 NTSTATUS status;
1618 STRING fileA;
1619
1620 RtlInitAnsiString(&fileA, file);
1621 if ((status = RtlAnsiStringToUnicodeString(fileW, &fileA, FALSE)))
1622 return RtlNtStatusToDosError( status );
1623 return RegSaveKeyW(hkey, fileW->Buffer, sa);
1624 }
1625
1626
1627 /******************************************************************************
1628 * RegRestoreKeyW [ADVAPI32.@]
1629 *
1630 * PARAMS
1631 * hkey [I] Handle of key where restore begins
1632 * lpFile [I] Address of filename containing saved tree
1633 * dwFlags [I] Optional flags
1634 */
1635 LONG WINAPI RegRestoreKeyW( HKEY hkey, LPCWSTR lpFile, DWORD dwFlags )
1636 {
1637 TRACE("(%p,%s,%ld)\n",hkey,debugstr_w(lpFile),dwFlags);
1638
1639 /* It seems to do this check before the hkey check */
1640 if (!lpFile || !*lpFile)
1641 return ERROR_INVALID_PARAMETER;
1642
1643 FIXME("(%p,%s,%ld): stub\n",hkey,debugstr_w(lpFile),dwFlags);
1644
1645 /* Check for file existence */
1646
1647 return ERROR_SUCCESS;
1648 }
1649
1650
1651 /******************************************************************************
1652 * RegRestoreKeyA [ADVAPI32.@]
1653 */
1654 LONG WINAPI RegRestoreKeyA( HKEY hkey, LPCSTR lpFile, DWORD dwFlags )
1655 {
1656 UNICODE_STRING lpFileW;
1657 LONG ret;
1658
1659 RtlCreateUnicodeStringFromAsciiz( &lpFileW, lpFile );
1660 ret = RegRestoreKeyW( hkey, lpFileW.Buffer, dwFlags );
1661 RtlFreeUnicodeString( &lpFileW );
1662 return ret;
1663 }
1664
1665
1666 /******************************************************************************
1667 * RegUnLoadKeyW [ADVAPI32.@]
1668 *
1669 * PARAMS
1670 * hkey [I] Handle of open key
1671 * lpSubKey [I] Address of name of subkey to unload
1672 */
1673 LONG WINAPI RegUnLoadKeyW( HKEY hkey, LPCWSTR lpSubKey )
1674 {
1675 DWORD ret;
1676 HKEY shkey;
1677
1678 TRACE("(%p,%s)\n",hkey, debugstr_w(lpSubKey));
1679
1680 ret = RegOpenKeyW(hkey,lpSubKey,&shkey);
1681 if( ret )
1682 return ERROR_INVALID_PARAMETER;
1683
1684 SERVER_START_REQ( unload_registry )
1685 {
1686 req->hkey = shkey;
1687 ret = RtlNtStatusToDosError( wine_server_call(req) );
1688 }
1689 SERVER_END_REQ;
1690 RegCloseKey(shkey);
1691
1692 return ret;
1693 }
1694
1695
1696 /******************************************************************************
1697 * RegUnLoadKeyA [ADVAPI32.@]
1698 */
1699 LONG WINAPI RegUnLoadKeyA( HKEY hkey, LPCSTR lpSubKey )
1700 {
1701 UNICODE_STRING lpSubKeyW;
1702 LONG ret;
1703
1704 RtlCreateUnicodeStringFromAsciiz( &lpSubKeyW, lpSubKey );
1705 ret = RegUnLoadKeyW( hkey, lpSubKeyW.Buffer );
1706 RtlFreeUnicodeString( &lpSubKeyW );
1707 return ret;
1708 }
1709
1710
1711 /******************************************************************************
1712 * RegReplaceKeyW [ADVAPI32.@]
1713 *
1714 * PARAMS
1715 * hkey [I] Handle of open key
1716 * lpSubKey [I] Address of name of subkey
1717 * lpNewFile [I] Address of filename for file with new data
1718 * lpOldFile [I] Address of filename for backup file
1719 */
1720 LONG WINAPI RegReplaceKeyW( HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpNewFile,
1721 LPCWSTR lpOldFile )
1722 {
1723 FIXME("(%p,%s,%s,%s): stub\n", hkey, debugstr_w(lpSubKey),
1724 debugstr_w(lpNewFile),debugstr_w(lpOldFile));
1725 return ERROR_SUCCESS;
1726 }
1727
1728
1729 /******************************************************************************
1730 * RegReplaceKeyA [ADVAPI32.@]
1731 */
1732 LONG WINAPI RegReplaceKeyA( HKEY hkey, LPCSTR lpSubKey, LPCSTR lpNewFile,
1733 LPCSTR lpOldFile )
1734 {
1735 UNICODE_STRING lpSubKeyW;
1736 UNICODE_STRING lpNewFileW;
1737 UNICODE_STRING lpOldFileW;
1738 LONG ret;
1739
1740 RtlCreateUnicodeStringFromAsciiz( &lpSubKeyW, lpSubKey );
1741 RtlCreateUnicodeStringFromAsciiz( &lpOldFileW, lpOldFile );
1742 RtlCreateUnicodeStringFromAsciiz( &lpNewFileW, lpNewFile );
1743 ret = RegReplaceKeyW( hkey, lpSubKeyW.Buffer, lpNewFileW.Buffer, lpOldFileW.Buffer );
1744 RtlFreeUnicodeString( &lpOldFileW );
1745 RtlFreeUnicodeString( &lpNewFileW );
1746 RtlFreeUnicodeString( &lpSubKeyW );
1747 return ret;
1748 }
1749
1750
1751 /******************************************************************************
1752 * RegSetKeySecurity [ADVAPI32.@]
1753 *
1754 * PARAMS
1755 * hkey [I] Open handle of key to set
1756 * SecurityInfo [I] Descriptor contents
1757 * pSecurityDesc [I] Address of descriptor for key
1758 */
1759 LONG WINAPI RegSetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInfo,
1760 PSECURITY_DESCRIPTOR pSecurityDesc )
1761 {
1762 TRACE("(%p,%ld,%p)\n",hkey,SecurityInfo,pSecurityDesc);
1763
1764 /* It seems to perform this check before the hkey check */
1765 if ((SecurityInfo & OWNER_SECURITY_INFORMATION) ||
1766 (SecurityInfo & GROUP_SECURITY_INFORMATION) ||
1767 (SecurityInfo & DACL_SECURITY_INFORMATION) ||
1768 (SecurityInfo & SACL_SECURITY_INFORMATION)) {
1769 /* Param OK */
1770 } else
1771 return ERROR_INVALID_PARAMETER;
1772
1773 if (!pSecurityDesc)
1774 return ERROR_INVALID_PARAMETER;
1775
1776 FIXME(":(%p,%ld,%p): stub\n",hkey,SecurityInfo,pSecurityDesc);
1777
1778 return ERROR_SUCCESS;
1779 }
1780
1781
1782 /******************************************************************************
1783 * RegGetKeySecurity [ADVAPI32.@]
1784 * Retrieves a copy of security descriptor protecting the registry key
1785 *
1786 * PARAMS
1787 * hkey [I] Open handle of key to set
1788 * SecurityInformation [I] Descriptor contents
1789 * pSecurityDescriptor [O] Address of descriptor for key
1790 * lpcbSecurityDescriptor [I/O] Address of size of buffer and description
1791 *
1792 * RETURNS
1793 * Success: ERROR_SUCCESS
1794 * Failure: Error code
1795 */
1796 LONG WINAPI RegGetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInformation,
1797 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1798 LPDWORD lpcbSecurityDescriptor )
1799 {
1800 TRACE("(%p,%ld,%p,%ld)\n",hkey,SecurityInformation,pSecurityDescriptor,
1801 lpcbSecurityDescriptor?*lpcbSecurityDescriptor:0);
1802
1803 /* FIXME: Check for valid SecurityInformation values */
1804
1805 if (*lpcbSecurityDescriptor < sizeof(SECURITY_DESCRIPTOR))
1806 return ERROR_INSUFFICIENT_BUFFER;
1807
1808 FIXME("(%p,%ld,%p,%ld): stub\n",hkey,SecurityInformation,
1809 pSecurityDescriptor,lpcbSecurityDescriptor?*lpcbSecurityDescriptor:0);
1810
1811 /* Do not leave security descriptor filled with garbage */
1812 RtlCreateSecurityDescriptor(pSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
1813
1814 return ERROR_SUCCESS;
1815 }
1816
1817
1818 /******************************************************************************
1819 * RegFlushKey [ADVAPI32.@]
1820 * Immediately writes key to registry.
1821 * Only returns after data has been written to disk.
1822 *
1823 * FIXME: does it really wait until data is written ?
1824 *
1825 * PARAMS
1826 * hkey [I] Handle of key to write
1827 *
1828 * RETURNS
1829 * Success: ERROR_SUCCESS
1830 * Failure: Error code
1831 */
1832 DWORD WINAPI RegFlushKey( HKEY hkey )
1833 {
1834 hkey = get_special_root_hkey( hkey );
1835 if (!hkey) return ERROR_INVALID_HANDLE;
1836
1837 return RtlNtStatusToDosError( NtFlushKey( hkey ) );
1838 }
1839
1840
1841 /******************************************************************************
1842 * RegConnectRegistryW [ADVAPI32.@]
1843 *
1844 * PARAMS
1845 * lpMachineName [I] Address of name of remote computer
1846 * hHey [I] Predefined registry handle
1847 * phkResult [I] Address of buffer for remote registry handle
1848 */
1849 LONG WINAPI RegConnectRegistryW( LPCWSTR lpMachineName, HKEY hKey,
1850 PHKEY phkResult )
1851 {
1852 TRACE("(%s,%p,%p): stub\n",debugstr_w(lpMachineName),hKey,phkResult);
1853
1854 if (!lpMachineName || !*lpMachineName) {
1855 /* Use the local machine name */
1856 return RegOpenKeyW( hKey, NULL, phkResult );
1857 }
1858
1859 FIXME("Cannot connect to %s\n",debugstr_w(lpMachineName));
1860 return ERROR_BAD_NETPATH;
1861 }
1862
1863
1864 /******************************************************************************
1865 * RegConnectRegistryA [ADVAPI32.@]
1866 */
1867 LONG WINAPI RegConnectRegistryA( LPCSTR machine, HKEY hkey, PHKEY reskey )
1868 {
1869 UNICODE_STRING machineW;
1870 LONG ret;
1871
1872 RtlCreateUnicodeStringFromAsciiz( &machineW, machine );
1873 ret = RegConnectRegistryW( machineW.Buffer, hkey, reskey );
1874 RtlFreeUnicodeString( &machineW );
1875 return ret;
1876 }
1877
1878
1879 /******************************************************************************
1880 * RegNotifyChangeKeyValue [ADVAPI32.@]
1881 *
1882 * PARAMS
1883 * hkey [I] Handle of key to watch
1884 * fWatchSubTree [I] Flag for subkey notification
1885 * fdwNotifyFilter [I] Changes to be reported
1886 * hEvent [I] Handle of signaled event
1887 * fAsync [I] Flag for asynchronous reporting
1888 */
1889 LONG WINAPI RegNotifyChangeKeyValue( HKEY hkey, BOOL fWatchSubTree,
1890 DWORD fdwNotifyFilter, HANDLE hEvent,
1891 BOOL fAsync )
1892 {
1893 LONG ret;
1894
1895 TRACE("(%p,%i,%ld,%p,%i)\n",hkey,fWatchSubTree,fdwNotifyFilter,
1896 hEvent,fAsync);
1897
1898 if( !fAsync )
1899 hEvent = CreateEventA(NULL, 0, 0, NULL);
1900
1901 SERVER_START_REQ( set_registry_notification )
1902 {
1903 req->hkey = hkey;
1904 req->event = hEvent;
1905 req->subtree = fWatchSubTree;
1906 req->filter = fdwNotifyFilter;
1907 ret = RtlNtStatusToDosError( wine_server_call(req) );
1908 }
1909 SERVER_END_REQ;
1910
1911 if( !fAsync )
1912 {
1913 if( ret == ERROR_SUCCESS )
1914 WaitForSingleObject( hEvent, INFINITE );
1915 CloseHandle( hEvent );
1916 }
1917
1918 return ret;
1919 }
1920
1921 /******************************************************************************
1922 * RegOpenUserClassesRoot [ADVAPI32.@]
1923 * Opens the HKEY_CLASSES_ROOT key for the user represented by the token
1924 *
1925 * PARAMS
1926 * hToken [I] Handle of token representing user
1927 * dwOptions [I] Reserved
1928 * samDesired [I] Desired access rights
1929 * phkResult [O] Address of buffer for opened handle
1930 *
1931 * NOTES:
1932 * On Windows 2000 and upwards the HKEY_CLASSES_ROOT key is a view of the
1933 * HKEY_LOCAL_MACHINE\Software\Classes and the
1934 * HKEY_CURRENT_USER\Software\Classes keys merged together.
1935 */
1936 LONG WINAPI RegOpenUserClassesRoot(
1937 HANDLE hToken,
1938 DWORD dwOptions,
1939 REGSAM samDesired,
1940 PHKEY phkResult
1941 )
1942 {
1943 FIXME("(%p, 0x%lx, 0x%lx, %p) semi-stub\n", hToken, dwOptions, samDesired, phkResult);
1944
1945 *phkResult = HKEY_CLASSES_ROOT;
1946 return ERROR_SUCCESS;
1947 }
Work in progress by Kai Blin