?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernelbase/tests: Add more PathAllocCanonicalize tests.
[wine.git] / server / registry.c
blob48a0f28c97e882e48ac9c821626a848d7f048ee9
1 /*
2 * Server-side registry management
3 *
4 * Copyright (C) 1999 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 /* To do:
22 * - symbolic links
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <assert.h>
29 #include <ctype.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <limits.h>
33 #include <stdio.h>
34 #include <stdarg.h>
35 #include <string.h>
36 #include <stdlib.h>
37 #include <sys/stat.h>
38 #include <unistd.h>
39
40 #include "ntstatus.h"
41 #define WIN32_NO_STATUS
42 #include "object.h"
43 #include "file.h"
44 #include "handle.h"
45 #include "request.h"
46 #include "process.h"
47 #include "unicode.h"
48 #include "security.h"
49
50 #include "winternl.h"
51 #include "wine/library.h"
52
53 struct notify
54 {
55 struct list entry; /* entry in list of notifications */
56 struct event *event; /* event to set when changing this key */
57 int subtree; /* true if subtree notification */
58 unsigned int filter; /* which events to notify on */
59 obj_handle_t hkey; /* hkey associated with this notification */
60 struct process *process; /* process in which the hkey is valid */
61 };
62
63 /* a registry key */
64 struct key
65 {
66 struct object obj; /* object header */
67 WCHAR *name; /* key name */
68 WCHAR *class; /* key class */
69 unsigned short namelen; /* length of key name */
70 unsigned short classlen; /* length of class name */
71 struct key *parent; /* parent key */
72 int last_subkey; /* last in use subkey */
73 int nb_subkeys; /* count of allocated subkeys */
74 struct key **subkeys; /* subkeys array */
75 int last_value; /* last in use value */
76 int nb_values; /* count of allocated values in array */
77 struct key_value *values; /* values array */
78 unsigned int flags; /* flags */
79 timeout_t modif; /* last modification time */
80 struct list notify_list; /* list of notifications */
81 };
82
83 /* key flags */
84 #define KEY_VOLATILE 0x0001 /* key is volatile (not saved to disk) */
85 #define KEY_DELETED 0x0002 /* key has been deleted */
86 #define KEY_DIRTY 0x0004 /* key has been modified */
87 #define KEY_SYMLINK 0x0008 /* key is a symbolic link */
88 #define KEY_WOW64 0x0010 /* key contains a Wow6432Node subkey */
89 #define KEY_WOWSHARE 0x0020 /* key is a Wow64 shared key (used for Software\Classes) */
90
91 /* a key value */
92 struct key_value
93 {
94 WCHAR *name; /* value name */
95 unsigned short namelen; /* length of value name */
96 unsigned int type; /* value type */
97 data_size_t len; /* value data length in bytes */
98 void *data; /* pointer to value data */
99 };
100
101 #define MIN_SUBKEYS 8 /* min. number of allocated subkeys per key */
102 #define MIN_VALUES 8 /* min. number of allocated values per key */
103
104 #define MAX_NAME_LEN 256 /* max. length of a key name */
105 #define MAX_VALUE_LEN 16383 /* max. length of a value name */
106
107 /* the root of the registry tree */
108 static struct key *root_key;
109
110 static const timeout_t ticks_1601_to_1970 = (timeout_t)86400 * (369 * 365 + 89) * TICKS_PER_SEC;
111 static const timeout_t save_period = 30 * -TICKS_PER_SEC; /* delay between periodic saves */
112 static struct timeout_user *save_timeout_user; /* saving timer */
113 static enum prefix_type { PREFIX_UNKNOWN, PREFIX_32BIT, PREFIX_64BIT } prefix_type;
114
115 static const WCHAR root_name[] = { '\\','R','e','g','i','s','t','r','y','\\' };
116 static const WCHAR wow6432node[] = {'W','o','w','6','4','3','2','N','o','d','e'};
117 static const WCHAR symlink_value[] = {'S','y','m','b','o','l','i','c','L','i','n','k','V','a','l','u','e'};
118 static const struct unicode_str symlink_str = { symlink_value, sizeof(symlink_value) };
119
120 static void set_periodic_save_timer(void);
121 static struct key_value *find_value( const struct key *key, const struct unicode_str *name, int *index );
122
123 /* information about where to save a registry branch */
124 struct save_branch_info
125 {
126 struct key *key;
127 const char *path;
128 };
129
130 #define MAX_SAVE_BRANCH_INFO 3
131 static int save_branch_count;
132 static struct save_branch_info save_branch_info[MAX_SAVE_BRANCH_INFO];
133
134
135 /* information about a file being loaded */
136 struct file_load_info
137 {
138 const char *filename; /* input file name */
139 FILE *file; /* input file */
140 char *buffer; /* line buffer */
141 int len; /* buffer length */
142 int line; /* current input line */
143 WCHAR *tmp; /* temp buffer to use while parsing input */
144 size_t tmplen; /* length of temp buffer */
145 };
146
147
148 static void key_dump( struct object *obj, int verbose );
149 static struct object_type *key_get_type( struct object *obj );
150 static unsigned int key_map_access( struct object *obj, unsigned int access );
151 static struct security_descriptor *key_get_sd( struct object *obj );
152 static int key_close_handle( struct object *obj, struct process *process, obj_handle_t handle );
153 static void key_destroy( struct object *obj );
154
155 static const struct object_ops key_ops =
156 {
157 sizeof(struct key), /* size */
158 key_dump, /* dump */
159 key_get_type, /* get_type */
160 no_add_queue, /* add_queue */
161 NULL, /* remove_queue */
162 NULL, /* signaled */
163 NULL, /* satisfied */
164 no_signal, /* signal */
165 no_get_fd, /* get_fd */
166 key_map_access, /* map_access */
167 key_get_sd, /* get_sd */
168 default_set_sd, /* set_sd */
169 no_lookup_name, /* lookup_name */
170 no_link_name, /* link_name */
171 NULL, /* unlink_name */
172 no_open_file, /* open_file */
173 no_kernel_obj_list, /* get_kernel_obj_list */
174 key_close_handle, /* close_handle */
175 key_destroy /* destroy */
176 };
177
178
179 static inline int is_wow6432node( const WCHAR *name, unsigned int len )
180 {
181 return (len == sizeof(wow6432node) &&
182 !memicmpW( name, wow6432node, ARRAY_SIZE( wow6432node )));
183 }
184
185 /*
186 * The registry text file format v2 used by this code is similar to the one
187 * used by REGEDIT import/export functionality, with the following differences:
188 * - strings and key names can contain \x escapes for Unicode
189 * - key names use escapes too in order to support Unicode
190 * - the modification time optionally follows the key name
191 * - REG_EXPAND_SZ and REG_MULTI_SZ are saved as strings instead of hex
192 */
193
194 /* dump the full path of a key */
195 static void dump_path( const struct key *key, const struct key *base, FILE *f )
196 {
197 if (key->parent && key->parent != base)
198 {
199 dump_path( key->parent, base, f );
200 fprintf( f, "\\\\" );
201 }
202 dump_strW( key->name, key->namelen / sizeof(WCHAR), f, "[]" );
203 }
204
205 /* dump a value to a text file */
206 static void dump_value( const struct key_value *value, FILE *f )
207 {
208 unsigned int i, dw;
209 int count;
210
211 if (value->namelen)
212 {
213 fputc( '\"', f );
214 count = 1 + dump_strW( value->name, value->namelen / sizeof(WCHAR), f, "\"\"" );
215 count += fprintf( f, "\"=" );
216 }
217 else count = fprintf( f, "@=" );
218
219 switch(value->type)
220 {
221 case REG_SZ:
222 case REG_EXPAND_SZ:
223 case REG_MULTI_SZ:
224 /* only output properly terminated strings in string format */
225 if (value->len < sizeof(WCHAR)) break;
226 if (value->len % sizeof(WCHAR)) break;
227 if (((WCHAR *)value->data)[value->len / sizeof(WCHAR) - 1]) break;
228 if (value->type != REG_SZ) fprintf( f, "str(%x):", value->type );
229 fputc( '\"', f );
230 dump_strW( (WCHAR *)value->data, value->len / sizeof(WCHAR), f, "\"\"" );
231 fprintf( f, "\"\n" );
232 return;
233
234 case REG_DWORD:
235 if (value->len != sizeof(dw)) break;
236 memcpy( &dw, value->data, sizeof(dw) );
237 fprintf( f, "dword:%08x\n", dw );
238 return;
239 }
240
241 if (value->type == REG_BINARY) count += fprintf( f, "hex:" );
242 else count += fprintf( f, "hex(%x):", value->type );
243 for (i = 0; i < value->len; i++)
244 {
245 count += fprintf( f, "%02x", *((unsigned char *)value->data + i) );
246 if (i < value->len-1)
247 {
248 fputc( ',', f );
249 if (++count > 76)
250 {
251 fprintf( f, "\\\n " );
252 count = 2;
253 }
254 }
255 }
256 fputc( '\n', f );
257 }
258
259 /* save a registry and all its subkeys to a text file */
260 static void save_subkeys( const struct key *key, const struct key *base, FILE *f )
261 {
262 int i;
263
264 if (key->flags & KEY_VOLATILE) return;
265 /* save key if it has either some values or no subkeys, or needs special options */
266 /* keys with no values but subkeys are saved implicitly by saving the subkeys */
267 if ((key->last_value >= 0) || (key->last_subkey == -1) || key->class || (key->flags & KEY_SYMLINK))
268 {
269 fprintf( f, "\n[" );
270 if (key != base) dump_path( key, base, f );
271 fprintf( f, "] %u\n", (unsigned int)((key->modif - ticks_1601_to_1970) / TICKS_PER_SEC) );
272 fprintf( f, "#time=%x%08x\n", (unsigned int)(key->modif >> 32), (unsigned int)key->modif );
273 if (key->class)
274 {
275 fprintf( f, "#class=\"" );
276 dump_strW( key->class, key->classlen / sizeof(WCHAR), f, "\"\"" );
277 fprintf( f, "\"\n" );
278 }
279 if (key->flags & KEY_SYMLINK) fputs( "#link\n", f );
280 for (i = 0; i <= key->last_value; i++) dump_value( &key->values[i], f );
281 }
282 for (i = 0; i <= key->last_subkey; i++) save_subkeys( key->subkeys[i], base, f );
283 }
284
285 static void dump_operation( const struct key *key, const struct key_value *value, const char *op )
286 {
287 fprintf( stderr, "%s key ", op );
288 if (key) dump_path( key, NULL, stderr );
289 else fprintf( stderr, "ERROR" );
290 if (value)
291 {
292 fprintf( stderr, " value ");
293 dump_value( value, stderr );
294 }
295 else fprintf( stderr, "\n" );
296 }
297
298 static void key_dump( struct object *obj, int verbose )
299 {
300 struct key *key = (struct key *)obj;
301 assert( obj->ops == &key_ops );
302 fprintf( stderr, "Key flags=%x ", key->flags );
303 dump_path( key, NULL, stderr );
304 fprintf( stderr, "\n" );
305 }
306
307 static struct object_type *key_get_type( struct object *obj )
308 {
309 static const WCHAR name[] = {'K','e','y'};
310 static const struct unicode_str str = { name, sizeof(name) };
311 return get_object_type( &str );
312 }
313
314 /* notify waiter and maybe delete the notification */
315 static void do_notification( struct key *key, struct notify *notify, int del )
316 {
317 if (notify->event)
318 {
319 set_event( notify->event );
320 release_object( notify->event );
321 notify->event = NULL;
322 }
323 if (del)
324 {
325 list_remove( &notify->entry );
326 free( notify );
327 }
328 }
329
330 static inline struct notify *find_notify( struct key *key, struct process *process, obj_handle_t hkey )
331 {
332 struct notify *notify;
333
334 LIST_FOR_EACH_ENTRY( notify, &key->notify_list, struct notify, entry )
335 {
336 if (notify->process == process && notify->hkey == hkey) return notify;
337 }
338 return NULL;
339 }
340
341 static unsigned int key_map_access( struct object *obj, unsigned int access )
342 {
343 if (access & GENERIC_READ) access |= KEY_READ;
344 if (access & GENERIC_WRITE) access |= KEY_WRITE;
345 if (access & GENERIC_EXECUTE) access |= KEY_EXECUTE;
346 if (access & GENERIC_ALL) access |= KEY_ALL_ACCESS;
347 /* filter the WOW64 masks, as they aren't real access bits */
348 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL |
349 KEY_WOW64_64KEY | KEY_WOW64_32KEY);
350 }
351
352 static struct security_descriptor *key_get_sd( struct object *obj )
353 {
354 static struct security_descriptor *key_default_sd;
355
356 if (obj->sd) return obj->sd;
357
358 if (!key_default_sd)
359 {
360 size_t users_sid_len = security_sid_len( security_builtin_users_sid );
361 size_t admins_sid_len = security_sid_len( security_builtin_admins_sid );
362 size_t dacl_len = sizeof(ACL) + 2 * offsetof( ACCESS_ALLOWED_ACE, SidStart )
363 + users_sid_len + admins_sid_len;
364 ACCESS_ALLOWED_ACE *aaa;
365 ACL *dacl;
366
367 key_default_sd = mem_alloc( sizeof(*key_default_sd) + 2 * admins_sid_len + dacl_len );
368 key_default_sd->control = SE_DACL_PRESENT;
369 key_default_sd->owner_len = admins_sid_len;
370 key_default_sd->group_len = admins_sid_len;
371 key_default_sd->sacl_len = 0;
372 key_default_sd->dacl_len = dacl_len;
373 memcpy( key_default_sd + 1, security_builtin_admins_sid, admins_sid_len );
374 memcpy( (char *)(key_default_sd + 1) + admins_sid_len, security_builtin_admins_sid, admins_sid_len );
375
376 dacl = (ACL *)((char *)(key_default_sd + 1) + 2 * admins_sid_len);
377 dacl->AclRevision = ACL_REVISION;
378 dacl->Sbz1 = 0;
379 dacl->AclSize = dacl_len;
380 dacl->AceCount = 2;
381 dacl->Sbz2 = 0;
382 aaa = (ACCESS_ALLOWED_ACE *)(dacl + 1);
383 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
384 aaa->Header.AceFlags = INHERIT_ONLY_ACE | CONTAINER_INHERIT_ACE;
385 aaa->Header.AceSize = offsetof( ACCESS_ALLOWED_ACE, SidStart ) + users_sid_len;
386 aaa->Mask = GENERIC_READ;
387 memcpy( &aaa->SidStart, security_builtin_users_sid, users_sid_len );
388 aaa = (ACCESS_ALLOWED_ACE *)((char *)aaa + aaa->Header.AceSize);
389 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
390 aaa->Header.AceFlags = 0;
391 aaa->Header.AceSize = offsetof( ACCESS_ALLOWED_ACE, SidStart ) + admins_sid_len;
392 aaa->Mask = KEY_ALL_ACCESS;
393 memcpy( &aaa->SidStart, security_builtin_admins_sid, admins_sid_len );
394 }
395 return key_default_sd;
396 }
397
398 /* close the notification associated with a handle */
399 static int key_close_handle( struct object *obj, struct process *process, obj_handle_t handle )
400 {
401 struct key * key = (struct key *) obj;
402 struct notify *notify = find_notify( key, process, handle );
403 if (notify) do_notification( key, notify, 1 );
404 return 1; /* ok to close */
405 }
406
407 static void key_destroy( struct object *obj )
408 {
409 int i;
410 struct list *ptr;
411 struct key *key = (struct key *)obj;
412 assert( obj->ops == &key_ops );
413
414 free( key->name );
415 free( key->class );
416 for (i = 0; i <= key->last_value; i++)
417 {
418 free( key->values[i].name );
419 free( key->values[i].data );
420 }
421 free( key->values );
422 for (i = 0; i <= key->last_subkey; i++)
423 {
424 key->subkeys[i]->parent = NULL;
425 release_object( key->subkeys[i] );
426 }
427 free( key->subkeys );
428 /* unconditionally notify everything waiting on this key */
429 while ((ptr = list_head( &key->notify_list )))
430 {
431 struct notify *notify = LIST_ENTRY( ptr, struct notify, entry );
432 do_notification( key, notify, 1 );
433 }
434 }
435
436 /* get the request vararg as registry path */
437 static inline void get_req_path( struct unicode_str *str, int skip_root )
438 {
439 str->str = get_req_data();
440 str->len = (get_req_data_size() / sizeof(WCHAR)) * sizeof(WCHAR);
441
442 if (skip_root && str->len >= sizeof(root_name) &&
443 !memicmpW( str->str, root_name, ARRAY_SIZE( root_name )))
444 {
445 str->str += ARRAY_SIZE( root_name );
446 str->len -= sizeof(root_name);
447 }
448 }
449
450 /* return the next token in a given path */
451 /* token->str must point inside the path, or be NULL for the first call */
452 static struct unicode_str *get_path_token( const struct unicode_str *path, struct unicode_str *token )
453 {
454 data_size_t i = 0, len = path->len / sizeof(WCHAR);
455
456 if (!token->str) /* first time */
457 {
458 /* path cannot start with a backslash */
459 if (len && path->str[0] == '\\')
460 {
461 set_error( STATUS_OBJECT_PATH_INVALID );
462 return NULL;
463 }
464 }
465 else
466 {
467 i = token->str - path->str;
468 i += token->len / sizeof(WCHAR);
469 while (i < len && path->str[i] == '\\') i++;
470 }
471 token->str = path->str + i;
472 while (i < len && path->str[i] != '\\') i++;
473 token->len = (path->str + i - token->str) * sizeof(WCHAR);
474 return token;
475 }
476
477 /* allocate a key object */
478 static struct key *alloc_key( const struct unicode_str *name, timeout_t modif )
479 {
480 struct key *key;
481 if ((key = alloc_object( &key_ops )))
482 {
483 key->name = NULL;
484 key->class = NULL;
485 key->namelen = name->len;
486 key->classlen = 0;
487 key->flags = 0;
488 key->last_subkey = -1;
489 key->nb_subkeys = 0;
490 key->subkeys = NULL;
491 key->nb_values = 0;
492 key->last_value = -1;
493 key->values = NULL;
494 key->modif = modif;
495 key->parent = NULL;
496 list_init( &key->notify_list );
497 if (name->len && !(key->name = memdup( name->str, name->len )))
498 {
499 release_object( key );
500 key = NULL;
501 }
502 }
503 return key;
504 }
505
506 /* mark a key and all its parents as dirty (modified) */
507 static void make_dirty( struct key *key )
508 {
509 while (key)
510 {
511 if (key->flags & (KEY_DIRTY|KEY_VOLATILE)) return; /* nothing to do */
512 key->flags |= KEY_DIRTY;
513 key = key->parent;
514 }
515 }
516
517 /* mark a key and all its subkeys as clean (not modified) */
518 static void make_clean( struct key *key )
519 {
520 int i;
521
522 if (key->flags & KEY_VOLATILE) return;
523 if (!(key->flags & KEY_DIRTY)) return;
524 key->flags &= ~KEY_DIRTY;
525 for (i = 0; i <= key->last_subkey; i++) make_clean( key->subkeys[i] );
526 }
527
528 /* go through all the notifications and send them if necessary */
529 static void check_notify( struct key *key, unsigned int change, int not_subtree )
530 {
531 struct list *ptr, *next;
532
533 LIST_FOR_EACH_SAFE( ptr, next, &key->notify_list )
534 {
535 struct notify *n = LIST_ENTRY( ptr, struct notify, entry );
536 if ( ( not_subtree || n->subtree ) && ( change & n->filter ) )
537 do_notification( key, n, 0 );
538 }
539 }
540
541 /* update key modification time */
542 static void touch_key( struct key *key, unsigned int change )
543 {
544 struct key *k;
545
546 key->modif = current_time;
547 make_dirty( key );
548
549 /* do notifications */
550 check_notify( key, change, 1 );
551 for ( k = key->parent; k; k = k->parent )
552 check_notify( k, change, 0 );
553 }
554
555 /* try to grow the array of subkeys; return 1 if OK, 0 on error */
556 static int grow_subkeys( struct key *key )
557 {
558 struct key **new_subkeys;
559 int nb_subkeys;
560
561 if (key->nb_subkeys)
562 {
563 nb_subkeys = key->nb_subkeys + (key->nb_subkeys / 2); /* grow by 50% */
564 if (!(new_subkeys = realloc( key->subkeys, nb_subkeys * sizeof(*new_subkeys) )))
565 {
566 set_error( STATUS_NO_MEMORY );
567 return 0;
568 }
569 }
570 else
571 {
572 nb_subkeys = MIN_SUBKEYS;
573 if (!(new_subkeys = mem_alloc( nb_subkeys * sizeof(*new_subkeys) ))) return 0;
574 }
575 key->subkeys = new_subkeys;
576 key->nb_subkeys = nb_subkeys;
577 return 1;
578 }
579
580 /* allocate a subkey for a given key, and return its index */
581 static struct key *alloc_subkey( struct key *parent, const struct unicode_str *name,
582 int index, timeout_t modif )
583 {
584 struct key *key;
585 int i;
586
587 if (name->len > MAX_NAME_LEN * sizeof(WCHAR))
588 {
589 set_error( STATUS_INVALID_PARAMETER );
590 return NULL;
591 }
592 if (parent->last_subkey + 1 == parent->nb_subkeys)
593 {
594 /* need to grow the array */
595 if (!grow_subkeys( parent )) return NULL;
596 }
597 if ((key = alloc_key( name, modif )) != NULL)
598 {
599 key->parent = parent;
600 for (i = ++parent->last_subkey; i > index; i--)
601 parent->subkeys[i] = parent->subkeys[i-1];
602 parent->subkeys[index] = key;
603 if (is_wow6432node( key->name, key->namelen ) && !is_wow6432node( parent->name, parent->namelen ))
604 parent->flags |= KEY_WOW64;
605 }
606 return key;
607 }
608
609 /* free a subkey of a given key */
610 static void free_subkey( struct key *parent, int index )
611 {
612 struct key *key;
613 int i, nb_subkeys;
614
615 assert( index >= 0 );
616 assert( index <= parent->last_subkey );
617
618 key = parent->subkeys[index];
619 for (i = index; i < parent->last_subkey; i++) parent->subkeys[i] = parent->subkeys[i + 1];
620 parent->last_subkey--;
621 key->flags |= KEY_DELETED;
622 key->parent = NULL;
623 if (is_wow6432node( key->name, key->namelen )) parent->flags &= ~KEY_WOW64;
624 release_object( key );
625
626 /* try to shrink the array */
627 nb_subkeys = parent->nb_subkeys;
628 if (nb_subkeys > MIN_SUBKEYS && parent->last_subkey < nb_subkeys / 2)
629 {
630 struct key **new_subkeys;
631 nb_subkeys -= nb_subkeys / 3; /* shrink by 33% */
632 if (nb_subkeys < MIN_SUBKEYS) nb_subkeys = MIN_SUBKEYS;
633 if (!(new_subkeys = realloc( parent->subkeys, nb_subkeys * sizeof(*new_subkeys) ))) return;
634 parent->subkeys = new_subkeys;
635 parent->nb_subkeys = nb_subkeys;
636 }
637 }
638
639 /* find the named child of a given key and return its index */
640 static struct key *find_subkey( const struct key *key, const struct unicode_str *name, int *index )
641 {
642 int i, min, max, res;
643 data_size_t len;
644
645 min = 0;
646 max = key->last_subkey;
647 while (min <= max)
648 {
649 i = (min + max) / 2;
650 len = min( key->subkeys[i]->namelen, name->len );
651 res = memicmpW( key->subkeys[i]->name, name->str, len / sizeof(WCHAR) );
652 if (!res) res = key->subkeys[i]->namelen - name->len;
653 if (!res)
654 {
655 *index = i;
656 return key->subkeys[i];
657 }
658 if (res > 0) max = i - 1;
659 else min = i + 1;
660 }
661 *index = min; /* this is where we should insert it */
662 return NULL;
663 }
664
665 /* return the wow64 variant of the key, or the key itself if none */
666 static struct key *find_wow64_subkey( struct key *key, const struct unicode_str *name )
667 {
668 static const struct unicode_str wow6432node_str = { wow6432node, sizeof(wow6432node) };
669 int index;
670
671 if (!(key->flags & KEY_WOW64)) return key;
672 if (!is_wow6432node( name->str, name->len ))
673 {
674 key = find_subkey( key, &wow6432node_str, &index );
675 assert( key ); /* if KEY_WOW64 is set we must find it */
676 }
677 return key;
678 }
679
680
681 /* follow a symlink and return the resolved key */
682 static struct key *follow_symlink( struct key *key, int iteration )
683 {
684 struct unicode_str path, token;
685 struct key_value *value;
686 int index;
687
688 if (iteration > 16) return NULL;
689 if (!(key->flags & KEY_SYMLINK)) return key;
690 if (!(value = find_value( key, &symlink_str, &index ))) return NULL;
691
692 path.str = value->data;
693 path.len = (value->len / sizeof(WCHAR)) * sizeof(WCHAR);
694 if (path.len <= sizeof(root_name)) return NULL;
695 if (memicmpW( path.str, root_name, ARRAY_SIZE( root_name ))) return NULL;
696 path.str += ARRAY_SIZE( root_name );
697 path.len -= sizeof(root_name);
698
699 key = root_key;
700 token.str = NULL;
701 if (!get_path_token( &path, &token )) return NULL;
702 while (token.len)
703 {
704 if (!(key = find_subkey( key, &token, &index ))) break;
705 if (!(key = follow_symlink( key, iteration + 1 ))) break;
706 get_path_token( &path, &token );
707 }
708 return key;
709 }
710
711 /* open a key until we find an element that doesn't exist */
712 /* helper for open_key and create_key */
713 static struct key *open_key_prefix( struct key *key, const struct unicode_str *name,
714 unsigned int access, struct unicode_str *token, int *index )
715 {
716 token->str = NULL;
717 if (!get_path_token( name, token )) return NULL;
718 if (access & KEY_WOW64_32KEY) key = find_wow64_subkey( key, token );
719 while (token->len)
720 {
721 struct key *subkey;
722 if (!(subkey = find_subkey( key, token, index )))
723 {
724 if ((key->flags & KEY_WOWSHARE) && !(access & KEY_WOW64_64KEY))
725 {
726 /* try in the 64-bit parent */
727 key = key->parent;
728 subkey = find_subkey( key, token, index );
729 }
730 }
731 if (!subkey) break;
732 key = subkey;
733 get_path_token( name, token );
734 if (!token->len) break;
735 if (!(access & KEY_WOW64_64KEY)) key = find_wow64_subkey( key, token );
736 if (!(key = follow_symlink( key, 0 )))
737 {
738 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
739 return NULL;
740 }
741 }
742 return key;
743 }
744
745 /* open a subkey */
746 static struct key *open_key( struct key *key, const struct unicode_str *name, unsigned int access,
747 unsigned int attributes )
748 {
749 int index;
750 struct unicode_str token;
751
752 if (!(key = open_key_prefix( key, name, access, &token, &index ))) return NULL;
753
754 if (token.len)
755 {
756 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
757 return NULL;
758 }
759 if (!(access & KEY_WOW64_64KEY)) key = find_wow64_subkey( key, &token );
760 if (!(attributes & OBJ_OPENLINK) && !(key = follow_symlink( key, 0 )))
761 {
762 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
763 return NULL;
764 }
765 if (debug_level > 1) dump_operation( key, NULL, "Open" );
766 grab_object( key );
767 return key;
768 }
769
770 /* create a subkey */
771 static struct key *create_key( struct key *key, const struct unicode_str *name,
772 const struct unicode_str *class, unsigned int options,
773 unsigned int access, unsigned int attributes,
774 const struct security_descriptor *sd, int *created )
775 {
776 int index;
777 struct unicode_str token, next;
778
779 *created = 0;
780 if (!(key = open_key_prefix( key, name, access, &token, &index ))) return NULL;
781
782 if (!token.len) /* the key already exists */
783 {
784 if (!(access & KEY_WOW64_64KEY)) key = find_wow64_subkey( key, &token );
785 if (options & REG_OPTION_CREATE_LINK)
786 {
787 set_error( STATUS_OBJECT_NAME_COLLISION );
788 return NULL;
789 }
790 if (!(attributes & OBJ_OPENLINK) && !(key = follow_symlink( key, 0 )))
791 {
792 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
793 return NULL;
794 }
795 if (debug_level > 1) dump_operation( key, NULL, "Open" );
796 grab_object( key );
797 return key;
798 }
799
800 /* token must be the last path component at this point */
801 next = token;
802 get_path_token( name, &next );
803 if (next.len)
804 {
805 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
806 return NULL;
807 }
808
809 if ((key->flags & KEY_VOLATILE) && !(options & REG_OPTION_VOLATILE))
810 {
811 set_error( STATUS_CHILD_MUST_BE_VOLATILE );
812 return NULL;
813 }
814 *created = 1;
815 make_dirty( key );
816 if (!(key = alloc_subkey( key, &token, index, current_time ))) return NULL;
817
818 if (options & REG_OPTION_CREATE_LINK) key->flags |= KEY_SYMLINK;
819 if (options & REG_OPTION_VOLATILE) key->flags |= KEY_VOLATILE;
820 else key->flags |= KEY_DIRTY;
821
822 if (sd) default_set_sd( &key->obj, sd, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
823 DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION );
824
825 if (debug_level > 1) dump_operation( key, NULL, "Create" );
826 if (class && class->len)
827 {
828 key->classlen = class->len;
829 free(key->class);
830 if (!(key->class = memdup( class->str, key->classlen ))) key->classlen = 0;
831 }
832 touch_key( key->parent, REG_NOTIFY_CHANGE_NAME );
833 grab_object( key );
834 return key;
835 }
836
837 /* recursively create a subkey (for internal use only) */
838 static struct key *create_key_recursive( struct key *key, const struct unicode_str *name, timeout_t modif )
839 {
840 struct key *base;
841 int index;
842 struct unicode_str token;
843
844 token.str = NULL;
845 if (!get_path_token( name, &token )) return NULL;
846 while (token.len)
847 {
848 struct key *subkey;
849 if (!(subkey = find_subkey( key, &token, &index ))) break;
850 key = subkey;
851 if (!(key = follow_symlink( key, 0 )))
852 {
853 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
854 return NULL;
855 }
856 get_path_token( name, &token );
857 }
858
859 if (token.len)
860 {
861 if (!(key = alloc_subkey( key, &token, index, modif ))) return NULL;
862 base = key;
863 for (;;)
864 {
865 get_path_token( name, &token );
866 if (!token.len) break;
867 /* we know the index is always 0 in a new key */
868 if (!(key = alloc_subkey( key, &token, 0, modif )))
869 {
870 free_subkey( base, index );
871 return NULL;
872 }
873 }
874 }
875
876 grab_object( key );
877 return key;
878 }
879
880 /* query information about a key or a subkey */
881 static void enum_key( const struct key *key, int index, int info_class,
882 struct enum_key_reply *reply )
883 {
884 static const WCHAR backslash[] = { '\\' };
885 int i;
886 data_size_t len, namelen, classlen;
887 data_size_t max_subkey = 0, max_class = 0;
888 data_size_t max_value = 0, max_data = 0;
889 const struct key *k;
890 char *data;
891
892 if (index != -1) /* -1 means use the specified key directly */
893 {
894 if ((index < 0) || (index > key->last_subkey))
895 {
896 set_error( STATUS_NO_MORE_ENTRIES );
897 return;
898 }
899 key = key->subkeys[index];
900 }
901
902 namelen = key->namelen;
903 classlen = key->classlen;
904
905 switch(info_class)
906 {
907 case KeyNameInformation:
908 namelen = 0;
909 for (k = key; k != root_key; k = k->parent)
910 namelen += k->namelen + sizeof(backslash);
911 if (!namelen) return;
912 namelen += sizeof(root_name) - sizeof(backslash);
913 /* fall through */
914 case KeyBasicInformation:
915 classlen = 0; /* only return the name */
916 /* fall through */
917 case KeyNodeInformation:
918 reply->max_subkey = 0;
919 reply->max_class = 0;
920 reply->max_value = 0;
921 reply->max_data = 0;
922 break;
923 case KeyFullInformation:
924 case KeyCachedInformation:
925 for (i = 0; i <= key->last_subkey; i++)
926 {
927 if (key->subkeys[i]->namelen > max_subkey) max_subkey = key->subkeys[i]->namelen;
928 if (key->subkeys[i]->classlen > max_class) max_class = key->subkeys[i]->classlen;
929 }
930 for (i = 0; i <= key->last_value; i++)
931 {
932 if (key->values[i].namelen > max_value) max_value = key->values[i].namelen;
933 if (key->values[i].len > max_data) max_data = key->values[i].len;
934 }
935 reply->max_subkey = max_subkey;
936 reply->max_class = max_class;
937 reply->max_value = max_value;
938 reply->max_data = max_data;
939 reply->namelen = namelen;
940 if (info_class == KeyCachedInformation)
941 classlen = 0; /* don't return any data, only its size */
942 namelen = 0; /* don't return name */
943 break;
944 default:
945 set_error( STATUS_INVALID_PARAMETER );
946 return;
947 }
948 reply->subkeys = key->last_subkey + 1;
949 reply->values = key->last_value + 1;
950 reply->modif = key->modif;
951 reply->total = namelen + classlen;
952
953 len = min( reply->total, get_reply_max_size() );
954 if (len && (data = set_reply_data_size( len )))
955 {
956 if (len > namelen)
957 {
958 reply->namelen = namelen;
959 memcpy( data, key->name, namelen );
960 memcpy( data + namelen, key->class, len - namelen );
961 }
962 else if (info_class == KeyNameInformation)
963 {
964 data_size_t pos = namelen;
965 reply->namelen = namelen;
966 for (k = key; k != root_key; k = k->parent)
967 {
968 pos -= k->namelen;
969 if (pos < len) memcpy( data + pos, k->name,
970 min( k->namelen, len - pos ) );
971 pos -= sizeof(backslash);
972 if (pos < len) memcpy( data + pos, backslash,
973 min( sizeof(backslash), len - pos ) );
974 }
975 memcpy( data, root_name, min( sizeof(root_name) - sizeof(backslash), len ) );
976 }
977 else
978 {
979 reply->namelen = len;
980 memcpy( data, key->name, len );
981 }
982 }
983 if (debug_level > 1) dump_operation( key, NULL, "Enum" );
984 }
985
986 /* delete a key and its values */
987 static int delete_key( struct key *key, int recurse )
988 {
989 int index;
990 struct key *parent = key->parent;
991
992 /* must find parent and index */
993 if (key == root_key)
994 {
995 set_error( STATUS_ACCESS_DENIED );
996 return -1;
997 }
998 assert( parent );
999
1000 while (recurse && (key->last_subkey>=0))
1001 if (0 > delete_key(key->subkeys[key->last_subkey], 1))
1002 return -1;
1003
1004 for (index = 0; index <= parent->last_subkey; index++)
1005 if (parent->subkeys[index] == key) break;
1006 assert( index <= parent->last_subkey );
1007
1008 /* we can only delete a key that has no subkeys */
1009 if (key->last_subkey >= 0)
1010 {
1011 set_error( STATUS_ACCESS_DENIED );
1012 return -1;
1013 }
1014
1015 if (debug_level > 1) dump_operation( key, NULL, "Delete" );
1016 free_subkey( parent, index );
1017 touch_key( parent, REG_NOTIFY_CHANGE_NAME );
1018 return 0;
1019 }
1020
1021 /* try to grow the array of values; return 1 if OK, 0 on error */
1022 static int grow_values( struct key *key )
1023 {
1024 struct key_value *new_val;
1025 int nb_values;
1026
1027 if (key->nb_values)
1028 {
1029 nb_values = key->nb_values + (key->nb_values / 2); /* grow by 50% */
1030 if (!(new_val = realloc( key->values, nb_values * sizeof(*new_val) )))
1031 {
1032 set_error( STATUS_NO_MEMORY );
1033 return 0;
1034 }
1035 }
1036 else
1037 {
1038 nb_values = MIN_VALUES;
1039 if (!(new_val = mem_alloc( nb_values * sizeof(*new_val) ))) return 0;
1040 }
1041 key->values = new_val;
1042 key->nb_values = nb_values;
1043 return 1;
1044 }
1045
1046 /* find the named value of a given key and return its index in the array */
1047 static struct key_value *find_value( const struct key *key, const struct unicode_str *name, int *index )
1048 {
1049 int i, min, max, res;
1050 data_size_t len;
1051
1052 min = 0;
1053 max = key->last_value;
1054 while (min <= max)
1055 {
1056 i = (min + max) / 2;
1057 len = min( key->values[i].namelen, name->len );
1058 res = memicmpW( key->values[i].name, name->str, len / sizeof(WCHAR) );
1059 if (!res) res = key->values[i].namelen - name->len;
1060 if (!res)
1061 {
1062 *index = i;
1063 return &key->values[i];
1064 }
1065 if (res > 0) max = i - 1;
1066 else min = i + 1;
1067 }
1068 *index = min; /* this is where we should insert it */
1069 return NULL;
1070 }
1071
1072 /* insert a new value; the index must have been returned by find_value */
1073 static struct key_value *insert_value( struct key *key, const struct unicode_str *name, int index )
1074 {
1075 struct key_value *value;
1076 WCHAR *new_name = NULL;
1077 int i;
1078
1079 if (name->len > MAX_VALUE_LEN * sizeof(WCHAR))
1080 {
1081 set_error( STATUS_NAME_TOO_LONG );
1082 return NULL;
1083 }
1084 if (key->last_value + 1 == key->nb_values)
1085 {
1086 if (!grow_values( key )) return NULL;
1087 }
1088 if (name->len && !(new_name = memdup( name->str, name->len ))) return NULL;
1089 for (i = ++key->last_value; i > index; i--) key->values[i] = key->values[i - 1];
1090 value = &key->values[index];
1091 value->name = new_name;
1092 value->namelen = name->len;
1093 value->len = 0;
1094 value->data = NULL;
1095 return value;
1096 }
1097
1098 /* set a key value */
1099 static void set_value( struct key *key, const struct unicode_str *name,
1100 int type, const void *data, data_size_t len )
1101 {
1102 struct key_value *value;
1103 void *ptr = NULL;
1104 int index;
1105
1106 if ((value = find_value( key, name, &index )))
1107 {
1108 /* check if the new value is identical to the existing one */
1109 if (value->type == type && value->len == len &&
1110 value->data && !memcmp( value->data, data, len ))
1111 {
1112 if (debug_level > 1) dump_operation( key, value, "Skip setting" );
1113 return;
1114 }
1115 }
1116
1117 if (key->flags & KEY_SYMLINK)
1118 {
1119 if (type != REG_LINK || name->len != symlink_str.len ||
1120 memicmpW( name->str, symlink_str.str, name->len / sizeof(WCHAR) ))
1121 {
1122 set_error( STATUS_ACCESS_DENIED );
1123 return;
1124 }
1125 }
1126
1127 if (len && !(ptr = memdup( data, len ))) return;
1128
1129 if (!value)
1130 {
1131 if (!(value = insert_value( key, name, index )))
1132 {
1133 free( ptr );
1134 return;
1135 }
1136 }
1137 else free( value->data ); /* already existing, free previous data */
1138
1139 value->type = type;
1140 value->len = len;
1141 value->data = ptr;
1142 touch_key( key, REG_NOTIFY_CHANGE_LAST_SET );
1143 if (debug_level > 1) dump_operation( key, value, "Set" );
1144 }
1145
1146 /* get a key value */
1147 static void get_value( struct key *key, const struct unicode_str *name, int *type, data_size_t *len )
1148 {
1149 struct key_value *value;
1150 int index;
1151
1152 if ((value = find_value( key, name, &index )))
1153 {
1154 *type = value->type;
1155 *len = value->len;
1156 if (value->data) set_reply_data( value->data, min( value->len, get_reply_max_size() ));
1157 if (debug_level > 1) dump_operation( key, value, "Get" );
1158 }
1159 else
1160 {
1161 *type = -1;
1162 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
1163 }
1164 }
1165
1166 /* enumerate a key value */
1167 static void enum_value( struct key *key, int i, int info_class, struct enum_key_value_reply *reply )
1168 {
1169 struct key_value *value;
1170
1171 if (i < 0 || i > key->last_value) set_error( STATUS_NO_MORE_ENTRIES );
1172 else
1173 {
1174 void *data;
1175 data_size_t namelen, maxlen;
1176
1177 value = &key->values[i];
1178 reply->type = value->type;
1179 namelen = value->namelen;
1180
1181 switch(info_class)
1182 {
1183 case KeyValueBasicInformation:
1184 reply->total = namelen;
1185 break;
1186 case KeyValueFullInformation:
1187 reply->total = namelen + value->len;
1188 break;
1189 case KeyValuePartialInformation:
1190 reply->total = value->len;
1191 namelen = 0;
1192 break;
1193 default:
1194 set_error( STATUS_INVALID_PARAMETER );
1195 return;
1196 }
1197
1198 maxlen = min( reply->total, get_reply_max_size() );
1199 if (maxlen && ((data = set_reply_data_size( maxlen ))))
1200 {
1201 if (maxlen > namelen)
1202 {
1203 reply->namelen = namelen;
1204 memcpy( data, value->name, namelen );
1205 memcpy( (char *)data + namelen, value->data, maxlen - namelen );
1206 }
1207 else
1208 {
1209 reply->namelen = maxlen;
1210 memcpy( data, value->name, maxlen );
1211 }
1212 }
1213 if (debug_level > 1) dump_operation( key, value, "Enum" );
1214 }
1215 }
1216
1217 /* delete a value */
1218 static void delete_value( struct key *key, const struct unicode_str *name )
1219 {
1220 struct key_value *value;
1221 int i, index, nb_values;
1222
1223 if (!(value = find_value( key, name, &index )))
1224 {
1225 set_error( STATUS_OBJECT_NAME_NOT_FOUND );
1226 return;
1227 }
1228 if (debug_level > 1) dump_operation( key, value, "Delete" );
1229 free( value->name );
1230 free( value->data );
1231 for (i = index; i < key->last_value; i++) key->values[i] = key->values[i + 1];
1232 key->last_value--;
1233 touch_key( key, REG_NOTIFY_CHANGE_LAST_SET );
1234
1235 /* try to shrink the array */
1236 nb_values = key->nb_values;
1237 if (nb_values > MIN_VALUES && key->last_value < nb_values / 2)
1238 {
1239 struct key_value *new_val;
1240 nb_values -= nb_values / 3; /* shrink by 33% */
1241 if (nb_values < MIN_VALUES) nb_values = MIN_VALUES;
1242 if (!(new_val = realloc( key->values, nb_values * sizeof(*new_val) ))) return;
1243 key->values = new_val;
1244 key->nb_values = nb_values;
1245 }
1246 }
1247
1248 /* get the registry key corresponding to an hkey handle */
1249 static struct key *get_hkey_obj( obj_handle_t hkey, unsigned int access )
1250 {
1251 struct key *key = (struct key *)get_handle_obj( current->process, hkey, access, &key_ops );
1252
1253 if (key && key->flags & KEY_DELETED)
1254 {
1255 set_error( STATUS_KEY_DELETED );
1256 release_object( key );
1257 key = NULL;
1258 }
1259 return key;
1260 }
1261
1262 /* get the registry key corresponding to a parent key handle */
1263 static inline struct key *get_parent_hkey_obj( obj_handle_t hkey )
1264 {
1265 if (!hkey) return (struct key *)grab_object( root_key );
1266 return get_hkey_obj( hkey, 0 );
1267 }
1268
1269 /* read a line from the input file */
1270 static int read_next_line( struct file_load_info *info )
1271 {
1272 char *newbuf;
1273 int newlen, pos = 0;
1274
1275 info->line++;
1276 for (;;)
1277 {
1278 if (!fgets( info->buffer + pos, info->len - pos, info->file ))
1279 return (pos != 0); /* EOF */
1280 pos = strlen(info->buffer);
1281 if (info->buffer[pos-1] == '\n')
1282 {
1283 /* got a full line */
1284 info->buffer[--pos] = 0;
1285 if (pos > 0 && info->buffer[pos-1] == '\r') info->buffer[pos-1] = 0;
1286 return 1;
1287 }
1288 if (pos < info->len - 1) return 1; /* EOF but something was read */
1289
1290 /* need to enlarge the buffer */
1291 newlen = info->len + info->len / 2;
1292 if (!(newbuf = realloc( info->buffer, newlen )))
1293 {
1294 set_error( STATUS_NO_MEMORY );
1295 return -1;
1296 }
1297 info->buffer = newbuf;
1298 info->len = newlen;
1299 }
1300 }
1301
1302 /* make sure the temp buffer holds enough space */
1303 static int get_file_tmp_space( struct file_load_info *info, size_t size )
1304 {
1305 WCHAR *tmp;
1306 if (info->tmplen >= size) return 1;
1307 if (!(tmp = realloc( info->tmp, size )))
1308 {
1309 set_error( STATUS_NO_MEMORY );
1310 return 0;
1311 }
1312 info->tmp = tmp;
1313 info->tmplen = size;
1314 return 1;
1315 }
1316
1317 /* report an error while loading an input file */
1318 static void file_read_error( const char *err, struct file_load_info *info )
1319 {
1320 if (info->filename)
1321 fprintf( stderr, "%s:%d: %s '%s'\n", info->filename, info->line, err, info->buffer );
1322 else
1323 fprintf( stderr, "<fd>:%d: %s '%s'\n", info->line, err, info->buffer );
1324 }
1325
1326 /* convert a data type tag to a value type */
1327 static int get_data_type( const char *buffer, int *type, int *parse_type )
1328 {
1329 struct data_type { const char *tag; int len; int type; int parse_type; };
1330
1331 static const struct data_type data_types[] =
1332 { /* actual type */ /* type to assume for parsing */
1333 { "\"", 1, REG_SZ, REG_SZ },
1334 { "str:\"", 5, REG_SZ, REG_SZ },
1335 { "str(2):\"", 8, REG_EXPAND_SZ, REG_SZ },
1336 { "str(7):\"", 8, REG_MULTI_SZ, REG_SZ },
1337 { "hex:", 4, REG_BINARY, REG_BINARY },
1338 { "dword:", 6, REG_DWORD, REG_DWORD },
1339 { "hex(", 4, -1, REG_BINARY },
1340 { NULL, 0, 0, 0 }
1341 };
1342
1343 const struct data_type *ptr;
1344 char *end;
1345
1346 for (ptr = data_types; ptr->tag; ptr++)
1347 {
1348 if (strncmp( ptr->tag, buffer, ptr->len )) continue;
1349 *parse_type = ptr->parse_type;
1350 if ((*type = ptr->type) != -1) return ptr->len;
1351 /* "hex(xx):" is special */
1352 *type = (int)strtoul( buffer + 4, &end, 16 );
1353 if ((end <= buffer) || strncmp( end, "):", 2 )) return 0;
1354 return end + 2 - buffer;
1355 }
1356 return 0;
1357 }
1358
1359 /* load and create a key from the input file */
1360 static struct key *load_key( struct key *base, const char *buffer, int prefix_len,
1361 struct file_load_info *info, timeout_t *modif )
1362 {
1363 WCHAR *p;
1364 struct unicode_str name;
1365 int res;
1366 unsigned int mod;
1367 data_size_t len;
1368
1369 if (!get_file_tmp_space( info, strlen(buffer) * sizeof(WCHAR) )) return NULL;
1370
1371 len = info->tmplen;
1372 if ((res = parse_strW( info->tmp, &len, buffer, ']' )) == -1)
1373 {
1374 file_read_error( "Malformed key", info );
1375 return NULL;
1376 }
1377 if (sscanf( buffer + res, " %u", &mod ) == 1)
1378 *modif = (timeout_t)mod * TICKS_PER_SEC + ticks_1601_to_1970;
1379 else
1380 *modif = current_time;
1381
1382 p = info->tmp;
1383 while (prefix_len && *p) { if (*p++ == '\\') prefix_len--; }
1384
1385 if (!*p)
1386 {
1387 if (prefix_len > 1)
1388 {
1389 file_read_error( "Malformed key", info );
1390 return NULL;
1391 }
1392 /* empty key name, return base key */
1393 return (struct key *)grab_object( base );
1394 }
1395 name.str = p;
1396 name.len = len - (p - info->tmp + 1) * sizeof(WCHAR);
1397 return create_key_recursive( base, &name, 0 );
1398 }
1399
1400 /* update the modification time of a key (and its parents) after it has been loaded from a file */
1401 static void update_key_time( struct key *key, timeout_t modif )
1402 {
1403 while (key && !key->modif)
1404 {
1405 key->modif = modif;
1406 key = key->parent;
1407 }
1408 }
1409
1410 /* load a global option from the input file */
1411 static int load_global_option( const char *buffer, struct file_load_info *info )
1412 {
1413 const char *p;
1414
1415 if (!strncmp( buffer, "#arch=", 6 ))
1416 {
1417 enum prefix_type type;
1418 p = buffer + 6;
1419 if (!strcmp( p, "win32" )) type = PREFIX_32BIT;
1420 else if (!strcmp( p, "win64" )) type = PREFIX_64BIT;
1421 else
1422 {
1423 file_read_error( "Unknown architecture", info );
1424 set_error( STATUS_NOT_REGISTRY_FILE );
1425 return 0;
1426 }
1427 if (prefix_type == PREFIX_UNKNOWN) prefix_type = type;
1428 else if (type != prefix_type)
1429 {
1430 file_read_error( "Mismatched architecture", info );
1431 set_error( STATUS_NOT_REGISTRY_FILE );
1432 return 0;
1433 }
1434 }
1435 /* ignore unknown options */
1436 return 1;
1437 }
1438
1439 /* load a key option from the input file */
1440 static int load_key_option( struct key *key, const char *buffer, struct file_load_info *info )
1441 {
1442 const char *p;
1443 data_size_t len;
1444
1445 if (!strncmp( buffer, "#time=", 6 ))
1446 {
1447 timeout_t modif = 0;
1448 for (p = buffer + 6; *p; p++)
1449 {
1450 if (*p >= '0' && *p <= '9') modif = (modif << 4) | (*p - '0');
1451 else if (*p >= 'A' && *p <= 'F') modif = (modif << 4) | (*p - 'A' + 10);
1452 else if (*p >= 'a' && *p <= 'f') modif = (modif << 4) | (*p - 'a' + 10);
1453 else break;
1454 }
1455 update_key_time( key, modif );
1456 }
1457 if (!strncmp( buffer, "#class=", 7 ))
1458 {
1459 p = buffer + 7;
1460 if (*p++ != '"') return 0;
1461 if (!get_file_tmp_space( info, strlen(p) * sizeof(WCHAR) )) return 0;
1462 len = info->tmplen;
1463 if (parse_strW( info->tmp, &len, p, '\"' ) == -1) return 0;
1464 free( key->class );
1465 if (!(key->class = memdup( info->tmp, len ))) len = 0;
1466 key->classlen = len;
1467 }
1468 if (!strncmp( buffer, "#link", 5 )) key->flags |= KEY_SYMLINK;
1469 /* ignore unknown options */
1470 return 1;
1471 }
1472
1473 /* parse a comma-separated list of hex digits */
1474 static int parse_hex( unsigned char *dest, data_size_t *len, const char *buffer )
1475 {
1476 const char *p = buffer;
1477 data_size_t count = 0;
1478 char *end;
1479
1480 while (isxdigit(*p))
1481 {
1482 unsigned int val = strtoul( p, &end, 16 );
1483 if (end == p || val > 0xff) return -1;
1484 if (count++ >= *len) return -1; /* dest buffer overflow */
1485 *dest++ = val;
1486 p = end;
1487 while (isspace(*p)) p++;
1488 if (*p == ',') p++;
1489 while (isspace(*p)) p++;
1490 }
1491 *len = count;
1492 return p - buffer;
1493 }
1494
1495 /* parse a value name and create the corresponding value */
1496 static struct key_value *parse_value_name( struct key *key, const char *buffer, data_size_t *len,
1497 struct file_load_info *info )
1498 {
1499 struct key_value *value;
1500 struct unicode_str name;
1501 int index;
1502
1503 if (!get_file_tmp_space( info, strlen(buffer) * sizeof(WCHAR) )) return NULL;
1504 name.str = info->tmp;
1505 name.len = info->tmplen;
1506 if (buffer[0] == '@')
1507 {
1508 name.len = 0;
1509 *len = 1;
1510 }
1511 else
1512 {
1513 int r = parse_strW( info->tmp, &name.len, buffer + 1, '\"' );
1514 if (r == -1) goto error;
1515 *len = r + 1; /* for initial quote */
1516 name.len -= sizeof(WCHAR); /* terminating null */
1517 }
1518 while (isspace(buffer[*len])) (*len)++;
1519 if (buffer[*len] != '=') goto error;
1520 (*len)++;
1521 while (isspace(buffer[*len])) (*len)++;
1522 if (!(value = find_value( key, &name, &index ))) value = insert_value( key, &name, index );
1523 return value;
1524
1525 error:
1526 file_read_error( "Malformed value name", info );
1527 return NULL;
1528 }
1529
1530 /* load a value from the input file */
1531 static int load_value( struct key *key, const char *buffer, struct file_load_info *info )
1532 {
1533 DWORD dw;
1534 void *ptr, *newptr;
1535 int res, type, parse_type;
1536 data_size_t maxlen, len;
1537 struct key_value *value;
1538
1539 if (!(value = parse_value_name( key, buffer, &len, info ))) return 0;
1540 if (!(res = get_data_type( buffer + len, &type, &parse_type ))) goto error;
1541 buffer += len + res;
1542
1543 switch(parse_type)
1544 {
1545 case REG_SZ:
1546 if (!get_file_tmp_space( info, strlen(buffer) * sizeof(WCHAR) )) return 0;
1547 len = info->tmplen;
1548 if ((res = parse_strW( info->tmp, &len, buffer, '\"' )) == -1) goto error;
1549 ptr = info->tmp;
1550 break;
1551 case REG_DWORD:
1552 dw = strtoul( buffer, NULL, 16 );
1553 ptr = &dw;
1554 len = sizeof(dw);
1555 break;
1556 case REG_BINARY: /* hex digits */
1557 len = 0;
1558 for (;;)
1559 {
1560 maxlen = 1 + strlen(buffer) / 2; /* at least 2 chars for one hex byte */
1561 if (!get_file_tmp_space( info, len + maxlen )) return 0;
1562 if ((res = parse_hex( (unsigned char *)info->tmp + len, &maxlen, buffer )) == -1) goto error;
1563 len += maxlen;
1564 buffer += res;
1565 while (isspace(*buffer)) buffer++;
1566 if (!*buffer) break;
1567 if (*buffer != '\\') goto error;
1568 if (read_next_line( info) != 1) goto error;
1569 buffer = info->buffer;
1570 while (isspace(*buffer)) buffer++;
1571 }
1572 ptr = info->tmp;
1573 break;
1574 default:
1575 assert(0);
1576 ptr = NULL; /* keep compiler quiet */
1577 break;
1578 }
1579
1580 if (!len) newptr = NULL;
1581 else if (!(newptr = memdup( ptr, len ))) return 0;
1582
1583 free( value->data );
1584 value->data = newptr;
1585 value->len = len;
1586 value->type = type;
1587 return 1;
1588
1589 error:
1590 file_read_error( "Malformed value", info );
1591 free( value->data );
1592 value->data = NULL;
1593 value->len = 0;
1594 value->type = REG_NONE;
1595 return 0;
1596 }
1597
1598 /* return the length (in path elements) of name that is part of the key name */
1599 /* for instance if key is USER\foo\bar and name is foo\bar\baz, return 2 */
1600 static int get_prefix_len( struct key *key, const char *name, struct file_load_info *info )
1601 {
1602 WCHAR *p;
1603 int res;
1604 data_size_t len;
1605
1606 if (!get_file_tmp_space( info, strlen(name) * sizeof(WCHAR) )) return 0;
1607
1608 len = info->tmplen;
1609 if ((res = parse_strW( info->tmp, &len, name, ']' )) == -1)
1610 {
1611 file_read_error( "Malformed key", info );
1612 return 0;
1613 }
1614 for (p = info->tmp; *p; p++) if (*p == '\\') break;
1615 len = (p - info->tmp) * sizeof(WCHAR);
1616 for (res = 1; key != root_key; res++)
1617 {
1618 if (len == key->namelen && !memicmpW( info->tmp, key->name, len / sizeof(WCHAR) )) break;
1619 key = key->parent;
1620 }
1621 if (key == root_key) res = 0; /* no matching name */
1622 return res;
1623 }
1624
1625 /* load all the keys from the input file */
1626 /* prefix_len is the number of key name prefixes to skip, or -1 for autodetection */
1627 static void load_keys( struct key *key, const char *filename, FILE *f, int prefix_len )
1628 {
1629 struct key *subkey = NULL;
1630 struct file_load_info info;
1631 timeout_t modif = current_time;
1632 char *p;
1633
1634 info.filename = filename;
1635 info.file = f;
1636 info.len = 4;
1637 info.tmplen = 4;
1638 info.line = 0;
1639 if (!(info.buffer = mem_alloc( info.len ))) return;
1640 if (!(info.tmp = mem_alloc( info.tmplen )))
1641 {
1642 free( info.buffer );
1643 return;
1644 }
1645
1646 if ((read_next_line( &info ) != 1) ||
1647 strcmp( info.buffer, "WINE REGISTRY Version 2" ))
1648 {
1649 set_error( STATUS_NOT_REGISTRY_FILE );
1650 goto done;
1651 }
1652
1653 while (read_next_line( &info ) == 1)
1654 {
1655 p = info.buffer;
1656 while (*p && isspace(*p)) p++;
1657 switch(*p)
1658 {
1659 case '[': /* new key */
1660 if (subkey)
1661 {
1662 update_key_time( subkey, modif );
1663 release_object( subkey );
1664 }
1665 if (prefix_len == -1) prefix_len = get_prefix_len( key, p + 1, &info );
1666 if (!(subkey = load_key( key, p + 1, prefix_len, &info, &modif )))
1667 file_read_error( "Error creating key", &info );
1668 break;
1669 case '@': /* default value */
1670 case '\"': /* value */
1671 if (subkey) load_value( subkey, p, &info );
1672 else file_read_error( "Value without key", &info );
1673 break;
1674 case '#': /* option */
1675 if (subkey) load_key_option( subkey, p, &info );
1676 else if (!load_global_option( p, &info )) goto done;
1677 break;
1678 case ';': /* comment */
1679 case 0: /* empty line */
1680 break;
1681 default:
1682 file_read_error( "Unrecognized input", &info );
1683 break;
1684 }
1685 }
1686
1687 done:
1688 if (subkey)
1689 {
1690 update_key_time( subkey, modif );
1691 release_object( subkey );
1692 }
1693 free( info.buffer );
1694 free( info.tmp );
1695 }
1696
1697 /* load a part of the registry from a file */
1698 static void load_registry( struct key *key, obj_handle_t handle )
1699 {
1700 struct file *file;
1701 int fd;
1702
1703 if (!(file = get_file_obj( current->process, handle, FILE_READ_DATA ))) return;
1704 fd = dup( get_file_unix_fd( file ) );
1705 release_object( file );
1706 if (fd != -1)
1707 {
1708 FILE *f = fdopen( fd, "r" );
1709 if (f)
1710 {
1711 load_keys( key, NULL, f, -1 );
1712 fclose( f );
1713 }
1714 else file_set_error();
1715 }
1716 }
1717
1718 /* load one of the initial registry files */
1719 static int load_init_registry_from_file( const char *filename, struct key *key )
1720 {
1721 FILE *f;
1722
1723 if ((f = fopen( filename, "r" )))
1724 {
1725 load_keys( key, filename, f, 0 );
1726 fclose( f );
1727 if (get_error() == STATUS_NOT_REGISTRY_FILE)
1728 {
1729 fprintf( stderr, "%s is not a valid registry file\n", filename );
1730 return 1;
1731 }
1732 }
1733
1734 assert( save_branch_count < MAX_SAVE_BRANCH_INFO );
1735
1736 save_branch_info[save_branch_count].path = filename;
1737 save_branch_info[save_branch_count++].key = (struct key *)grab_object( key );
1738 make_object_static( &key->obj );
1739 return (f != NULL);
1740 }
1741
1742 static WCHAR *format_user_registry_path( const SID *sid, struct unicode_str *path )
1743 {
1744 static const WCHAR prefixW[] = {'U','s','e','r','\\','S',0};
1745 static const WCHAR formatW[] = {'-','%','u',0};
1746 WCHAR buffer[7 + 10 + 10 + 10 * SID_MAX_SUB_AUTHORITIES];
1747 WCHAR *p = buffer;
1748 unsigned int i;
1749
1750 strcpyW( p, prefixW );
1751 p += strlenW( prefixW );
1752 p += sprintfW( p, formatW, sid->Revision );
1753 p += sprintfW( p, formatW, MAKELONG( MAKEWORD( sid->IdentifierAuthority.Value[5],
1754 sid->IdentifierAuthority.Value[4] ),
1755 MAKEWORD( sid->IdentifierAuthority.Value[3],
1756 sid->IdentifierAuthority.Value[2] )));
1757 for (i = 0; i < sid->SubAuthorityCount; i++)
1758 p += sprintfW( p, formatW, sid->SubAuthority[i] );
1759
1760 path->len = (p - buffer) * sizeof(WCHAR);
1761 path->str = p = memdup( buffer, path->len );
1762 return p;
1763 }
1764
1765 /* get the cpu architectures that can be supported in the current prefix */
1766 unsigned int get_prefix_cpu_mask(void)
1767 {
1768 /* Allowed server/client/prefix combinations:
1769 *
1770 * prefix
1771 * 32 64
1772 * server +------+------+ client
1773 * | ok | fail | 32
1774 * 32 +------+------+---
1775 * | fail | fail | 64
1776 * ---+------+------+---
1777 * | ok | ok | 32
1778 * 64 +------+------+---
1779 * | fail | ok | 64
1780 * ---+------+------+---
1781 */
1782 switch (prefix_type)
1783 {
1784 case PREFIX_64BIT:
1785 /* 64-bit prefix requires 64-bit server */
1786 return sizeof(void *) > sizeof(int) ? ~0 : 0;
1787 case PREFIX_32BIT:
1788 default:
1789 return ~CPU_64BIT_MASK; /* only 32-bit cpus supported on 32-bit prefix */
1790 }
1791 }
1792
1793 /* registry initialisation */
1794 void init_registry(void)
1795 {
1796 static const WCHAR HKLM[] = { 'M','a','c','h','i','n','e' };
1797 static const WCHAR HKU_default[] = { 'U','s','e','r','\\','.','D','e','f','a','u','l','t' };
1798 static const WCHAR classes[] = {'S','o','f','t','w','a','r','e','\\',
1799 'C','l','a','s','s','e','s','\\',
1800 'W','o','w','6','4','3','2','N','o','d','e'};
1801 static const struct unicode_str root_name = { NULL, 0 };
1802 static const struct unicode_str HKLM_name = { HKLM, sizeof(HKLM) };
1803 static const struct unicode_str HKU_name = { HKU_default, sizeof(HKU_default) };
1804 static const struct unicode_str classes_name = { classes, sizeof(classes) };
1805
1806 WCHAR *current_user_path;
1807 struct unicode_str current_user_str;
1808 struct key *key, *hklm, *hkcu;
1809 char *p;
1810
1811 /* switch to the config dir */
1812
1813 if (fchdir( config_dir_fd ) == -1) fatal_error( "chdir to config dir: %s\n", strerror( errno ));
1814
1815 /* create the root key */
1816 root_key = alloc_key( &root_name, current_time );
1817 assert( root_key );
1818 make_object_static( &root_key->obj );
1819
1820 /* load system.reg into Registry\Machine */
1821
1822 if (!(hklm = create_key_recursive( root_key, &HKLM_name, current_time )))
1823 fatal_error( "could not create Machine registry key\n" );
1824
1825 if (!load_init_registry_from_file( "system.reg", hklm ))
1826 {
1827 if ((p = getenv( "WINEARCH" )) && !strcmp( p, "win32" ))
1828 prefix_type = PREFIX_32BIT;
1829 else
1830 prefix_type = sizeof(void *) > sizeof(int) ? PREFIX_64BIT : PREFIX_32BIT;
1831 }
1832 else if (prefix_type == PREFIX_UNKNOWN)
1833 prefix_type = PREFIX_32BIT;
1834
1835 /* load userdef.reg into Registry\User\.Default */
1836
1837 if (!(key = create_key_recursive( root_key, &HKU_name, current_time )))
1838 fatal_error( "could not create User\\.Default registry key\n" );
1839
1840 load_init_registry_from_file( "userdef.reg", key );
1841 release_object( key );
1842
1843 /* load user.reg into HKEY_CURRENT_USER */
1844
1845 /* FIXME: match default user in token.c. should get from process token instead */
1846 current_user_path = format_user_registry_path( security_local_user_sid, &current_user_str );
1847 if (!current_user_path ||
1848 !(hkcu = create_key_recursive( root_key, &current_user_str, current_time )))
1849 fatal_error( "could not create HKEY_CURRENT_USER registry key\n" );
1850 free( current_user_path );
1851 load_init_registry_from_file( "user.reg", hkcu );
1852
1853 /* set the shared flag on Software\Classes\Wow6432Node */
1854 if (prefix_type == PREFIX_64BIT)
1855 {
1856 if ((key = create_key_recursive( hklm, &classes_name, current_time )))
1857 {
1858 key->flags |= KEY_WOWSHARE;
1859 release_object( key );
1860 }
1861 /* FIXME: handle HKCU too */
1862 }
1863
1864 release_object( hklm );
1865 release_object( hkcu );
1866
1867 /* start the periodic save timer */
1868 set_periodic_save_timer();
1869
1870 /* create windows directories */
1871
1872 if (!mkdir( "drive_c/windows", 0777 ))
1873 {
1874 mkdir( "drive_c/windows/system32", 0777 );
1875 if (prefix_type == PREFIX_64BIT) mkdir( "drive_c/windows/syswow64", 0777 );
1876 }
1877
1878 /* go back to the server dir */
1879 if (fchdir( server_dir_fd ) == -1) fatal_error( "chdir to server dir: %s\n", strerror( errno ));
1880 }
1881
1882 /* save a registry branch to a file */
1883 static void save_all_subkeys( struct key *key, FILE *f )
1884 {
1885 fprintf( f, "WINE REGISTRY Version 2\n" );
1886 fprintf( f, ";; All keys relative to " );
1887 dump_path( key, NULL, f );
1888 fprintf( f, "\n" );
1889 switch (prefix_type)
1890 {
1891 case PREFIX_32BIT:
1892 fprintf( f, "\n#arch=win32\n" );
1893 break;
1894 case PREFIX_64BIT:
1895 fprintf( f, "\n#arch=win64\n" );
1896 break;
1897 default:
1898 break;
1899 }
1900 save_subkeys( key, key, f );
1901 }
1902
1903 /* save a registry branch to a file handle */
1904 static void save_registry( struct key *key, obj_handle_t handle )
1905 {
1906 struct file *file;
1907 int fd;
1908
1909 if (!(file = get_file_obj( current->process, handle, FILE_WRITE_DATA ))) return;
1910 fd = dup( get_file_unix_fd( file ) );
1911 release_object( file );
1912 if (fd != -1)
1913 {
1914 FILE *f = fdopen( fd, "w" );
1915 if (f)
1916 {
1917 save_all_subkeys( key, f );
1918 if (fclose( f )) file_set_error();
1919 }
1920 else
1921 {
1922 file_set_error();
1923 close( fd );
1924 }
1925 }
1926 }
1927
1928 /* save a registry branch to a file */
1929 static int save_branch( struct key *key, const char *path )
1930 {
1931 struct stat st;
1932 char *p, *tmp = NULL;
1933 int fd, count = 0, ret = 0;
1934 FILE *f;
1935
1936 if (!(key->flags & KEY_DIRTY))
1937 {
1938 if (debug_level > 1) dump_operation( key, NULL, "Not saving clean" );
1939 return 1;
1940 }
1941
1942 /* test the file type */
1943
1944 if ((fd = open( path, O_WRONLY )) != -1)
1945 {
1946 /* if file is not a regular file or has multiple links or is accessed
1947 * via symbolic links, write directly into it; otherwise use a temp file */
1948 if (!lstat( path, &st ) && (!S_ISREG(st.st_mode) || st.st_nlink > 1))
1949 {
1950 ftruncate( fd, 0 );
1951 goto save;
1952 }
1953 close( fd );
1954 }
1955
1956 /* create a temp file in the same directory */
1957
1958 if (!(tmp = malloc( strlen(path) + 20 ))) goto done;
1959 strcpy( tmp, path );
1960 if ((p = strrchr( tmp, '/' ))) p++;
1961 else p = tmp;
1962 for (;;)
1963 {
1964 sprintf( p, "reg%lx%04x.tmp", (long) getpid(), count++ );
1965 if ((fd = open( tmp, O_CREAT | O_EXCL | O_WRONLY, 0666 )) != -1) break;
1966 if (errno != EEXIST) goto done;
1967 close( fd );
1968 }
1969
1970 /* now save to it */
1971
1972 save:
1973 if (!(f = fdopen( fd, "w" )))
1974 {
1975 if (tmp) unlink( tmp );
1976 close( fd );
1977 goto done;
1978 }
1979
1980 if (debug_level > 1)
1981 {
1982 fprintf( stderr, "%s: ", path );
1983 dump_operation( key, NULL, "saving" );
1984 }
1985
1986 save_all_subkeys( key, f );
1987 ret = !fclose(f);
1988
1989 if (tmp)
1990 {
1991 /* if successfully written, rename to final name */
1992 if (ret) ret = !rename( tmp, path );
1993 if (!ret) unlink( tmp );
1994 }
1995
1996 done:
1997 free( tmp );
1998 if (ret) make_clean( key );
1999 return ret;
2000 }
2001
2002 /* periodic saving of the registry */
2003 static void periodic_save( void *arg )
2004 {
2005 int i;
2006
2007 if (fchdir( config_dir_fd ) == -1) return;
2008 save_timeout_user = NULL;
2009 for (i = 0; i < save_branch_count; i++)
2010 save_branch( save_branch_info[i].key, save_branch_info[i].path );
2011 if (fchdir( server_dir_fd ) == -1) fatal_error( "chdir to server dir: %s\n", strerror( errno ));
2012 set_periodic_save_timer();
2013 }
2014
2015 /* start the periodic save timer */
2016 static void set_periodic_save_timer(void)
2017 {
2018 if (save_timeout_user) remove_timeout_user( save_timeout_user );
2019 save_timeout_user = add_timeout_user( save_period, periodic_save, NULL );
2020 }
2021
2022 /* save the modified registry branches to disk */
2023 void flush_registry(void)
2024 {
2025 int i;
2026
2027 if (fchdir( config_dir_fd ) == -1) return;
2028 for (i = 0; i < save_branch_count; i++)
2029 {
2030 if (!save_branch( save_branch_info[i].key, save_branch_info[i].path ))
2031 {
2032 fprintf( stderr, "wineserver: could not save registry branch to %s",
2033 save_branch_info[i].path );
2034 perror( " " );
2035 }
2036 }
2037 if (fchdir( server_dir_fd ) == -1) fatal_error( "chdir to server dir: %s\n", strerror( errno ));
2038 }
2039
2040 /* determine if the thread is wow64 (32-bit client running on 64-bit prefix) */
2041 static int is_wow64_thread( struct thread *thread )
2042 {
2043 return (prefix_type == PREFIX_64BIT && !(CPU_FLAG(thread->process->cpu) & CPU_64BIT_MASK));
2044 }
2045
2046
2047 /* create a registry key */
2048 DECL_HANDLER(create_key)
2049 {
2050 struct key *key = NULL, *parent;
2051 struct unicode_str name, class;
2052 unsigned int access = req->access;
2053 const struct security_descriptor *sd;
2054 const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, NULL );
2055
2056 if (!objattr) return;
2057
2058 if (!is_wow64_thread( current )) access = (access & ~KEY_WOW64_32KEY) | KEY_WOW64_64KEY;
2059
2060 class.str = get_req_data_after_objattr( objattr, &class.len );
2061 class.len = (class.len / sizeof(WCHAR)) * sizeof(WCHAR);
2062
2063 if (!objattr->rootdir && name.len >= sizeof(root_name) &&
2064 !memicmpW( name.str, root_name, ARRAY_SIZE( root_name )))
2065 {
2066 name.str += ARRAY_SIZE( root_name );
2067 name.len -= sizeof(root_name);
2068 }
2069
2070 /* NOTE: no access rights are required from the parent handle to create a key */
2071 if ((parent = get_parent_hkey_obj( objattr->rootdir )))
2072 {
2073 if ((key = create_key( parent, &name, &class, req->options, access,
2074 objattr->attributes, sd, &reply->created )))
2075 {
2076 reply->hkey = alloc_handle( current->process, key, access, objattr->attributes );
2077 release_object( key );
2078 }
2079 release_object( parent );
2080 }
2081 }
2082
2083 /* open a registry key */
2084 DECL_HANDLER(open_key)
2085 {
2086 struct key *key, *parent;
2087 struct unicode_str name;
2088 unsigned int access = req->access;
2089
2090 if (!is_wow64_thread( current )) access = (access & ~KEY_WOW64_32KEY) | KEY_WOW64_64KEY;
2091
2092 reply->hkey = 0;
2093 /* NOTE: no access rights are required to open the parent key, only the child key */
2094 if ((parent = get_parent_hkey_obj( req->parent )))
2095 {
2096 get_req_path( &name, !req->parent );
2097 if ((key = open_key( parent, &name, access, req->attributes )))
2098 {
2099 reply->hkey = alloc_handle( current->process, key, access, req->attributes );
2100 release_object( key );
2101 }
2102 release_object( parent );
2103 }
2104 }
2105
2106 /* delete a registry key */
2107 DECL_HANDLER(delete_key)
2108 {
2109 struct key *key;
2110
2111 if ((key = get_hkey_obj( req->hkey, DELETE )))
2112 {
2113 delete_key( key, 0);
2114 release_object( key );
2115 }
2116 }
2117
2118 /* flush a registry key */
2119 DECL_HANDLER(flush_key)
2120 {
2121 struct key *key = get_hkey_obj( req->hkey, 0 );
2122 if (key)
2123 {
2124 /* we don't need to do anything here with the current implementation */
2125 release_object( key );
2126 }
2127 }
2128
2129 /* enumerate registry subkeys */
2130 DECL_HANDLER(enum_key)
2131 {
2132 struct key *key;
2133
2134 if ((key = get_hkey_obj( req->hkey,
2135 req->index == -1 ? KEY_QUERY_VALUE : KEY_ENUMERATE_SUB_KEYS )))
2136 {
2137 enum_key( key, req->index, req->info_class, reply );
2138 release_object( key );
2139 }
2140 }
2141
2142 /* set a value of a registry key */
2143 DECL_HANDLER(set_key_value)
2144 {
2145 struct key *key;
2146 struct unicode_str name;
2147
2148 if (req->namelen > get_req_data_size())
2149 {
2150 set_error( STATUS_INVALID_PARAMETER );
2151 return;
2152 }
2153 name.str = get_req_data();
2154 name.len = (req->namelen / sizeof(WCHAR)) * sizeof(WCHAR);
2155
2156 if ((key = get_hkey_obj( req->hkey, KEY_SET_VALUE )))
2157 {
2158 data_size_t datalen = get_req_data_size() - req->namelen;
2159 const char *data = (const char *)get_req_data() + req->namelen;
2160
2161 set_value( key, &name, req->type, data, datalen );
2162 release_object( key );
2163 }
2164 }
2165
2166 /* retrieve the value of a registry key */
2167 DECL_HANDLER(get_key_value)
2168 {
2169 struct key *key;
2170 struct unicode_str name = get_req_unicode_str();
2171
2172 reply->total = 0;
2173 if ((key = get_hkey_obj( req->hkey, KEY_QUERY_VALUE )))
2174 {
2175 get_value( key, &name, &reply->type, &reply->total );
2176 release_object( key );
2177 }
2178 }
2179
2180 /* enumerate the value of a registry key */
2181 DECL_HANDLER(enum_key_value)
2182 {
2183 struct key *key;
2184
2185 if ((key = get_hkey_obj( req->hkey, KEY_QUERY_VALUE )))
2186 {
2187 enum_value( key, req->index, req->info_class, reply );
2188 release_object( key );
2189 }
2190 }
2191
2192 /* delete a value of a registry key */
2193 DECL_HANDLER(delete_key_value)
2194 {
2195 struct key *key;
2196 struct unicode_str name = get_req_unicode_str();
2197
2198 if ((key = get_hkey_obj( req->hkey, KEY_SET_VALUE )))
2199 {
2200 delete_value( key, &name );
2201 release_object( key );
2202 }
2203 }
2204
2205 /* load a registry branch from a file */
2206 DECL_HANDLER(load_registry)
2207 {
2208 struct key *key, *parent;
2209 struct unicode_str name;
2210 const struct security_descriptor *sd;
2211 const struct object_attributes *objattr = get_req_object_attributes( &sd, &name, NULL );
2212
2213 if (!objattr) return;
2214
2215 if (!thread_single_check_privilege( current, &SeRestorePrivilege ))
2216 {
2217 set_error( STATUS_PRIVILEGE_NOT_HELD );
2218 return;
2219 }
2220
2221 if (!objattr->rootdir && name.len >= sizeof(root_name) &&
2222 !memicmpW( name.str, root_name, ARRAY_SIZE( root_name )))
2223 {
2224 name.str += ARRAY_SIZE( root_name );
2225 name.len -= sizeof(root_name);
2226 }
2227
2228 if ((parent = get_parent_hkey_obj( objattr->rootdir )))
2229 {
2230 int dummy;
2231 if ((key = create_key( parent, &name, NULL, 0, KEY_WOW64_64KEY, 0, sd, &dummy )))
2232 {
2233 load_registry( key, req->file );
2234 release_object( key );
2235 }
2236 release_object( parent );
2237 }
2238 }
2239
2240 DECL_HANDLER(unload_registry)
2241 {
2242 struct key *key;
2243
2244 if (!thread_single_check_privilege( current, &SeRestorePrivilege ))
2245 {
2246 set_error( STATUS_PRIVILEGE_NOT_HELD );
2247 return;
2248 }
2249
2250 if ((key = get_hkey_obj( req->hkey, 0 )))
2251 {
2252 delete_key( key, 1 ); /* FIXME */
2253 release_object( key );
2254 }
2255 }
2256
2257 /* save a registry branch to a file */
2258 DECL_HANDLER(save_registry)
2259 {
2260 struct key *key;
2261
2262 if (!thread_single_check_privilege( current, &SeBackupPrivilege ))
2263 {
2264 set_error( STATUS_PRIVILEGE_NOT_HELD );
2265 return;
2266 }
2267
2268 if ((key = get_hkey_obj( req->hkey, 0 )))
2269 {
2270 save_registry( key, req->file );
2271 release_object( key );
2272 }
2273 }
2274
2275 /* add a registry key change notification */
2276 DECL_HANDLER(set_registry_notification)
2277 {
2278 struct key *key;
2279 struct event *event;
2280 struct notify *notify;
2281
2282 key = get_hkey_obj( req->hkey, KEY_NOTIFY );
2283 if (key)
2284 {
2285 event = get_event_obj( current->process, req->event, SYNCHRONIZE );
2286 if (event)
2287 {
2288 notify = find_notify( key, current->process, req->hkey );
2289 if (notify)
2290 {
2291 if (notify->event)
2292 release_object( notify->event );
2293 grab_object( event );
2294 notify->event = event;
2295 }
2296 else
2297 {
2298 notify = mem_alloc( sizeof(*notify) );
2299 if (notify)
2300 {
2301 grab_object( event );
2302 notify->event = event;
2303 notify->subtree = req->subtree;
2304 notify->filter = req->filter;
2305 notify->hkey = req->hkey;
2306 notify->process = current->process;
2307 list_add_head( &key->notify_list, &notify->entry );
2308 }
2309 }
2310 if (notify)
2311 {
2312 reset_event( event );
2313 set_error( STATUS_PENDING );
2314 }
2315 release_object( event );
2316 }
2317 release_object( key );
2318 }
2319 }
Windows API implementation