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