gio/gregistrysettingsbackend.c

   1 /*
   2  * Copyright © 2009-10 Sam Thursfield
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-or-later
   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, see <http://www.gnu.org/licenses/>.
  18  *
  19  * Author: Sam Thursfield <ssssam@gmail.com>
  20  */
  21
  22 /* GRegistrySettingsBackend implementation notes:
  23  *
  24  *   - All settings are stored under the registry path given at construction
  25  *     time. Permissions and system-wide defaults are not implemented and will
  26  *     probably always be out of scope of the Windows port of GLib.
  27  *
  28  *   - The registry type system is limited. Most GVariant types are stored as
  29  *     literals via g_variant_print/parse(). Strings are stored without the
  30  *     quotes that GVariant requires. Integer types are stored as native
  31  *     REG_DWORD or REG_QWORD. The REG_MULTI_SZ (string array) type could be
  32  *     used to avoid flattening container types.
  33  *
  34  *   - Notifications are handled; the change event is watched for in a separate
  35  *     thread (Windows does not provide a callback API) which sends them with
  36  *     g_idle_add to the GLib main loop. The threading is done using Windows
  37  *     API functions, so there is no dependence on GThread.
  38  *
  39  *   - Windows doesn't tell us which value has changed. This means we have to
  40  *     maintain a cache of every stored value so we can play spot the
  41  *     difference. This should not be a performance issue because if you are
  42  *     storing thousands of values in GSettings, you are probably using it
  43  *     wrong.
  44  *
  45  *   - The cache stores the value as a registry type. Because many variants are
  46  *     stored as string representations, values which have changed equality but
  47  *     not equivalence may trigger spurious change notifications. GSettings
  48  *     users must already deal with this possibility and converting all data to
  49  *     GVariant values would be more effort.
  50  *
  51  *   - Because we have to cache every registry value locally, reads are done
  52  *     from the cache rather than directly from the registry. Writes update
  53  *     both. This means that the backend will not work if the watch thread is
  54  *     not running. A GSettings object always subscribes to changes so we can
  55  *     be sure that the watch thread will be running, but if for some reason
  56  *     the backend is being used directly you should bear that in mind.
  57  *
  58  *   - The registry is totally user-editable, so we are very forgiving about
  59  *     errors in the data we get.
  60  *
  61  *   - The registry uses backslashes as path separators. GSettings keys only
  62  *     allow [A-Za-z\-] so no escaping is needed. No attempt is made to solve
  63  *     clashes between keys differing only in case.
  64  *
  65  *   - RegCreateKeyW is used - We should always make the UTF-8 -> UTF-16
  66  *     conversion ourselves to avoid problems when the system language changes.
  67  *
  68  *   - The Windows registry has the following limitations: a key may not exceed
  69  *     255 characters, an entry's value may not exceed 16,383 characters, and
  70  *     all the values of a key may not exceed 65,535 characters.
  71  *
  72  *   - Terminology:
  73  *     * in GSettings, a 'key' is eg. /desktop/gnome/background/primary-color
  74  *     * in the registry, the 'key' is path, which contains some 'values'.
  75  *     * in this file, any GSettings key is a 'key', while a registry key is
  76  *       termed a 'path', which contains 'values'.
  77  *
  78  *   - My set of tests for this backend are currently at:
  79  *       http://gitorious.org/gsettings-gtk/gsettings-test.git
  80  *
  81  *   - There is an undocumented function in ntdll.dll which might be more
  82  *     than RegNotifyChangeKeyValue(), NtNotifyChangeKey:
  83  *       http://source.winehq.org/source/dlls/ntdll/reg.c#L618
  84  *       http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/Key/NtNotifyChangeKey.html
  85  *
  86  *   - If updating the cache ever becomes a performance issue it may make sense
  87  *     to use a red-black tree, but I don't currently think it's worth the time
  88  */
  89
  90 #include "config.h"
  91
  92 #include "gregistrysettingsbackend.h"
  93 #include "gsettingsbackend.h"
  94 #include "gsettingsbackendinternal.h"
  95 #include "giomodule-priv.h"
  96
  97 #include <glibintl.h>
  98
  99 #include <windows.h>
 100
 101 //#define TRACE
 102
 103 /* GSettings' limit */
 104 #define MAX_KEY_NAME_LENGTH   128
 105
 106 /* Testing (on Windows XP SP3) shows that WaitForMultipleObjects fails with
 107  * "The parameter is incorrect" after 64 watches. We need one for the
 108  * message_sent cond, which is allowed for in the way the watches_remaining
 109  * variable is used.
 110  */
 111 #define MAX_WATCHES   64
 112
 113 /* A watch on one registry path and its subkeys */
 114 typedef struct
 115 {
 116   HANDLE event;
 117   HKEY hpath;
 118   char *prefix;
 119   GNode *cache_node;
 120 } RegistryWatch;
 121
 122 /* Simple message passing for the watch thread. Not enough traffic to
 123  * justify a queue.
 124  */
 125 typedef enum
 126 {
 127   WATCH_THREAD_NONE,
 128   WATCH_THREAD_ADD_WATCH,
 129   WATCH_THREAD_REMOVE_WATCH,
 130   WATCH_THREAD_STOP
 131 } WatchThreadMessageType;
 132
 133 typedef struct
 134 {
 135   WatchThreadMessageType type;
 136   RegistryWatch watch;
 137 } WatchThreadMessage;
 138
 139 typedef struct
 140 {
 141   GSettingsBackend *owner;
 142   HANDLE *thread;
 143
 144   /* Details of the things we are watching. */
 145   int watches_remaining;
 146   GPtrArray *events, *handles, *prefixes, *cache_nodes;
 147
 148   /* Communication with the main thread. Only one message is stored at a time,
 149    * to make sure that messages are acknowledged before being overwritten we
 150    * create two events - one is signalled when a new message is set, the
 151    * other is signalled by the thread when it has processed the message.
 152    */
 153   WatchThreadMessage message;
 154   CRITICAL_SECTION *message_lock;
 155   HANDLE message_sent_event, message_received_event;
 156 } WatchThreadState;
 157
 158 #define G_TYPE_REGISTRY_SETTINGS_BACKEND      (g_registry_settings_backend_get_type ())
 159 #define G_REGISTRY_SETTINGS_BACKEND(inst)     (G_TYPE_CHECK_INSTANCE_CAST ((inst),         \
 160                                                G_TYPE_REGISTRY_SETTINGS_BACKEND, GRegistrySettingsBackend))
 161 #define G_IS_REGISTRY_SETTINGS_BACKEND(inst)  (G_TYPE_CHECK_INSTANCE_TYPE ((inst),         \
 162                                                G_TYPE_REGISTRY_SETTINGS_BACKEND))
 163
 164 typedef enum {
 165   PROP_REGISTRY_KEY = 1,
 166 } GRegistrySettingsBackendProperty;
 167
 168 typedef GSettingsBackendClass GRegistrySettingsBackendClass;
 169
 170 typedef struct {
 171   GSettingsBackend parent_instance;
 172
 173   HKEY base_key;
 174   gchar *base_path;
 175   gunichar2 *base_pathw;
 176
 177   /* A stored copy of the whole tree being watched. When we receive a change notification
 178    * we have to check against this to see what has changed ... every time ...*/
 179   CRITICAL_SECTION *cache_lock;
 180   GNode *cache_root;
 181
 182   WatchThreadState *watch;
 183 } GRegistrySettingsBackend;
 184
 185 G_DEFINE_TYPE_WITH_CODE (GRegistrySettingsBackend,
 186                          g_registry_settings_backend,
 187                          G_TYPE_SETTINGS_BACKEND,
 188                          _g_io_modules_ensure_extension_points_registered ();
 189                          g_io_extension_point_implement (G_SETTINGS_BACKEND_EXTENSION_POINT_NAME,
 190                                                          g_define_type_id, "registry", 90))
 191
 192 /**********************************************************************************
 193  * Utility functions
 194  **********************************************************************************/
 195
 196 #include <stdio.h>
 197 static void
 198 trace (const char *format,
 199        ...)
 200 {
 201 #ifdef TRACE
 202   va_list va; va_start (va, format);
 203   vprintf (format, va);
 204   fflush (stdout);
 205   va_end (va);
 206 #endif
 207 }
 208
 209 /* g_message including a windows error message. It is not useful to have an
 210  * equivalent function for g_warning because none of the registry errors can
 211  * result from programmer error (Microsoft programmers don't count), instead
 212  * they will mostly occur from people messing with the registry by hand. */
 213 static void G_GNUC_PRINTF (2, 3)
 214 g_message_win32_error (DWORD        result_code,
 215                        const gchar *format,
 216                       ...)
 217 {
 218   va_list va;
 219   gchar *message;
 220   gchar *win32_error;
 221   gchar *win32_message;
 222
 223   g_return_if_fail (result_code != 0);
 224
 225   va_start (va, format);
 226   message = g_strdup_vprintf (format, va);
 227   win32_error = g_win32_error_message (result_code);
 228   win32_message = g_strdup_printf ("%s: %s", message, win32_error);
 229   g_free (message);
 230   g_free (win32_error);
 231
 232   if (result_code == ERROR_KEY_DELETED)
 233     trace ("(%s)", win32_message);
 234   else
 235     g_message ("%s", win32_message);
 236
 237   g_free (win32_message);
 238 }
 239
 240 /* Make gsettings key into a registry path & value pair.
 241  *
 242  * Note that the return value *only* needs freeing - registry_value_name
 243  * is a pointer to further inside the same block of memory.
 244  */
 245 static gchar *
 246 parse_key (const gchar  *key_name,
 247            const gchar  *registry_prefix,
 248            gchar       **value_name)
 249 {
 250   gchar *path_name, *c;
 251
 252   /* All key paths are treated as absolute; gsettings doesn't seem to enforce a
 253    * preceding /.
 254    */
 255   if (key_name[0] == '/')
 256     key_name++;
 257
 258   if (registry_prefix == NULL)
 259     path_name = g_strdup (key_name);
 260   else
 261     path_name = g_strjoin ("/", registry_prefix, key_name, NULL);
 262
 263   /* Prefix is expected to be in registry format (\ separators) so don't escape that. */
 264   for (c = path_name + (registry_prefix ? strlen (registry_prefix) : 0); *c != 0; c++)
 265     {
 266       if (*c == '/')
 267         {
 268           *c = '\\';
 269           *value_name = c;
 270         }
 271     }
 272
 273   **value_name = 0;
 274   (*value_name)++;
 275
 276   return path_name;
 277 }
 278
 279 static DWORD
 280 g_variant_get_as_dword (GVariant *variant)
 281 {
 282   switch (g_variant_get_type_string (variant)[0])
 283     {
 284     case 'b':
 285       return g_variant_get_boolean (variant);
 286     case 'y':
 287       return g_variant_get_byte (variant);
 288     case 'n':
 289       return g_variant_get_int16 (variant);
 290     case 'q':
 291       return g_variant_get_uint16 (variant);
 292     case 'i':
 293       return g_variant_get_int32 (variant);
 294     case 'u':
 295       return g_variant_get_uint32 (variant);
 296     default:
 297       g_warn_if_reached ();
 298     }
 299   return 0;
 300 }
 301
 302 static DWORDLONG
 303 g_variant_get_as_qword (GVariant *variant)
 304 {
 305   switch (g_variant_get_type_string (variant)[0])
 306     {
 307     case 'x':
 308       return g_variant_get_int64 (variant);
 309     case 't':
 310       return g_variant_get_uint64 (variant);
 311     default:
 312       g_warn_if_reached ();
 313     }
 314   return 0;
 315 }
 316
 317 static void
 318 handle_read_error (LONG         result,
 319                    const gchar *path_name,
 320                    const gchar *value_name)
 321 {
 322   /* file not found means key value not set, this isn't an error for us. */
 323   if (result != ERROR_FILE_NOT_FOUND)
 324     g_message_win32_error (result, "Unable to query value %s/%s",
 325                            path_name, value_name);
 326 }
 327
 328 typedef struct {
 329   HKEY handle;
 330   const char *name;
 331 } HandleNamePair;
 332
 333 static const HandleNamePair predefined_key_names[] = {
 334   { HKEY_CLASSES_ROOT, "HKEY_CLASSES_ROOT" },
 335   { HKEY_CURRENT_CONFIG, "HKEY_CURRENT_CONFIG" },
 336   { HKEY_CURRENT_USER, "HKEY_CURRENT_USER" },
 337   { HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE" },
 338   { HKEY_USERS, "HKEY_USERS" }
 339 };
 340
 341 static const gchar*
 342 predefined_key_to_string (HKEY key)
 343 {
 344   for (gsize i = 0; i < G_N_ELEMENTS (predefined_key_names); i++)
 345     {
 346       if (predefined_key_names[i].handle == key)
 347         return predefined_key_names[i].name;
 348     }
 349
 350   g_warning ("gregistrysettingsbackend: unexpected root key (%p)", key);
 351   return "";
 352 }
 353
 354 static const gchar*
 355 split_registry_path (const gchar *full_path,
 356                      HKEY        *root_key)
 357 {
 358   g_assert (full_path != NULL);
 359
 360   for (gsize i = 0; i < G_N_ELEMENTS (predefined_key_names); i++)
 361     {
 362       const gchar *root_name = predefined_key_names[i].name;
 363
 364       if (g_str_has_prefix (full_path, root_name))
 365         {
 366           const gchar *rest = full_path + strlen (root_name);
 367
 368           if (*rest == '\\')
 369             {
 370               if (root_key != NULL)
 371                 *root_key = predefined_key_names[i].handle;
 372
 373               return ++rest;
 374             }
 375         }
 376     }
 377
 378   return NULL;
 379 }
 380
 381 /***************************************************************************
 382  * Cache of registry values
 383  ***************************************************************************/
 384
 385 /* Generic container for registry values */
 386 typedef struct {
 387   DWORD type;
 388
 389   union {
 390     gint  dword;  /* FIXME: could inline QWORD on 64-bit systems too */
 391     void *ptr;
 392   };
 393 } RegistryValue;
 394
 395 static char *
 396 registry_value_dump (RegistryValue value)
 397 {
 398   if (value.type == REG_DWORD)
 399     return g_strdup_printf ("%d", value.dword);
 400   else if (value.type == REG_QWORD)
 401     return g_strdup_printf ("%"G_GINT64_FORMAT, value.ptr == NULL ? 0: *(DWORDLONG *)value.ptr);
 402   else if (value.type == REG_SZ)
 403     return g_strdup_printf ("%s", (char *)value.ptr);
 404   else if (value.type == REG_NONE)
 405     return g_strdup_printf ("<empty>");
 406   else
 407     return g_strdup_printf ("<invalid>");
 408 }
 409
 410 static void
 411 registry_value_free (RegistryValue value)
 412 {
 413   if (value.type == REG_SZ || value.type == REG_QWORD)
 414     g_free (value.ptr);
 415
 416   value.type = REG_NONE;
 417   value.ptr = NULL;
 418 }
 419
 420 /* The registry cache is stored as a tree, for easy traversal. Right now we
 421  * don't sort it in a clever way. Each node corresponds to a path element
 422  * ('key' in registry terms) or a value.
 423  *
 424  * Each subscription uses the same cache. Because GSettings can subscribe to
 425  * the tree at any node any number of times, we need to reference count the
 426  * nodes.
 427  */
 428 typedef struct
 429 {
 430   /* Component of path that this node represents */
 431   gchar *name;
 432
 433   /* If a watch is subscribed at this point (subscription_count > 0) we can
 434    * block its next notification. This is useful because if two watches cover
 435    * the same path, both will trigger when it changes. It also allows changes
 436    * done by the application to be ignored by the watch thread.
 437    */
 438   gint32 block_count : 8;
 439
 440   /* Number of times g_settings_subscribe has been called for this location
 441    * (I guess you can't subscribe more than 16383 times) */
 442   gint32 subscription_count : 14;
 443
 444   gint32 ref_count : 9;
 445
 446   gint32 readable : 1;
 447   RegistryValue value;
 448 } RegistryCacheItem;
 449
 450 static GNode *
 451 registry_cache_add_item (GNode         *parent,
 452                          gchar         *name,
 453                          RegistryValue  value,
 454                          gint           ref_count)
 455 {
 456   RegistryCacheItem *item;
 457   GNode *cache_node;
 458
 459   g_return_val_if_fail (name != NULL, NULL);
 460   g_return_val_if_fail (parent != NULL, NULL);
 461
 462   item = g_slice_new (RegistryCacheItem);
 463
 464   /* Ref count should be the number of watch points above this node */
 465   item->ref_count = ref_count;
 466
 467   item->name = g_strdup (name);
 468   item->value = value;
 469   item->subscription_count = 0;
 470   item->block_count = 0;
 471   item->readable = FALSE;
 472
 473   trace ("\tregistry cache: adding %s to %s\n",
 474          name, ((RegistryCacheItem *)parent->data)->name);
 475
 476   cache_node = g_node_new (item);
 477   g_node_append (parent, cache_node);
 478
 479   return cache_node;
 480 }
 481
 482 /* The reference counting of cache tree nodes works like this: when a node is
 483  * subscribed to (GSettings wants us to watch that path and everything below
 484  * it) the reference count of that node and everything below is increased, as
 485  * well as each parent up to the root.
 486  */
 487
 488 static void
 489 _ref_down (GNode *node)
 490 {
 491   RegistryCacheItem *item = node->data;
 492
 493   g_node_children_foreach (node, G_TRAVERSE_ALL,
 494                            (GNodeForeachFunc)_ref_down, NULL);
 495   item->ref_count++;
 496 }
 497
 498 static void
 499 registry_cache_ref_tree (GNode *tree)
 500 {
 501   RegistryCacheItem *item = tree->data;
 502   GNode *node = tree->parent;
 503
 504   g_return_if_fail (tree != NULL);
 505
 506   item->ref_count++;
 507
 508   g_node_children_foreach (tree, G_TRAVERSE_ALL,
 509                            (GNodeForeachFunc)_ref_down, NULL);
 510
 511   for (node = tree->parent; node; node = node->parent)
 512     {
 513       item = node->data;
 514       item->ref_count++;
 515     }
 516 }
 517
 518 static void
 519 registry_cache_item_free (RegistryCacheItem *item)
 520 {
 521   trace ("\t -- Free node %s\n", item->name);
 522
 523   g_free (item->name);
 524   registry_value_free (item->value);
 525   g_slice_free (RegistryCacheItem, item);
 526 }
 527
 528 /* Unreferencing has to be done bottom-up */
 529 static void
 530 _unref_node (GNode *node)
 531 {
 532   RegistryCacheItem *item = node->data;
 533
 534   item->ref_count--;
 535
 536   g_warn_if_fail (item->ref_count >= 0);
 537
 538   if (item->ref_count == 0)
 539     {
 540       registry_cache_item_free (item);
 541       g_node_destroy (node);
 542     }
 543 }
 544
 545 static void
 546 _unref_down (GNode *node)
 547 {
 548   g_node_children_foreach (node, G_TRAVERSE_ALL,
 549                            (GNodeForeachFunc)_unref_down, NULL);
 550   _unref_node (node);
 551 }
 552
 553 static void
 554 registry_cache_unref_tree (GNode *tree)
 555 {
 556   GNode *parent = tree->parent, *next_parent;
 557
 558   _unref_down (tree);
 559
 560   while (parent)
 561     {
 562       next_parent = parent->parent;
 563       _unref_node (parent);
 564       parent = next_parent;
 565     }
 566 }
 567
 568 #if 0
 569 static void
 570 registry_cache_dump (GNode    *cache_node,
 571                      gpointer  data)
 572 {
 573   RegistryCacheItem *item = cache_node->data;
 574
 575   int depth     = GPOINTER_TO_INT(data),
 576       new_depth = depth+1,
 577       i;
 578
 579   g_return_if_fail (cache_node != NULL);
 580
 581   for (i=0; i<depth; i++)
 582     g_print ("  ");
 583   if (item == NULL)
 584     g_print ("*root*\n");
 585   else
 586     g_print ("'%s'  [%i] @ %x = %s\n", item->name, item->ref_count, (guint)cache_node,
 587              registry_value_dump (item->value));
 588   g_node_children_foreach (cache_node, G_TRAVERSE_ALL, registry_cache_dump,
 589                            GINT_TO_POINTER (new_depth));
 590 }
 591 #endif
 592
 593 typedef struct
 594 {
 595   gchar *name;
 596   GNode *result;
 597 } RegistryCacheSearch;
 598
 599 static gboolean
 600 registry_cache_find_compare (GNode    *node,
 601                              gpointer  data)
 602 {
 603   RegistryCacheSearch *search = data;
 604   RegistryCacheItem *item = node->data;
 605
 606   if (item == NULL)  /* root node */
 607     return FALSE;
 608
 609   g_return_val_if_fail (search->name != NULL, FALSE);
 610   g_return_val_if_fail (item->name != NULL, FALSE);
 611
 612   if (strcmp (search->name, item->name) == 0)
 613     {
 614       search->result = node;
 615       return TRUE;
 616     }
 617
 618   return FALSE;
 619 }
 620
 621 static GNode *
 622 registry_cache_find_immediate_child (GNode *node,
 623                                      gchar *name)
 624 {
 625   RegistryCacheSearch search;
 626
 627   search.result = NULL;
 628   search.name = name;
 629
 630   g_node_traverse (node, G_POST_ORDER, G_TRAVERSE_ALL, 2,
 631                    registry_cache_find_compare, &search);
 632
 633   return search.result;
 634 }
 635
 636 static GNode *
 637 registry_cache_get_node_for_key_recursive (GNode    *node,
 638                                            gchar    *key_name,
 639                                            gboolean  create_if_not_found,
 640                                            gint      n_parent_watches)
 641 {
 642   RegistryCacheItem *item;
 643   gchar *component = key_name;
 644   gchar *c = strchr (component, '/');
 645   GNode *child;
 646
 647   if (c != NULL)
 648     *c = 0;
 649
 650   /* We count up how many watch points we travel through finding this node,
 651    * because a new node should have as many references as there are watches at
 652    * points above it in the tree.
 653    */
 654   item = node->data;
 655   if (item->subscription_count > 0)
 656     n_parent_watches++;
 657
 658   child = registry_cache_find_immediate_child (node, component);
 659   if (child == NULL && create_if_not_found)
 660     {
 661       RegistryValue null_value = { REG_NONE, {0} };
 662
 663       child = registry_cache_add_item (node, component,
 664                                        null_value, n_parent_watches);
 665
 666       trace ("\tget node for key recursive: new %x = %s.\n", node, component);
 667     }
 668
 669   /* We are done if there are no more path components. Allow for a trailing /. */
 670   if (child == NULL || c == NULL || *(c + 1) == 0)
 671     return child;
 672
 673   trace ("get node for key recursive: next: %s.\n", c + 1);
 674
 675   return registry_cache_get_node_for_key_recursive (child, c + 1,
 676                                                     create_if_not_found,
 677                                                     n_parent_watches);
 678 }
 679
 680 /* Look up a GSettings key in the cache. */
 681 static GNode *
 682 registry_cache_get_node_for_key (GNode       *root,
 683                                  const gchar *key_name,
 684                                  gboolean     create_if_not_found)
 685 {
 686   GNode *child = NULL;
 687   GNode *result = NULL;
 688   gchar *component, *c;
 689
 690   g_return_val_if_fail (key_name != NULL, NULL);
 691
 692   if (key_name[0] == '/')
 693     key_name++;
 694
 695   /* Ignore preceding / */
 696   component = g_strdup (key_name);
 697   c = strchr (component, '/');
 698
 699   if (c == NULL)
 700     {
 701       g_free (component);
 702       return root;
 703     }
 704
 705   if (c != NULL)
 706     *c = 0;
 707
 708   child = registry_cache_find_immediate_child (root, component);
 709   if (child == NULL && create_if_not_found)
 710     {
 711       RegistryValue null_value = { REG_NONE, {0} };
 712
 713       /* Reference count is set to 0, tree should be referenced by the caller */
 714       child = registry_cache_add_item (root, component,
 715                                        null_value, 0);
 716
 717       trace ("get_node_for_key: New node for component '%s'\n", component);
 718     }
 719
 720   if (*(c + 1) == 0)
 721     result = child;
 722   else if (child != NULL)
 723     result = registry_cache_get_node_for_key_recursive (child, c + 1,
 724                                                         create_if_not_found, 0);
 725
 726   g_free (component);
 727
 728   return result;
 729 }
 730
 731 /* Check the cache node against the registry key it represents. Return TRUE if
 732  * they differ, and update the cache with the new value.
 733  */
 734 static gboolean
 735 registry_cache_update_node (GNode        *cache_node,
 736                             RegistryValue registry_value)
 737 {
 738   RegistryCacheItem *cache_item;
 739
 740   g_return_val_if_fail (cache_node != NULL, FALSE);
 741   g_return_val_if_fail (cache_node->data != NULL, FALSE);
 742
 743   cache_item = cache_node->data;
 744
 745   if (registry_value.type != cache_item->value.type)
 746     {
 747       /* The type has changed. Update cache item and register it as changed.
 748        * Either the schema has changed and this is entirely legitimate, or
 749        * whenever the app reads the key it will get the default value due to
 750        * the type mismatch.
 751        */
 752       cache_item->value = registry_value;
 753       return TRUE;
 754     }
 755
 756   switch (registry_value.type)
 757     {
 758     case REG_DWORD:
 759       {
 760         if (cache_item->value.dword == registry_value.dword)
 761           return FALSE;
 762         else
 763           {
 764             cache_item->value.dword = registry_value.dword;
 765             return TRUE;
 766           }
 767       }
 768     case REG_QWORD:
 769       {
 770         g_return_val_if_fail (registry_value.ptr != NULL &&
 771                               cache_item->value.ptr != NULL, FALSE);
 772
 773         if (memcmp (registry_value.ptr, cache_item->value.ptr, 8)==0)
 774           {
 775             g_free (registry_value.ptr);
 776             return FALSE;
 777           }
 778         else
 779           {
 780             g_free (cache_item->value.ptr);
 781             cache_item->value.ptr = registry_value.ptr;
 782             return TRUE;
 783           }
 784       }
 785     case REG_SZ:
 786       {
 787         /* Value should not exist if it is NULL, an empty string is "" */
 788         g_return_val_if_fail (cache_item->value.ptr != NULL, FALSE);
 789         g_return_val_if_fail (registry_value.ptr != NULL, FALSE);
 790
 791         if (strcmp (registry_value.ptr, cache_item->value.ptr) == 0)
 792           {
 793             g_free (registry_value.ptr);
 794             return FALSE;
 795           }
 796         else
 797           {
 798             g_free (cache_item->value.ptr);
 799             cache_item->value.ptr = registry_value.ptr;
 800             return TRUE;
 801           }
 802       }
 803     default:
 804       g_warning ("gregistrysettingsbackend: registry_cache_update_node: Unhandled value type");
 805       return FALSE;
 806     }
 807 }
 808
 809 /* Blocking notifications is a useful optimisation. When a change is made
 810  * through GSettings we update the cache manually, but a notification is
 811  * triggered as well. This function is also used for nested notifications,
 812  * eg. if /test and /test/foo are watched, and /test/foo/value is changed then
 813  * we will get notified both for /test/foo and /test and it is helpful to block
 814  * the second.
 815  */
 816 static void
 817 registry_cache_block_notification (GNode *node)
 818 {
 819   RegistryCacheItem *item = node->data;
 820
 821   g_return_if_fail (node != NULL);
 822
 823   if (item->subscription_count > 0)
 824     item->block_count++;
 825
 826   if (node->parent != NULL)
 827     registry_cache_block_notification (node->parent);
 828 }
 829
 830 static void registry_cache_destroy_tree (GNode            *node,
 831                                          WatchThreadState *self);
 832
 833 /***************************************************************************
 834  * Reading and writing
 835  ***************************************************************************/
 836
 837 static gboolean
 838 registry_read (HKEY           hpath,
 839                const gchar   *path_name,
 840                const gchar   *value_name,
 841                RegistryValue *p_value)
 842 {
 843   LONG result;
 844   DWORD value_data_size;
 845   gpointer *buffer;
 846   gunichar2 *value_namew;
 847
 848   g_return_val_if_fail (p_value != NULL, FALSE);
 849
 850   p_value->type = REG_NONE;
 851   p_value->ptr = NULL;
 852
 853   value_namew = g_utf8_to_utf16 (value_name, -1, NULL, NULL, NULL);
 854
 855   result = RegQueryValueExW (hpath, value_namew, 0, &p_value->type, NULL, &value_data_size);
 856   if (result != ERROR_SUCCESS)
 857     {
 858       handle_read_error (result, path_name, value_name);
 859       g_free (value_namew);
 860       return FALSE;
 861     }
 862
 863   if (p_value->type == REG_SZ && value_data_size == 0)
 864     {
 865       p_value->ptr = g_strdup ("");
 866       g_free (value_namew);
 867       return TRUE;
 868     }
 869
 870   if (p_value->type == REG_DWORD)
 871     /* REG_DWORD is inlined */
 872     buffer = (void *)&p_value->dword;
 873   else
 874     buffer = p_value->ptr = g_malloc (value_data_size);
 875
 876   result = RegQueryValueExW (hpath, value_namew, 0, NULL, (LPBYTE)buffer, &value_data_size);
 877   g_free (value_namew);
 878
 879   if (result != ERROR_SUCCESS)
 880     {
 881       handle_read_error (result, path_name, value_name);
 882
 883       if (p_value->type != REG_DWORD)
 884         g_free (buffer);
 885
 886       return FALSE;
 887     }
 888
 889   if (p_value->type == REG_SZ)
 890     {
 891       gchar *valueu8 = g_utf16_to_utf8 (p_value->ptr, -1, NULL, NULL, NULL);
 892       g_free (p_value->ptr);
 893       p_value->ptr = valueu8;
 894     }
 895
 896   return TRUE;
 897 }
 898
 899 static GVariant *
 900 g_registry_settings_backend_read (GSettingsBackend   *backend,
 901                                   const gchar        *key_name,
 902                                   const GVariantType *expected_type,
 903                                   gboolean            default_value)
 904 {
 905   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (backend);
 906   GNode *cache_node;
 907   RegistryValue registry_value;
 908   GVariant *gsettings_value = NULL;
 909   gchar *gsettings_type;
 910
 911   g_return_val_if_fail (expected_type != NULL, NULL);
 912
 913   if (default_value)
 914     return NULL;
 915
 916   /* Simply read from the cache, which is updated from the registry by the
 917    * watch thread as soon as changes can propagate. Any changes not yet in the
 918    * cache will have the 'changed' signal emitted after this function returns.
 919    */
 920   EnterCriticalSection (self->cache_lock);
 921   cache_node = registry_cache_get_node_for_key (self->cache_root, key_name, FALSE);
 922   LeaveCriticalSection (self->cache_lock);
 923
 924   trace ("Reading key %s, cache node %x\n", key_name, cache_node);
 925
 926   /* Maybe it's not set, we can return to default */
 927   if (cache_node == NULL)
 928     return NULL;
 929
 930   trace ("\t- cached value %s\n", registry_value_dump (((RegistryCacheItem *)cache_node->data)->value));
 931
 932   registry_value = ((RegistryCacheItem *)cache_node->data)->value;
 933
 934   gsettings_type = g_variant_type_dup_string (expected_type);
 935
 936   /* The registry is user-editable, so we need to be fault-tolerant here. */
 937   switch (gsettings_type[0])
 938     {
 939     case 'b':
 940     case 'y':
 941     case 'n':
 942     case 'q':
 943     case 'i':
 944     case 'u':
 945       if (registry_value.type == REG_DWORD)
 946         gsettings_value = g_variant_new (gsettings_type, registry_value.dword);
 947       break;
 948
 949     case 't':
 950     case 'x':
 951       if (registry_value.type == REG_QWORD)
 952         {
 953           DWORDLONG qword_value = *(DWORDLONG *)registry_value.ptr;
 954           gsettings_value = g_variant_new (gsettings_type, qword_value);
 955         }
 956       break;
 957
 958     default:
 959       if (registry_value.type == REG_SZ)
 960         {
 961           if (gsettings_type[0] == 's')
 962             gsettings_value = g_variant_new_string ((char *)registry_value.ptr);
 963           else
 964             {
 965               GError *error = NULL;
 966
 967               gsettings_value = g_variant_parse (expected_type, registry_value.ptr,
 968                                                  NULL, NULL, &error);
 969
 970               if (error != NULL)
 971                 g_message ("gregistrysettingsbackend: error parsing key %s: %s",
 972                            key_name, error->message);
 973             }
 974         }
 975         break;
 976     }
 977
 978   g_free (gsettings_type);
 979
 980   return gsettings_value;
 981 }
 982
 983
 984 typedef struct
 985 {
 986   GRegistrySettingsBackend *self;
 987   HKEY hroot;
 988 } RegistryWrite;
 989
 990 static gboolean
 991 g_registry_settings_backend_write_one (const char *key_name,
 992                                        GVariant   *variant,
 993                                        gpointer    user_data)
 994 {
 995   GRegistrySettingsBackend *self;
 996   RegistryWrite *action;
 997   RegistryValue value;
 998   HKEY hroot;
 999   HKEY hpath;
1000   gchar *path_name;
1001   gunichar2 *path_namew;
1002   gchar *value_name = NULL;
1003   gunichar2 *value_namew;
1004   DWORD value_data_size;
1005   LPVOID value_data;
1006   gunichar2 *value_dataw;
1007   LONG result;
1008   GNode *node;
1009   gboolean changed;
1010   const gchar *type_string;
1011
1012   type_string = g_variant_get_type_string (variant);
1013   action = user_data;
1014   self = G_REGISTRY_SETTINGS_BACKEND (action->self);
1015   hroot = action->hroot;
1016
1017   value.type = REG_NONE;
1018   value.ptr = NULL;
1019
1020   switch (type_string[0])
1021     {
1022     case 'b':
1023     case 'y':
1024     case 'n':
1025     case 'q':
1026     case 'i':
1027     case 'u':
1028       value.type = REG_DWORD;
1029       value.dword = g_variant_get_as_dword (variant);
1030       value_data_size = 4;
1031       value_data = &value.dword;
1032       break;
1033
1034     case 'x':
1035     case 't':
1036       value.type = REG_QWORD;
1037       value.ptr = g_malloc (8);
1038       *(DWORDLONG *)value.ptr = g_variant_get_as_qword (variant);
1039       value_data_size = 8;
1040       value_data = value.ptr;
1041       break;
1042
1043     default:
1044       value.type = REG_SZ;
1045       if (type_string[0] == 's')
1046         {
1047           gsize length;
1048           value.ptr = g_strdup (g_variant_get_string (variant, &length));
1049           value_data_size = length + 1;
1050           value_data = value.ptr;
1051         }
1052       else
1053         {
1054           GString *value_string;
1055           value_string = g_variant_print_string (variant, NULL, FALSE);
1056           value_data_size = value_string->len + 1;
1057           value.ptr = value_data = g_string_free (value_string, FALSE);
1058         }
1059       break;
1060     }
1061
1062   /* First update the cache, because the value may not have changed and we can
1063    * save a write.
1064    *
1065    * If 'value' has changed then its memory will not be freed by update_node(),
1066    * because it will be stored in the node.
1067    */
1068   EnterCriticalSection (self->cache_lock);
1069   node = registry_cache_get_node_for_key (self->cache_root, key_name, TRUE);
1070   changed = registry_cache_update_node (node, value);
1071   LeaveCriticalSection (self->cache_lock);
1072
1073   if (!changed)
1074     return FALSE;
1075
1076   /* Block the next notification to any watch points above this location,
1077    * because they will each get triggered on a change that is already updated
1078    * in the cache.
1079    */
1080   registry_cache_block_notification (node);
1081
1082   path_name = parse_key (key_name, NULL, &value_name);
1083
1084   trace ("Set key: %s / %s\n", path_name, value_name);
1085
1086   path_namew = g_utf8_to_utf16 (path_name, -1, NULL, NULL, NULL);
1087
1088   /* Store the value in the registry */
1089   result = RegCreateKeyExW (hroot, path_namew, 0, NULL, 0, KEY_WRITE, NULL, &hpath, NULL);
1090   if (result != ERROR_SUCCESS)
1091     {
1092       g_message_win32_error (result, "gregistrysettingsbackend: opening key %s failed",
1093                              path_name + 1);
1094       registry_value_free (value);
1095       g_free (path_namew);
1096       g_free (path_name);
1097       return FALSE;
1098     }
1099
1100   g_free (path_namew);
1101
1102   value_namew = g_utf8_to_utf16 (value_name, -1, NULL, NULL, NULL);
1103
1104   value_dataw = NULL;
1105
1106   switch (type_string[0])
1107     {
1108     case 'b':
1109     case 'y':
1110     case 'n':
1111     case 'q':
1112     case 'i':
1113     case 'u':
1114     case 'x':
1115     case 't':
1116       break;
1117     default:
1118       value_dataw = g_utf8_to_utf16 (value_data, -1, NULL, NULL, NULL);
1119       value_data = value_dataw;
1120       value_data_size = (DWORD)((wcslen (value_data) + 1) * sizeof (gunichar2));
1121       break;
1122     }
1123
1124   result = RegSetValueExW (hpath, value_namew, 0, value.type, value_data, value_data_size);
1125
1126   if (result != ERROR_SUCCESS)
1127     g_message_win32_error (result, "gregistrysettingsbackend: setting value %s\\%s\\%s\\%s failed.\n",
1128                            predefined_key_to_string (self->base_key),
1129                            self->base_path, path_name, value_name);
1130
1131   /* If the write fails then it will seem like the value has changed until the
1132    * next execution (because we wrote to the cache first). There's no reason
1133    * for it to fail unless something is weirdly broken, however.
1134    */
1135
1136   RegCloseKey (hpath);
1137   g_free (path_name);
1138   g_free (value_namew);
1139   g_free (value_dataw);
1140
1141   return FALSE;
1142 }
1143
1144 /* The dconf write policy is to do the write while making out it succeeded,
1145  * and then backtrack if it didn't. The registry functions are synchronous so
1146  * we can't do that. */
1147
1148 static gboolean
1149 g_registry_settings_backend_write (GSettingsBackend *backend,
1150                                    const gchar      *key_name,
1151                                    GVariant         *value,
1152                                    gpointer          origin_tag)
1153 {
1154   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (backend);
1155   LONG result;
1156   HKEY hroot;
1157   RegistryWrite action;
1158
1159   result = RegCreateKeyExW (self->base_key, self->base_pathw, 0, NULL, 0,
1160                             KEY_WRITE, NULL, &hroot, NULL);
1161   if (result != ERROR_SUCCESS)
1162     {
1163       trace ("Error opening/creating key %s\\%s.\n",
1164              predefined_key_to_string (self->base_key),
1165              self->base_path);
1166       return FALSE;
1167     }
1168
1169   action.self = self;
1170   action.hroot = hroot;
1171   g_registry_settings_backend_write_one (key_name, value, &action);
1172   g_settings_backend_changed (backend, key_name, origin_tag);
1173
1174   RegCloseKey (hroot);
1175
1176   return TRUE;
1177 }
1178
1179 static gboolean
1180 g_registry_settings_backend_write_tree (GSettingsBackend *backend,
1181                                         GTree            *values,
1182                                         gpointer          origin_tag)
1183 {
1184   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (backend);
1185   LONG result;
1186   HKEY hroot;
1187   RegistryWrite action;
1188
1189   result = RegCreateKeyExW (self->base_key, self->base_pathw, 0, NULL, 0,
1190                             KEY_WRITE, NULL, &hroot, NULL);
1191   if (result != ERROR_SUCCESS)
1192     {
1193       trace ("Error opening/creating key %s\\%s.\n",
1194              predefined_key_to_string (self->base_key),
1195              self->base_path);
1196       return FALSE;
1197     }
1198
1199   action.self =  self;
1200   action.hroot = hroot;
1201   g_tree_foreach (values, (GTraverseFunc)g_registry_settings_backend_write_one,
1202                   &action);
1203
1204   g_settings_backend_changed_tree (backend, values, origin_tag);
1205   RegCloseKey (hroot);
1206
1207   return TRUE;
1208 }
1209
1210 static void
1211 g_registry_settings_backend_reset (GSettingsBackend *backend,
1212                                    const gchar      *key_name,
1213                                    gpointer          origin_tag)
1214 {
1215   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (backend);
1216   gchar *path_name;
1217   gunichar2 *path_namew;
1218   gchar *value_name = NULL;
1219   gunichar2 *value_namew;
1220   GNode *cache_node;
1221   LONG result;
1222   HKEY hpath;
1223
1224   /* Remove from cache */
1225   EnterCriticalSection (self->cache_lock);
1226   cache_node = registry_cache_get_node_for_key (self->cache_root, key_name, FALSE);
1227   if (cache_node)
1228     registry_cache_destroy_tree (cache_node, self->watch);
1229   LeaveCriticalSection (self->cache_lock);
1230
1231   /* Remove from the registry */
1232   path_name = parse_key (key_name, self->base_path, &value_name);
1233   path_namew = g_utf8_to_utf16 (path_name, -1, NULL, NULL, NULL);
1234
1235   result = RegOpenKeyExW (self->base_key, path_namew, 0, KEY_SET_VALUE, &hpath);
1236   g_free (path_namew);
1237
1238   if (result != ERROR_SUCCESS)
1239     {
1240       g_message_win32_error (result, "Registry: resetting key '%s\\%s'",
1241                              predefined_key_to_string (self->base_key),
1242                              path_name);
1243       g_free (path_name);
1244       return;
1245     }
1246
1247   value_namew = g_utf8_to_utf16 (value_name, -1, NULL, NULL, NULL);
1248
1249   result = RegDeleteValueW (hpath, value_namew);
1250   g_free (value_namew);
1251   RegCloseKey (hpath);
1252
1253   if (result != ERROR_SUCCESS)
1254     {
1255       g_message_win32_error (result, "Registry: resetting key '%s\\%s'",
1256                              predefined_key_to_string (self->base_key),
1257                              path_name);
1258       g_free (path_name);
1259       return;
1260     }
1261
1262   g_free (path_name);
1263
1264   g_settings_backend_changed (backend, key_name, origin_tag);
1265 }
1266
1267 static gboolean
1268 g_registry_settings_backend_get_writable (GSettingsBackend *backend,
1269                                           const gchar      *key_name)
1270 {
1271   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (backend);
1272   gchar *path_name;
1273   gunichar2 *path_namew;
1274   gchar *value_name = NULL;
1275   HKEY hpath;
1276   LONG result;
1277
1278   path_name = parse_key (key_name, self->base_path, &value_name);
1279   path_namew = g_utf8_to_utf16 (path_name, -1, NULL, NULL, NULL);
1280
1281   /* Note: we create the key if it wasn't created yet, but it is not much
1282    * of a problem since at the end of the day we have to create it anyway
1283    * to read or to write from it
1284    */
1285   result = RegCreateKeyExW (self->base_key, path_namew, 0, NULL, 0,
1286                             KEY_WRITE, NULL, &hpath, NULL);
1287   g_free (path_namew);
1288
1289   if (result != ERROR_SUCCESS)
1290     {
1291       trace ("Error opening/creating key to check writability: %s\\%s.\n",
1292              predefined_key_to_string (self->base_key),
1293              path_name);
1294       g_free (path_name);
1295
1296       return FALSE;
1297     }
1298
1299   g_free (path_name);
1300   RegCloseKey (hpath);
1301
1302   return TRUE;
1303 }
1304
1305 /********************************************************************************
1306  * Spot-the-difference engine
1307  ********************************************************************************/
1308
1309 static void
1310 _free_watch (WatchThreadState *self,
1311              guint             index,
1312              GNode            *cache_node);
1313
1314 static void
1315 registry_cache_item_reset_readable (GNode    *node,
1316                                     gpointer  data)
1317 {
1318   RegistryCacheItem *item = node->data;
1319   item->readable = FALSE;
1320 }
1321
1322 /* Delete a node and any children, for when it has been deleted from the registry */
1323 static void
1324 registry_cache_destroy_tree (GNode            *node,
1325                              WatchThreadState *self)
1326 {
1327   RegistryCacheItem *item = node->data;
1328
1329   g_node_children_foreach (node, G_TRAVERSE_ALL,
1330                            (GNodeForeachFunc)registry_cache_destroy_tree, self);
1331
1332   if (item->subscription_count > 0)
1333     {
1334       guint i;
1335
1336       /* There must be some watches active if this node is a watch point */
1337       g_warn_if_fail (self->cache_nodes->len > 1);
1338
1339       /* This is a watch point that has been deleted. Let's free the watch! */
1340       for (i = 1; i < self->cache_nodes->len; i++)
1341         {
1342           if (g_ptr_array_index (self->cache_nodes, i) == node)
1343             break;
1344         }
1345
1346       if (i >= self->cache_nodes->len)
1347         g_warning ("watch thread: a watch point was deleted, but unable to "
1348                    "find '%s' in the list of %i watch nodes\n", item->name,
1349                    self->cache_nodes->len - 1);
1350       else
1351         {
1352           _free_watch (self, i, node);
1353           g_atomic_int_inc (&self->watches_remaining);
1354         }
1355     }
1356   registry_cache_item_free (node->data);
1357   g_node_destroy (node);
1358 }
1359
1360 /* One of these is sent down the pipe when something happens in the registry. */
1361 typedef struct
1362 {
1363   GRegistrySettingsBackend *self;
1364   gchar *prefix;          /* prefix is a gsettings path, all items are subkeys of this. */
1365   GPtrArray *items;       /* each item is a subkey below prefix that has changed. */
1366 } RegistryEvent;
1367
1368 typedef struct
1369 {
1370   RegistryEvent *event;
1371   gchar *current_key_name;
1372 } DeletedItemData;
1373
1374 static void
1375 mark_all_subkeys_as_changed (GNode    *node,
1376                              gpointer  data)
1377 {
1378   RegistryCacheItem *item = node->data;
1379   DeletedItemData *item_data = data;
1380
1381   if (item_data->current_key_name == NULL)
1382     item_data->current_key_name = g_strdup (item->name);
1383   else
1384     {
1385       gchar *name;
1386
1387       name = g_build_path ("/", item_data->current_key_name, item->name, NULL);
1388       g_free (item_data->current_key_name);
1389       item_data->current_key_name = name;
1390     }
1391
1392   /* Iterate until we find an item that is a value */
1393   if (item->value.type == REG_NONE)
1394     g_node_children_foreach (node, G_TRAVERSE_ALL,
1395                              mark_all_subkeys_as_changed, data);
1396   else
1397     g_ptr_array_add (item_data->event->items, item_data->current_key_name);
1398 }
1399
1400 static void
1401 registry_cache_remove_deleted (GNode    *node,
1402                                gpointer  data)
1403 {
1404   RegistryCacheItem *item = node->data;
1405   RegistryEvent *event = data;
1406
1407   if (!item->readable)
1408     {
1409       DeletedItemData item_data;
1410
1411       item_data.event = event;
1412       item_data.current_key_name = NULL;
1413
1414       mark_all_subkeys_as_changed (node, &item_data);
1415       registry_cache_destroy_tree (node, event->self->watch);
1416     }
1417 }
1418
1419 /* Update cache from registry, and optionally report on the changes.
1420  *
1421  * This function is sometimes called from the watch thread, with no locking. It
1422  * does call g_registry_settings_backend functions, but this is okay because they only
1423  * access self->base which is constant.
1424  *
1425  * When looking at this code bear in mind the terminology: in the registry, keys
1426  * are containers that contain values, and other keys. Keys have a 'default'
1427  * value which we always ignore.
1428  *
1429  * n_parent_watches: a counter used to set the reference count of any new nodes
1430  *                   that are created - they should have as many references as
1431  *                   there are notifications that are watching them.
1432  */
1433 static void
1434 registry_cache_update (GRegistrySettingsBackend *self,
1435                        HKEY                      hpath,
1436                        const gchar              *prefix,
1437                        const gchar              *partial_key_name,
1438                        GNode                    *cache_node,
1439                        int                       n_watches,
1440                        RegistryEvent            *event)
1441 {
1442   gunichar2 bufferw[MAX_KEY_NAME_LENGTH + 1];
1443   gchar *buffer;
1444   gchar *key_name;
1445   gint i;
1446   LONG result;
1447   RegistryCacheItem *item;
1448
1449   item = cache_node->data;
1450
1451   if (item->subscription_count > 0)
1452     n_watches++;
1453
1454   /* prefix is the level that all changes occur below; partial_key_name should
1455    * be NULL on the first call to this function */
1456   key_name = g_build_path ("/", prefix, partial_key_name, NULL);
1457
1458   trace ("registry cache update: %s. Node %x has %i children\n", key_name,
1459          cache_node, g_node_n_children (cache_node));
1460
1461   /* Start by zeroing 'readable' flag. When the registry traversal is done, any unreadable nodes
1462    * must have been deleted from the registry.
1463    */
1464   g_node_children_foreach (cache_node, G_TRAVERSE_ALL,
1465                            registry_cache_item_reset_readable, NULL);
1466
1467   /* Recurse into each subpath at the current level, if any */
1468   i = 0;
1469   while (1)
1470     {
1471       DWORD bufferw_size = MAX_KEY_NAME_LENGTH + 1;
1472       HKEY  hsubpath;
1473
1474       result = RegEnumKeyExW (hpath, i++, bufferw, &bufferw_size, NULL, NULL, NULL, NULL);
1475       if (result != ERROR_SUCCESS)
1476         break;
1477
1478       result = RegOpenKeyExW (hpath, bufferw, 0, KEY_READ, &hsubpath);
1479       if (result == ERROR_SUCCESS)
1480         {
1481           GNode *subkey_node;
1482           RegistryCacheItem *child_item;
1483           gchar *new_partial_key_name;
1484
1485           buffer = g_utf16_to_utf8 (bufferw, -1, NULL, NULL, NULL);
1486           if (buffer == NULL)
1487             continue;
1488
1489           subkey_node = registry_cache_find_immediate_child (cache_node, buffer);
1490           if (subkey_node == NULL)
1491             {
1492               RegistryValue null_value = {REG_NONE, {0}};
1493               subkey_node = registry_cache_add_item (cache_node, buffer,
1494                                                      null_value, n_watches);
1495             }
1496
1497           new_partial_key_name = g_build_path ("/", partial_key_name, buffer, NULL);
1498           registry_cache_update (self, hsubpath, prefix, new_partial_key_name,
1499                                  subkey_node, n_watches, event);
1500           g_free (new_partial_key_name);
1501
1502           child_item = subkey_node->data;
1503           child_item->readable = TRUE;
1504
1505           g_free (buffer);
1506           RegCloseKey (hsubpath);
1507         }
1508     }
1509
1510   if (result != ERROR_NO_MORE_ITEMS)
1511     g_message_win32_error (result, "gregistrysettingsbackend: error enumerating subkeys for cache.");
1512
1513   /* Enumerate each value at 'path' and check if it has changed */
1514   i = 0;
1515   while (1)
1516     {
1517       DWORD bufferw_size = MAX_KEY_NAME_LENGTH + 1;
1518       GNode *cache_child_node;
1519       RegistryCacheItem *child_item;
1520       RegistryValue value;
1521       gboolean changed = FALSE;
1522
1523       result = RegEnumValueW (hpath, i++, bufferw, &bufferw_size, NULL, NULL, NULL, NULL);
1524       if (result != ERROR_SUCCESS)
1525         break;
1526
1527       buffer = g_utf16_to_utf8 (bufferw, -1, NULL, NULL, NULL);
1528
1529       if (buffer == NULL || buffer[0] == 0)
1530         {
1531           /* This is the key's 'default' value, for which we have no use. */
1532           g_free (buffer);
1533           continue;
1534         }
1535
1536       cache_child_node = registry_cache_find_immediate_child (cache_node, buffer);
1537
1538       if (!registry_read (hpath, key_name, buffer, &value))
1539         {
1540           g_free (buffer);
1541           continue;
1542         }
1543
1544       trace ("\tgot value %s for %s, node %x\n",
1545              registry_value_dump (value), buffer, cache_child_node);
1546
1547       if (cache_child_node == NULL)
1548         {
1549           /* This is a new value */
1550           cache_child_node = registry_cache_add_item (cache_node, buffer, value,
1551                                                       n_watches);
1552           changed = TRUE;
1553         }
1554       else
1555         {
1556          /* For efficiency, instead of converting every value back to a GVariant to
1557           * compare it, we compare them as registry values (integers, or string
1558           * representations of the variant). The spurious change notifications that may
1559           * result should not be a big issue.
1560           *
1561           * Note that 'value' is swallowed or freed.
1562           */
1563           changed = registry_cache_update_node (cache_child_node, value);
1564         }
1565
1566       child_item = cache_child_node->data;
1567       child_item->readable = TRUE;
1568       if (changed && event != NULL)
1569         {
1570           gchar *item_path;
1571
1572           if (partial_key_name == NULL)
1573             item_path = g_strdup (buffer);
1574           else
1575             item_path = g_build_path ("/", partial_key_name, buffer, NULL);
1576
1577           g_ptr_array_add (event->items, item_path);
1578         }
1579
1580       g_free (buffer);
1581     }
1582
1583   if (result != ERROR_NO_MORE_ITEMS)
1584     g_message_win32_error (result, "gregistrysettingsbackend: error enumerating values for cache");
1585
1586   /* Any nodes now left unreadable must have been deleted, remove them from cache */
1587   g_node_children_foreach (cache_node, G_TRAVERSE_ALL,
1588                            registry_cache_remove_deleted, event);
1589
1590   trace ("registry cache update complete.\n");
1591
1592   g_free (key_name);
1593 }
1594
1595 /***********************************************************************************
1596  * Thread to watch for registry change events
1597  ***********************************************************************************/
1598
1599 /* Called by watch thread. Apply for notifications on a registry key and its subkeys. */
1600 static DWORD
1601 registry_watch_key (HKEY   hpath,
1602                     HANDLE event)
1603 {
1604   return RegNotifyChangeKeyValue (hpath, TRUE,
1605                                   REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET,
1606                                   event, TRUE);
1607 }
1608
1609 /* This handler runs in the main thread to emit the changed signals */
1610 static gboolean
1611 watch_handler (RegistryEvent *event)
1612 {
1613   trace ("Watch handler: got event in %s, items %i.\n", event->prefix, event->items->len);
1614
1615   /* GSettings requires us to NULL-terminate the array. */
1616   g_ptr_array_add (event->items, NULL);
1617   g_settings_backend_keys_changed (G_SETTINGS_BACKEND (event->self), event->prefix,
1618                                    (gchar const **)event->items->pdata, NULL);
1619
1620   g_ptr_array_free (event->items, TRUE);
1621   g_free (event->prefix);
1622   g_object_unref (event->self);
1623   g_slice_free (RegistryEvent, event);
1624
1625   return G_SOURCE_REMOVE;
1626 }
1627
1628 static void
1629 _free_watch (WatchThreadState *self,
1630              guint             index,
1631              GNode            *cache_node)
1632 {
1633   HKEY hpath;
1634   HANDLE cond;
1635   gchar *prefix;
1636
1637   g_return_if_fail (index > 0 && index < self->events->len);
1638
1639   cond = g_ptr_array_index (self->events, index);
1640   hpath = g_ptr_array_index (self->handles, index);
1641   prefix = g_ptr_array_index (self->prefixes, index);
1642
1643   trace ("Freeing watch %i [%s]\n", index, prefix);
1644
1645   /* These can be NULL if the watch was already dead, this can happen when eg.
1646    * a key is deleted but GSettings is still subscribed to it - the watch is
1647    * kept alive so that the unsubscribe function works properly, but does not
1648    * do anything.
1649    */
1650   if (hpath != NULL)
1651     RegCloseKey (hpath);
1652
1653   if (cache_node != NULL)
1654     {
1655       //registry_cache_dump (G_REGISTRY_SETTINGS_BACKEND (self->owner)->cache_root, NULL);
1656       registry_cache_unref_tree (cache_node);
1657     }
1658
1659   CloseHandle (cond);
1660   g_free (prefix);
1661
1662   /* As long as we remove from each array at the same time, it doesn't matter that
1663    * their orders get messed up - they all get messed up the same.
1664    */
1665   g_ptr_array_remove_index_fast (self->handles, index);
1666   g_ptr_array_remove_index_fast (self->events, index);
1667   g_ptr_array_remove_index_fast (self->prefixes, index);
1668   g_ptr_array_remove_index_fast (self->cache_nodes, index);
1669 }
1670
1671 static void
1672 watch_thread_handle_message (WatchThreadState *self)
1673 {
1674   switch (self->message.type)
1675     {
1676     case WATCH_THREAD_NONE:
1677       trace ("watch thread: you woke me up for nothin', man!");
1678       break;
1679
1680     case WATCH_THREAD_ADD_WATCH:
1681       {
1682         RegistryWatch *watch = &self->message.watch;
1683         LONG result;
1684
1685         result = registry_watch_key (watch->hpath, watch->event);
1686
1687         if (result == ERROR_SUCCESS)
1688           {
1689             g_ptr_array_add (self->events, watch->event);
1690             g_ptr_array_add (self->handles, watch->hpath);
1691             g_ptr_array_add (self->prefixes, watch->prefix);
1692             g_ptr_array_add (self->cache_nodes, watch->cache_node);
1693
1694             trace ("watch thread: new watch on %s, %i total\n", watch->prefix,
1695                    self->events->len);
1696           }
1697         else
1698           {
1699             g_message_win32_error (result, "watch thread: could not watch %s", watch->prefix);
1700
1701             CloseHandle (watch->event);
1702             RegCloseKey (watch->hpath);
1703             g_free (watch->prefix);
1704             registry_cache_unref_tree (watch->cache_node);
1705           }
1706         break;
1707       }
1708
1709     case WATCH_THREAD_REMOVE_WATCH:
1710       {
1711         GNode *cache_node;
1712         RegistryCacheItem *cache_item;
1713         guint i;
1714
1715         for (i = 1; i < self->prefixes->len; i++)
1716           {
1717             if (strcmp (g_ptr_array_index (self->prefixes, i),
1718                         self->message.watch.prefix) == 0)
1719               break;
1720           }
1721
1722         if (i >= self->prefixes->len)
1723           {
1724             /* Don't make a fuss if the prefix is not being watched because
1725              * maybe the path was deleted so we removed the watch.
1726              */
1727             trace ("unsubscribe: prefix %s is not being watched [%i things are]!\n",
1728                    self->message.watch.prefix, self->prefixes->len);
1729             g_free (self->message.watch.prefix);
1730             break;
1731           }
1732
1733         cache_node = g_ptr_array_index (self->cache_nodes, i);
1734
1735         trace ("watch thread: unsubscribe: freeing node %p, prefix %s, index %i\n",
1736                cache_node, self->message.watch.prefix, i);
1737
1738         if (cache_node != NULL)
1739           {
1740             cache_item = cache_node->data;
1741
1742             /* There may be more than one GSettings object subscribed to this
1743              * path, only free the watch when the last one unsubscribes.
1744              */
1745             cache_item->subscription_count--;
1746             if (cache_item->subscription_count > 0)
1747               break;
1748           }
1749
1750         _free_watch (self, i, cache_node);
1751         g_free (self->message.watch.prefix);
1752
1753         g_atomic_int_inc (&self->watches_remaining);
1754         break;
1755       }
1756
1757     case WATCH_THREAD_STOP:
1758       {
1759         guint i;
1760
1761         /* Free any remaining cache and watch handles */
1762         for (i = 1; i < self->events->len; i++)
1763           _free_watch (self, i, g_ptr_array_index (self->cache_nodes, i));
1764
1765         SetEvent (self->message_received_event);
1766         ExitThread (0);
1767       }
1768     }
1769
1770   self->message.type = WATCH_THREAD_NONE;
1771   SetEvent (self->message_received_event);
1772 }
1773
1774 /* Thread which watches for win32 registry events */
1775 static DWORD WINAPI
1776 watch_thread_function (LPVOID parameter)
1777 {
1778   WatchThreadState *self = (WatchThreadState *)parameter;
1779   DWORD result;
1780
1781   self->events = g_ptr_array_new ();
1782   self->handles = g_ptr_array_new ();
1783   self->prefixes = g_ptr_array_new ();
1784   self->cache_nodes = g_ptr_array_new ();
1785   g_ptr_array_add (self->events, self->message_sent_event);
1786   g_ptr_array_add (self->handles, NULL);
1787   g_ptr_array_add (self->prefixes, NULL);
1788   g_ptr_array_add (self->cache_nodes, NULL);
1789
1790   while (1)
1791     {
1792       trace ("watch thread: going to sleep; %i events watched.\n", self->events->len);
1793       result = WaitForMultipleObjects (self->events->len, self->events->pdata, FALSE, INFINITE);
1794
1795       if (result == WAIT_OBJECT_0)
1796         {
1797           /* A message to you. The sender (main thread) will block until we signal the received
1798            * event, so there should be no danger of it sending another before we receive the
1799            * first.
1800            */
1801           watch_thread_handle_message (self);
1802         }
1803       else if (result > WAIT_OBJECT_0 && result <= WAIT_OBJECT_0 + self->events->len)
1804         {
1805           HKEY hpath;
1806           HANDLE cond;
1807           gchar *prefix;
1808           GNode *cache_node;
1809           RegistryCacheItem *cache_item;
1810           RegistryEvent *event;
1811           gint notify_index;
1812
1813           /* One of our notifications has triggered. All we know is which one, and which key
1814            * this is for. We do most of the processing here, because we may as well. If the
1815            * registry changes further while we are processing it doesn't matter - we will then
1816            * receive another change notification from the OS anyway.
1817            */
1818           notify_index = result - WAIT_OBJECT_0;
1819           hpath = g_ptr_array_index (self->handles, notify_index);
1820           cond = g_ptr_array_index (self->events, notify_index);
1821           prefix = g_ptr_array_index (self->prefixes, notify_index);
1822           cache_node = g_ptr_array_index (self->cache_nodes, notify_index);
1823
1824           trace ("Watch thread: notify received on prefix %i: %s.\n", notify_index, prefix);
1825
1826           if (cache_node == NULL)
1827             {
1828               /* This path has been deleted */
1829               trace ("Notify received on a path that was deleted\n");
1830               continue;
1831             }
1832
1833           /* Firstly we need to reapply for the notification, because (what a
1834            * sensible API) we won't receive any more. MSDN is pretty
1835            * inconsistent on this matter:
1836            *   http://msdn.microsoft.com/en-us/library/ms724892%28VS.85%29.aspx
1837            *   http://support.microsoft.com/kb/236570
1838            * But my tests (on Windows XP SP3) show that we need to reapply
1839            * each time.
1840            */
1841           result = registry_watch_key (hpath, cond);
1842
1843           if (result != ERROR_SUCCESS)
1844             {
1845               /* Watch failed, most likely because the key has just been
1846                * deleted. Free the watch and unref the cache nodes.
1847                */
1848              if (result != ERROR_KEY_DELETED)
1849                g_message_win32_error (result, "watch thread: failed to watch %s", prefix);
1850
1851              _free_watch (self, notify_index, cache_node);
1852              g_atomic_int_inc (&self->watches_remaining);
1853              continue;
1854             }
1855
1856           /* The notification may have been blocked because we just changed
1857            * some data ourselves.
1858            */
1859           cache_item = cache_node->data;
1860           if (cache_item->block_count)
1861             {
1862               cache_item->block_count--;
1863               trace ("Watch thread: notify blocked at %s\n", prefix);
1864               continue;
1865             }
1866
1867           /* Now we update our stored cache from registry data, and find which keys have
1868            * actually changed. If more changes happen while we are processing, we will get
1869            * another event because we have reapplied for change notifications already.
1870            *
1871            * Working here rather than in the main thread is preferable because the UI is less
1872            * likely to block (only when changing notification subscriptions).
1873            */
1874           event = g_slice_new (RegistryEvent);
1875           event->self = G_REGISTRY_SETTINGS_BACKEND (g_object_ref (self->owner));
1876           event->prefix = g_strdup (prefix);
1877           event->items = g_ptr_array_new_with_free_func (g_free);
1878
1879           EnterCriticalSection (G_REGISTRY_SETTINGS_BACKEND (self->owner)->cache_lock);
1880           registry_cache_update (G_REGISTRY_SETTINGS_BACKEND (self->owner), hpath,
1881                                  prefix, NULL, cache_node, 0, event);
1882           LeaveCriticalSection (G_REGISTRY_SETTINGS_BACKEND (self->owner)->cache_lock);
1883
1884           if (event->items->len > 0)
1885             g_idle_add ((GSourceFunc) watch_handler, event);
1886           else
1887             {
1888               g_object_unref (event->self);
1889               g_free (event->prefix);
1890               g_ptr_array_free (event->items, TRUE);
1891               g_slice_free (RegistryEvent, event);
1892             }
1893         }
1894       else
1895         {
1896           /* God knows what has happened */
1897           g_message_win32_error (GetLastError(), "watch thread: WaitForMultipleObjects error");
1898         }
1899     }
1900
1901   return -1;
1902 }
1903
1904 static gboolean
1905 watch_start (GRegistrySettingsBackend *self)
1906 {
1907   WatchThreadState *watch;
1908
1909   g_return_val_if_fail (self->watch == NULL, FALSE);
1910
1911   watch = g_slice_new (WatchThreadState);
1912   watch->owner = G_SETTINGS_BACKEND (self);
1913
1914   watch->watches_remaining = MAX_WATCHES;
1915
1916   watch->message_lock = g_slice_new (CRITICAL_SECTION);
1917   InitializeCriticalSection (watch->message_lock);
1918   watch->message_sent_event = CreateEvent (NULL, FALSE, FALSE, NULL);
1919   watch->message_received_event = CreateEvent (NULL, FALSE, FALSE, NULL);
1920   if (watch->message_sent_event == NULL || watch->message_received_event == NULL)
1921     {
1922       g_message_win32_error (GetLastError (), "gregistrysettingsbackend: Failed to create sync objects.");
1923       goto fail;
1924     }
1925
1926   /* Use a small stack to make the thread more lightweight. */
1927   watch->thread = CreateThread (NULL, 1024, watch_thread_function, watch, 0, NULL);
1928   if (watch->thread == NULL)
1929     {
1930       g_message_win32_error (GetLastError (), "gregistrysettingsbackend: Failed to create notify watch thread.");
1931       goto fail;
1932     }
1933
1934   self->watch = watch;
1935
1936   return TRUE;
1937
1938 fail:
1939   DeleteCriticalSection (watch->message_lock);
1940   g_slice_free (CRITICAL_SECTION, watch->message_lock);
1941   if (watch->message_sent_event != NULL)
1942     CloseHandle (watch->message_sent_event);
1943   if (watch->message_received_event != NULL)
1944     CloseHandle (watch->message_received_event);
1945   g_slice_free (WatchThreadState, watch);
1946
1947   return FALSE;
1948 }
1949
1950 /* This function assumes you hold the message lock! */
1951 static void
1952 watch_stop_unlocked (GRegistrySettingsBackend *self)
1953 {
1954   WatchThreadState *watch = self->watch;
1955   DWORD result;
1956
1957   g_return_if_fail (watch != NULL);
1958
1959   watch->message.type = WATCH_THREAD_STOP;
1960   SetEvent (watch->message_sent_event);
1961
1962   /* This is signalled as soon as the message is received. We must not return
1963    * while the watch thread is still firing off callbacks. Freeing all of the
1964    * memory is done in the watch thread after this is signalled.
1965    */
1966   result = WaitForSingleObject (watch->message_received_event, INFINITE);
1967   if (result != WAIT_OBJECT_0)
1968     {
1969       g_warning ("gregistrysettingsbackend: unable to stop watch thread.");
1970       return;
1971     }
1972
1973   LeaveCriticalSection (watch->message_lock);
1974   DeleteCriticalSection (watch->message_lock);
1975   g_slice_free (CRITICAL_SECTION, watch->message_lock);
1976   CloseHandle (watch->message_sent_event);
1977   CloseHandle (watch->message_received_event);
1978   CloseHandle (watch->thread);
1979   g_slice_free (WatchThreadState, watch);
1980
1981   trace ("\nwatch thread: %x: all data freed.\n", self);
1982   self->watch = NULL;
1983 }
1984
1985 static gboolean
1986 watch_add_notify (GRegistrySettingsBackend *self,
1987                   HANDLE                    event,
1988                   HKEY                      hpath,
1989                   gchar                    *gsettings_prefix)
1990 {
1991   WatchThreadState *watch = self->watch;
1992   GNode *cache_node;
1993   RegistryCacheItem *cache_item;
1994 #ifdef TRACE
1995   DWORD result;
1996 #endif
1997
1998   g_return_val_if_fail (watch != NULL, FALSE);
1999
2000   trace ("watch_add_notify: prefix %s.\n", gsettings_prefix);
2001
2002   /* Duplicate tree into the cache in the main thread, before we add the notify: if we do it in the
2003    * thread we can miss changes while we are caching.
2004    */
2005   EnterCriticalSection (self->cache_lock);
2006   cache_node = registry_cache_get_node_for_key (self->cache_root, gsettings_prefix, TRUE);
2007
2008   if (cache_node == NULL || cache_node->data == NULL)
2009     {
2010       LeaveCriticalSection (self->cache_lock);
2011       g_warn_if_reached ();
2012       return FALSE;
2013     }
2014
2015   cache_item = cache_node->data;
2016
2017   cache_item->subscription_count++;
2018   if (cache_item->subscription_count > 1)
2019     {
2020       trace ("watch_add_notify: prefix %s already watched, %i subscribers.\n",
2021              gsettings_prefix, cache_item->subscription_count);
2022       LeaveCriticalSection (self->cache_lock);
2023       return FALSE;
2024     }
2025
2026   registry_cache_ref_tree (cache_node);
2027   registry_cache_update (self, hpath, gsettings_prefix, NULL, cache_node, 0, NULL);
2028   //registry_cache_dump (self->cache_root, NULL);
2029   LeaveCriticalSection (self->cache_lock);
2030
2031   EnterCriticalSection (watch->message_lock);
2032   watch->message.type = WATCH_THREAD_ADD_WATCH;
2033   watch->message.watch.event = event;
2034   watch->message.watch.hpath = hpath;
2035   watch->message.watch.prefix = gsettings_prefix;
2036   watch->message.watch.cache_node = cache_node;
2037
2038   SetEvent (watch->message_sent_event);
2039
2040   /* Wait for the received event in return, to avoid sending another message before the first
2041    * one was received. If it takes > 200ms there is a possible race but the worst outcome is
2042    * a notification is ignored.
2043    */
2044 #ifdef TRACE
2045   result =
2046 #endif
2047     WaitForSingleObject (watch->message_received_event, 200);
2048 #ifdef TRACE
2049   if (result != WAIT_OBJECT_0)
2050     trace ("watch thread is slow to respond - notification may not be added.");
2051 #endif
2052
2053   LeaveCriticalSection (watch->message_lock);
2054
2055   return TRUE;
2056 }
2057
2058 static void
2059 watch_remove_notify (GRegistrySettingsBackend *self,
2060                      const gchar              *key_name)
2061 {
2062   WatchThreadState *watch = self->watch;
2063   LONG result;
2064
2065   if (self->watch == NULL)
2066     /* Here we assume that the unsubscribe message is for somewhere that was
2067      * deleted, and so it has already been removed and the watch thread has
2068      * stopped.
2069      */
2070     return;
2071
2072   EnterCriticalSection (watch->message_lock);
2073   watch->message.type = WATCH_THREAD_REMOVE_WATCH;
2074   watch->message.watch.prefix = g_strdup (key_name);
2075
2076   SetEvent (watch->message_sent_event);
2077
2078   /* Wait for the received event in return, to avoid sending another message before the first
2079    * one was received.
2080    */
2081   result = WaitForSingleObject (watch->message_received_event, INFINITE);
2082
2083   if (result != ERROR_SUCCESS)
2084     g_warning ("unsubscribe from %s: message not acknowledged", key_name);
2085
2086   if (g_atomic_int_get (&watch->watches_remaining) >= MAX_WATCHES)
2087     /* Stop it before any new ones can get added and confuse things */
2088     watch_stop_unlocked (self);
2089   else
2090     LeaveCriticalSection (watch->message_lock);
2091 }
2092
2093 /* dconf semantics are: if the key ends in /, watch the keys underneath it - if not, watch that
2094  * key. Our job is easier because keys and values are separate.
2095  */
2096 static void
2097 g_registry_settings_backend_subscribe (GSettingsBackend *backend,
2098                                        const char       *key_name)
2099 {
2100   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (backend);
2101   gchar *path_name;
2102   gunichar2 *path_namew;
2103   gchar *value_name = NULL;
2104   HKEY hpath;
2105   HANDLE event;
2106   LONG result;
2107
2108   if (self->watch == NULL && !watch_start (self))
2109     return;
2110
2111   if (g_atomic_int_dec_and_test (&self->watch->watches_remaining))
2112     {
2113       g_atomic_int_inc (&self->watch->watches_remaining);
2114       g_warning ("subscribe() failed: only %i different paths may be watched.", MAX_WATCHES);
2115       return;
2116     }
2117
2118   path_name = parse_key (key_name, self->base_path, &value_name);
2119
2120   /* Must check for this, otherwise strange crashes occur because the cache
2121    * node that is being watched gets freed. All path names to subscribe must
2122    * end in a slash!
2123    */
2124   if (value_name != NULL && *value_name != 0)
2125     g_warning ("subscribe() failed: path must end in a /, got %s", key_name);
2126
2127   trace ("Subscribing to %s [registry %s / %s] - watch %x\n", key_name, path_name, value_name, self->watch);
2128
2129   path_namew = g_utf8_to_utf16 (path_name, -1, NULL, NULL, NULL);
2130   g_free (path_name);
2131
2132   /* Give the caller the benefit of the doubt if the key doesn't exist and create it. The caller
2133    * is almost certainly a new g_settings with this path as base path. */
2134   result = RegCreateKeyExW (self->base_key, path_namew, 0, NULL, 0, KEY_READ, NULL, &hpath,
2135                             NULL);
2136   g_free (path_namew);
2137
2138   if (result != ERROR_SUCCESS)
2139     {
2140       g_message_win32_error (result, "gregistrysettingsbackend: Unable to subscribe to key %s.", key_name);
2141       g_atomic_int_inc (&self->watch->watches_remaining);
2142       return;
2143     }
2144
2145   event = CreateEvent (NULL, FALSE, FALSE, NULL);
2146   if (event == NULL)
2147     {
2148       g_message_win32_error (result, "gregistrysettingsbackend: CreateEvent failed.");
2149       g_atomic_int_inc (&self->watch->watches_remaining);
2150       RegCloseKey (hpath);
2151       return;
2152     }
2153
2154   /* The actual watch is added by the thread, which has to re-subscribe each time it
2155    * receives a change. */
2156   if (!watch_add_notify (self, event, hpath, g_strdup (key_name)))
2157     {
2158       g_atomic_int_inc (&self->watch->watches_remaining);
2159       RegCloseKey (hpath);
2160       CloseHandle (event);
2161     }
2162 }
2163
2164 static void
2165 g_registry_settings_backend_unsubscribe (GSettingsBackend *backend,
2166                                          const char       *key_name)
2167 {
2168   trace ("unsubscribe: %s.\n", key_name);
2169
2170   watch_remove_notify (G_REGISTRY_SETTINGS_BACKEND (backend), key_name);
2171 }
2172
2173 /********************************************************************************
2174  * Object management junk
2175  ********************************************************************************/
2176
2177 static void
2178 g_registry_settings_backend_finalize (GObject *object)
2179 {
2180   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (object);
2181   RegistryCacheItem *item;
2182
2183   item = self->cache_root->data;
2184   g_warn_if_fail (item->ref_count == 1);
2185
2186   registry_cache_item_free (item);
2187   g_node_destroy (self->cache_root);
2188
2189   if (self->watch != NULL)
2190     {
2191       EnterCriticalSection (self->watch->message_lock);
2192       watch_stop_unlocked (self);
2193     }
2194
2195   DeleteCriticalSection (self->cache_lock);
2196   g_slice_free (CRITICAL_SECTION, self->cache_lock);
2197
2198   g_free (self->base_path);
2199   g_free (self->base_pathw);
2200 }
2201
2202 static void
2203 g_registry_settings_backend_constructed (GObject *object)
2204 {
2205   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (object);
2206
2207   if (self->base_key == NULL || self->base_path == NULL || self->base_pathw == NULL)
2208     {
2209       self->base_key = HKEY_CURRENT_USER;
2210       self->base_path = g_strdup ("Software\\GSettings");
2211       self->base_pathw = g_utf8_to_utf16 (self->base_path, -1, NULL, NULL, NULL);
2212     }
2213 }
2214
2215 static void
2216 g_registry_settings_backend_get_property (GObject    *object,
2217                                           guint       prop_id,
2218                                           GValue     *value,
2219                                           GParamSpec *pspec)
2220 {
2221   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (object);
2222
2223   switch ((GRegistrySettingsBackendProperty) prop_id)
2224     {
2225     case PROP_REGISTRY_KEY:
2226       g_value_take_string (value,
2227                            g_strdup_printf ("%s\\%s",
2228                                             predefined_key_to_string (self->base_key),
2229                                             self->base_path));
2230       break;
2231
2232     default:
2233       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2234       break;
2235     }
2236 }
2237
2238 static void
2239 g_registry_settings_backend_set_property (GObject      *object,
2240                                           guint         prop_id,
2241                                           const GValue *value,
2242                                           GParamSpec   *pspec)
2243 {
2244   GRegistrySettingsBackend *self = G_REGISTRY_SETTINGS_BACKEND (object);
2245   const gchar *reg_path;
2246
2247   switch ((GRegistrySettingsBackendProperty) prop_id)
2248     {
2249     case PROP_REGISTRY_KEY:
2250       /* Construct only. */
2251       g_assert (self->base_key == NULL);
2252       g_assert (self->base_path == NULL);
2253       g_assert (self->base_pathw == NULL);
2254
2255       reg_path = g_value_get_string (value);
2256       if (reg_path != NULL)
2257         {
2258           HKEY base_key;
2259           const gchar *base_path = split_registry_path (reg_path, &base_key);
2260
2261           if (base_path != NULL)
2262             {
2263               gunichar2 *base_pathw = g_utf8_to_utf16 (base_path, -1, NULL, NULL, NULL);
2264
2265               if (base_pathw != NULL)
2266                 {
2267                   self->base_key = g_steal_pointer (&base_key);
2268                   self->base_path = g_strdup (base_path);
2269                   self->base_pathw = g_steal_pointer (&base_pathw);
2270                 }
2271               else
2272                 g_warning ("gregistrysettingsbackend: invalid base registry path '%s'", reg_path);
2273             }
2274           else
2275             g_warning ("gregistrysettingsbackend: base registry path '%s' does not start with a valid root key", reg_path);
2276         }
2277       break;
2278
2279     default:
2280       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2281       break;
2282     }
2283 }
2284
2285 static void
2286 g_registry_settings_backend_class_init (GRegistrySettingsBackendClass *class)
2287 {
2288   GSettingsBackendClass *backend_class = G_SETTINGS_BACKEND_CLASS (class);
2289   GObjectClass *object_class = G_OBJECT_CLASS (class);
2290
2291   object_class->finalize = g_registry_settings_backend_finalize;
2292   object_class->constructed = g_registry_settings_backend_constructed;
2293   object_class->get_property = g_registry_settings_backend_get_property;
2294   object_class->set_property = g_registry_settings_backend_set_property;
2295
2296   backend_class->read = g_registry_settings_backend_read;
2297   backend_class->write = g_registry_settings_backend_write;
2298   backend_class->write_tree = g_registry_settings_backend_write_tree;
2299   backend_class->reset = g_registry_settings_backend_reset;
2300   backend_class->get_writable = g_registry_settings_backend_get_writable;
2301   backend_class->subscribe = g_registry_settings_backend_subscribe;
2302   backend_class->unsubscribe = g_registry_settings_backend_unsubscribe;
2303
2304   /**
2305    * GRegistrySettingsBackend:registry-key:
2306    *
2307    * The location where settings are stored in the registry. Must
2308    * start with one of the following:
2309    * - `HKEY_CLASSES_ROOT`
2310    * - `HKEY_CURRENT_CONFIG`
2311    * - `HKEY_CURRENT_USER`
2312    * - `HKEY_LOCAL_MACHINE`
2313    * - `HKEY_USERS`
2314    *
2315    * Defaults to `HKEY_CURRENT_USER\Software\GSettings`.
2316    *
2317    * Since: 2.78
2318    */
2319   g_object_class_install_property (object_class,
2320                                    PROP_REGISTRY_KEY,
2321                                    g_param_spec_string ("registry-key",
2322                                                         NULL, NULL,
2323                                                         "HKEY_CURRENT_USER\\Software\\GSettings",
2324                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
2325                                                         G_PARAM_STATIC_STRINGS));
2326 }
2327
2328 static void
2329 g_registry_settings_backend_init (GRegistrySettingsBackend *self)
2330 {
2331   RegistryCacheItem *item;
2332
2333   item = g_slice_new (RegistryCacheItem);
2334   item->value.type = REG_NONE;
2335   item->value.ptr = NULL;
2336   item->name = g_strdup ("<root>");
2337   item->ref_count = 1;
2338   self->cache_root = g_node_new (item);
2339
2340   self->cache_lock = g_slice_new (CRITICAL_SECTION);
2341   InitializeCriticalSection (self->cache_lock);
2342
2343   self->watch = NULL;
2344 }
2345
2346 /**
2347  * g_registry_settings_backend_new:
2348  * @registry_key: (nullable): the path to the registry key where
2349  *                settings are stored, or %NULL.
2350  *
2351  * If @registry_key is %NULL then the default path
2352  * `HKEY_CURRENT_USER\Software\GSettings` is used.
2353  *
2354  * Returns: (transfer full): a registry-backed #GSettingsBackend
2355  *
2356  * Since: 2.78
2357  **/
2358 GSettingsBackend *
2359 g_registry_settings_backend_new (const gchar *registry_key)
2360 {
2361   g_return_val_if_fail (registry_key == NULL || split_registry_path (registry_key, NULL), NULL);
2362
2363   return G_SETTINGS_BACKEND (g_object_new (G_TYPE_REGISTRY_SETTINGS_BACKEND,
2364                                            "registry-key", registry_key,
2365                                            NULL));
2366 }