/*

 * Copyright © 2010 Codethink Limited

 * Copyright © 2011 Canonical Limited

 *

 * 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 "gsettingsschema-internal.h"

#include "gsettings.h"

#include "gvdb/gvdb-reader.h"

#include "strinfo.c"

#include <glibintl.h>

#include <locale.h>

#include <string.h>

/**

 * SECTION:gsettingsschema

 * @short_description: Introspecting and controlling the loading

 *     of GSettings schemas

 * @include: gio/gio.h

 *

 * The #GSettingsSchemaSource and #GSettingsSchema APIs provide a

 * mechanism for advanced control over the loading of schemas and a

 * mechanism for introspecting their content.

 *

 * Plugin loading systems that wish to provide plugins a way to access

 * settings face the problem of how to make the schemas for these

 * settings visible to GSettings.  Typically, a plugin will want to ship

 * the schema along with itself and it won't be installed into the

 * standard system directories for schemas.

 *

 * #GSettingsSchemaSource provides a mechanism for dealing with this by

 * allowing the creation of a new 'schema source' from which schemas can

 * be acquired.  This schema source can then become part of the metadata

 * associated with the plugin and queried whenever the plugin requires

 * access to some settings.

 *

 * Consider the following example:

 *

 * |[

 * typedef struct

 * {

 *    ...

 *    GSettingsSchemaSource *schema_source;

 *    ...

 * } Plugin;

 *

 * Plugin *

 * initialise_plugin (const gchar *dir)

 * {

 *   Plugin *plugin;

 *

 *   ...

 *

 *   plugin->schema_source =

 *     g_settings_schema_source_new_from_directory (dir,

 *       g_settings_schema_source_get_default (), FALSE, NULL);

 *

 *   ...

 *

 *   return plugin;

 * }

 *

 * ...

 *

 * GSettings *

 * plugin_get_settings (Plugin      *plugin,

 *                      const gchar *schema_id)

 * {

 *   GSettingsSchema *schema;

 *

 *   if (schema_id == NULL)

 *     schema_id = plugin->identifier;

 *

 *   schema = g_settings_schema_source_lookup (plugin->schema_source,

 *                                             schema_id, FALSE);

 *

 *   if (schema == NULL)

 *     {

 *       ... disable the plugin or abort, etc ...

 *     }

 *

 *   return g_settings_new_full (schema, NULL, NULL);

 * }

 * ]|

 *

 * The code above shows how hooks should be added to the code that

 * initialises (or enables) the plugin to create the schema source and

 * how an API can be added to the plugin system to provide a convenient

 * way for the plugin to access its settings, using the schemas that it

 * ships.

 *

 * From the standpoint of the plugin, it would need to ensure that it

 * ships a gschemas.compiled file as part of itself, and then simply do

 * the following:

 *

 * |[

 * {

 *   GSettings *settings;

 *   gint some_value;

 *

 *   settings = plugin_get_settings (self, NULL);

 *   some_value = g_settings_get_int (settings, "some-value");

 *   ...

 * }

 * ]|

 *

 * It's also possible that the plugin system expects the schema source

 * files (ie: .gschema.xml files) instead of a gschemas.compiled file.

 * In that case, the plugin loading system must compile the schemas for

 * itself before attempting to create the settings source.

 *

 * Since: 2.32

 **/

/**

 * GSettingsSchemaKey:

 *

 * #GSettingsSchemaKey is an opaque data structure and can only be accessed

 * using the following functions.

 **/

/**

 * GSettingsSchema:

 *

 * This is an opaque structure type.  You may not access it directly.

 *

 * Since: 2.32

 **/

struct _GSettingsSchema

{

  GSettingsSchemaSource *source;

  const gchar *gettext_domain;

  const gchar *path;

  GQuark *items;

  gint n_items;

  GvdbTable *table;

  gchar *id;

  GSettingsSchema *extends;

  gint ref_count;

};

/**

 * G_TYPE_SETTINGS_SCHEMA_SOURCE:

 *

 * A boxed #GType corresponding to #GSettingsSchemaSource.

 *

 * Since: 2.32

 **/

G_DEFINE_BOXED_TYPE (GSettingsSchemaSource, g_settings_schema_source, g_settings_schema_source_ref, g_settings_schema_source_unref)

/**

 * G_TYPE_SETTINGS_SCHEMA:

 *

 * A boxed #GType corresponding to #GSettingsSchema.

 *

 * Since: 2.32

 **/

G_DEFINE_BOXED_TYPE (GSettingsSchema, g_settings_schema, g_settings_schema_ref, g_settings_schema_unref)

/**

 * GSettingsSchemaSource:

 *

 * This is an opaque structure type.  You may not access it directly.

 *

 * Since: 2.32

 **/

struct _GSettingsSchemaSource

{

  GSettingsSchemaSource *parent;

  gchar *directory;

  GvdbTable *table;

  GHashTable **text_tables;

  gint ref_count;

};

static GSettingsSchemaSource *schema_sources;

/**

 * g_settings_schema_source_ref:

 * @source: a #GSettingsSchemaSource

 *

 * Increase the reference count of @source, returning a new reference.

 *

 * Returns: a new reference to @source

 *

 * Since: 2.32

 **/

GSettingsSchemaSource *

g_settings_schema_source_ref (GSettingsSchemaSource *source)

{

  g_atomic_int_inc (&source->ref_count);

  return source;

}

/**

 * g_settings_schema_source_unref:

 * @source: a #GSettingsSchemaSource

 *

 * Decrease the reference count of @source, possibly freeing it.

 *

 * Since: 2.32

 **/

void

g_settings_schema_source_unref (GSettingsSchemaSource *source)

{

  if (g_atomic_int_dec_and_test (&source->ref_count))

    {

      if (source == schema_sources)

        g_error ("g_settings_schema_source_unref() called too many times on the default schema source");

      if (source->parent)

        g_settings_schema_source_unref (source->parent);

      gvdb_table_unref (source->table);

      g_free (source->directory);

      if (source->text_tables)

        {

          g_hash_table_unref (source->text_tables[0]);

          g_hash_table_unref (source->text_tables[1]);

          g_free (source->text_tables);

        }

      g_slice_free (GSettingsSchemaSource, source);

    }

}

/**

 * g_settings_schema_source_new_from_directory:

 * @directory: (type filename): the filename of a directory

 * @parent: (nullable): a #GSettingsSchemaSource, or %NULL

 * @trusted: %TRUE, if the directory is trusted

 * @error: a pointer to a #GError pointer set to %NULL, or %NULL

 *

 * Attempts to create a new schema source corresponding to the contents

 * of the given directory.

 *

 * This function is not required for normal uses of #GSettings but it

 * may be useful to authors of plugin management systems.

 *

 * The directory should contain a file called `gschemas.compiled` as

 * produced by the [glib-compile-schemas][glib-compile-schemas] tool.

 *

 * If @trusted is %TRUE then `gschemas.compiled` is trusted not to be

 * corrupted. This assumption has a performance advantage, but can result

 * in crashes or inconsistent behaviour in the case of a corrupted file.

 * Generally, you should set @trusted to %TRUE for files installed by the

 * system and to %FALSE for files in the home directory.

 *

 * If @parent is non-%NULL then there are two effects.

 *

 * First, if g_settings_schema_source_lookup() is called with the

 * @recursive flag set to %TRUE and the schema can not be found in the

 * source, the lookup will recurse to the parent.

 *

 * Second, any references to other schemas specified within this

 * source (ie: `child` or `extends`) references may be resolved

 * from the @parent.

 *

 * For this second reason, except in very unusual situations, the

 * @parent should probably be given as the default schema source, as

 * returned by g_settings_schema_source_get_default().

 *

 * Since: 2.32

 **/

GSettingsSchemaSource *

g_settings_schema_source_new_from_directory (const gchar            *directory,

                                             GSettingsSchemaSource  *parent,

                                             gboolean                trusted,

                                             GError                **error)

{

  GSettingsSchemaSource *source;

  GvdbTable *table;

  gchar *filename;

  filename = g_build_filename (directory, "gschemas.compiled", NULL);

  table = gvdb_table_new (filename, trusted, error);

  g_free (filename);

  if (table == NULL)

    return NULL;

  source = g_slice_new (GSettingsSchemaSource);

  source->directory = g_strdup (directory);

  source->parent = parent ? g_settings_schema_source_ref (parent) : NULL;

  source->text_tables = NULL;

  source->table = table;

  source->ref_count = 1;

  return source;

}

static void

try_prepend_dir (const gchar *directory)

{

  GSettingsSchemaSource *source;

  source = g_settings_schema_source_new_from_directory (directory, schema_sources, TRUE, NULL);

  /* If we successfully created it then prepend it to the global list */

  if (source != NULL)

    schema_sources = source;

}

static void

try_prepend_data_dir (const gchar *directory)

{

  gchar *dirname = g_build_filename (directory, "glib-2.0", "schemas", NULL);

  try_prepend_dir (dirname);

  g_free (dirname);

}

static void

initialise_schema_sources (void)

{

  static gsize initialised;

  /* need a separate variable because 'schema_sources' may legitimately

   * be null if we have zero valid schema sources

   */

  if G_UNLIKELY (g_once_init_enter (&initialised))

    {

      const gchar * const *dirs;

      const gchar *path;

      gint i;

      /* iterate in reverse: count up, then count down */

      dirs = g_get_system_data_dirs ();

      for (i = 0; dirs[i]; i++);

      while (i--)

        try_prepend_data_dir (dirs[i]);

      try_prepend_data_dir (g_get_user_data_dir ());

      if ((path = g_getenv ("GSETTINGS_SCHEMA_DIR")) != NULL)

        try_prepend_dir (path);

      g_once_init_leave (&initialised, TRUE);

    }

}

/**

 * g_settings_schema_source_get_default:

 *

 * Gets the default system schema source.

 *

 * This function is not required for normal uses of #GSettings but it

 * may be useful to authors of plugin management systems or to those who

 * want to introspect the content of schemas.

 *

 * If no schemas are installed, %NULL will be returned.

 *

 * The returned source may actually consist of multiple schema sources

 * from different directories, depending on which directories were given

 * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all

 * lookups performed against the default source should probably be done

 * recursively.

 *

 * Returns: (transfer none) (nullable): the default schema source

 *

 * Since: 2.32

 **/

GSettingsSchemaSource *

g_settings_schema_source_get_default (void)

{

  initialise_schema_sources ();

  return schema_sources;

}

/**

 * g_settings_schema_source_lookup:

 * @source: a #GSettingsSchemaSource

 * @schema_id: a schema ID

 * @recursive: %TRUE if the lookup should be recursive

 *

 * Looks up a schema with the identifier @schema_id in @source.

 *

 * This function is not required for normal uses of #GSettings but it

 * may be useful to authors of plugin management systems or to those who

 * want to introspect the content of schemas.

 *

 * If the schema isn't found directly in @source and @recursive is %TRUE

 * then the parent sources will also be checked.

 *

 * If the schema isn't found, %NULL is returned.

 *

 * Returns: (nullable) (transfer full): a new #GSettingsSchema

 *

 * Since: 2.32

 **/

GSettingsSchema *

g_settings_schema_source_lookup (GSettingsSchemaSource *source,

                                 const gchar           *schema_id,

                                 gboolean               recursive)

{

  GSettingsSchema *schema;

  GvdbTable *table;

  const gchar *extends;

  g_return_val_if_fail (source != NULL, NULL);

  g_return_val_if_fail (schema_id != NULL, NULL);

  table = gvdb_table_get_table (source->table, schema_id);

  if (table == NULL && recursive)

    for (source = source->parent; source; source = source->parent)

      if ((table = gvdb_table_get_table (source->table, schema_id)))

        break;

  if (table == NULL)

    return NULL;

  schema = g_slice_new0 (GSettingsSchema);

  schema->source = g_settings_schema_source_ref (source);

  schema->ref_count = 1;

  schema->id = g_strdup (schema_id);

  schema->table = table;

  schema->path = g_settings_schema_get_string (schema, ".path");

  schema->gettext_domain = g_settings_schema_get_string (schema, ".gettext-domain");

  if (schema->gettext_domain)

    bind_textdomain_codeset (schema->gettext_domain, "UTF-8");

  extends = g_settings_schema_get_string (schema, ".extends");

  if (extends)

    {

      schema->extends = g_settings_schema_source_lookup (source, extends, TRUE);

      if (schema->extends == NULL)

        g_warning ("Schema '%s' extends schema '%s' but we could not find it", schema_id, extends);

    }

  return schema;

}

typedef struct

{

  GHashTable *summaries;

  GHashTable *descriptions;

  GSList     *gettext_domain;

  GSList     *schema_id;

  GSList     *key_name;

  GString    *string;

} TextTableParseInfo;

static const gchar *

get_attribute_value (GSList *list)

{

  GSList *node;

  for (node = list; node; node = node->next)

    if (node->data)

      return node->data;

  return NULL;

}

static void

pop_attribute_value (GSList **list)

{

  gchar *top;

  top = (*list)->data;

  *list = g_slist_remove (*list, top);

  g_free (top);

}

static void

push_attribute_value (GSList      **list,

                      const gchar  *value)

{

  *list = g_slist_prepend (*list, g_strdup (value));

}

static void

start_element (GMarkupParseContext  *context,

               const gchar          *element_name,

               const gchar         **attribute_names,

               const gchar         **attribute_values,

               gpointer              user_data,

               GError              **error)

{

  TextTableParseInfo *info = user_data;

  const gchar *gettext_domain = NULL;

  const gchar *schema_id = NULL;

  const gchar *key_name = NULL;

  gint i;

  for (i = 0; attribute_names[i]; i++)

    {

      if (g_str_equal (attribute_names[i], "gettext-domain"))

        gettext_domain = attribute_values[i];

      else if (g_str_equal (attribute_names[i], "id"))

        schema_id = attribute_values[i];

      else if (g_str_equal (attribute_names[i], "name"))

        key_name = attribute_values[i];

    }

  push_attribute_value (&info->gettext_domain, gettext_domain);

  push_attribute_value (&info->schema_id, schema_id);

  push_attribute_value (&info->key_name, key_name);

  if (info->string)

    {

      g_string_free (info->string, TRUE);

      info->string = NULL;

    }

  if (g_str_equal (element_name, "summary") || g_str_equal (element_name, "description"))

    info->string = g_string_new (NULL);

}

static gchar *

normalise_whitespace (const gchar *orig)

{

  /* We normalise by the same rules as in intltool:

   *

   *   sub cleanup {

   *       s/^\s+//;

   *       s/\s+$//;

   *       s/\s+/ /g;

   *       return $_;

   *   }

   *

   *   $message = join "\n\n", map &cleanup, split/\n\s*\n+/, $message;

   *

   * Where \s is an ascii space character.

   *

   * We aim for ease of implementation over efficiency -- this code is

   * not run in normal applications.

   */

  static GRegex *cleanup[3];

  static GRegex *splitter;

  gchar **lines;

  gchar *result;

  gint i;

  if (g_once_init_enter (&splitter))

    {

      GRegex *s;

      cleanup[0] = g_regex_new ("^\\s+", 0, 0, 0);

      cleanup[1] = g_regex_new ("\\s+$", 0, 0, 0);

      cleanup[2] = g_regex_new ("\\s+", 0, 0, 0);

      s = g_regex_new ("\\n\\s*\\n+", 0, 0, 0);

      g_once_init_leave (&splitter, s);

    }

  lines = g_regex_split (splitter, orig, 0);

  for (i = 0; lines[i]; i++)

    {

      gchar *a, *b, *c;

      a = g_regex_replace_literal (cleanup[0], lines[i], -1, 0, "", 0, 0);

      b = g_regex_replace_literal (cleanup[1], a, -1, 0, "", 0, 0);

      c = g_regex_replace_literal (cleanup[2], b, -1, 0, " ", 0, 0);

      g_free (lines[i]);

      g_free (a);

      g_free (b);

      lines[i] = c;

    }

  result = g_strjoinv ("\n\n", lines);

  g_strfreev (lines);

  return result;

}

static void

end_element (GMarkupParseContext *context,

             const gchar *element_name,

             gpointer user_data,

             GError **error)

{

  TextTableParseInfo *info = user_data;

  pop_attribute_value (&info->gettext_domain);

  pop_attribute_value (&info->schema_id);

  pop_attribute_value (&info->key_name);

  if (info->string)

    {

      GHashTable *source_table = NULL;

      const gchar *gettext_domain;

      const gchar *schema_id;

      const gchar *key_name;

      gettext_domain = get_attribute_value (info->gettext_domain);

      schema_id = get_attribute_value (info->schema_id);

      key_name = get_attribute_value (info->key_name);

      if (g_str_equal (element_name, "summary"))

        source_table = info->summaries;

      else if (g_str_equal (element_name, "description"))

        source_table = info->descriptions;

      if (source_table && schema_id && key_name)

        {

          GHashTable *schema_table;

          gchar *normalised;

          schema_table = g_hash_table_lookup (source_table, schema_id);

          if (schema_table == NULL)

            {

              schema_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);

              g_hash_table_insert (source_table, g_strdup (schema_id), schema_table);

            }

          normalised = normalise_whitespace (info->string->str);

          if (gettext_domain && normalised[0])

            {

              gchar *translated;

              translated = g_strdup (g_dgettext (gettext_domain, normalised));

              g_free (normalised);

              normalised = translated;

            }

          g_hash_table_insert (schema_table, g_strdup (key_name), normalised);

        }

      g_string_free (info->string, TRUE);

      info->string = NULL;

    }

}

static void

text (GMarkupParseContext  *context,

      const gchar          *text,

      gsize                 text_len,

      gpointer              user_data,

      GError              **error)

{

  TextTableParseInfo *info = user_data;

  if (info->string)

    g_string_append_len (info->string, text, text_len);

}

static void

parse_into_text_tables (const gchar *directory,

                        GHashTable  *summaries,

                        GHashTable  *descriptions)

{

  GMarkupParser parser = { start_element, end_element, text };

  TextTableParseInfo info = { summaries, descriptions };

  const gchar *basename;

  GDir *dir;

  dir = g_dir_open (directory, 0, NULL);

  while ((basename = g_dir_read_name (dir)))

    {

      gchar *filename;

      gchar *contents;

      gsize size;

      filename = g_build_filename (directory, basename, NULL);

      if (g_file_get_contents (filename, &contents, &size, NULL))

        {

          GMarkupParseContext *context;

          context = g_markup_parse_context_new (&parser, G_MARKUP_TREAT_CDATA_AS_TEXT, &info, NULL);

          /* Ignore errors here, this is best effort only. */

          if (g_markup_parse_context_parse (context, contents, size, NULL))

            (void) g_markup_parse_context_end_parse (context, NULL);

          g_markup_parse_context_free (context);

          /* Clean up dangling stuff in case there was an error. */

          g_slist_free_full (info.gettext_domain, g_free);

          g_slist_free_full (info.schema_id, g_free);

          g_slist_free_full (info.key_name, g_free);

          info.gettext_domain = NULL;

          info.schema_id = NULL;

          info.key_name = NULL;

          if (info.string)

            {

              g_string_free (info.string, TRUE);

              info.string = NULL;

            }

          g_free (contents);

        }

      g_free (filename);

    }

  g_dir_close (dir);

}

static GHashTable **

g_settings_schema_source_get_text_tables (GSettingsSchemaSource *source)

{

  if (g_once_init_enter (&source->text_tables))

    {

      GHashTable **text_tables;

      text_tables = g_new (GHashTable *, 2);

      text_tables[0] = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_unref);

      text_tables[1] = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_unref);

      if (source->directory)

        parse_into_text_tables (source->directory, text_tables[0], text_tables[1]);

      g_once_init_leave (&source->text_tables, text_tables);

    }

  return source->text_tables;

}

/**

 * g_settings_schema_source_list_schemas:

 * @source: a #GSettingsSchemaSource

 * @recursive: if we should recurse

 * @non_relocatable: (out) (transfer full) (array zero-terminated=1): the

 *   list of non-relocatable schemas

 * @relocatable: (out) (transfer full) (array zero-terminated=1): the list

 *   of relocatable schemas

 *

 * Lists the schemas in a given source.

 *

 * If @recursive is %TRUE then include parent sources.  If %FALSE then

 * only include the schemas from one source (ie: one directory).  You

 * probably want %TRUE.

 *

 * Non-relocatable schemas are those for which you can call

 * g_settings_new().  Relocatable schemas are those for which you must

 * use g_settings_new_with_path().

 *

 * Do not call this function from normal programs.  This is designed for

 * use by database editors, commandline tools, etc.

 *

 * Since: 2.40

 **/

void

g_settings_schema_source_list_schemas (GSettingsSchemaSource   *source,

                                       gboolean                 recursive,

                                       gchar                 ***non_relocatable,

                                       gchar                 ***relocatable)

{

  GHashTable *single, *reloc;

  GSettingsSchemaSource *s;

  /* We use hash tables to avoid duplicate listings for schemas that

   * appear in more than one file.

   */

  single = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

  reloc = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

  for (s = source; s; s = s->parent)

    {

      gchar **list;

      gint i;

      list = gvdb_table_list (s->table, "");

      /* empty schema cache file? */

      if (list == NULL)

        continue;

      for (i = 0; list[i]; i++)

        {

          if (!g_hash_table_contains (single, list[i]) &&

              !g_hash_table_contains (reloc, list[i]))

            {

              gchar *schema;

              GvdbTable *table;

              schema = g_strdup (list[i]);

              table = gvdb_table_get_table (s->table, list[i]);

              g_assert (table != NULL);

              if (gvdb_table_has_value (table, ".path"))

                g_hash_table_add (single, schema);

              else

                g_hash_table_add (reloc, schema);

              gvdb_table_unref (table);

            }

        }

      g_strfreev (list);

      /* Only the first source if recursive not requested */

      if (!recursive)

        break;

    }

  if (non_relocatable)

    {

      *non_relocatable = (gchar **) g_hash_table_get_keys_as_array (single, NULL);

      g_hash_table_steal_all (single);

    }

  if (relocatable)

    {

      *relocatable = (gchar **) g_hash_table_get_keys_as_array (reloc, NULL);

      g_hash_table_steal_all (reloc);

    }

  g_hash_table_unref (single);

  g_hash_table_unref (reloc);

}

static gchar **non_relocatable_schema_list;

static gchar **relocatable_schema_list;

static gsize schema_lists_initialised;

static void

ensure_schema_lists (void)

{

  if (g_once_init_enter (&schema_lists_initialised))

    {

      initialise_schema_sources ();

      g_settings_schema_source_list_schemas (schema_sources, TRUE,

                                             &non_relocatable_schema_list,

                                             &relocatable_schema_list);

      g_once_init_leave (&schema_lists_initialised, TRUE);

    }

}

/**

 * g_settings_list_schemas:

 *

 * Deprecated.

 *

 * Returns: (element-type utf8) (transfer none):  a list of #GSettings

 *   schemas that are available.  The list must not be modified or

 *   freed.

 *

 * Since: 2.26

 *

 * Deprecated: 2.40: Use g_settings_schema_source_list_schemas() instead.

 * If you used g_settings_list_schemas() to check for the presence of

 * a particular schema, use g_settings_schema_source_lookup() instead

 * of your whole loop.

 **/

const gchar * const *

g_settings_list_schemas (void)

{

  ensure_schema_lists ();

  return (const gchar **) non_relocatable_schema_list;

}

/**

 * g_settings_list_relocatable_schemas:

 *

 * Deprecated.

 *

 * Returns: (element-type utf8) (transfer none): a list of relocatable

 *   #GSettings schemas that are available.  The list must not be