/* GIO - GLib Input, Output and Streaming Library

 *

 * Copyright (C) 2014 Руслан Ижбулатов <lrn1986@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 */

#include "config.h"

#include "ginitable.h"

#include "gwin32registrykey.h"

#include <gio/gioerror.h>

#ifdef _MSC_VER

#pragma warning ( disable:4005 )

#endif

#include <windows.h>

#include <ntstatus.h>

#include <winternl.h>

#ifndef _WDMDDK_

typedef enum _KEY_INFORMATION_CLASS {

  KeyBasicInformation,

  KeyNodeInformation,

  KeyFullInformation,

  KeyNameInformation,

  KeyCachedInformation,

  KeyFlagsInformation,

  KeyVirtualizationInformation,

  KeyHandleTagsInformation,

  MaxKeyInfoClass

} KEY_INFORMATION_CLASS;

typedef struct _KEY_BASIC_INFORMATION {

  LARGE_INTEGER LastWriteTime;

  ULONG TitleIndex;

  ULONG NameLength;

  WCHAR Name[1];

} KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;

#endif

#if !defined (__OBJECT_ATTRIBUTES_DEFINED) && defined (__MINGW32_)

#define __OBJECT_ATTRIBUTES_DEFINED

  typedef struct _OBJECT_ATTRIBUTES {

    ULONG Length;

#ifdef _WIN64

    ULONG pad1;

#endif

    HANDLE RootDirectory;

    PUNICODE_STRING ObjectName;

    ULONG Attributes;

#ifdef _WIN64

    ULONG pad2;

#endif

    PVOID SecurityDescriptor;

    PVOID SecurityQualityOfService;

  } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;

#endif

#ifndef HKEY_CURRENT_USER_LOCAL_SETTINGS

#define HKEY_CURRENT_USER_LOCAL_SETTINGS ((HKEY) (ULONG_PTR)((LONG)0x80000007))

#endif

#if !defined (__UNICODE_STRING_DEFINED) && defined (__MINGW32_)

#define __UNICODE_STRING_DEFINED

typedef struct _UNICODE_STRING {

  USHORT Length;

  USHORT MaximumLength;

  PWSTR  Buffer;

} UNICODE_STRING, *PUNICODE_STRING;

#endif

typedef const UNICODE_STRING* PCUNICODE_STRING;

typedef NTSTATUS

(NTAPI * NtQueryKeyFunc)(HANDLE                key_handle,

                         KEY_INFORMATION_CLASS key_info_class,

                         PVOID                 key_info_buffer,

                         ULONG                 key_info_buffer_size,

                         PULONG                result_size);

typedef NTSTATUS

(NTAPI * NtNotifyChangeMultipleKeysFunc)(HANDLE             key_handle,

                                         ULONG              subkey_count,

                                         POBJECT_ATTRIBUTES subkeys,

                                         HANDLE             event,

                                         PIO_APC_ROUTINE    apc_routine,

                                         PVOID              apc_closure,

                                         PIO_STATUS_BLOCK   status_block,

                                         ULONG              filter,

                                         BOOLEAN            watch_tree,

                                         PVOID              buffer,

                                         ULONG              buffer_size,

                                         BOOLEAN            async);

static NtQueryKeyFunc nt_query_key = NULL;

static NtNotifyChangeMultipleKeysFunc nt_notify_change_multiple_keys = NULL;

#define G_WIN32_KEY_UNWATCHED 0

#define G_WIN32_KEY_WATCHED 1

#define G_WIN32_KEY_UNCHANGED 0

#define G_WIN32_KEY_CHANGED 1

#define G_WIN32_KEY_UNKNOWN -1

enum

{

  PROP_0,

  PROP_PATH,

  PROP_PATH_UTF16,

  PROP_MAX,

};

typedef enum

{

  G_WIN32_REGISTRY_UPDATED_NOTHING = 0,

  G_WIN32_REGISTRY_UPDATED_PATH = 1,

} GWin32RegistryKeyUpdateFlag;

static gunichar2 *

g_wcsdup (const gunichar2 *str,

          gssize           str_size)

{

  if (str_size == -1)

    {

      str_size = wcslen (str) + 1;

      str_size *= sizeof (gunichar2);

    }

  return g_memdup (str, str_size);

}

/**

 * g_win32_registry_subkey_iter_copy:

 * @iter: an iterator

 *

 * Creates a dynamically-allocated copy of an iterator. Dynamically-allocated

 * state of the iterator is duplicated too.

 *

 * Returns: (transfer full): a copy of the @iter,

 * free with g_win32_registry_subkey_iter_free ()

 *

 * Since: 2.46

 **/

GWin32RegistrySubkeyIter *

g_win32_registry_subkey_iter_copy (const GWin32RegistrySubkeyIter *iter)

{

  GWin32RegistrySubkeyIter *new_iter;

  g_return_val_if_fail (iter != NULL, NULL);

  new_iter = g_new0 (GWin32RegistrySubkeyIter, 1);

  new_iter->key = g_object_ref (iter->key);

  new_iter->counter = iter->counter;

  new_iter->subkey_count = iter->subkey_count;

  new_iter->subkey_name = g_wcsdup (iter->subkey_name, iter->subkey_name_size);

  new_iter->subkey_name_size = iter->subkey_name_size;

  if (iter->subkey_name_u8)

    new_iter->subkey_name_u8 = iter->subkey_name_u8;

  else

    new_iter->subkey_name_u8 = NULL;

  return new_iter;

}

/**

 * g_win32_registry_subkey_iter_free:

 * @iter: a dynamically-allocated iterator

 *

 * Free an iterator allocated on the heap. For iterators that are allocated

 * on the stack use g_win32_registry_subkey_iter_clear () instead.

 *

 * Since: 2.46

 **/

void

g_win32_registry_subkey_iter_free (GWin32RegistrySubkeyIter *iter)

{

  g_return_if_fail (iter != NULL);

  g_object_unref (iter->key);

  g_free (iter->subkey_name);

  g_free (iter->subkey_name_u8);

  g_free (iter);

}

/**

 * g_win32_registry_subkey_iter_assign:

 * @iter: a #GWin32RegistrySubkeyIter

 * @other: another #GWin32RegistrySubkeyIter

 *

 * Assigns the value of @other to @iter.  This function

 * is not useful in applications, because iterators can be assigned

 * with `GWin32RegistrySubkeyIter i = j;`. The

 * function is used by language bindings.

 *

 * Since: 2.46

 **/

void

g_win32_registry_subkey_iter_assign (GWin32RegistrySubkeyIter       *iter,

                                     const GWin32RegistrySubkeyIter *other)

{

  g_return_if_fail (iter != NULL);

  g_return_if_fail (other != NULL);

  *iter = *other;

}

G_DEFINE_BOXED_TYPE (GWin32RegistrySubkeyIter, g_win32_registry_subkey_iter,

                     g_win32_registry_subkey_iter_copy,

                     g_win32_registry_subkey_iter_free)

/**

 * g_win32_registry_value_iter_copy:

 * @iter: an iterator

 *

 * Creates a dynamically-allocated copy of an iterator. Dynamically-allocated

 * state of the iterator is duplicated too.

 *

 * Returns: (transfer full): a copy of the @iter,

 * free with g_win32_registry_value_iter_free ().

 *

 * Since: 2.46

 **/

GWin32RegistryValueIter *

g_win32_registry_value_iter_copy (const GWin32RegistryValueIter *iter)

{

  GWin32RegistryValueIter *new_iter;

  g_return_val_if_fail (iter != NULL, NULL);

  new_iter = g_new0 (GWin32RegistryValueIter, 1);

  new_iter->key = g_object_ref (iter->key);

  new_iter->counter = iter->counter;

  new_iter->value_count = iter->value_count;

  new_iter->value_name = g_wcsdup (iter->value_name, iter->value_name_size);

  new_iter->value_name_size = iter->value_name_size;

  if (iter->value_data != NULL)

    new_iter->value_data = g_memdup (iter->value_data, iter->value_data_size);

  new_iter->value_data_size = iter->value_data_size;

  if (iter->value_name_u8 != NULL)

    new_iter->value_name_u8 = g_strdup (iter->value_name_u8);

  new_iter->value_name_u8_len = iter->value_name_u8_len;

  if (iter->value_data_u8 != NULL)

    new_iter->value_data_u8 = g_strdup (iter->value_data_u8);

  new_iter->value_data_u8_size = iter->value_data_u8_size;

  if (iter->value_data_expanded != NULL)

    new_iter->value_data_expanded = g_wcsdup ((gunichar2 *) iter->value_data_expanded,

                                              iter->value_data_expanded_charsize * sizeof (gunichar2));

  new_iter->value_data_expanded_charsize = iter->value_data_expanded_charsize;

  if (iter->value_data_expanded_u8 != NULL)

    new_iter->value_data_expanded_u8 = g_memdup (iter->value_data_expanded_u8,

                                                 iter->value_data_expanded_charsize);

  new_iter->value_data_expanded_u8_size = iter->value_data_expanded_charsize;

  return new_iter;

}

/**

 * g_win32_registry_value_iter_free:

 * @iter: a dynamically-allocated iterator

 *

 * Free an iterator allocated on the heap. For iterators that are allocated

 * on the stack use g_win32_registry_value_iter_clear () instead.

 *

 * Since: 2.46

 **/

void

g_win32_registry_value_iter_free (GWin32RegistryValueIter *iter)

{

  g_return_if_fail (iter != NULL);

  g_object_unref (iter->key);

  g_free (iter->value_name);

  g_free (iter->value_data);

  g_free (iter->value_data_expanded);

  g_free (iter->value_name_u8);

  g_free (iter->value_data_u8);

  g_free (iter->value_data_expanded_u8);

  g_free (iter);

}

/**

 * g_win32_registry_value_iter_assign:

 * @iter: a #GWin32RegistryValueIter

 * @other: another #GWin32RegistryValueIter

 *

 * Assigns the value of @other to @iter.  This function

 * is not useful in applications, because iterators can be assigned

 * with `GWin32RegistryValueIter i = j;`. The

 * function is used by language bindings.

 *

 * Since: 2.46

 **/

void

g_win32_registry_value_iter_assign (GWin32RegistryValueIter       *iter,

                                    const GWin32RegistryValueIter *other)

{

  g_return_if_fail (iter != NULL);

  g_return_if_fail (other != NULL);

  *iter = *other;

}

G_DEFINE_BOXED_TYPE (GWin32RegistryValueIter, g_win32_registry_value_iter,

                     g_win32_registry_value_iter_copy,

                     g_win32_registry_value_iter_free)

/**

 * SECTION:gwin32registrykey

 * @title: GWin32RegistryKey

 * @short_description: W32 registry access helper

 * @include: gio/win32/gwin32registrykey.h

 *

 * #GWin32RegistryKey represents a single Windows Registry key.

 *

 * #GWin32RegistryKey is used by a number of helper functions that read

 * Windows Registry. All keys are opened with read-only access, and at

 * the moment there is no API for writing into registry keys or creating

 * new ones.

 *

 * #GWin32RegistryKey implements the #GInitable interface, so if it is manually

 * constructed by e.g. g_object_new() you must call g_initable_init() and check

 * the results before using the object. This is done automatically

 * in g_win32_registry_key_new() and g_win32_registry_key_get_child(), so these

 * functions can return %NULL.

 *

 * To increase efficiency, a UTF-16 variant is available for all functions

 * that deal with key or value names in the registry. Use these to perform

 * deep registry queries or other operations that require querying a name

 * of a key or a value and then opening it (or querying its data). The use

 * of UTF-16 functions avoids the overhead of converting names to UTF-8 and

 * back.

 *

 * All functions operate in current user's context (it is not possible to

 * access registry tree of a different user).

 *

 * Key paths must use '\\' as a separator, '/' is not supported. Key names

 * must not include '\\', because it's used as a separator. Value names

 * can include '\\'.

 *

 * Key and value names are not case sensitive.

 *

 * Full key name (excluding the pre-defined ancestor's name) can't exceed

 * 255 UTF-16 characters, give or take. Value name can't exceed 16383 UTF-16

 * characters. Tree depth is limited to 512 levels.

 **/

struct _GWin32RegistryKeyPrivate {

  /* Ancestor of this key. May not be the immediate parent, because

   * RegOpenKeyEx() allows grand*-children to be opened transitively.

   * May be NULL.

   */

  GWin32RegistryKey *ancestor;

  /* Handle to the key */

  HKEY handle;

  /* Full absolute path of the key, in UTF-16. Always allocated.

   * Can become out of sync if the key is renamed from while we have it

   * open, check watch_indicator to see if anything changed.

   */

  gunichar2 *absolute_path_w;

  /* Full absolute path of the key, in UTF-8. Allocated when needed by

   * converting the UTF-16 value from absolute_path_w. */

  gchar *absolute_path;

  /* TRUE if this object represents one of the pre-defined keys

   * (and thus must not be closed).

   */

  gboolean predefined;

  /* Set to G_WIN32_KEY_UNWATCHED if the key is not being watched.

   * Set to G_WIN32_KEY_WATCHED when the key is put on watch notification.

   */

  gint watch_indicator;

  /* Set to G_WIN32_KEY_UNKNOWN while the key is not being watched.

   * Set to G_WIN32_KEY_UNCHANGED once the key is put under watch.

   * Set to G_WIN32_KEY_CHANGED by the watch notification APC on key change.

   */

  gint change_indicator;

  /* Unset after the key is changed, individual bits are set when their

   * respective key parameters are updated from the registry.

   * This prevents GLib from re-querying things like key name each time

   * one is requested by the client while key is in G_WIN32_KEY_CHANGED state.

   */

  GWin32RegistryKeyUpdateFlag update_flags;

  GWin32RegistryKeyWatchCallbackFunc callback;

  gpointer user_data;

};

static void     g_win32_registry_key_initable_iface_init (GInitableIface  *iface);

static gboolean g_win32_registry_key_initable_init       (GInitable       *initable,

                                                          GCancellable    *cancellable,

                                                          GError         **error);

G_DEFINE_TYPE_WITH_CODE (GWin32RegistryKey, g_win32_registry_key, G_TYPE_OBJECT,

                         G_ADD_PRIVATE (GWin32RegistryKey)

                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,

                                                g_win32_registry_key_initable_iface_init));

static void

g_win32_registry_key_dispose (GObject *object)

{

  GWin32RegistryKey *key;

  GWin32RegistryKeyPrivate *priv;

  key = G_WIN32_REGISTRY_KEY (object);

  priv = key->priv;

  g_clear_object (&priv->ancestor);

  g_clear_pointer (&priv->absolute_path_w, g_free);

  g_clear_pointer (&priv->absolute_path, g_free);

  if (!priv->predefined && priv->handle != INVALID_HANDLE_VALUE)

    {

      RegCloseKey (priv->handle);

      priv->handle = INVALID_HANDLE_VALUE;

    }

  G_OBJECT_CLASS (g_win32_registry_key_parent_class)->dispose (object);

}

/**

 * g_win32_registry_key_new:

 * @path: absolute full name of a key to open (in UTF-8)

 * @error: (nullable): a pointer to a %NULL #GError, or %NULL

 *

 * Creates an object that represents a registry key specified by @path.

 * @path must start with one of the following pre-defined names:

 * - HKEY_CLASSES_ROOT

 * - HKEY_CURRENT_CONFIG

 * - HKEY_CURRENT_USER

 * - HKEY_CURRENT_USER_LOCAL_SETTINGS

 * - HKEY_LOCAL_MACHINE

 * - HKEY_PERFORMANCE_DATA

 * - HKEY_PERFORMANCE_NLSTEXT

 * - HKEY_PERFORMANCE_TEXT

 * - HKEY_USERS

 * @path must not end with '\\'.

 *

 * Returns: (nullable) (transfer full): a #GWin32RegistryKey or %NULL if can't

 *   be opened. Free with g_object_unref().

 */

GWin32RegistryKey *

g_win32_registry_key_new (const gchar  *path,

                          GError      **error)

{

  g_return_val_if_fail (path != NULL, NULL);

  return g_initable_new (G_TYPE_WIN32_REGISTRY_KEY,

                         NULL,

                         error,

                         "path",

                         path,

                         NULL);

}

/**

 * g_win32_registry_key_new_w:

 * @path: (in) (transfer none): absolute full name of a key to open (in UTF-16)

 * @error: (inout) (optional) (nullable): a pointer to a %NULL #GError, or %NULL

 *

 * Creates an object that represents a registry key specified by @path.

 * @path must start with one of the following pre-defined names:

 * - HKEY_CLASSES_ROOT

 * - HKEY_CURRENT_CONFIG

 * - HKEY_CURRENT_USER

 * - HKEY_CURRENT_USER_LOCAL_SETTINGS

 * - HKEY_LOCAL_MACHINE

 * - HKEY_PERFORMANCE_DATA

 * - HKEY_PERFORMANCE_NLSTEXT

 * - HKEY_PERFORMANCE_TEXT

 * - HKEY_USERS

 * @path must not end with L'\\'.

 *

 * Returns: (nullable) (transfer full): a #GWin32RegistryKey or %NULL if can't

 *   be opened. Free with g_object_unref().

 */

GWin32RegistryKey *

g_win32_registry_key_new_w (const gunichar2  *path,

                            GError          **error)

{

  GObject *result;

  g_return_val_if_fail (path != NULL, NULL);

  result = g_initable_new (G_TYPE_WIN32_REGISTRY_KEY,

                           NULL,

                           error,

                           "path-utf16",

                           g_wcsdup (path, -1),

                           NULL);

  return result ? G_WIN32_REGISTRY_KEY (result) : NULL;

}

static void

g_win32_registry_key_initable_iface_init (GInitableIface *iface)

{

  iface->init = g_win32_registry_key_initable_init;

}

static gboolean

g_win32_registry_key_initable_init (GInitable     *initable,

                                    GCancellable  *cancellable,

                                    GError       **error)

{

  GWin32RegistryKey *key;

  GWin32RegistryKeyPrivate *priv;

  gunichar2 *path;

  gunichar2 *first_chunk_end;

  gsize first_chunk_len;

  gunichar2 *second_chunk_begin;

  gunichar2 *first_chunk;

  HKEY ancestor;

  HKEY key_handle;

  LONG opened;

  g_return_val_if_fail (G_IS_WIN32_REGISTRY_KEY (initable), FALSE);

  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  key = G_WIN32_REGISTRY_KEY (initable);

  priv = key->priv;

  if (priv->absolute_path_w == NULL)

    {

      priv->absolute_path_w = g_utf8_to_utf16 (priv->absolute_path,

                                               -1,

                                               NULL,

                                               NULL,

                                               error);

      if (priv->absolute_path_w == NULL)

        return FALSE;

    }

  path = priv->absolute_path_w;

  first_chunk_end = wcschr (path, L'\\');

  if (first_chunk_end == NULL)

    first_chunk_end = &path[wcslen (path)];

  first_chunk_len = first_chunk_end - path;

  first_chunk = g_wcsdup (path, -1);

  first_chunk[first_chunk_len] = L'\0';

  if (wcscmp (first_chunk, L"HKEY_CLASSES_ROOT") == 0)

    ancestor = HKEY_CLASSES_ROOT;

  else if (wcscmp (first_chunk, L"HKEY_LOCAL_MACHINE") == 0)

    ancestor = HKEY_LOCAL_MACHINE;

  else if (wcscmp (first_chunk, L"HKEY_CURRENT_USER") == 0)

    ancestor = HKEY_CURRENT_USER;

  else if (wcscmp (first_chunk, L"HKEY_CURRENT_CONFIG") == 0)

    ancestor = HKEY_CURRENT_CONFIG;

  else if (wcscmp (first_chunk, L"HKEY_CURRENT_USER_LOCAL_SETTINGS") == 0)

    ancestor = HKEY_CURRENT_USER_LOCAL_SETTINGS;

  else if (wcscmp (first_chunk, L"HKEY_USERS") == 0)

    ancestor = HKEY_USERS;

  else if (wcscmp (first_chunk, L"HKEY_PERFORMANCE_DATA") == 0)

    ancestor = HKEY_PERFORMANCE_DATA;

  else if (wcscmp (first_chunk, L"HKEY_PERFORMANCE_NLSTEXT") == 0)

    ancestor = HKEY_PERFORMANCE_NLSTEXT;

  else if (wcscmp (first_chunk, L"HKEY_PERFORMANCE_TEXT") == 0)

    ancestor = HKEY_PERFORMANCE_TEXT;

  else

    {

      g_critical ("Root key '%S' is not a pre-defined key", first_chunk);

      g_free (first_chunk);

      return FALSE;

    }

  g_free (first_chunk);

  second_chunk_begin = first_chunk_end;

  while (second_chunk_begin[0] != L'\0' && second_chunk_begin[0] == L'\\')

    second_chunk_begin++;

  if (second_chunk_begin != first_chunk_end && second_chunk_begin[0] == L'\0')

    {

      g_critical ("Key name '%S' ends with '\\'", path);

      return FALSE;

    }

  opened = RegOpenKeyExW (ancestor, second_chunk_begin, 0, KEY_READ, &key_handle);

  if (opened != ERROR_SUCCESS)

    {

      g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (opened),

                   "Failed to open registry key '%S'", path);

      return FALSE;

    }

  priv->ancestor = NULL;

  priv->handle = key_handle;

  priv->predefined = (second_chunk_begin[0] == L'\0');

  return TRUE;

}

/**

 * g_win32_registry_key_get_child:

 * @key: (in) (transfer none): a parent #GWin32RegistryKey

 * @subkey: (in) (transfer none): name of a child key to open (in UTF-8), relative to @key

 * @error: (inout) (optional) (nullable): a pointer to a %NULL #GError, or %NULL

 *

 * Opens a @subkey of the @key.

 *

 * Returns: (nullable): a #GWin32RegistryKey or %NULL if can't be opened. Free

 *                      with g_object_unref().

 */

GWin32RegistryKey *

g_win32_registry_key_get_child (GWin32RegistryKey  *key,

                                const gchar        *subkey,

                                GError            **error)

{

  gunichar2 *subkey_w;

  GWin32RegistryKey *result = NULL;

  g_return_val_if_fail (G_IS_WIN32_REGISTRY_KEY (key), NULL);

  g_return_val_if_fail (subkey != NULL, NULL);

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  subkey_w = g_utf8_to_utf16 (subkey, -1, NULL, NULL, error);

  if (subkey_w != NULL)

    {

      result = g_win32_registry_key_get_child_w (key, subkey_w, error);

      g_free (subkey_w);

    }

  return result;

}

/**

 * g_win32_registry_key_get_child_w:

 * @key: (in) (transfer none): a parent #GWin32RegistryKey

 * @subkey: (in) (transfer none): name of a child key to open (in UTF-8), relative to @key

 * @error: (inout) (optional) (nullable): a pointer to a %NULL #GError, or %NULL

 *

 * Opens a @subkey of the @key.

 *

 * Returns: (nullable): a #GWin32RegistryKey or %NULL if can't be opened. Free

 *                      with g_object_unref().

 */

GWin32RegistryKey *

g_win32_registry_key_get_child_w (GWin32RegistryKey  *key,

                                  const gunichar2    *subkey,

                                  GError            **error)

{

  HKEY key_handle;

  LONG opened;

  const gunichar2 *end_of_subkey;

  gsize subkey_len;

  GWin32RegistryKey *result;

  const gunichar2 *key_path;

  g_return_val_if_fail (G_IS_WIN32_REGISTRY_KEY (key), NULL);

  g_return_val_if_fail (subkey != NULL, NULL);

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  if (subkey[0] == L'\\')

    {

      g_critical ("Subkey name '%S' starts with '\\'", subkey);

      return NULL;

    }

  subkey_len = wcslen (subkey);

  end_of_subkey = &subkey[subkey_len];

  if (subkey_len == 0)

    end_of_subkey = subkey;

  if (end_of_subkey[0] == L'\\')

    {

      g_critical ("Subkey name '%S' ends with '\\'", subkey);

      return NULL;

    }

  key_path = g_win32_registry_key_get_path_w (key);

  opened = RegOpenKeyExW (key->priv->handle, subkey, 0, KEY_READ, &key_handle);

  if (opened != ERROR_SUCCESS)

    {

      g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (opened),

                   "Failed to open registry subkey '%S' of key '%S'",

                   subkey, key_path);

      return NULL;

    }

  result = g_object_new (G_TYPE_WIN32_REGISTRY_KEY, NULL);

  result->priv->handle = key_handle;

  result->priv->absolute_path_w =

      g_malloc ((wcslen (key_path) + 2 + subkey_len) * sizeof (gunichar2));

  result->priv->absolute_path_w[0] = L'\0';

  wcscat (&result->priv->absolute_path_w[0], key_path);

  wcscat (&result->priv->absolute_path_w[wcslen (key_path)], L"\\");

  wcscat (&result->priv->absolute_path_w[wcslen (key_path) + 1], subkey);

  result->priv->predefined = (subkey[0] == L'\0' && key->priv->predefined);

  if (subkey[0] != L'\0')

    result->priv->ancestor = g_object_ref (key);

  else

    result->priv->ancestor = NULL;

  result->priv->change_indicator = G_WIN32_KEY_UNKNOWN;

  return result;

}

/**

 * g_win32_registry_subkey_iter_init:

 * @iter: (in) (transfer none): a pointer to a #GWin32RegistrySubkeyIter

 * @key: (in) (transfer none): a #GWin32RegistryKey to iterate over

 * @error: (inout) (optional) (nullable): a pointer to %NULL #GError, or %NULL

 *

 * Initialises (without allocating) a #GWin32RegistrySubkeyIter.  @iter may be

 * completely uninitialised prior to this call; its old value is

 * ignored.

 *

 * The iterator remains valid for as long as @key exists.

 * Clean up its internal buffers with a call to

 * g_win32_registry_subkey_iter_clear() when done.

 *

 * Returns: %TRUE if iterator was initialized successfully, %FALSE on error.

 *

 * Since: 2.46

 **/

gboolean

g_win32_registry_subkey_iter_init (GWin32RegistrySubkeyIter  *iter,

                                   GWin32RegistryKey         *key,

                                   GError                   **error)

{

  LONG status;

  DWORD subkey_count;

  DWORD max_subkey_len;

  g_return_val_if_fail (iter != NULL, FALSE);

  g_return_val_if_fail (G_IS_WIN32_REGISTRY_KEY (key), FALSE);

  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  status = RegQueryInfoKeyW (key->priv->handle,

                             NULL, NULL, NULL,

                             &subkey_count, &max_subkey_len,

                             NULL, NULL, NULL, NULL, NULL, NULL);

  if (status != ERROR_SUCCESS)

    {

      g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (status),

                   "Failed to query info for registry key '%S'",

                   g_win32_registry_key_get_path_w (key));

      return FALSE;

    }

  iter->key = g_object_ref (key);

  iter->counter = -1;

  iter->subkey_count = subkey_count;

  iter->subkey_name_size = sizeof (gunichar2) * (max_subkey_len + 1);

  iter->subkey_name = g_malloc (iter->subkey_name_size);

  iter->subkey_name_u8 = NULL;

  return TRUE;

}

/**

 * g_win32_registry_subkey_iter_clear:

 * @iter: (in) (transfer none): a #GWin32RegistrySubkeyIter

 *

 * Frees internal buffers of a #GWin32RegistrySubkeyIter.

 *

 * Since: 2.46

 **/

void

g_win32_registry_subkey_iter_clear (GWin32RegistrySubkeyIter *iter)

{

  g_return_if_fail (iter != NULL);

  g_free (iter->subkey_name);

  g_free (iter->subkey_name_u8);

  g_clear_object (&iter->key);

}

/**

 * g_win32_registry_subkey_iter_n_subkeys:

 * @iter: (in) (transfer none): a #GWin32RegistrySubkeyIter

 *

 * Queries the number of subkeys items in the key that we are

 * iterating over.  This is the total number of subkeys -- not the number

 * of items remaining.

 *

 * This information is accurate at the point of iterator initialization,

 * and may go out of sync with reality even while subkeys are enumerated.

 *

 * Returns: the number of subkeys in the key

 *

 * Since: 2.46

 **/

gsize

g_win32_registry_subkey_iter_n_subkeys (GWin32RegistrySubkeyIter *iter)

{

  g_return_val_if_fail (iter != NULL, 0);

  return iter->subkey_count;

}

/**

 * g_win32_registry_subkey_iter_next:

 * @iter: (in) (transfer none): a #GWin32RegistrySubkeyIter

 * @skip_errors: (in): %TRUE if iterator should silently ignore errors (such as

 *     the actual number of subkeys being less than expected) and

 *     proceed forward

 * @error: (nullable): a pointer to %NULL #GError, or %NULL

 *

 * Moves iterator to the next subkey.

 * Enumeration errors can be ignored if @skip_errors is %TRUE

 *

 * Here is an example for iterating with g_win32_registry_subkey_iter_next():

 * |[

 *   // recursively iterate a key

 *   void

 *   iterate_key_recursive (GWin32RegistryKey *key)

 *   {

 *     GWin32RegistrySubkeyIter iter;

 *     gchar *name;

 *     GWin32RegistryKey *child;

 *

 *     if (!g_win32_registry_subkey_iter_init (&iter, key, NULL))

 *       return;

 *

 *     while (g_win32_registry_subkey_iter_next (&iter, TRUE, NULL))

 *       {

 *         if (!g_win32_registry_subkey_iter_get_name (&iter, &name, NULL, NULL))

 *           continue;

 *

 *         g_print ("subkey '%s'\n", name);

 *         child = g_win32_registry_key_get_child (key, name, NULL);

 *

 *         if (child)

 *           iterate_key_recursive (child);

 *       }

 *

 *     g_win32_registry_subkey_iter_clear (&iter);

 *   }

 * ]|

 *

 * Returns: %TRUE if next subkey info was retrieved, %FALSE otherwise.

 *

 * Since: 2.46

 **/

gboolean

g_win32_registry_subkey_iter_next (GWin32RegistrySubkeyIter  *iter,

                                   gboolean                   skip_errors,

                                   GError                   **error)