2 * Server-side registry management
4 * Copyright (C) 1999 Alexandre Julliard
8 * - behavior with deleted keys
9 * - values larger than request buffer
31 #include "winnt.h" /* registry definitions */
37 struct object obj
; /* object header */
38 WCHAR
*name
; /* key name */
39 WCHAR
*class; /* key class */
40 struct key
*parent
; /* parent key */
41 int last_subkey
; /* last in use subkey */
42 int nb_subkeys
; /* count of allocated subkeys */
43 struct key
**subkeys
; /* subkeys array */
44 int last_value
; /* last in use value */
45 int nb_values
; /* count of allocated values in array */
46 struct key_value
*values
; /* values array */
47 short flags
; /* flags */
48 short level
; /* saving level */
49 time_t modif
; /* last modification time */
53 #define KEY_VOLATILE 0x0001 /* key is volatile (not saved to disk) */
54 #define KEY_DELETED 0x0002 /* key has been deleted */
55 #define KEY_ROOT 0x0004 /* key is a root key */
60 WCHAR
*name
; /* value name */
61 int type
; /* value type */
62 size_t len
; /* value data length in bytes */
63 void *data
; /* pointer to value data */
66 #define MIN_SUBKEYS 8 /* min. number of allocated subkeys per key */
67 #define MIN_VALUES 8 /* min. number of allocated values per key */
70 /* the special root keys */
71 #define HKEY_SPECIAL_ROOT_FIRST HKEY_CLASSES_ROOT
72 #define HKEY_SPECIAL_ROOT_LAST HKEY_DYN_DATA
73 #define NB_SPECIAL_ROOT_KEYS (HKEY_SPECIAL_ROOT_LAST - HKEY_SPECIAL_ROOT_FIRST + 1)
74 #define IS_SPECIAL_ROOT_HKEY(h) (((h) >= HKEY_SPECIAL_ROOT_FIRST) && ((h) <= HKEY_SPECIAL_ROOT_LAST))
75 static struct key
*special_root_keys
[NB_SPECIAL_ROOT_KEYS
];
77 /* the real root key */
78 static struct key
*root_key
;
80 /* the special root key names */
81 static const char * const special_root_names
[NB_SPECIAL_ROOT_KEYS
] =
83 "Machine\\Software\\Classes", /* HKEY_CLASSES_ROOT */
84 "User\\", /* we append the user name dynamically */ /* HKEY_CURRENT_USER */
85 "Machine", /* HKEY_LOCAL_MACHINE */
86 "User", /* HKEY_USERS */
87 "PerfData", /* HKEY_PERFORMANCE_DATA */
88 "Machine\\System\\CurrentControlSet\\HardwareProfiles\\Current", /* HKEY_CURRENT_CONFIG */
89 "DynData" /* HKEY_DYN_DATA */
93 /* keys saving level */
94 /* current_level is the level that is put into all newly created or modified keys */
95 /* saving_level is the minimum level that a key needs in order to get saved */
96 static int current_level
;
97 static int saving_level
;
99 static struct timeval next_save_time
; /* absolute time of next periodic save */
100 static int save_period
; /* delay between periodic saves (ms) */
101 static struct timeout_user
*save_timeout_user
; /* saving timer */
103 /* information about where to save a registry branch */
104 struct save_branch_info
110 #define MAX_SAVE_BRANCH_INFO 8
111 static int save_branch_count
;
112 static struct save_branch_info save_branch_info
[MAX_SAVE_BRANCH_INFO
];
115 /* information about a file being loaded */
116 struct file_load_info
118 FILE *file
; /* input file */
119 char *buffer
; /* line buffer */
120 int len
; /* buffer length */
121 int line
; /* current input line */
122 char *tmp
; /* temp buffer to use while parsing input */
123 int tmplen
; /* length of temp buffer */
127 static void key_dump( struct object
*obj
, int verbose
);
128 static void key_destroy( struct object
*obj
);
130 static const struct object_ops key_ops
=
132 sizeof(struct key
), /* size */
134 no_add_queue
, /* add_queue */
135 NULL
, /* remove_queue */
137 NULL
, /* satisfied */
138 NULL
, /* get_poll_events */
139 NULL
, /* poll_event */
140 no_read_fd
, /* get_read_fd */
141 no_write_fd
, /* get_write_fd */
142 no_flush
, /* flush */
143 no_get_file_info
, /* get_file_info */
144 key_destroy
/* destroy */
149 * The registry text file format v2 used by this code is similar to the one
150 * used by REGEDIT import/export functionality, with the following differences:
151 * - strings and key names can contain \x escapes for Unicode
152 * - key names use escapes too in order to support Unicode
153 * - the modification time optionally follows the key name
154 * - REG_EXPAND_SZ and REG_MULTI_SZ are saved as strings instead of hex
157 static inline char to_hex( char ch
)
159 if (isdigit(ch
)) return ch
- '0';
160 return tolower(ch
) - 'a' + 10;
163 /* dump the full path of a key */
164 static void dump_path( struct key
*key
, struct key
*base
, FILE *f
)
166 if (key
->parent
&& key
->parent
!= base
)
168 dump_path( key
->parent
, base
, f
);
169 fprintf( f
, "\\\\" );
171 dump_strW( key
->name
, strlenW(key
->name
), f
, "[]" );
174 /* dump a value to a text file */
175 static void dump_value( struct key_value
*value
, FILE *f
)
182 count
= 1 + dump_strW( value
->name
, strlenW(value
->name
), f
, "\"\"" );
183 count
+= fprintf( f
, "\"=" );
185 else count
= fprintf( f
, "@=" );
192 if (value
->type
!= REG_SZ
) fprintf( f
, "str(%d):", value
->type
);
194 if (value
->data
) dump_strW( (WCHAR
*)value
->data
, value
->len
/ sizeof(WCHAR
), f
, "\"\"" );
198 if (value
->len
== sizeof(DWORD
))
201 memcpy( &dw
, value
->data
, sizeof(DWORD
) );
202 fprintf( f
, "dword:%08lx", dw
);
205 /* else fall through */
207 if (value
->type
== REG_BINARY
) count
+= fprintf( f
, "hex:" );
208 else count
+= fprintf( f
, "hex(%x):", value
->type
);
209 for (i
= 0; i
< value
->len
; i
++)
211 count
+= fprintf( f
, "%02x", *((unsigned char *)value
->data
+ i
) );
212 if (i
< value
->len
-1)
217 fprintf( f
, "\\\n " );
227 /* save a registry and all its subkeys to a text file */
228 static void save_subkeys( struct key
*key
, struct key
*base
, FILE *f
)
232 if (key
->flags
& KEY_VOLATILE
) return;
233 /* save key if it has the proper level, and has either some values or no subkeys */
234 /* keys with no values but subkeys are saved implicitly by saving the subkeys */
235 if ((key
->level
>= saving_level
) && ((key
->last_value
>= 0) || (key
->last_subkey
== -1)))
238 if (key
!= base
) dump_path( key
, base
, f
);
239 fprintf( f
, "] %ld\n", key
->modif
);
240 for (i
= 0; i
<= key
->last_value
; i
++) dump_value( &key
->values
[i
], f
);
242 for (i
= 0; i
<= key
->last_subkey
; i
++) save_subkeys( key
->subkeys
[i
], base
, f
);
245 static void dump_operation( struct key
*key
, struct key_value
*value
, const char *op
)
247 fprintf( stderr
, "%s key ", op
);
248 if (key
) dump_path( key
, NULL
, stderr
);
249 else fprintf( stderr
, "ERROR" );
252 fprintf( stderr
, " value ");
253 dump_value( value
, stderr
);
255 else fprintf( stderr
, "\n" );
258 static void key_dump( struct object
*obj
, int verbose
)
260 struct key
*key
= (struct key
*)obj
;
261 assert( obj
->ops
== &key_ops
);
262 fprintf( stderr
, "Key flags=%x ", key
->flags
);
263 dump_path( key
, NULL
, stderr
);
264 fprintf( stderr
, "\n" );
267 static void key_destroy( struct object
*obj
)
270 struct key
*key
= (struct key
*)obj
;
271 assert( obj
->ops
== &key_ops
);
273 if (key
->name
) free( key
->name
);
274 if (key
->class) free( key
->class );
275 for (i
= 0; i
<= key
->last_value
; i
++)
277 free( key
->values
[i
].name
);
278 if (key
->values
[i
].data
) free( key
->values
[i
].data
);
280 for (i
= 0; i
<= key
->last_subkey
; i
++)
282 key
->subkeys
[i
]->parent
= NULL
;
283 release_object( key
->subkeys
[i
] );
287 /* duplicate a key path from the request buffer */
288 /* returns a pointer to a static buffer, so only useable once per request */
289 static WCHAR
*copy_path( const path_t path
)
291 static WCHAR buffer
[MAX_PATH
+1];
294 while (p
< buffer
+ sizeof(buffer
) - 1) if (!(*p
++ = *path
++)) break;
299 /* return the next token in a given path */
300 /* returns a pointer to a static buffer, so only useable once per request */
301 static WCHAR
*get_path_token( const WCHAR
*initpath
, size_t maxlen
)
303 static const WCHAR
*path
;
304 static const WCHAR
*end
;
305 static WCHAR buffer
[MAX_PATH
+1];
311 end
= path
+ maxlen
/ sizeof(WCHAR
);
313 while ((path
< end
) && (*path
== '\\')) path
++;
314 while ((path
< end
) && (p
< buffer
+ sizeof(buffer
) - 1))
317 if (!ch
|| (ch
== '\\')) break;
325 /* duplicate a Unicode string from the request buffer */
326 static WCHAR
*req_strdupW( const void *req
, const WCHAR
*str
)
329 size_t len
= get_req_strlenW( req
, str
);
330 if ((name
= mem_alloc( (len
+ 1) * sizeof(WCHAR
) )) != NULL
)
332 memcpy( name
, str
, len
* sizeof(WCHAR
) );
338 /* allocate a key object */
339 static struct key
*alloc_key( const WCHAR
*name
, time_t modif
)
342 if ((key
= (struct key
*)alloc_object( &key_ops
, -1 )))
346 key
->last_subkey
= -1;
350 key
->last_value
= -1;
352 key
->level
= current_level
;
355 if (!(key
->name
= strdupW( name
)))
357 release_object( key
);
364 /* update key modification time */
365 static void touch_key( struct key
*key
)
367 key
->modif
= time(NULL
);
368 key
->level
= max( key
->level
, current_level
);
371 /* try to grow the array of subkeys; return 1 if OK, 0 on error */
372 static int grow_subkeys( struct key
*key
)
374 struct key
**new_subkeys
;
379 nb_subkeys
= key
->nb_subkeys
+ (key
->nb_subkeys
/ 2); /* grow by 50% */
380 if (!(new_subkeys
= realloc( key
->subkeys
, nb_subkeys
* sizeof(*new_subkeys
) )))
382 set_error( STATUS_NO_MEMORY
);
388 nb_subkeys
= MIN_VALUES
;
389 if (!(new_subkeys
= mem_alloc( nb_subkeys
* sizeof(*new_subkeys
) ))) return 0;
391 key
->subkeys
= new_subkeys
;
392 key
->nb_subkeys
= nb_subkeys
;
396 /* allocate a subkey for a given key, and return its index */
397 static struct key
*alloc_subkey( struct key
*parent
, const WCHAR
*name
, int index
, time_t modif
)
402 if (parent
->last_subkey
+ 1 == parent
->nb_subkeys
)
404 /* need to grow the array */
405 if (!grow_subkeys( parent
)) return NULL
;
407 if ((key
= alloc_key( name
, modif
)) != NULL
)
409 key
->parent
= parent
;
410 for (i
= ++parent
->last_subkey
; i
> index
; i
--)
411 parent
->subkeys
[i
] = parent
->subkeys
[i
-1];
412 parent
->subkeys
[index
] = key
;
417 /* free a subkey of a given key */
418 static void free_subkey( struct key
*parent
, int index
)
423 assert( index
>= 0 );
424 assert( index
<= parent
->last_subkey
);
426 key
= parent
->subkeys
[index
];
427 for (i
= index
; i
< parent
->last_subkey
; i
++) parent
->subkeys
[i
] = parent
->subkeys
[i
+ 1];
428 parent
->last_subkey
--;
429 key
->flags
|= KEY_DELETED
;
431 release_object( key
);
433 /* try to shrink the array */
434 nb_subkeys
= key
->nb_subkeys
;
435 if (nb_subkeys
> MIN_SUBKEYS
&& key
->last_subkey
< nb_subkeys
/ 2)
437 struct key
**new_subkeys
;
438 nb_subkeys
-= nb_subkeys
/ 3; /* shrink by 33% */
439 if (nb_subkeys
< MIN_SUBKEYS
) nb_subkeys
= MIN_SUBKEYS
;
440 if (!(new_subkeys
= realloc( key
->subkeys
, nb_subkeys
* sizeof(*new_subkeys
) ))) return;
441 key
->subkeys
= new_subkeys
;
442 key
->nb_subkeys
= nb_subkeys
;
446 /* find the named child of a given key and return its index */
447 static struct key
*find_subkey( struct key
*key
, const WCHAR
*name
, int *index
)
449 int i
, min
, max
, res
;
452 max
= key
->last_subkey
;
456 if (!(res
= strcmpiW( key
->subkeys
[i
]->name
, name
)))
459 return key
->subkeys
[i
];
461 if (res
> 0) max
= i
- 1;
464 *index
= min
; /* this is where we should insert it */
469 static struct key
*open_key( struct key
*key
, const WCHAR
*name
, size_t maxlen
)
474 path
= get_path_token( name
, maxlen
);
477 if (!(key
= find_subkey( key
, path
, &index
)))
479 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
482 path
= get_path_token( NULL
, 0 );
485 if (debug_level
> 1) dump_operation( key
, NULL
, "Open" );
486 if (key
) grab_object( key
);
490 /* create a subkey */
491 static struct key
*create_key( struct key
*key
, const WCHAR
*name
, size_t maxlen
, WCHAR
*class,
492 unsigned int options
, time_t modif
, int *created
)
495 int base_idx
, index
, flags
= 0;
498 if (key
->flags
& KEY_DELETED
) /* we cannot create a subkey under a deleted key */
500 set_error( STATUS_KEY_DELETED
);
503 if (options
& REG_OPTION_VOLATILE
) flags
|= KEY_VOLATILE
;
504 else if (key
->flags
& KEY_VOLATILE
)
506 set_error( STATUS_CHILD_MUST_BE_VOLATILE
);
509 if (!modif
) modif
= time(NULL
);
511 path
= get_path_token( name
, maxlen
);
516 if (!(subkey
= find_subkey( key
, path
, &index
))) break;
518 path
= get_path_token( NULL
, 0 );
521 /* create the remaining part */
523 if (!*path
) goto done
;
527 key
= alloc_subkey( key
, path
, index
, modif
);
531 path
= get_path_token( NULL
, 0 );
532 if (!*path
) goto done
;
533 /* we know the index is always 0 in a new key */
534 key
= alloc_subkey( key
, path
, 0, modif
);
536 if (base_idx
!= -1) free_subkey( base
, base_idx
);
540 if (debug_level
> 1) dump_operation( key
, NULL
, "Create" );
541 if (class) key
->class = strdupW(class);
546 /* find a subkey of a given key by its index */
547 static void enum_key( struct key
*parent
, int index
, WCHAR
*name
, WCHAR
*class, time_t *modif
)
551 if ((index
< 0) || (index
> parent
->last_subkey
)) set_error( STATUS_NO_MORE_ENTRIES
);
554 key
= parent
->subkeys
[index
];
556 strcpyW( name
, key
->name
);
557 if (key
->class) strcpyW( class, key
->class ); /* FIXME: length */
559 if (debug_level
> 1) dump_operation( key
, NULL
, "Enum" );
563 /* query information about a key */
564 static void query_key( struct key
*key
, struct query_key_info_request
*req
)
567 int max_subkey
= 0, max_class
= 0;
568 int max_value
= 0, max_data
= 0;
570 for (i
= 0; i
<= key
->last_subkey
; i
++)
572 struct key
*subkey
= key
->subkeys
[i
];
573 len
= strlenW( subkey
->name
);
574 if (len
> max_subkey
) max_subkey
= len
;
575 if (!subkey
->class) continue;
576 len
= strlenW( subkey
->class );
577 if (len
> max_class
) max_class
= len
;
579 for (i
= 0; i
<= key
->last_value
; i
++)
581 len
= strlenW( key
->values
[i
].name
);
582 if (len
> max_value
) max_value
= len
;
583 len
= key
->values
[i
].len
;
584 if (len
> max_data
) max_data
= len
;
586 req
->subkeys
= key
->last_subkey
+ 1;
587 req
->max_subkey
= max_subkey
;
588 req
->max_class
= max_class
;
589 req
->values
= key
->last_value
+ 1;
590 req
->max_value
= max_value
;
591 req
->max_data
= max_data
;
592 req
->modif
= key
->modif
;
593 strcpyW( req
->name
, key
->name
);
594 if (key
->class) strcpyW( req
->class, key
->class ); /* FIXME: length */
595 else req
->class[0] = 0;
596 if (debug_level
> 1) dump_operation( key
, NULL
, "Query" );
599 /* delete a key and its values */
600 static void delete_key( struct key
*key
, const WCHAR
*name
, size_t maxlen
)
606 path
= get_path_token( name
, maxlen
);
609 /* deleting this key, must find parent and index */
610 if (key
->flags
& KEY_ROOT
)
612 set_error( STATUS_ACCESS_DENIED
);
615 if (!(parent
= key
->parent
) || (key
->flags
& KEY_DELETED
))
617 set_error( STATUS_KEY_DELETED
);
620 for (index
= 0; index
<= parent
->last_subkey
; index
++)
621 if (parent
->subkeys
[index
] == key
) break;
622 assert( index
<= parent
->last_subkey
);
627 if (!(key
= find_subkey( parent
, path
, &index
)))
629 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
632 path
= get_path_token( NULL
, 0 );
635 /* we can only delete a key that has no subkeys (FIXME) */
636 if ((key
->flags
& KEY_ROOT
) || (key
->last_subkey
>= 0))
638 set_error( STATUS_ACCESS_DENIED
);
641 if (debug_level
> 1) dump_operation( key
, NULL
, "Delete" );
642 free_subkey( parent
, index
);
646 /* try to grow the array of values; return 1 if OK, 0 on error */
647 static int grow_values( struct key
*key
)
649 struct key_value
*new_val
;
654 nb_values
= key
->nb_values
+ (key
->nb_values
/ 2); /* grow by 50% */
655 if (!(new_val
= realloc( key
->values
, nb_values
* sizeof(*new_val
) )))
657 set_error( STATUS_NO_MEMORY
);
663 nb_values
= MIN_VALUES
;
664 if (!(new_val
= mem_alloc( nb_values
* sizeof(*new_val
) ))) return 0;
666 key
->values
= new_val
;
667 key
->nb_values
= nb_values
;
671 /* find the named value of a given key and return its index in the array */
672 static struct key_value
*find_value( const struct key
*key
, const WCHAR
*name
, int *index
)
674 int i
, min
, max
, res
;
677 max
= key
->last_value
;
681 if (!(res
= strcmpiW( key
->values
[i
].name
, name
)))
684 return &key
->values
[i
];
686 if (res
> 0) max
= i
- 1;
689 *index
= min
; /* this is where we should insert it */
693 /* insert a new value or return a pointer to an existing one */
694 static struct key_value
*insert_value( struct key
*key
, const WCHAR
*name
)
696 struct key_value
*value
;
700 if (!(value
= find_value( key
, name
, &index
)))
702 /* not found, add it */
703 if (key
->last_value
+ 1 == key
->nb_values
)
705 if (!grow_values( key
)) return NULL
;
707 if (!(new_name
= strdupW(name
))) return NULL
;
708 for (i
= ++key
->last_value
; i
> index
; i
--) key
->values
[i
] = key
->values
[i
- 1];
709 value
= &key
->values
[index
];
710 value
->name
= new_name
;
717 /* set a key value */
718 static void set_value( struct key
*key
, WCHAR
*name
, int type
, unsigned int total_len
,
719 unsigned int offset
, unsigned int data_len
, void *data
)
721 struct key_value
*value
;
724 if (data_len
+ offset
> total_len
)
726 set_error( STATUS_INVALID_PARAMETER
);
730 if (offset
) /* adding data to an existing value */
733 if (!(value
= find_value( key
, name
, &index
)))
735 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
738 if (value
->len
!= total_len
)
740 set_error( STATUS_INVALID_PARAMETER
);
743 memcpy( (char *)value
->data
+ offset
, data
, data_len
);
744 if (debug_level
> 1) dump_operation( key
, value
, "Set" );
748 /* first copy the data */
751 if (!(ptr
= mem_alloc( total_len
))) return;
752 memcpy( ptr
, data
, data_len
);
753 if (data_len
< total_len
) memset( (char *)ptr
+ data_len
, 0, total_len
- data_len
);
756 if (!(value
= insert_value( key
, name
)))
758 if (ptr
) free( ptr
);
761 if (value
->data
) free( value
->data
); /* already existing, free previous data */
763 value
->len
= total_len
;
766 if (debug_level
> 1) dump_operation( key
, value
, "Set" );
769 /* get a key value */
770 static void get_value( struct key
*key
, WCHAR
*name
, unsigned int offset
,
771 unsigned int maxlen
, int *type
, int *len
, void *data
)
773 struct key_value
*value
;
776 if ((value
= find_value( key
, name
, &index
)))
780 if (value
->data
&& offset
< value
->len
)
782 if (maxlen
> value
->len
- offset
) maxlen
= value
->len
- offset
;
783 memcpy( data
, (char *)value
->data
+ offset
, maxlen
);
785 if (debug_level
> 1) dump_operation( key
, value
, "Get" );
790 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
794 /* enumerate a key value */
795 static void enum_value( struct key
*key
, int i
, WCHAR
*name
, unsigned int offset
,
796 unsigned int maxlen
, int *type
, int *len
, void *data
)
798 struct key_value
*value
;
800 if (i
< 0 || i
> key
->last_value
) set_error( STATUS_NO_MORE_ENTRIES
);
803 value
= &key
->values
[i
];
804 strcpyW( name
, value
->name
);
807 if (value
->data
&& offset
< value
->len
)
809 if (maxlen
> value
->len
- offset
) maxlen
= value
->len
- offset
;
810 memcpy( data
, (char *)value
->data
+ offset
, maxlen
);
812 if (debug_level
> 1) dump_operation( key
, value
, "Enum" );
817 static void delete_value( struct key
*key
, const WCHAR
*name
)
819 struct key_value
*value
;
820 int i
, index
, nb_values
;
822 if (!(value
= find_value( key
, name
, &index
)))
824 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
827 if (debug_level
> 1) dump_operation( key
, value
, "Delete" );
829 if (value
->data
) free( value
->data
);
830 for (i
= index
; i
< key
->last_value
; i
++) key
->values
[i
] = key
->values
[i
+ 1];
834 /* try to shrink the array */
835 nb_values
= key
->nb_values
;
836 if (nb_values
> MIN_VALUES
&& key
->last_value
< nb_values
/ 2)
838 struct key_value
*new_val
;
839 nb_values
-= nb_values
/ 3; /* shrink by 33% */
840 if (nb_values
< MIN_VALUES
) nb_values
= MIN_VALUES
;
841 if (!(new_val
= realloc( key
->values
, nb_values
* sizeof(*new_val
) ))) return;
842 key
->values
= new_val
;
843 key
->nb_values
= nb_values
;
847 static struct key
*create_root_key( int hkey
)
854 p
= special_root_names
[hkey
- HKEY_SPECIAL_ROOT_FIRST
];
856 while (*p
) keyname
[i
++] = *p
++;
858 if (hkey
== HKEY_CURRENT_USER
) /* this one is special */
860 /* get the current user name */
862 struct passwd
*pwd
= getpwuid( getuid() );
864 if (pwd
) p
= pwd
->pw_name
;
867 sprintf( buffer
, "%ld", (long) getuid() );
870 while (*p
&& i
< sizeof(keyname
)/sizeof(WCHAR
)-1) keyname
[i
++] = *p
++;
874 if ((key
= create_key( root_key
, keyname
, i
*sizeof(WCHAR
), NULL
, 0, time(NULL
), &dummy
)))
876 special_root_keys
[hkey
- HKEY_SPECIAL_ROOT_FIRST
] = key
;
877 key
->flags
|= KEY_ROOT
;
882 /* get the registry key corresponding to an hkey handle */
883 static struct key
*get_hkey_obj( int hkey
, unsigned int access
)
887 if (!hkey
) return (struct key
*)grab_object( root_key
);
888 if (IS_SPECIAL_ROOT_HKEY(hkey
))
890 if (!(key
= special_root_keys
[hkey
- HKEY_SPECIAL_ROOT_FIRST
]))
891 key
= create_root_key( hkey
);
896 key
= (struct key
*)get_handle_obj( current
->process
, hkey
, access
, &key_ops
);
900 /* read a line from the input file */
901 static int read_next_line( struct file_load_info
*info
)
909 if (!fgets( info
->buffer
+ pos
, info
->len
- pos
, info
->file
))
910 return (pos
!= 0); /* EOF */
911 pos
= strlen(info
->buffer
);
912 if (info
->buffer
[pos
-1] == '\n')
914 /* got a full line */
915 info
->buffer
[--pos
] = 0;
916 if (pos
> 0 && info
->buffer
[pos
-1] == '\r') info
->buffer
[pos
-1] = 0;
919 if (pos
< info
->len
- 1) return 1; /* EOF but something was read */
921 /* need to enlarge the buffer */
922 newlen
= info
->len
+ info
->len
/ 2;
923 if (!(newbuf
= realloc( info
->buffer
, newlen
)))
925 set_error( STATUS_NO_MEMORY
);
928 info
->buffer
= newbuf
;
933 /* make sure the temp buffer holds enough space */
934 static int get_file_tmp_space( struct file_load_info
*info
, int size
)
937 if (info
->tmplen
>= size
) return 1;
938 if (!(tmp
= realloc( info
->tmp
, size
)))
940 set_error( STATUS_NO_MEMORY
);
948 /* report an error while loading an input file */
949 static void file_read_error( const char *err
, struct file_load_info
*info
)
951 fprintf( stderr
, "Line %d: %s '%s'\n", info
->line
, err
, info
->buffer
);
954 /* parse an escaped string back into Unicode */
955 /* return the number of chars read from the input, or -1 on output overflow */
956 static int parse_strW( WCHAR
*dest
, int *len
, const char *src
, char endchar
)
958 int count
= sizeof(WCHAR
); /* for terminating null */
960 while (*p
&& *p
!= endchar
)
962 if (*p
!= '\\') *dest
= (WCHAR
)*p
++;
968 case 'a': *dest
= '\a'; p
++; break;
969 case 'b': *dest
= '\b'; p
++; break;
970 case 'e': *dest
= '\e'; p
++; break;
971 case 'f': *dest
= '\f'; p
++; break;
972 case 'n': *dest
= '\n'; p
++; break;
973 case 'r': *dest
= '\r'; p
++; break;
974 case 't': *dest
= '\t'; p
++; break;
975 case 'v': *dest
= '\v'; p
++; break;
976 case 'x': /* hex escape */
978 if (!isxdigit(*p
)) *dest
= 'x';
981 *dest
= to_hex(*p
++);
982 if (isxdigit(*p
)) *dest
= (*dest
* 16) + to_hex(*p
++);
983 if (isxdigit(*p
)) *dest
= (*dest
* 16) + to_hex(*p
++);
984 if (isxdigit(*p
)) *dest
= (*dest
* 16) + to_hex(*p
++);
994 case '7': /* octal escape */
996 if (*p
>= '0' && *p
<= '7') *dest
= (*dest
* 8) + (*p
++ - '0');
997 if (*p
>= '0' && *p
<= '7') *dest
= (*dest
* 8) + (*p
++ - '0');
1000 *dest
= (WCHAR
)*p
++;
1004 if ((count
+= sizeof(WCHAR
)) > *len
) return -1; /* dest buffer overflow */
1008 if (!*p
) return -1; /* delimiter not found */
1013 /* convert a data type tag to a value type */
1014 static int get_data_type( const char *buffer
, int *type
, int *parse_type
)
1016 struct data_type
{ const char *tag
; int len
; int type
; int parse_type
; };
1018 static const struct data_type data_types
[] =
1019 { /* actual type */ /* type to assume for parsing */
1020 { "\"", 1, REG_SZ
, REG_SZ
},
1021 { "str:\"", 5, REG_SZ
, REG_SZ
},
1022 { "str(2):\"", 8, REG_EXPAND_SZ
, REG_SZ
},
1023 { "str(7):\"", 8, REG_MULTI_SZ
, REG_SZ
},
1024 { "hex:", 4, REG_BINARY
, REG_BINARY
},
1025 { "dword:", 6, REG_DWORD
, REG_DWORD
},
1026 { "hex(", 4, -1, REG_BINARY
},
1030 const struct data_type
*ptr
;
1033 for (ptr
= data_types
; ptr
->tag
; ptr
++)
1035 if (memcmp( ptr
->tag
, buffer
, ptr
->len
)) continue;
1036 *parse_type
= ptr
->parse_type
;
1037 if ((*type
= ptr
->type
) != -1) return ptr
->len
;
1038 /* "hex(xx):" is special */
1039 *type
= (int)strtoul( buffer
+ 4, &end
, 16 );
1040 if ((end
<= buffer
) || memcmp( end
, "):", 2 )) return 0;
1041 return end
+ 2 - buffer
;
1046 /* load and create a key from the input file */
1047 static struct key
*load_key( struct key
*base
, const char *buffer
, unsigned int options
,
1048 int prefix_len
, struct file_load_info
*info
)
1051 int res
, len
, modif
;
1053 len
= strlen(buffer
) * sizeof(WCHAR
);
1054 if (!get_file_tmp_space( info
, len
)) return NULL
;
1056 if ((res
= parse_strW( (WCHAR
*)info
->tmp
, &len
, buffer
, ']' )) == -1)
1058 file_read_error( "Malformed key", info
);
1061 if (!sscanf( buffer
+ res
, " %d", &modif
)) modif
= time(NULL
);
1063 p
= (WCHAR
*)info
->tmp
;
1064 while (prefix_len
&& *p
) { if (*p
++ == '\\') prefix_len
--; }
1070 file_read_error( "Malformed key", info
);
1073 /* empty key name, return base key */
1074 return (struct key
*)grab_object( base
);
1076 return create_key( base
, p
, len
- ((char *)p
- info
->tmp
), NULL
, options
, modif
, &res
);
1079 /* parse a comma-separated list of hex digits */
1080 static int parse_hex( unsigned char *dest
, int *len
, const char *buffer
)
1082 const char *p
= buffer
;
1084 while (isxdigit(*p
))
1088 memcpy( buf
, p
, 2 );
1090 sscanf( buf
, "%x", &val
);
1091 if (count
++ >= *len
) return -1; /* dest buffer overflow */
1092 *dest
++ = (unsigned char )val
;
1100 /* parse a value name and create the corresponding value */
1101 static struct key_value
*parse_value_name( struct key
*key
, const char *buffer
, int *len
,
1102 struct file_load_info
*info
)
1104 int maxlen
= strlen(buffer
) * sizeof(WCHAR
);
1105 if (!get_file_tmp_space( info
, maxlen
)) return NULL
;
1106 if (buffer
[0] == '@')
1108 info
->tmp
[0] = info
->tmp
[1] = 0;
1113 if ((*len
= parse_strW( (WCHAR
*)info
->tmp
, &maxlen
, buffer
+ 1, '\"' )) == -1) goto error
;
1114 (*len
)++; /* for initial quote */
1116 while (isspace(buffer
[*len
])) (*len
)++;
1117 if (buffer
[*len
] != '=') goto error
;
1119 while (isspace(buffer
[*len
])) (*len
)++;
1120 return insert_value( key
, (WCHAR
*)info
->tmp
);
1123 file_read_error( "Malformed value name", info
);
1127 /* load a value from the input file */
1128 static int load_value( struct key
*key
, const char *buffer
, struct file_load_info
*info
)
1132 int maxlen
, len
, res
;
1133 int type
, parse_type
;
1134 struct key_value
*value
;
1136 if (!(value
= parse_value_name( key
, buffer
, &len
, info
))) return 0;
1137 if (!(res
= get_data_type( buffer
+ len
, &type
, &parse_type
))) goto error
;
1138 buffer
+= len
+ res
;
1143 len
= strlen(buffer
) * sizeof(WCHAR
);
1144 if (!get_file_tmp_space( info
, len
)) return 0;
1145 if ((res
= parse_strW( (WCHAR
*)info
->tmp
, &len
, buffer
, '\"' )) == -1) goto error
;
1149 dw
= strtoul( buffer
, NULL
, 16 );
1153 case REG_BINARY
: /* hex digits */
1157 maxlen
= 1 + strlen(buffer
)/3; /* 3 chars for one hex byte */
1158 if (!get_file_tmp_space( info
, len
+ maxlen
)) return 0;
1159 if ((res
= parse_hex( info
->tmp
+ len
, &maxlen
, buffer
)) == -1) goto error
;
1162 while (isspace(*buffer
)) buffer
++;
1163 if (!*buffer
) break;
1164 if (*buffer
!= '\\') goto error
;
1165 if (read_next_line( info
) != 1) goto error
;
1166 buffer
= info
->buffer
;
1167 while (isspace(*buffer
)) buffer
++;
1173 ptr
= NULL
; /* keep compiler quiet */
1177 if (!len
) newptr
= NULL
;
1178 else if (!(newptr
= memdup( ptr
, len
))) return 0;
1180 if (value
->data
) free( value
->data
);
1181 value
->data
= newptr
;
1184 /* update the key level but not the modification time */
1185 key
->level
= max( key
->level
, current_level
);
1189 file_read_error( "Malformed value", info
);
1193 /* return the length (in path elements) of name that is part of the key name */
1194 /* for instance if key is USER\foo\bar and name is foo\bar\baz, return 2 */
1195 static int get_prefix_len( struct key
*key
, const char *name
, struct file_load_info
*info
)
1199 int len
= strlen(name
) * sizeof(WCHAR
);
1200 if (!get_file_tmp_space( info
, len
)) return 0;
1202 if ((res
= parse_strW( (WCHAR
*)info
->tmp
, &len
, name
, ']' )) == -1)
1204 file_read_error( "Malformed key", info
);
1207 for (p
= (WCHAR
*)info
->tmp
; *p
; p
++) if (*p
== '\\') break;
1209 for (res
= 1; key
!= root_key
; res
++)
1211 if (!strcmpiW( (WCHAR
*)info
->tmp
, key
->name
)) break;
1214 if (key
== root_key
) res
= 0; /* no matching name */
1218 /* load all the keys from the input file */
1219 static void load_keys( struct key
*key
, FILE *f
)
1221 struct key
*subkey
= NULL
;
1222 struct file_load_info info
;
1224 unsigned int options
= 0;
1225 int prefix_len
= -1; /* number of key name prefixes to skip */
1227 if (key
->flags
& KEY_VOLATILE
) options
|= REG_OPTION_VOLATILE
;
1233 if (!(info
.buffer
= mem_alloc( info
.len
))) return;
1234 if (!(info
.tmp
= mem_alloc( info
.tmplen
)))
1236 free( info
.buffer
);
1240 if ((read_next_line( &info
) != 1) ||
1241 strcmp( info
.buffer
, "WINE REGISTRY Version 2" ))
1243 set_error( STATUS_NOT_REGISTRY_FILE
);
1247 while (read_next_line( &info
) == 1)
1249 for (p
= info
.buffer
; *p
&& isspace(*p
); p
++);
1252 case '[': /* new key */
1253 if (subkey
) release_object( subkey
);
1254 if (prefix_len
== -1) prefix_len
= get_prefix_len( key
, p
+ 1, &info
);
1255 if (!(subkey
= load_key( key
, p
+ 1, options
, prefix_len
, &info
)))
1256 file_read_error( "Error creating key", &info
);
1258 case '@': /* default value */
1259 case '\"': /* value */
1260 if (subkey
) load_value( subkey
, p
, &info
);
1261 else file_read_error( "Value without key", &info
);
1263 case '#': /* comment */
1264 case ';': /* comment */
1265 case 0: /* empty line */
1268 file_read_error( "Unrecognized input", &info
);
1274 if (subkey
) release_object( subkey
);
1275 free( info
.buffer
);
1279 /* load a part of the registry from a file */
1280 static void load_registry( struct key
*key
, int handle
)
1285 if (!(obj
= get_handle_obj( current
->process
, handle
, GENERIC_READ
, NULL
))) return;
1286 fd
= obj
->ops
->get_read_fd( obj
);
1287 release_object( obj
);
1290 FILE *f
= fdopen( fd
, "r" );
1293 load_keys( key
, f
);
1296 else file_set_error();
1300 /* registry initialisation */
1301 void init_registry(void)
1303 static const WCHAR root_name
[] = { 0 };
1304 static const WCHAR config_name
[] =
1305 { 'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\',
1306 'W','i','n','e','\\','W','i','n','e','\\','C','o','n','f','i','g',0 };
1312 /* create the root key */
1313 root_key
= alloc_key( root_name
, time(NULL
) );
1315 root_key
->flags
|= KEY_ROOT
;
1317 /* load the config file */
1318 config
= get_config_dir();
1319 if (!(filename
= malloc( strlen(config
) + 8 ))) fatal_error( "out of memory\n" );
1320 strcpy( filename
, config
);
1321 strcat( filename
, "/config" );
1322 if ((f
= fopen( filename
, "r" )))
1327 /* create the config key */
1328 if (!(key
= create_key( root_key
, config_name
, sizeof(config_name
),
1329 NULL
, 0, time(NULL
), &dummy
)))
1330 fatal_error( "could not create config key\n" );
1331 key
->flags
|= KEY_VOLATILE
;
1333 load_keys( key
, f
);
1335 if (get_error() == STATUS_NOT_REGISTRY_FILE
)
1336 fatal_error( "%s is not a valid registry file\n", filename
);
1338 fatal_error( "loading %s failed with error %x\n", filename
, get_error() );
1340 release_object( key
);
1345 /* update the level of the parents of a key (only needed for the old format) */
1346 static int update_level( struct key
*key
)
1349 int max
= key
->level
;
1350 for (i
= 0; i
<= key
->last_subkey
; i
++)
1352 int sub
= update_level( key
->subkeys
[i
] );
1353 if (sub
> max
) max
= sub
;
1359 /* save a registry branch to a file */
1360 static void save_all_subkeys( struct key
*key
, FILE *f
)
1362 fprintf( f
, "WINE REGISTRY Version 2\n" );
1363 fprintf( f
, ";; All keys relative to " );
1364 dump_path( key
, NULL
, f
);
1366 save_subkeys( key
, key
, f
);
1369 /* save a registry branch to a file handle */
1370 static void save_registry( struct key
*key
, int handle
)
1375 if (key
->flags
& KEY_DELETED
)
1377 set_error( STATUS_KEY_DELETED
);
1380 if (!(obj
= get_handle_obj( current
->process
, handle
, GENERIC_WRITE
, NULL
))) return;
1381 fd
= obj
->ops
->get_write_fd( obj
);
1382 release_object( obj
);
1385 FILE *f
= fdopen( fd
, "w" );
1388 save_all_subkeys( key
, f
);
1389 if (fclose( f
)) file_set_error();
1399 /* register a key branch for being saved on exit */
1400 static void register_branch_for_saving( struct key
*key
, const char *path
, size_t len
)
1402 if (save_branch_count
>= MAX_SAVE_BRANCH_INFO
)
1404 set_error( STATUS_NO_MORE_ENTRIES
);
1407 if (!(save_branch_info
[save_branch_count
].path
= memdup( path
, len
+1 ))) return;
1408 save_branch_info
[save_branch_count
].path
[len
] = 0;
1409 save_branch_info
[save_branch_count
].key
= (struct key
*)grab_object( key
);
1410 save_branch_count
++;
1413 /* save a registry branch to a file */
1414 static int save_branch( struct key
*key
, const char *path
)
1416 char *p
, *real
, *tmp
= NULL
;
1417 int fd
, count
= 0, ret
= 0;
1420 /* get the real path */
1422 if (!(real
= malloc( PATH_MAX
))) return 0;
1423 if (!realpath( path
, real
))
1430 /* test the file type */
1432 if ((fd
= open( path
, O_WRONLY
)) != -1)
1435 /* if file is not a regular file or has multiple links,
1436 write directly into it; otherwise use a temp file */
1437 if (!fstat( fd
, &st
) && (!S_ISREG(st
.st_mode
) || st
.st_nlink
> 1))
1445 /* create a temp file in the same directory */
1447 if (!(tmp
= malloc( strlen(path
) + 20 ))) goto done
;
1448 strcpy( tmp
, path
);
1449 if ((p
= strrchr( tmp
, '/' ))) p
++;
1453 sprintf( p
, "reg%lx%04x.tmp", (long) getpid(), count
++ );
1454 if ((fd
= open( tmp
, O_CREAT
| O_EXCL
| O_WRONLY
, 0666 )) != -1) break;
1455 if (errno
!= EEXIST
) goto done
;
1459 /* now save to it */
1462 if (!(f
= fdopen( fd
, "w" )))
1464 if (tmp
) unlink( tmp
);
1469 if (debug_level
> 1)
1471 fprintf( stderr
, "%s: ", path
);
1472 dump_operation( key
, NULL
, "saving" );
1475 save_all_subkeys( key
, f
);
1480 /* if successfully written, rename to final name */
1481 if (ret
) ret
= !rename( tmp
, path
);
1482 if (!ret
) unlink( tmp
);
1487 if (real
) free( real
);
1491 /* periodic saving of the registry */
1492 static void periodic_save( void *arg
)
1495 for (i
= 0; i
< save_branch_count
; i
++)
1496 save_branch( save_branch_info
[i
].key
, save_branch_info
[i
].path
);
1497 add_timeout( &next_save_time
, save_period
);
1498 save_timeout_user
= add_timeout_user( &next_save_time
, periodic_save
, 0 );
1501 /* save the registry and close the top-level keys; used on server exit */
1502 void close_registry(void)
1506 for (i
= 0; i
< save_branch_count
; i
++)
1508 if (!save_branch( save_branch_info
[i
].key
, save_branch_info
[i
].path
))
1510 fprintf( stderr
, "wineserver: could not save registry branch to %s",
1511 save_branch_info
[i
].path
);
1514 release_object( save_branch_info
[i
].key
);
1516 release_object( root_key
);
1520 /* create a registry key */
1521 DECL_HANDLER(create_key
)
1523 struct key
*key
, *parent
;
1525 unsigned int access
= req
->access
;
1527 if (access
& MAXIMUM_ALLOWED
) access
= KEY_ALL_ACCESS
; /* FIXME: needs general solution */
1529 if ((parent
= get_hkey_obj( req
->parent
, 0 /*FIXME*/ )))
1531 if ((class = req_strdupW( req
, req
->class )))
1533 if ((key
= create_key( parent
, req
->name
, sizeof(req
->name
), class, req
->options
,
1534 req
->modif
, &req
->created
)))
1536 req
->hkey
= alloc_handle( current
->process
, key
, access
, 0 );
1537 release_object( key
);
1541 release_object( parent
);
1545 /* open a registry key */
1546 DECL_HANDLER(open_key
)
1548 struct key
*key
, *parent
;
1549 unsigned int access
= req
->access
;
1551 if (access
& MAXIMUM_ALLOWED
) access
= KEY_ALL_ACCESS
; /* FIXME: needs general solution */
1553 if ((parent
= get_hkey_obj( req
->parent
, 0 /*FIXME*/ )))
1555 if ((key
= open_key( parent
, req
->name
, sizeof(req
->name
) )))
1557 req
->hkey
= alloc_handle( current
->process
, key
, access
, 0 );
1558 release_object( key
);
1560 release_object( parent
);
1564 /* delete a registry key */
1565 DECL_HANDLER(delete_key
)
1569 if ((key
= get_hkey_obj( req
->hkey
, 0 /*FIXME*/ )))
1571 delete_key( key
, req
->name
, sizeof(req
->name
) );
1572 release_object( key
);
1576 /* close a registry key */
1577 DECL_HANDLER(close_key
)
1579 int hkey
= req
->hkey
;
1580 /* ignore attempts to close a root key */
1581 if (hkey
&& !IS_SPECIAL_ROOT_HKEY(hkey
)) close_handle( current
->process
, hkey
);
1584 /* enumerate registry subkeys */
1585 DECL_HANDLER(enum_key
)
1589 req
->name
[0] = req
->class[0] = 0;
1590 if ((key
= get_hkey_obj( req
->hkey
, KEY_ENUMERATE_SUB_KEYS
)))
1592 enum_key( key
, req
->index
, req
->name
, req
->class, &req
->modif
);
1593 release_object( key
);
1597 /* query information about a registry key */
1598 DECL_HANDLER(query_key_info
)
1602 req
->name
[0] = req
->class[0] = 0;
1603 if ((key
= get_hkey_obj( req
->hkey
, KEY_QUERY_VALUE
)))
1605 query_key( key
, req
);
1606 release_object( key
);
1610 /* set a value of a registry key */
1611 DECL_HANDLER(set_key_value
)
1614 unsigned int max
= get_req_size( req
, req
->data
, sizeof(req
->data
[0]) );
1615 unsigned int datalen
= req
->len
;
1617 if (datalen
> max
) datalen
= max
;
1618 if ((key
= get_hkey_obj( req
->hkey
, KEY_SET_VALUE
)))
1620 set_value( key
, copy_path( req
->name
), req
->type
, req
->total
,
1621 req
->offset
, datalen
, req
->data
);
1622 release_object( key
);
1626 /* retrieve the value of a registry key */
1627 DECL_HANDLER(get_key_value
)
1630 unsigned int max
= get_req_size( req
, req
->data
, sizeof(req
->data
[0]) );
1633 if ((key
= get_hkey_obj( req
->hkey
, KEY_QUERY_VALUE
)))
1635 get_value( key
, copy_path( req
->name
), req
->offset
, max
,
1636 &req
->type
, &req
->len
, req
->data
);
1637 release_object( key
);
1641 /* enumerate the value of a registry key */
1642 DECL_HANDLER(enum_key_value
)
1645 unsigned int max
= get_req_size( req
, req
->data
, sizeof(req
->data
[0]) );
1649 if ((key
= get_hkey_obj( req
->hkey
, KEY_QUERY_VALUE
)))
1651 enum_value( key
, req
->index
, req
->name
, req
->offset
, max
,
1652 &req
->type
, &req
->len
, req
->data
);
1653 release_object( key
);
1657 /* delete a value of a registry key */
1658 DECL_HANDLER(delete_key_value
)
1663 if ((key
= get_hkey_obj( req
->hkey
, KEY_SET_VALUE
)))
1665 if ((name
= req_strdupW( req
, req
->name
)))
1667 delete_value( key
, name
);
1670 release_object( key
);
1674 /* load a registry branch from a file */
1675 DECL_HANDLER(load_registry
)
1679 if ((key
= get_hkey_obj( req
->hkey
, KEY_SET_VALUE
| KEY_CREATE_SUB_KEY
)))
1681 /* FIXME: use subkey name */
1682 load_registry( key
, req
->file
);
1683 release_object( key
);
1687 /* save a registry branch to a file */
1688 DECL_HANDLER(save_registry
)
1692 if ((key
= get_hkey_obj( req
->hkey
, KEY_QUERY_VALUE
| KEY_ENUMERATE_SUB_KEYS
)))
1694 save_registry( key
, req
->file
);
1695 release_object( key
);
1699 /* set the current and saving level for the registry */
1700 DECL_HANDLER(set_registry_levels
)
1702 current_level
= req
->current
;
1703 saving_level
= req
->saving
;
1705 /* set periodic save timer */
1707 if (save_timeout_user
)
1709 remove_timeout_user( save_timeout_user
);
1710 save_timeout_user
= NULL
;
1712 if ((save_period
= req
->period
))
1714 if (save_period
< 10000) save_period
= 10000; /* limit rate */
1715 gettimeofday( &next_save_time
, 0 );
1716 add_timeout( &next_save_time
, save_period
);
1717 save_timeout_user
= add_timeout_user( &next_save_time
, periodic_save
, 0 );
1721 /* save a registry branch at server exit */
1722 DECL_HANDLER(save_registry_atexit
)
1726 if ((key
= get_hkey_obj( req
->hkey
, KEY_QUERY_VALUE
| KEY_ENUMERATE_SUB_KEYS
)))
1728 register_branch_for_saving( key
, req
->file
, get_req_strlen( req
, req
->file
) );
1729 release_object( key
);