server/registry.c

   1 /*
   2  * Server-side registry management
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  */
   6
   7 /* To do:
   8  * - behavior with deleted keys
   9  * - values larger than request buffer
  10  * - symbolic links
  11  */
  12
  13 #include <assert.h>
  14 #include <limits.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <unistd.h>
  18 #include <pwd.h>
  19 #include "object.h"
  20 #include "handle.h"
  21 #include "request.h"
  22 #include "unicode.h"
  23
  24 #include "winbase.h"
  25 #include "winreg.h"
  26 #include "winnt.h" /* registry definitions */
  27
  28
  29 /* a registry key */
  30 struct key
  31 {
  32     struct object     obj;         /* object header */
  33     WCHAR            *name;        /* key name */
  34     WCHAR            *class;       /* key class */
  35     struct key       *parent;      /* parent key */
  36     int               last_subkey; /* last in use subkey */
  37     int               nb_subkeys;  /* count of allocated subkeys */
  38     struct key      **subkeys;     /* subkeys array */
  39     int               last_value;  /* last in use value */
  40     int               nb_values;   /* count of allocated values in array */
  41     struct key_value *values;      /* values array */
  42     short             flags;       /* flags */
  43     short             level;       /* saving level */
  44     time_t            modif;       /* last modification time */
  45 };
  46
  47 /* key flags */
  48 #define KEY_VOLATILE 0x0001  /* key is volatile (not saved to disk) */
  49 #define KEY_DELETED  0x0002  /* key has been deleted */
  50 #define KEY_ROOT     0x0004  /* key is a root key */
  51
  52 /* a key value */
  53 struct key_value
  54 {
  55     WCHAR            *name;    /* value name */
  56     int               type;    /* value type */
  57     size_t            len;     /* value data length in bytes */
  58     void             *data;    /* pointer to value data */
  59 };
  60
  61 #define MIN_SUBKEYS  8   /* min. number of allocated subkeys per key */
  62 #define MIN_VALUES   8   /* min. number of allocated values per key */
  63
  64
  65 /* the root keys */
  66 #define HKEY_ROOT_FIRST   HKEY_CLASSES_ROOT
  67 #define HKEY_ROOT_LAST    HKEY_DYN_DATA
  68 #define NB_ROOT_KEYS      (HKEY_ROOT_LAST - HKEY_ROOT_FIRST + 1)
  69 #define IS_ROOT_HKEY(h)   (((h) >= HKEY_ROOT_FIRST) && ((h) <= HKEY_ROOT_LAST))
  70 static struct key *root_keys[NB_ROOT_KEYS];
  71
  72 static const char * const root_key_names[NB_ROOT_KEYS] =
  73 {
  74     "HKEY_CLASSES_ROOT",
  75     "HKEY_CURRENT_USER",
  76     "HKEY_LOCAL_MACHINE",
  77     "HKEY_USERS",
  78     "HKEY_PERFORMANCE_DATA",
  79     "HKEY_CURRENT_CONFIG",
  80     "HKEY_DYN_DATA"
  81 };
  82
  83
  84 /* keys saving level */
  85 /* current_level is the level that is put into all newly created or modified keys */
  86 /* saving_level is the minimum level that a key needs in order to get saved */
  87 static int current_level;
  88 static int saving_level;
  89
  90 static int saving_version = 1;  /* file format version */
  91
  92
  93 /* information about a file being loaded */
  94 struct file_load_info
  95 {
  96     FILE *file;    /* input file */
  97     char *buffer;  /* line buffer */
  98     int   len;     /* buffer length */
  99     int   line;    /* current input line */
 100     char *tmp;     /* temp buffer to use while parsing input */
 101     int   tmplen;  /* length of temp buffer */
 102 };
 103
 104
 105 static void key_dump( struct object *obj, int verbose );
 106 static void key_destroy( struct object *obj );
 107
 108 static const struct object_ops key_ops =
 109 {
 110     sizeof(struct key),      /* size */
 111     key_dump,                /* dump */
 112     no_add_queue,            /* add_queue */
 113     NULL,                    /* remove_queue */
 114     NULL,                    /* signaled */
 115     NULL,                    /* satisfied */
 116     NULL,                    /* get_poll_events */
 117     NULL,                    /* poll_event */
 118     no_read_fd,              /* get_read_fd */
 119     no_write_fd,             /* get_write_fd */
 120     no_flush,                /* flush */
 121     no_get_file_info,        /* get_file_info */
 122     key_destroy              /* destroy */
 123 };
 124
 125
 126 /*
 127  * The registry text file format v2 used by this code is similar to the one
 128  * used by REGEDIT import/export functionality, with the following differences:
 129  * - strings and key names can contain \x escapes for Unicode
 130  * - key names use escapes too in order to support Unicode
 131  * - the modification time optionally follows the key name
 132  * - REG_EXPAND_SZ and REG_MULTI_SZ are saved as strings instead of hex
 133  */
 134
 135 static inline char to_hex( char ch )
 136 {
 137     if (isdigit(ch)) return ch - '0';
 138     return tolower(ch) - 'a' + 10;
 139 }
 140
 141 /* dump the full path of a key */
 142 static void dump_path( struct key *key, struct key *base, FILE *f )
 143 {
 144     if (key->parent && key != base)
 145     {
 146         dump_path( key->parent, base, f );
 147         fprintf( f, "\\\\" );
 148     }
 149
 150     if (key->name) dump_strW( key->name, strlenW(key->name), f, "[]" );
 151     else  /* root key */
 152     {
 153         int i;
 154         for (i = 0; i < NB_ROOT_KEYS; i++)
 155             if (root_keys[i] == key) fprintf( f, "%s", root_key_names[i] );
 156     }
 157 }
 158
 159 /* dump a value to a text file */
 160 static void dump_value( struct key_value *value, FILE *f )
 161 {
 162     int i, count;
 163
 164     if (value->name[0])
 165     {
 166         fputc( '\"', f );
 167         count = 1 + dump_strW( value->name, strlenW(value->name), f, "\"\"" );
 168         count += fprintf( f, "\"=" );
 169     }
 170     else count = fprintf( f, "@=" );
 171
 172     switch(value->type)
 173     {
 174     case REG_SZ:
 175     case REG_EXPAND_SZ:
 176     case REG_MULTI_SZ:
 177         if (value->type != REG_SZ) fprintf( f, "str(%d):", value->type );
 178         fputc( '\"', f );
 179         if (value->data) dump_strW( (WCHAR *)value->data, value->len / sizeof(WCHAR), f, "\"\"" );
 180         fputc( '\"', f );
 181         break;
 182     case REG_DWORD:
 183         if (value->len == sizeof(DWORD))
 184         {
 185             DWORD dw;
 186             memcpy( &dw, value->data, sizeof(DWORD) );
 187             fprintf( f, "dword:%08lx", dw );
 188             break;
 189         }
 190         /* else fall through */
 191     default:
 192         if (value->type == REG_BINARY) count += fprintf( f, "hex:" );
 193         else count += fprintf( f, "hex(%x):", value->type );
 194         for (i = 0; i < value->len; i++)
 195         {
 196             count += fprintf( f, "%02x", *((unsigned char *)value->data + i) );
 197             if (i < value->len-1)
 198             {
 199                 fputc( ',', f );
 200                 if (++count > 76)
 201                 {
 202                     fprintf( f, "\\\n  " );
 203                     count = 2;
 204                 }
 205             }
 206         }
 207         break;
 208     }
 209     fputc( '\n', f );
 210 }
 211
 212 /* save a registry and all its subkeys to a text file */
 213 static void save_subkeys( struct key *key, struct key *base, FILE *f )
 214 {
 215     int i;
 216
 217     if (key->flags & KEY_VOLATILE) return;
 218     /* save key if it has the proper level, and has either some values or no subkeys */
 219     /* keys with no values but subkeys are saved implicitly by saving the subkeys */
 220     if ((key->level >= saving_level) && ((key->last_value >= 0) || (key->last_subkey == -1)))
 221     {
 222         fprintf( f, "\n[" );
 223         dump_path( key, base, f );
 224         fprintf( f, "] %ld\n", key->modif );
 225         for (i = 0; i <= key->last_value; i++) dump_value( &key->values[i], f );
 226     }
 227     for (i = 0; i <= key->last_subkey; i++) save_subkeys( key->subkeys[i], base, f );
 228 }
 229
 230 static void dump_operation( struct key *key, struct key_value *value, const char *op )
 231 {
 232     fprintf( stderr, "%s key ", op );
 233     if (key) dump_path( key, NULL, stderr );
 234     else fprintf( stderr, "ERROR" );
 235     if (value)
 236     {
 237         fprintf( stderr, " value ");
 238         dump_value( value, stderr );
 239     }
 240     else fprintf( stderr, "\n" );
 241 }
 242
 243 static void key_dump( struct object *obj, int verbose )
 244 {
 245     struct key *key = (struct key *)obj;
 246     assert( obj->ops == &key_ops );
 247     fprintf( stderr, "Key flags=%x ", key->flags );
 248     dump_path( key, NULL, stderr );
 249     fprintf( stderr, "\n" );
 250 }
 251
 252 static void key_destroy( struct object *obj )
 253 {
 254     int i;
 255     struct key *key = (struct key *)obj;
 256     assert( obj->ops == &key_ops );
 257
 258     free( key->name );
 259     if (key->class) free( key->class );
 260     for (i = 0; i <= key->last_value; i++)
 261     {
 262         free( key->values[i].name );
 263         if (key->values[i].data) free( key->values[i].data );
 264     }
 265     for (i = 0; i <= key->last_subkey; i++)
 266     {
 267         key->subkeys[i]->parent = NULL;
 268         release_object( key->subkeys[i] );
 269     }
 270 }
 271
 272 /* duplicate a key path from the request buffer */
 273 /* returns a pointer to a static buffer, so only useable once per request */
 274 static WCHAR *copy_path( const path_t path )
 275 {
 276     static WCHAR buffer[MAX_PATH+1];
 277     WCHAR *p = buffer;
 278
 279     while (p < buffer + sizeof(buffer) - 1) if (!(*p++ = *path++)) break;
 280     *p = 0;
 281     return buffer;
 282 }
 283
 284 /* return the next token in a given path */
 285 /* returns a pointer to a static buffer, so only useable once per request */
 286 static WCHAR *get_path_token( const WCHAR *initpath, size_t maxlen )
 287 {
 288     static const WCHAR *path;
 289     static const WCHAR *end;
 290     static WCHAR buffer[MAX_PATH+1];
 291     WCHAR *p = buffer;
 292
 293     if (initpath)
 294     {
 295         path = initpath;
 296         end  = path + maxlen / sizeof(WCHAR);
 297     }
 298     while ((path < end) && (*path == '\\')) path++;
 299     while ((path < end) && (p < buffer + sizeof(buffer) - 1))
 300     {
 301         WCHAR ch = *path;
 302         if (!ch || (ch == '\\')) break;
 303         *p++ = ch;
 304         path++;
 305     }
 306     *p = 0;
 307     return buffer;
 308 }
 309
 310 /* duplicate a Unicode string from the request buffer */
 311 static WCHAR *req_strdupW( const WCHAR *str )
 312 {
 313     WCHAR *name;
 314     size_t len = get_req_strlenW( str );
 315     if ((name = mem_alloc( (len + 1) * sizeof(WCHAR) )) != NULL)
 316     {
 317         memcpy( name, str, len * sizeof(WCHAR) );
 318         name[len] = 0;
 319     }
 320     return name;
 321 }
 322
 323 /* allocate a key object */
 324 static struct key *alloc_key( const WCHAR *name, time_t modif )
 325 {
 326     struct key *key;
 327     if ((key = (struct key *)alloc_object( &key_ops, -1 )))
 328     {
 329         key->name        = NULL;
 330         key->class       = NULL;
 331         key->flags       = 0;
 332         key->last_subkey = -1;
 333         key->nb_subkeys  = 0;
 334         key->subkeys     = NULL;
 335         key->nb_values   = 0;
 336         key->last_value  = -1;
 337         key->values      = NULL;
 338         key->level       = current_level;
 339         key->modif       = modif;
 340         key->parent      = NULL;
 341         if (name && !(key->name = strdupW( name )))
 342         {
 343             release_object( key );
 344             key = NULL;
 345         }
 346     }
 347     return key;
 348 }
 349
 350 /* update key modification time */
 351 static void touch_key( struct key *key )
 352 {
 353     key->modif = time(NULL);
 354     key->level = max( key->level, current_level );
 355 }
 356
 357 /* try to grow the array of subkeys; return 1 if OK, 0 on error */
 358 static int grow_subkeys( struct key *key )
 359 {
 360     struct key **new_subkeys;
 361     int nb_subkeys;
 362
 363     if (key->nb_subkeys)
 364     {
 365         nb_subkeys = key->nb_subkeys + (key->nb_subkeys / 2);  /* grow by 50% */
 366         if (!(new_subkeys = realloc( key->subkeys, nb_subkeys * sizeof(*new_subkeys) )))
 367         {
 368             set_error( STATUS_NO_MEMORY );
 369             return 0;
 370         }
 371     }
 372     else
 373     {
 374         nb_subkeys = MIN_VALUES;
 375         if (!(new_subkeys = mem_alloc( nb_subkeys * sizeof(*new_subkeys) ))) return 0;
 376     }
 377     key->subkeys    = new_subkeys;
 378     key->nb_subkeys = nb_subkeys;
 379     return 1;
 380 }
 381
 382 /* allocate a subkey for a given key, and return its index */
 383 static struct key *alloc_subkey( struct key *parent, const WCHAR *name, int index, time_t modif )
 384 {
 385     struct key *key;
 386     int i;
 387
 388     if (parent->last_subkey + 1 == parent->nb_subkeys)
 389     {
 390         /* need to grow the array */
 391         if (!grow_subkeys( parent )) return NULL;
 392     }
 393     if ((key = alloc_key( name, modif )) != NULL)
 394     {
 395         key->parent = parent;
 396         for (i = ++parent->last_subkey; i > index; i--)
 397             parent->subkeys[i] = parent->subkeys[i-1];
 398         parent->subkeys[index] = key;
 399     }
 400     return key;
 401 }
 402
 403 /* free a subkey of a given key */
 404 static void free_subkey( struct key *parent, int index )
 405 {
 406     struct key *key;
 407     int i, nb_subkeys;
 408
 409     assert( index >= 0 );
 410     assert( index <= parent->last_subkey );
 411
 412     key = parent->subkeys[index];
 413     for (i = index; i < parent->last_subkey; i++) parent->subkeys[i] = parent->subkeys[i + 1];
 414     parent->last_subkey--;
 415     key->flags |= KEY_DELETED;
 416     key->parent = NULL;
 417     release_object( key );
 418
 419     /* try to shrink the array */
 420     nb_subkeys = key->nb_subkeys;
 421     if (nb_subkeys > MIN_SUBKEYS && key->last_subkey < nb_subkeys / 2)
 422     {
 423         struct key **new_subkeys;
 424         nb_subkeys -= nb_subkeys / 3;  /* shrink by 33% */
 425         if (nb_subkeys < MIN_SUBKEYS) nb_subkeys = MIN_SUBKEYS;
 426         if (!(new_subkeys = realloc( key->subkeys, nb_subkeys * sizeof(*new_subkeys) ))) return;
 427         key->subkeys = new_subkeys;
 428         key->nb_subkeys = nb_subkeys;
 429     }
 430 }
 431
 432 /* find the named child of a given key and return its index */
 433 static struct key *find_subkey( struct key *key, const WCHAR *name, int *index )
 434 {
 435     int i, min, max, res;
 436
 437     min = 0;
 438     max = key->last_subkey;
 439     while (min <= max)
 440     {
 441         i = (min + max) / 2;
 442         if (!(res = strcmpiW( key->subkeys[i]->name, name )))
 443         {
 444             *index = i;
 445             return key->subkeys[i];
 446         }
 447         if (res > 0) max = i - 1;
 448         else min = i + 1;
 449     }
 450     *index = min;  /* this is where we should insert it */
 451     return NULL;
 452 }
 453
 454 /* open a subkey */
 455 static struct key *open_key( struct key *key, const WCHAR *name, size_t maxlen )
 456 {
 457     int index;
 458     WCHAR *path;
 459
 460     path = get_path_token( name, maxlen );
 461     while (*path)
 462     {
 463         if (!(key = find_subkey( key, path, &index )))
 464         {
 465             set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 466             break;
 467         }
 468         path = get_path_token( NULL, 0 );
 469     }
 470
 471     if (debug_level > 1) dump_operation( key, NULL, "Open" );
 472     if (key) grab_object( key );
 473     return key;
 474 }
 475
 476 /* create a subkey */
 477 static struct key *create_key( struct key *key, const WCHAR *name, size_t maxlen, WCHAR *class,
 478                                unsigned int options, time_t modif, int *created )
 479 {
 480     struct key *base;
 481     int base_idx, index, flags = 0;
 482     WCHAR *path;
 483
 484     if (key->flags & KEY_DELETED) /* we cannot create a subkey under a deleted key */
 485     {
 486         set_error( STATUS_KEY_DELETED );
 487         return NULL;
 488     }
 489     if (options & REG_OPTION_VOLATILE) flags |= KEY_VOLATILE;
 490     else if (key->flags & KEY_VOLATILE)
 491     {
 492         set_error( STATUS_CHILD_MUST_BE_VOLATILE );
 493         return NULL;
 494     }
 495
 496     path = get_path_token( name, maxlen );
 497     *created = 0;
 498     while (*path)
 499     {
 500         struct key *subkey;
 501         if (!(subkey = find_subkey( key, path, &index ))) break;
 502         key = subkey;
 503         path = get_path_token( NULL, 0 );
 504     }
 505
 506     /* create the remaining part */
 507
 508     if (!*path) goto done;
 509     *created = 1;
 510     base = key;
 511     base_idx = index;
 512     key = alloc_subkey( key, path, index, modif );
 513     while (key)
 514     {
 515         key->flags |= flags;
 516         path = get_path_token( NULL, 0 );
 517         if (!*path) goto done;
 518         /* we know the index is always 0 in a new key */
 519         key = alloc_subkey( key, path, 0, modif );
 520     }
 521     if (base_idx != -1) free_subkey( base, base_idx );
 522     return NULL;
 523
 524  done:
 525     if (debug_level > 1) dump_operation( key, NULL, "Create" );
 526     if (class) key->class = strdupW(class);
 527     grab_object( key );
 528     return key;
 529 }
 530
 531 /* find a subkey of a given key by its index */
 532 static void enum_key( struct key *parent, int index, WCHAR *name, WCHAR *class, time_t *modif )
 533 {
 534     struct key *key;
 535
 536     if ((index < 0) || (index > parent->last_subkey)) set_error( STATUS_NO_MORE_ENTRIES );
 537     else
 538     {
 539         key = parent->subkeys[index];
 540         *modif = key->modif;
 541         strcpyW( name, key->name );
 542         if (key->class) strcpyW( class, key->class );  /* FIXME: length */
 543         else *class = 0;
 544         if (debug_level > 1) dump_operation( key, NULL, "Enum" );
 545     }
 546 }
 547
 548 /* query information about a key */
 549 static void query_key( struct key *key, struct query_key_info_request *req )
 550 {
 551     int i, len;
 552     int max_subkey = 0, max_class = 0;
 553     int max_value = 0, max_data = 0;
 554
 555     for (i = 0; i <= key->last_subkey; i++)
 556     {
 557         struct key *subkey = key->subkeys[i];
 558         len = strlenW( subkey->name );
 559         if (len > max_subkey) max_subkey = len;
 560         if (!subkey->class) continue;
 561         len = strlenW( subkey->class );
 562         if (len > max_class) max_class = len;
 563     }
 564     for (i = 0; i <= key->last_value; i++)
 565     {
 566         len = strlenW( key->values[i].name );
 567         if (len > max_value) max_value = len;
 568         len = key->values[i].len;
 569         if (len > max_data) max_data = len;
 570     }
 571     req->subkeys    = key->last_subkey + 1;
 572     req->max_subkey = max_subkey;
 573     req->max_class  = max_class;
 574     req->values     = key->last_value + 1;
 575     req->max_value  = max_value;
 576     req->max_data   = max_data;
 577     req->modif      = key->modif;
 578     strcpyW( req->name, key->name);
 579     if (key->class) strcpyW( req->class, key->class );  /* FIXME: length */
 580     else req->class[0] = 0;
 581     if (debug_level > 1) dump_operation( key, NULL, "Query" );
 582 }
 583
 584 /* delete a key and its values */
 585 static void delete_key( struct key *key, const WCHAR *name, size_t maxlen )
 586 {
 587     int index;
 588     struct key *parent;
 589     WCHAR *path;
 590
 591     path = get_path_token( name, maxlen );
 592     if (!*path)
 593     {
 594         /* deleting this key, must find parent and index */
 595         if (key->flags & KEY_ROOT)
 596         {
 597             set_error( STATUS_ACCESS_DENIED );
 598             return;
 599         }
 600         if (!(parent = key->parent) || (key->flags & KEY_DELETED))
 601         {
 602             set_error( STATUS_KEY_DELETED );
 603             return;
 604         }
 605         for (index = 0; index <= parent->last_subkey; index++)
 606             if (parent->subkeys[index] == key) break;
 607         assert( index <= parent->last_subkey );
 608     }
 609     else while (*path)
 610     {
 611         parent = key;
 612         if (!(key = find_subkey( parent, path, &index )))
 613         {
 614             set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 615             return;
 616         }
 617         path = get_path_token( NULL, 0 );
 618     }
 619
 620     /* we can only delete a key that has no subkeys (FIXME) */
 621     if ((key->flags & KEY_ROOT) || (key->last_subkey >= 0))
 622     {
 623         set_error( STATUS_ACCESS_DENIED );
 624         return;
 625     }
 626     if (debug_level > 1) dump_operation( key, NULL, "Delete" );
 627     free_subkey( parent, index );
 628     touch_key( parent );
 629 }
 630
 631 /* try to grow the array of values; return 1 if OK, 0 on error */
 632 static int grow_values( struct key *key )
 633 {
 634     struct key_value *new_val;
 635     int nb_values;
 636
 637     if (key->nb_values)
 638     {
 639         nb_values = key->nb_values + (key->nb_values / 2);  /* grow by 50% */
 640         if (!(new_val = realloc( key->values, nb_values * sizeof(*new_val) )))
 641         {
 642             set_error( STATUS_NO_MEMORY );
 643             return 0;
 644         }
 645     }
 646     else
 647     {
 648         nb_values = MIN_VALUES;
 649         if (!(new_val = mem_alloc( nb_values * sizeof(*new_val) ))) return 0;
 650     }
 651     key->values = new_val;
 652     key->nb_values = nb_values;
 653     return 1;
 654 }
 655
 656 /* find the named value of a given key and return its index in the array */
 657 static struct key_value *find_value( const struct key *key, const WCHAR *name, int *index )
 658 {
 659     int i, min, max, res;
 660
 661     min = 0;
 662     max = key->last_value;
 663     while (min <= max)
 664     {
 665         i = (min + max) / 2;
 666         if (!(res = strcmpiW( key->values[i].name, name )))
 667         {
 668             *index = i;
 669             return &key->values[i];
 670         }
 671         if (res > 0) max = i - 1;
 672         else min = i + 1;
 673     }
 674     *index = min;  /* this is where we should insert it */
 675     return NULL;
 676 }
 677
 678 /* insert a new value or return a pointer to an existing one */
 679 static struct key_value *insert_value( struct key *key, const WCHAR *name )
 680 {
 681     struct key_value *value;
 682     WCHAR *new_name;
 683     int i, index;
 684
 685     if (!(value = find_value( key, name, &index )))
 686     {
 687         /* not found, add it */
 688         if (key->last_value + 1 == key->nb_values)
 689         {
 690             if (!grow_values( key )) return NULL;
 691         }
 692         if (!(new_name = strdupW(name))) return NULL;
 693         for (i = ++key->last_value; i > index; i--) key->values[i] = key->values[i - 1];
 694         value = &key->values[index];
 695         value->name = new_name;
 696         value->len  = 0;
 697         value->data = NULL;
 698     }
 699     return value;
 700 }
 701
 702 /* set a key value */
 703 static void set_value( struct key *key, WCHAR *name, int type, int datalen, void *data )
 704 {
 705     struct key_value *value;
 706     void *ptr = NULL;
 707
 708     /* first copy the data */
 709     if (datalen)
 710     {
 711         if (!(ptr = mem_alloc( datalen ))) return;
 712         memcpy( ptr, data, datalen );
 713     }
 714
 715     if (!(value = insert_value( key, name )))
 716     {
 717         if (ptr) free( ptr );
 718         return;
 719     }
 720     if (value->data) free( value->data ); /* already existing, free previous data */
 721     value->type  = type;
 722     value->len   = datalen;
 723     value->data  = ptr;
 724     touch_key( key );
 725     if (debug_level > 1) dump_operation( key, value, "Set" );
 726 }
 727
 728 /* get a key value */
 729 static void get_value( struct key *key, WCHAR *name, int *type, int *len, void *data )
 730 {
 731     struct key_value *value;
 732     int index;
 733
 734     if ((value = find_value( key, name, &index )))
 735     {
 736         *type = value->type;
 737         *len  = value->len;
 738         if (value->data) memcpy( data, value->data, value->len );
 739         if (debug_level > 1) dump_operation( key, value, "Get" );
 740     }
 741     else
 742     {
 743         *type = -1;
 744         *len = 0;
 745         set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 746     }
 747 }
 748
 749 /* enumerate a key value */
 750 static void enum_value( struct key *key, int i, WCHAR *name, int *type, int *len, void *data )
 751 {
 752     struct key_value *value;
 753
 754     if (i < 0 || i > key->last_value)
 755     {
 756         name[0] = 0;
 757         *len = 0;
 758         set_error( STATUS_NO_MORE_ENTRIES );
 759     }
 760     else
 761     {
 762         value = &key->values[i];
 763         strcpyW( name, value->name );
 764         *type = value->type;
 765         *len  = value->len;
 766         if (value->data) memcpy( data, value->data, value->len );
 767         if (debug_level > 1) dump_operation( key, value, "Enum" );
 768     }
 769 }
 770
 771 /* delete a value */
 772 static void delete_value( struct key *key, const WCHAR *name )
 773 {
 774     struct key_value *value;
 775     int i, index, nb_values;
 776
 777     if (!(value = find_value( key, name, &index )))
 778     {
 779         set_error( STATUS_OBJECT_NAME_NOT_FOUND );
 780         return;
 781     }
 782     if (debug_level > 1) dump_operation( key, value, "Delete" );
 783     free( value->name );
 784     if (value->data) free( value->data );
 785     for (i = index; i < key->last_value; i++) key->values[i] = key->values[i + 1];
 786     key->last_value--;
 787     touch_key( key );
 788
 789     /* try to shrink the array */
 790     nb_values = key->nb_values;
 791     if (nb_values > MIN_VALUES && key->last_value < nb_values / 2)
 792     {
 793         struct key_value *new_val;
 794         nb_values -= nb_values / 3;  /* shrink by 33% */
 795         if (nb_values < MIN_VALUES) nb_values = MIN_VALUES;
 796         if (!(new_val = realloc( key->values, nb_values * sizeof(*new_val) ))) return;
 797         key->values = new_val;
 798         key->nb_values = nb_values;
 799     }
 800 }
 801
 802 static struct key *get_hkey_obj( int hkey, unsigned int access );
 803
 804 static struct key *create_root_key( int hkey )
 805 {
 806     int dummy;
 807     struct key *key;
 808
 809     switch(hkey)
 810     {
 811     /* the two real root-keys */
 812     case HKEY_LOCAL_MACHINE:
 813         {
 814             static const WCHAR name[] = { 'M','A','C','H','I','N','E',0 };
 815             key = alloc_key( name, time(NULL) );
 816         }
 817         break;
 818     case HKEY_USERS:
 819         {
 820             static const WCHAR name[] = { 'U','S','E','R',0 };
 821             key = alloc_key( name, time(NULL) );
 822         }
 823         break;
 824     /* special subkeys */
 825     case HKEY_CLASSES_ROOT:
 826         {
 827             static const WCHAR name[] =
 828                           { 'S','O','F','T','W','A','R','E','\\','C','l','a','s','s','e','s',0 };
 829
 830             struct key *root = get_hkey_obj( HKEY_LOCAL_MACHINE, 0 );
 831             assert( root );
 832             key = create_key( root, name, sizeof(name), NULL, 0, time(NULL), &dummy );
 833             release_object( root );
 834         }
 835         break;
 836     case HKEY_CURRENT_CONFIG:
 837         {
 838             static const WCHAR name[] = {
 839                 'S','Y','S','T','E','M','\\',
 840                 'C','U','R','R','E','N','T','C','O','N','T','R','O','L','S','E','T','\\',
 841                 'H','A','R','D','W','A','R','E','P','R','O','F','I','L','E','S','\\',
 842                 'C','U','R','R','E','N','T',0};
 843             struct key *root = get_hkey_obj( HKEY_LOCAL_MACHINE, 0 );
 844             assert( root );
 845             key = create_key( root, name, sizeof(name), NULL, 0, time(NULL), &dummy );
 846             release_object( root );
 847         }
 848         break;
 849     case HKEY_CURRENT_USER:
 850         {
 851             /* get the current user name */
 852             int i, len;
 853             WCHAR *name;
 854             char buffer[10];
 855             const char *p;
 856             struct passwd *pwd = getpwuid( getuid() );
 857
 858             if (pwd) p = pwd->pw_name;
 859             else
 860             {
 861                 sprintf( buffer, "%ld", (long) getuid() );
 862                 p = buffer;
 863             }
 864             len = strlen(p);
 865             if ((name = mem_alloc( (len+1) * sizeof(WCHAR) )))
 866             {
 867                 struct key *root = get_hkey_obj( HKEY_USERS, 0 );
 868                 assert( root );
 869                 for (i = 0; i <= len; i++) name[i] = p[i];
 870                 key = create_key( root, name, (len+1) * sizeof(WCHAR),
 871                                   NULL, 0, time(NULL), &dummy );
 872                 release_object( root );
 873                 free( name );
 874             }
 875             else key = NULL;
 876         }
 877         break;
 878     /* dynamically generated keys */
 879     case HKEY_PERFORMANCE_DATA:
 880     case HKEY_DYN_DATA:
 881         key = alloc_key( NULL, time(NULL) );
 882         break;
 883     default:
 884         key = NULL;
 885         assert(0);
 886     }
 887     if (key)
 888     {
 889         root_keys[hkey - HKEY_ROOT_FIRST] = key;
 890         key->flags |= KEY_ROOT;
 891     }
 892     return key;
 893 }
 894
 895 /* close the top-level keys; used on server exit */
 896 void close_registry(void)
 897 {
 898     int i;
 899     for (i = 0; i < NB_ROOT_KEYS; i++)
 900     {
 901         if (root_keys[i]) release_object( root_keys[i] );
 902     }
 903 }
 904
 905 /* get the registry key corresponding to an hkey handle */
 906 static struct key *get_hkey_obj( int hkey, unsigned int access )
 907 {
 908     struct key *key;
 909
 910     if (IS_ROOT_HKEY(hkey))
 911     {
 912         if (!(key = root_keys[hkey - HKEY_ROOT_FIRST])) key = create_root_key( hkey );
 913         grab_object( key );
 914     }
 915     else
 916         key = (struct key *)get_handle_obj( current->process, hkey, access, &key_ops );
 917     return key;
 918 }
 919
 920 /* read a line from the input file */
 921 static int read_next_line( struct file_load_info *info )
 922 {
 923     char *newbuf;
 924     int newlen, pos = 0;
 925
 926     info->line++;
 927     for (;;)
 928     {
 929         if (!fgets( info->buffer + pos, info->len - pos, info->file ))
 930             return (pos != 0);  /* EOF */
 931         pos = strlen(info->buffer);
 932         if (info->buffer[pos-1] == '\n')
 933         {
 934             /* got a full line */
 935             info->buffer[--pos] = 0;
 936             if (pos > 0 && info->buffer[pos-1] == '\r') info->buffer[pos-1] = 0;
 937             return 1;
 938         }
 939         if (pos < info->len - 1) return 1;  /* EOF but something was read */
 940
 941         /* need to enlarge the buffer */
 942         newlen = info->len + info->len / 2;
 943         if (!(newbuf = realloc( info->buffer, newlen )))
 944         {
 945             set_error( STATUS_NO_MEMORY );
 946             return -1;
 947         }
 948         info->buffer = newbuf;
 949         info->len = newlen;
 950     }
 951 }
 952
 953 /* make sure the temp buffer holds enough space */
 954 static int get_file_tmp_space( struct file_load_info *info, int size )
 955 {
 956     char *tmp;
 957     if (info->tmplen >= size) return 1;
 958     if (!(tmp = realloc( info->tmp, size )))
 959     {
 960         set_error( STATUS_NO_MEMORY );
 961         return 0;
 962     }
 963     info->tmp = tmp;
 964     info->tmplen = size;
 965     return 1;
 966 }
 967
 968 /* report an error while loading an input file */
 969 static void file_read_error( const char *err, struct file_load_info *info )
 970 {
 971     fprintf( stderr, "Line %d: %s '%s'\n", info->line, err, info->buffer );
 972 }
 973
 974 /* parse an escaped string back into Unicode */
 975 /* return the number of chars read from the input, or -1 on output overflow */
 976 static int parse_strW( WCHAR *dest, int *len, const char *src, char endchar )
 977 {
 978     int count = sizeof(WCHAR);  /* for terminating null */
 979     const char *p = src;
 980     while (*p && *p != endchar)
 981     {
 982         if (*p != '\\') *dest = (WCHAR)*p++;
 983         else
 984         {
 985             p++;
 986             switch(*p)
 987             {
 988             case 'a': *dest = '\a'; p++; break;
 989             case 'b': *dest = '\b'; p++; break;
 990             case 'e': *dest = '\e'; p++; break;
 991             case 'f': *dest = '\f'; p++; break;
 992             case 'n': *dest = '\n'; p++; break;
 993             case 'r': *dest = '\r'; p++; break;
 994             case 't': *dest = '\t'; p++; break;
 995             case 'v': *dest = '\v'; p++; break;
 996             case 'x':  /* hex escape */
 997                 p++;
 998                 if (!isxdigit(*p)) *dest = 'x';
 999                 else
1000                 {
1001                     *dest = to_hex(*p++);
1002                     if (isxdigit(*p)) *dest = (*dest * 16) + to_hex(*p++);
1003                     if (isxdigit(*p)) *dest = (*dest * 16) + to_hex(*p++);
1004                     if (isxdigit(*p)) *dest = (*dest * 16) + to_hex(*p++);
1005                 }
1006                 break;
1007             case '0':
1008             case '1':
1009             case '2':
1010             case '3':
1011             case '4':
1012             case '5':
1013             case '6':
1014             case '7':  /* octal escape */
1015                 *dest = *p++ - '0';
1016                 if (*p >= '0' && *p <= '7') *dest = (*dest * 8) + (*p++ - '0');
1017                 if (*p >= '0' && *p <= '7') *dest = (*dest * 8) + (*p++ - '0');
1018                 break;
1019             default:
1020                 *dest = (WCHAR)*p++;
1021                 break;
1022             }
1023         }
1024         if ((count += sizeof(WCHAR)) > *len) return -1;  /* dest buffer overflow */
1025         dest++;
1026     }
1027     *dest = 0;
1028     if (!*p) return -1;  /* delimiter not found */
1029     *len = count;
1030     return p + 1 - src;
1031 }
1032
1033 /* convert a data type tag to a value type */
1034 static int get_data_type( const char *buffer, int *type, int *parse_type )
1035 {
1036     struct data_type { const char *tag; int len; int type; int parse_type; };
1037
1038     static const struct data_type data_types[] =
1039     {                   /* actual type */  /* type to assume for parsing */
1040         { "\"",        1,   REG_SZ,              REG_SZ },
1041         { "str:\"",    5,   REG_SZ,              REG_SZ },
1042         { "str(2):\"", 8,   REG_EXPAND_SZ,       REG_SZ },
1043         { "str(7):\"", 8,   REG_MULTI_SZ,        REG_SZ },
1044         { "hex:",      4,   REG_BINARY,          REG_BINARY },
1045         { "dword:",    6,   REG_DWORD,           REG_DWORD },
1046         { "hex(",      4,   -1,                  REG_BINARY },
1047         { NULL, }
1048     };
1049
1050     const struct data_type *ptr;
1051     char *end;
1052
1053     for (ptr = data_types; ptr->tag; ptr++)
1054     {
1055         if (memcmp( ptr->tag, buffer, ptr->len )) continue;
1056         *parse_type = ptr->parse_type;
1057         if ((*type = ptr->type) != -1) return ptr->len;
1058         /* "hex(xx):" is special */
1059         *type = (int)strtoul( buffer + 4, &end, 16 );
1060         if ((end <= buffer) || memcmp( end, "):", 2 )) return 0;
1061         return end + 2 - buffer;
1062     }
1063     return 0;
1064 }
1065
1066 /* load and create a key from the input file */
1067 static struct key *load_key( struct key *base, const char *buffer, struct file_load_info *info )
1068 {
1069     WCHAR *p;
1070     int res, len, modif;
1071
1072     len = strlen(buffer) * sizeof(WCHAR);
1073     if (!get_file_tmp_space( info, len )) return NULL;
1074
1075     if ((res = parse_strW( (WCHAR *)info->tmp, &len, buffer, ']' )) == -1)
1076     {
1077         file_read_error( "Malformed key", info );
1078         return NULL;
1079     }
1080     if (!sscanf( buffer + res, " %d", &modif )) modif = time(NULL);
1081
1082     for (p = (WCHAR *)info->tmp; *p; p++) if (*p == '\\') { p++; break; }
1083     return create_key( base, p, len - ((char *)p - info->tmp), NULL, 0, modif, &res );
1084 }
1085
1086 /* parse a comma-separated list of hex digits */
1087 static int parse_hex( unsigned char *dest, int *len, const char *buffer )
1088 {
1089     const char *p = buffer;
1090     int count = 0;
1091     while (isxdigit(*p))
1092     {
1093         int val;
1094         char buf[3];
1095         memcpy( buf, p, 2 );
1096         buf[2] = 0;
1097         sscanf( buf, "%x", &val );
1098         if (count++ >= *len) return -1;  /* dest buffer overflow */
1099         *dest++ = (unsigned char )val;
1100         p += 2;
1101         if (*p == ',') p++;
1102     }
1103     *len = count;
1104     return p - buffer;
1105 }
1106
1107 /* parse a value name and create the corresponding value */
1108 static struct key_value *parse_value_name( struct key *key, const char *buffer, int *len,
1109                                            struct file_load_info *info )
1110 {
1111     int maxlen = strlen(buffer) * sizeof(WCHAR);
1112     if (!get_file_tmp_space( info, maxlen )) return NULL;
1113     if (buffer[0] == '@')
1114     {
1115         info->tmp[0] = info->tmp[1] = 0;
1116         *len = 1;
1117     }
1118     else
1119     {
1120         if ((*len = parse_strW( (WCHAR *)info->tmp, &maxlen, buffer + 1, '\"' )) == -1) goto error;
1121         (*len)++;  /* for initial quote */
1122     }
1123     if (buffer[*len] != '=') goto error;
1124     (*len)++;
1125     return insert_value( key, (WCHAR *)info->tmp );
1126
1127  error:
1128     file_read_error( "Malformed value name", info );
1129     return NULL;
1130 }
1131
1132 /* load a value from the input file */
1133 static int load_value( struct key *key, const char *buffer, struct file_load_info *info )
1134 {
1135     DWORD dw;
1136     void *ptr, *newptr;
1137     int maxlen, len, res;
1138     int type, parse_type;
1139     struct key_value *value;
1140
1141     if (!(value = parse_value_name( key, buffer, &len, info ))) return 0;
1142     if (!(res = get_data_type( buffer + len, &type, &parse_type ))) goto error;
1143     buffer += len + res;
1144
1145     switch(parse_type)
1146     {
1147     case REG_SZ:
1148         len = strlen(buffer) * sizeof(WCHAR);
1149         if (!get_file_tmp_space( info, len )) return 0;
1150         if ((res = parse_strW( (WCHAR *)info->tmp, &len, buffer, '\"' )) == -1) goto error;
1151         ptr = info->tmp;
1152         break;
1153     case REG_DWORD:
1154         dw = strtoul( buffer, NULL, 16 );
1155         ptr = &dw;
1156         len = sizeof(dw);
1157         break;
1158     case REG_BINARY:  /* hex digits */
1159         len = 0;
1160         for (;;)
1161         {
1162             maxlen = 1 + strlen(buffer)/3;  /* 3 chars for one hex byte */
1163             if (!get_file_tmp_space( info, len + maxlen )) return 0;
1164             if ((res = parse_hex( info->tmp + len, &maxlen, buffer )) == -1) goto error;
1165             len += maxlen;
1166             buffer += res;
1167             while (isspace(*buffer)) buffer++;
1168             if (!*buffer) break;
1169             if (*buffer != '\\') goto error;
1170             if (read_next_line( info) != 1) goto error;
1171             buffer = info->buffer;
1172             while (isspace(*buffer)) buffer++;
1173         }
1174         ptr = info->tmp;
1175         break;
1176     default:
1177         assert(0);
1178         ptr = NULL;  /* keep compiler quiet */
1179         break;
1180     }
1181
1182     if (!len) newptr = NULL;
1183     else if (!(newptr = memdup( ptr, len ))) return 0;
1184
1185     if (value->data) free( value->data );
1186     value->data = newptr;
1187     value->len  = len;
1188     value->type = type;
1189     /* update the key level but not the modification time */
1190     key->level = max( key->level, current_level );
1191     return 1;
1192
1193  error:
1194     file_read_error( "Malformed value", info );
1195     return 0;
1196 }
1197
1198 /* load all the keys from the input file */
1199 static void load_keys( struct key *key, FILE *f )
1200 {
1201     struct key *subkey = NULL;
1202     struct file_load_info info;
1203     char *p;
1204
1205     info.file   = f;
1206     info.len    = 4;
1207     info.tmplen = 4;
1208     info.line   = 0;
1209     if (!(info.buffer = mem_alloc( info.len ))) return;
1210     if (!(info.tmp = mem_alloc( info.tmplen )))
1211     {
1212         free( info.buffer );
1213         return;
1214     }
1215
1216     if ((read_next_line( &info ) != 1) ||
1217         strcmp( info.buffer, "WINE REGISTRY Version 2" ))
1218     {
1219         set_error( STATUS_NOT_REGISTRY_FILE );
1220         goto done;
1221     }
1222
1223     while (read_next_line( &info ) == 1)
1224     {
1225         for (p = info.buffer; *p && isspace(*p); p++);
1226         switch(*p)
1227         {
1228         case '[':   /* new key */
1229             if (subkey) release_object( subkey );
1230             subkey = load_key( key, p + 1, &info );
1231             break;
1232         case '@':   /* default value */
1233         case '\"':  /* value */
1234             if (subkey) load_value( subkey, p, &info );
1235             else file_read_error( "Value without key", &info );
1236             break;
1237         case '#':   /* comment */
1238         case ';':   /* comment */
1239         case 0:     /* empty line */
1240             break;
1241         default:
1242             file_read_error( "Unrecognized input", &info );
1243             break;
1244         }
1245     }
1246
1247  done:
1248     if (subkey) release_object( subkey );
1249     free( info.buffer );
1250     free( info.tmp );
1251 }
1252
1253 /* load a part of the registry from a file */
1254 static void load_registry( struct key *key, int handle )
1255 {
1256     struct object *obj;
1257     int fd;
1258
1259     if (!(obj = get_handle_obj( current->process, handle, GENERIC_READ, NULL ))) return;
1260     fd = obj->ops->get_read_fd( obj );
1261     release_object( obj );
1262     if (fd != -1)
1263     {
1264         FILE *f = fdopen( fd, "r" );
1265         if (f)
1266         {
1267             load_keys( key, f );
1268             fclose( f );
1269         }
1270         else file_set_error();
1271     }
1272 }
1273
1274 /* update the level of the parents of a key (only needed for the old format) */
1275 static int update_level( struct key *key )
1276 {
1277     int i;
1278     int max = key->level;
1279     for (i = 0; i <= key->last_subkey; i++)
1280     {
1281         int sub = update_level( key->subkeys[i] );
1282         if (sub > max) max = sub;
1283     }
1284     key->level = max;
1285     return max;
1286 }
1287
1288 /* dump a string to a registry save file in the old v1 format */
1289 static void save_string_v1( LPCWSTR str, FILE *f, int len )
1290 {
1291     if (!str) return;
1292     while ((len == -1) ? *str : (*str && len--))
1293     {
1294         if ((*str > 0x7f) || (*str == '\n') || (*str == '='))
1295             fprintf( f, "\\u%04x", *str );
1296         else
1297         {
1298             if (*str == '\\') fputc( '\\', f );
1299             fputc( (char)*str, f );
1300         }
1301         str++;
1302     }
1303 }
1304
1305 /* save a registry and all its subkeys to a text file in the old v1 format */
1306 static void save_subkeys_v1( struct key *key, int nesting, FILE *f )
1307 {
1308     int i, j;
1309
1310     if (key->flags & KEY_VOLATILE) return;
1311     if (key->level < saving_level) return;
1312     for (i = 0; i <= key->last_value; i++)
1313     {
1314         struct key_value *value = &key->values[i];
1315         for (j = nesting; j > 0; j --) fputc( '\t', f );
1316         save_string_v1( value->name, f, -1 );
1317         fprintf( f, "=%d,%d,", value->type, 0 );
1318         if (value->type == REG_SZ || value->type == REG_EXPAND_SZ)
1319             save_string_v1( (LPWSTR)value->data, f, value->len / 2 );
1320         else
1321             for (j = 0; j < value->len; j++)
1322                 fprintf( f, "%02x", *((unsigned char *)value->data + j) );
1323         fputc( '\n', f );
1324     }
1325     for (i = 0; i <= key->last_subkey; i++)
1326     {
1327         for (j = nesting; j > 0; j --) fputc( '\t', f );
1328         save_string_v1( key->subkeys[i]->name, f, -1 );
1329         fputc( '\n', f );
1330         save_subkeys_v1( key->subkeys[i], nesting + 1, f );
1331     }
1332 }
1333
1334 /* save a registry branch to a file handle */
1335 static void save_registry( struct key *key, int handle )
1336 {
1337     struct object *obj;
1338     int fd;
1339
1340     if (key->flags & KEY_DELETED)
1341     {
1342         set_error( STATUS_KEY_DELETED );
1343         return;
1344     }
1345     if (!(obj = get_handle_obj( current->process, handle, GENERIC_WRITE, NULL ))) return;
1346     fd = obj->ops->get_write_fd( obj );
1347     release_object( obj );
1348     if (fd != -1)
1349     {
1350         FILE *f = fdopen( fd, "w" );
1351         if (f)
1352         {
1353             fprintf( f, "WINE REGISTRY Version %d\n", saving_version );
1354             if (saving_version == 2) save_subkeys( key, key, f );
1355             else
1356             {
1357                 update_level( key );
1358                 save_subkeys_v1( key, 0, f );
1359             }
1360             if (fclose( f )) file_set_error();
1361         }
1362         else
1363         {
1364             file_set_error();
1365             close( fd );
1366         }
1367     }
1368 }
1369
1370 /* create a registry key */
1371 DECL_HANDLER(create_key)
1372 {
1373     struct key *key, *parent;
1374     WCHAR *class;
1375     unsigned int access = req->access;
1376
1377     if (access & MAXIMUM_ALLOWED) access = KEY_ALL_ACCESS;  /* FIXME: needs general solution */
1378     req->hkey = -1;
1379     if ((parent = get_hkey_obj( req->parent, KEY_CREATE_SUB_KEY )))
1380     {
1381         if ((class = req_strdupW( req->class )))
1382         {
1383             if ((key = create_key( parent, req->name, sizeof(req->name), class, req->options,
1384                                    req->modif, &req->created )))
1385             {
1386                 req->hkey = alloc_handle( current->process, key, access, 0 );
1387                 release_object( key );
1388             }
1389             free( class );
1390         }
1391         release_object( parent );
1392     }
1393 }
1394
1395 /* open a registry key */
1396 DECL_HANDLER(open_key)
1397 {
1398     struct key *key, *parent;
1399     unsigned int access = req->access;
1400
1401     if (access & MAXIMUM_ALLOWED) access = KEY_ALL_ACCESS;  /* FIXME: needs general solution */
1402     req->hkey = -1;
1403     if ((parent = get_hkey_obj( req->parent, 0 /*FIXME*/ )))
1404     {
1405         if ((key = open_key( parent, req->name, sizeof(req->name) )))
1406         {
1407             req->hkey = alloc_handle( current->process, key, access, 0 );
1408             release_object( key );
1409         }
1410         release_object( parent );
1411     }
1412 }
1413
1414 /* delete a registry key */
1415 DECL_HANDLER(delete_key)
1416 {
1417     struct key *key;
1418
1419     if ((key = get_hkey_obj( req->hkey, KEY_CREATE_SUB_KEY /*FIXME*/ )))
1420     {
1421         delete_key( key, req->name, sizeof(req->name) );
1422         release_object( key );
1423     }
1424 }
1425
1426 /* close a registry key */
1427 DECL_HANDLER(close_key)
1428 {
1429     int hkey = req->hkey;
1430     /* ignore attempts to close a root key */
1431     if (!IS_ROOT_HKEY(hkey)) close_handle( current->process, hkey );
1432 }
1433
1434 /* enumerate registry subkeys */
1435 DECL_HANDLER(enum_key)
1436 {
1437     struct key *key;
1438
1439     if ((key = get_hkey_obj( req->hkey, KEY_ENUMERATE_SUB_KEYS )))
1440     {
1441         enum_key( key, req->index, req->name, req->class, &req->modif );
1442         release_object( key );
1443     }
1444 }
1445
1446 /* query information about a registry key */
1447 DECL_HANDLER(query_key_info)
1448 {
1449     struct key *key;
1450
1451     if ((key = get_hkey_obj( req->hkey, KEY_QUERY_VALUE )))
1452     {
1453         query_key( key, req );
1454         release_object( key );
1455     }
1456 }
1457
1458 /* set a value of a registry key */
1459 DECL_HANDLER(set_key_value)
1460 {
1461     struct key *key;
1462     int max = get_req_size( req->data, sizeof(req->data[0]) );
1463     int datalen = req->len;
1464     if (datalen > max)
1465     {
1466         set_error( STATUS_NO_MEMORY );  /* FIXME */
1467         return;
1468     }
1469     if ((key = get_hkey_obj( req->hkey, KEY_SET_VALUE )))
1470     {
1471         set_value( key, copy_path( req->name ), req->type, datalen, req->data );
1472         release_object( key );
1473     }
1474 }
1475
1476 /* retrieve the value of a registry key */
1477 DECL_HANDLER(get_key_value)
1478 {
1479     struct key *key;
1480
1481     if ((key = get_hkey_obj( req->hkey, KEY_QUERY_VALUE )))
1482     {
1483         get_value( key, copy_path( req->name ), &req->type, &req->len, req->data );
1484         release_object( key );
1485     }
1486 }
1487
1488 /* enumerate the value of a registry key */
1489 DECL_HANDLER(enum_key_value)
1490 {
1491     struct key *key;
1492
1493     if ((key = get_hkey_obj( req->hkey, KEY_QUERY_VALUE )))
1494     {
1495         enum_value( key, req->index, req->name, &req->type, &req->len, req->data );
1496         release_object( key );
1497     }
1498 }
1499
1500 /* delete a value of a registry key */
1501 DECL_HANDLER(delete_key_value)
1502 {
1503     WCHAR *name;
1504     struct key *key;
1505
1506     if ((key = get_hkey_obj( req->hkey, KEY_SET_VALUE )))
1507     {
1508         if ((name = req_strdupW( req->name )))
1509         {
1510             delete_value( key, name );
1511             free( name );
1512         }
1513         release_object( key );
1514     }
1515 }
1516
1517 /* load a registry branch from a file */
1518 DECL_HANDLER(load_registry)
1519 {
1520     struct key *key;
1521
1522     if ((key = get_hkey_obj( req->hkey, KEY_SET_VALUE | KEY_CREATE_SUB_KEY )))
1523     {
1524         /* FIXME: use subkey name */
1525         load_registry( key, req->file );
1526         release_object( key );
1527     }
1528 }
1529
1530 /* save a registry branch to a file */
1531 DECL_HANDLER(save_registry)
1532 {
1533     struct key *key;
1534
1535     if ((key = get_hkey_obj( req->hkey, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS )))
1536     {
1537         save_registry( key, req->file );
1538         release_object( key );
1539     }
1540 }
1541
1542 /* set the current and saving level for the registry */
1543 DECL_HANDLER(set_registry_levels)
1544 {
1545     current_level  = req->current;
1546     saving_level   = req->saving;
1547     saving_version = req->version;
1548 }
1549