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