gio/gsettings-tool.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the licence, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  *
  19  * Author: Ryan Lortie <desrt@desrt.ca>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <gio/gio.h>
  25 #include <gi18n.h>
  26 #include <locale.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 static gboolean
  31 contained (const gchar * const *items,
  32            const gchar         *item)
  33 {
  34   while (*items)
  35     if (strcmp (*items++, item) == 0)
  36       return TRUE;
  37
  38   return FALSE;
  39 }
  40
  41 static gboolean
  42 is_relocatable_schema (GSettingsSchema *schema)
  43 {
  44   return g_settings_schema_get_path (schema) == NULL;
  45 }
  46
  47 static gboolean
  48 check_relocatable_schema (GSettingsSchema *schema,
  49                           const gchar     *schema_id)
  50 {
  51   if (schema == NULL)
  52     {
  53       g_printerr (_("No such schema '%s'\n"), schema_id);
  54       return FALSE;
  55     }
  56
  57   if (!is_relocatable_schema (schema))
  58     {
  59       g_printerr (_("Schema '%s' is not relocatable "
  60                     "(path must not be specified)\n"),
  61                   schema_id);
  62       return FALSE;
  63     }
  64
  65   return TRUE;
  66 }
  67
  68 static gboolean
  69 check_schema (GSettingsSchema *schema,
  70               const gchar *schema_id)
  71 {
  72   if (schema == NULL)
  73     {
  74       g_printerr (_("No such schema '%s'\n"), schema_id);
  75       return FALSE;
  76     }
  77
  78   if (is_relocatable_schema (schema))
  79     {
  80       g_printerr (_("Schema '%s' is relocatable "
  81                     "(path must be specified)\n"),
  82                   schema_id);
  83       return FALSE;
  84     }
  85
  86   return TRUE;
  87 }
  88
  89 static gboolean
  90 check_path (const gchar *path)
  91 {
  92   if (path[0] == '\0')
  93     {
  94       g_printerr (_("Empty path given.\n"));
  95       return FALSE;
  96     }
  97
  98   if (path[0] != '/')
  99     {
 100       g_printerr (_("Path must begin with a slash (/)\n"));
 101       return FALSE;
 102     }
 103
 104   if (!g_str_has_suffix (path, "/"))
 105     {
 106       g_printerr (_("Path must end with a slash (/)\n"));
 107       return FALSE;
 108     }
 109
 110   if (strstr (path, "//"))
 111     {
 112       g_printerr (_("Path must not contain two adjacent slashes (//)\n"));
 113       return FALSE;
 114     }
 115
 116   return TRUE;
 117 }
 118
 119 static gboolean
 120 check_key (GSettings   *settings,
 121            const gchar *key)
 122 {
 123   gboolean good;
 124   gchar **keys;
 125
 126   keys = g_settings_list_keys (settings);
 127   good = contained ((const gchar **) keys, key);
 128   g_strfreev (keys);
 129
 130   if (good)
 131     return TRUE;
 132
 133   g_printerr (_("No such key '%s'\n"), key);
 134
 135   return FALSE;
 136 }
 137
 138 static void
 139 output_list (const gchar * const *list)
 140 {
 141   gint i;
 142
 143   for (i = 0; list[i]; i++)
 144     g_print ("%s\n", list[i]);
 145 }
 146
 147 static void
 148 gsettings_list_schemas (GSettings   *settings,
 149                         const gchar *key,
 150                         const gchar *value)
 151 {
 152   output_list (g_settings_list_schemas ());
 153 }
 154
 155 static void
 156 gsettings_list_relocatable_schemas (GSettings   *settings,
 157                                     const gchar *key,
 158                                     const gchar *value)
 159 {
 160   output_list (g_settings_list_relocatable_schemas ());
 161 }
 162
 163 static void
 164 gsettings_list_keys (GSettings   *settings,
 165                      const gchar *key,
 166                      const gchar *value)
 167 {
 168   gchar **keys;
 169
 170   keys = g_settings_list_keys (settings);
 171   output_list ((const gchar **) keys);
 172   g_strfreev (keys);
 173 }
 174
 175 static void
 176 gsettings_list_children (GSettings   *settings,
 177                          const gchar *key,
 178                          const gchar *value)
 179 {
 180   gchar **children;
 181   gint max = 0;
 182   gint i;
 183
 184   children = g_settings_list_children (settings);
 185   for (i = 0; children[i]; i++)
 186     if (strlen (children[i]) > max)
 187       max = strlen (children[i]);
 188
 189   for (i = 0; children[i]; i++)
 190     {
 191       GSettings *child;
 192       GSettingsSchema *schema;
 193       gchar *path;
 194
 195       child = g_settings_get_child (settings, children[i]);
 196       g_object_get (child,
 197                     "settings-schema", &schema,
 198                     "path", &path,
 199                     NULL);
 200
 201       if (g_settings_schema_get_path (schema) != NULL)
 202         g_print ("%-*s   %s\n", max, children[i], g_settings_schema_get_id (schema));
 203       else
 204         g_print ("%-*s   %s:%s\n", max, children[i], g_settings_schema_get_id (schema), path);
 205
 206       g_object_unref (child);
 207       g_settings_schema_unref (schema);
 208       g_free (path);
 209     }
 210
 211   g_strfreev (children);
 212 }
 213
 214 static void
 215 enumerate (GSettings *settings)
 216 {
 217   gchar **keys;
 218   gchar *schema;
 219   gint i;
 220
 221   g_object_get (settings, "schema", &schema, NULL);
 222
 223   keys = g_settings_list_keys (settings);
 224   for (i = 0; keys[i]; i++)
 225     {
 226       GVariant *value;
 227       gchar *printed;
 228
 229       value = g_settings_get_value (settings, keys[i]);
 230       printed = g_variant_print (value, TRUE);
 231       g_print ("%s %s %s\n", schema, keys[i], printed);
 232       g_variant_unref (value);
 233       g_free (printed);
 234     }
 235
 236   g_free (schema);
 237   g_strfreev (keys);
 238 }
 239
 240 static void
 241 gsettings_list_recursively (GSettings   *settings,
 242                             const gchar *key,
 243                             const gchar *value)
 244 {
 245   if (settings)
 246     {
 247       gchar **children;
 248       gint i;
 249
 250       enumerate (settings);
 251       children = g_settings_list_children (settings);
 252       for (i = 0; children[i]; i++)
 253         {
 254           GSettings *child;
 255           GSettingsSchema *schema;
 256
 257           child = g_settings_get_child (settings, children[i]);
 258           g_object_get (child, "settings-schema", &schema, NULL);
 259
 260           enumerate (child);
 261
 262           g_object_unref (child);
 263           g_settings_schema_unref (schema);
 264         }
 265
 266       g_strfreev (children);
 267     }
 268   else
 269     {
 270       const gchar * const *schemas;
 271       gint i;
 272
 273       schemas = g_settings_list_schemas ();
 274
 275       for (i = 0; schemas[i]; i++)
 276         {
 277           settings = g_settings_new (schemas[i]);
 278           enumerate (settings);
 279           g_object_unref (settings);
 280         }
 281     }
 282 }
 283
 284 static void
 285 gsettings_range (GSettings   *settings,
 286                  const gchar *key,
 287                  const gchar *value)
 288 {
 289   GVariant *range, *detail;
 290   const gchar *type;
 291
 292   range = g_settings_get_range (settings, key);
 293   g_variant_get (range, "(&sv)", &type, &detail);
 294
 295   if (strcmp (type, "type") == 0)
 296     g_print ("type %s\n", g_variant_get_type_string (detail) + 1);
 297
 298   else if (strcmp (type, "range") == 0)
 299     {
 300       GVariant *min, *max;
 301       gchar *smin, *smax;
 302
 303       g_variant_get (detail, "(**)", &min, &max);
 304       smin = g_variant_print (min, FALSE);
 305       smax = g_variant_print (max, FALSE);
 306
 307       g_print ("range %s %s %s\n",
 308                g_variant_get_type_string (min), smin, smax);
 309       g_variant_unref (min);
 310       g_variant_unref (max);
 311       g_free (smin);
 312       g_free (smax);
 313     }
 314
 315   else if (strcmp (type, "enum") == 0 || strcmp (type, "flags") == 0)
 316     {
 317       GVariantIter iter;
 318       GVariant *item;
 319
 320       g_print ("%s\n", type);
 321
 322       g_variant_iter_init (&iter, detail);
 323       while (g_variant_iter_loop (&iter, "*", &item))
 324         {
 325           gchar *printed;
 326
 327           printed = g_variant_print (item, FALSE);
 328           g_print ("%s\n", printed);
 329           g_free (printed);
 330         }
 331     }
 332
 333   g_variant_unref (detail);
 334   g_variant_unref (range);
 335 }
 336
 337 static void
 338 gsettings_get (GSettings   *settings,
 339                const gchar *key,
 340                const gchar *value_)
 341 {
 342   GVariant *value;
 343   gchar *printed;
 344
 345   value = g_settings_get_value (settings, key);
 346   printed = g_variant_print (value, TRUE);
 347   g_print ("%s\n", printed);
 348   g_variant_unref (value);
 349   g_free (printed);
 350 }
 351
 352 static void
 353 gsettings_reset (GSettings   *settings,
 354                  const gchar *key,
 355                  const gchar *value)
 356 {
 357   g_settings_reset (settings, key);
 358   g_settings_sync ();
 359 }
 360
 361 static void
 362 reset_all_keys (GSettings   *settings)
 363 {
 364   gchar **keys;
 365   gint i;
 366
 367   keys = g_settings_list_keys (settings);
 368   for (i = 0; keys[i]; i++)
 369     {
 370       g_settings_reset (settings, keys[i]);
 371     }
 372
 373   g_strfreev (keys);
 374 }
 375
 376 static void
 377 gsettings_reset_recursively (GSettings   *settings,
 378                              const gchar *key,
 379                              const gchar *value)
 380 {
 381   gchar **children;
 382   gint i;
 383
 384   g_settings_delay (settings);
 385
 386   reset_all_keys (settings);
 387   children = g_settings_list_children (settings);
 388   for (i = 0; children[i]; i++)
 389     {
 390       GSettings *child;
 391       child = g_settings_get_child (settings, children[i]);
 392
 393       reset_all_keys (child);
 394
 395       g_object_unref (child);
 396     }
 397
 398   g_strfreev (children);
 399
 400   g_settings_apply (settings);
 401   g_settings_sync ();
 402 }
 403
 404 static void
 405 gsettings_writable (GSettings   *settings,
 406                     const gchar *key,
 407                     const gchar *value)
 408 {
 409   g_print ("%s\n",
 410            g_settings_is_writable (settings, key) ?
 411            "true" : "false");
 412 }
 413
 414 static void
 415 value_changed (GSettings   *settings,
 416                const gchar *key,
 417                gpointer     user_data)
 418 {
 419   GVariant *value;
 420   gchar *printed;
 421
 422   value = g_settings_get_value (settings, key);
 423   printed = g_variant_print (value, TRUE);
 424   g_print ("%s: %s\n", key, printed);
 425   g_variant_unref (value);
 426   g_free (printed);
 427 }
 428
 429 static void
 430 gsettings_monitor (GSettings   *settings,
 431                    const gchar *key,
 432                    const gchar *value)
 433 {
 434   if (key)
 435     {
 436       gchar *name;
 437
 438       name = g_strdup_printf ("changed::%s", key);
 439       g_signal_connect (settings, name, G_CALLBACK (value_changed), NULL);
 440     }
 441   else
 442     g_signal_connect (settings, "changed", G_CALLBACK (value_changed), NULL);
 443
 444   g_main_loop_run (g_main_loop_new (NULL, FALSE));
 445 }
 446
 447 static void
 448 gsettings_set (GSettings   *settings,
 449                const gchar *key,
 450                const gchar *value)
 451 {
 452   const GVariantType *type;
 453   GError *error = NULL;
 454   GVariant *existing;
 455   GVariant *new;
 456   gchar *freeme = NULL;
 457
 458   existing = g_settings_get_value (settings, key);
 459   type = g_variant_get_type (existing);
 460
 461   new = g_variant_parse (type, value, NULL, NULL, &error);
 462
 463   /* If that didn't work and the type is string then we should assume
 464    * that the user is just trying to set a string directly and forgot
 465    * the quotes (or had them consumed by the shell).
 466    *
 467    * If the user started with a quote then we assume that some deeper
 468    * problem is at play and we want the failure in that case.
 469    *
 470    * Consider:
 471    *
 472    *   gsettings set x.y.z key "'i don't expect this to work'"
 473    *
 474    * Note that we should not just add quotes and try parsing again, but
 475    * rather assume that the user is providing us with a bare string.
 476    * Assume we added single quotes, then consider this case:
 477    *
 478    *   gsettings set x.y.z key "i'd expect this to work"
 479    *
 480    * A similar example could be given for double quotes.
 481    *
 482    * Avoid that whole mess by just using g_variant_new_string().
 483    */
 484   if (new == NULL &&
 485       g_variant_type_equal (type, G_VARIANT_TYPE_STRING) &&
 486       value[0] != '\'' && value[0] != '"')
 487     {
 488       g_clear_error (&error);
 489       new = g_variant_new_string (value);
 490     }
 491
 492   if (new == NULL)
 493     {
 494       g_printerr ("%s\n", error->message);
 495       exit (1);
 496     }
 497
 498   if (!g_settings_range_check (settings, key, new))
 499     {
 500       g_printerr (_("The provided value is outside of the valid range\n"));
 501       g_variant_unref (new);
 502       exit (1);
 503     }
 504
 505   g_settings_set_value (settings, key, new);
 506   g_variant_unref (existing);
 507   g_variant_unref (new);
 508
 509   g_settings_sync ();
 510
 511   g_free (freeme);
 512 }
 513
 514 static int
 515 gsettings_help (gboolean     requested,
 516                 const gchar *command)
 517 {
 518   const gchar *description;
 519   const gchar *synopsis;
 520   GString *string;
 521
 522   string = g_string_new (NULL);
 523
 524   if (command == NULL)
 525     ;
 526
 527   else if (strcmp (command, "help") == 0)
 528     {
 529       description = _("Print help");
 530       synopsis = "[COMMAND]";
 531     }
 532
 533   else if (strcmp (command, "list-schemas") == 0)
 534     {
 535       description = _("List the installed (non-relocatable) schemas");
 536       synopsis = "";
 537     }
 538
 539   else if (strcmp (command, "list-relocatable-schemas") == 0)
 540     {
 541       description = _("List the installed relocatable schemas");
 542       synopsis = "";
 543     }
 544
 545   else if (strcmp (command, "list-keys") == 0)
 546     {
 547       description = _("List the keys in SCHEMA");
 548       synopsis = N_("SCHEMA[:PATH]");
 549     }
 550
 551   else if (strcmp (command, "list-children") == 0)
 552     {
 553       description = _("List the children of SCHEMA");
 554       synopsis = N_("SCHEMA[:PATH]");
 555     }
 556
 557   else if (strcmp (command, "list-recursively") == 0)
 558     {
 559       description = _("List keys and values, recursively\n"
 560                       "If no SCHEMA is given, list all keys\n");
 561       synopsis = N_("[SCHEMA[:PATH]]");
 562     }
 563
 564   else if (strcmp (command, "get") == 0)
 565     {
 566       description = _("Get the value of KEY");
 567       synopsis = N_("SCHEMA[:PATH] KEY");
 568     }
 569
 570   else if (strcmp (command, "range") == 0)
 571     {
 572       description = _("Query the range of valid values for KEY");
 573       synopsis = N_("SCHEMA[:PATH] KEY");
 574     }
 575
 576   else if (strcmp (command, "set") == 0)
 577     {
 578       description = _("Set the value of KEY to VALUE");
 579       synopsis = N_("SCHEMA[:PATH] KEY VALUE");
 580     }
 581
 582   else if (strcmp (command, "reset") == 0)
 583     {
 584       description = _("Reset KEY to its default value");
 585       synopsis = N_("SCHEMA[:PATH] KEY");
 586     }
 587
 588   else if (strcmp (command, "reset-recursively") == 0)
 589     {
 590       description = _("Reset all keys in SCHEMA to their defaults");
 591       synopsis = N_("SCHEMA[:PATH]");
 592     }
 593
 594   else if (strcmp (command, "writable") == 0)
 595     {
 596       description = _("Check if KEY is writable");
 597       synopsis = N_("SCHEMA[:PATH] KEY");
 598     }
 599
 600   else if (strcmp (command, "monitor") == 0)
 601     {
 602       description = _("Monitor KEY for changes.\n"
 603                     "If no KEY is specified, monitor all keys in SCHEMA.\n"
 604                     "Use ^C to stop monitoring.\n");
 605       synopsis = N_("SCHEMA[:PATH] [KEY]");
 606     }
 607   else
 608     {
 609       g_string_printf (string, _("Unknown command %s\n\n"), command);
 610       requested = FALSE;
 611       command = NULL;
 612     }
 613
 614   if (command == NULL)
 615     {
 616       g_string_append (string,
 617       _("Usage:\n"
 618         "  gsettings [--schemadir SCHEMADIR] COMMAND [ARGS...]\n"
 619         "\n"
 620         "Commands:\n"
 621         "  help                      Show this information\n"
 622         "  list-schemas              List installed schemas\n"
 623         "  list-relocatable-schemas  List relocatable schemas\n"
 624         "  list-keys                 List keys in a schema\n"
 625         "  list-children             List children of a schema\n"
 626         "  list-recursively          List keys and values, recursively\n"
 627         "  range                     Queries the range of a key\n"
 628         "  get                       Get the value of a key\n"
 629         "  set                       Set the value of a key\n"
 630         "  reset                     Reset the value of a key\n"
 631         "  reset-recursively         Reset all values in a given schema\n"
 632         "  writable                  Check if a key is writable\n"
 633         "  monitor                   Watch for changes\n"
 634         "\n"
 635         "Use 'gsettings help COMMAND' to get detailed help.\n\n"));
 636     }
 637   else
 638     {
 639       g_string_append_printf (string, _("Usage:\n  gsettings [--schemadir SCHEMADIR] %s %s\n\n%s\n\n"),
 640                               command, synopsis[0] ? _(synopsis) : "", description);
 641
 642       g_string_append (string, _("Arguments:\n"));
 643
 644       g_string_append (string,
 645                        _("  SCHEMADIR A directory to search for additional schemas\n"));
 646
 647       if (strstr (synopsis, "[COMMAND]"))
 648         g_string_append (string,
 649                        _("  COMMAND   The (optional) command to explain\n"));
 650
 651       else if (strstr (synopsis, "SCHEMA"))
 652         g_string_append (string,
 653                        _("  SCHEMA    The name of the schema\n"
 654                          "  PATH      The path, for relocatable schemas\n"));
 655
 656       if (strstr (synopsis, "[KEY]"))
 657         g_string_append (string,
 658                        _("  KEY       The (optional) key within the schema\n"));
 659
 660       else if (strstr (synopsis, "KEY"))
 661         g_string_append (string,
 662                        _("  KEY       The key within the schema\n"));
 663
 664       if (strstr (synopsis, "VALUE"))
 665         g_string_append (string,
 666                        _("  VALUE     The value to set\n"));
 667
 668       g_string_append (string, "\n");
 669     }
 670
 671   if (requested)
 672     g_print ("%s", string->str);
 673   else
 674     g_printerr ("%s\n", string->str);
 675
 676   g_string_free (string, TRUE);
 677
 678   return requested ? 0 : 1;
 679 }
 680
 681
 682 int
 683 main (int argc, char **argv)
 684 {
 685   void (* function) (GSettings *, const gchar *, const gchar *);
 686   GSettingsSchemaSource *schema_source;
 687   GSettingsSchema *schema;
 688   GSettings *settings;
 689   const gchar *key;
 690
 691 #ifdef G_OS_WIN32
 692   extern gchar *_glib_get_locale_dir (void);
 693   gchar *tmp;
 694 #endif
 695
 696   setlocale (LC_ALL, "");
 697   textdomain (GETTEXT_PACKAGE);
 698
 699 #ifdef G_OS_WIN32
 700   tmp = _glib_get_locale_dir ();
 701   bindtextdomain (GETTEXT_PACKAGE, tmp);
 702   g_free (tmp);
 703 #else
 704   bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR);
 705 #endif
 706
 707 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
 708   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 709 #endif
 710
 711   if (argc < 2)
 712     return gsettings_help (FALSE, NULL);
 713
 714   schema_source = g_settings_schema_source_ref (g_settings_schema_source_get_default ());
 715
 716   if (argc > 3 && g_str_equal (argv[1], "--schemadir"))
 717     {
 718       GSettingsSchemaSource *parent = schema_source;
 719       GError *error = NULL;
 720
 721       schema_source = g_settings_schema_source_new_from_directory (argv[2], parent, FALSE, &error);
 722       g_settings_schema_source_unref (parent);
 723
 724       if (schema_source == NULL)
 725         {
 726           g_printerr ("Could not load schemas from %s: %s\n", argv[2], error->message);
 727           g_clear_error (&error);
 728
 729           return 1;
 730         }
 731
 732       /* shift remaining arguments (not correct wrt argv[0], but doesn't matter) */
 733       argv = argv + 2;
 734       argc -= 2;
 735     }
 736
 737   if (strcmp (argv[1], "help") == 0)
 738     return gsettings_help (TRUE, argv[2]);
 739
 740   else if (argc == 2 && strcmp (argv[1], "list-schemas") == 0)
 741     function = gsettings_list_schemas;
 742
 743   else if (argc == 2 && strcmp (argv[1], "list-relocatable-schemas") == 0)
 744     function = gsettings_list_relocatable_schemas;
 745
 746   else if (argc == 3 && strcmp (argv[1], "list-keys") == 0)
 747     function = gsettings_list_keys;
 748
 749   else if (argc == 3 && strcmp (argv[1], "list-children") == 0)
 750     function = gsettings_list_children;
 751
 752   else if ((argc == 2 || argc == 3) && strcmp (argv[1], "list-recursively") == 0)
 753     function = gsettings_list_recursively;
 754
 755   else if (argc == 4 && strcmp (argv[1], "range") == 0)
 756     function = gsettings_range;
 757
 758   else if (argc == 4 && strcmp (argv[1], "get") == 0)
 759     function = gsettings_get;
 760
 761   else if (argc == 5 && strcmp (argv[1], "set") == 0)
 762     function = gsettings_set;
 763
 764   else if (argc == 4 && strcmp (argv[1], "reset") == 0)
 765     function = gsettings_reset;
 766
 767   else if (argc == 3 && strcmp (argv[1], "reset-recursively") == 0)
 768     function = gsettings_reset_recursively;
 769
 770   else if (argc == 4 && strcmp (argv[1], "writable") == 0)
 771     function = gsettings_writable;
 772
 773   else if ((argc == 3 || argc == 4) && strcmp (argv[1], "monitor") == 0)
 774     function = gsettings_monitor;
 775
 776   else
 777     return gsettings_help (FALSE, argv[1]);
 778
 779   g_type_init ();
 780
 781   if (argc > 2)
 782     {
 783       gchar **parts;
 784
 785       if (argv[2][0] == '\0')
 786         {
 787           g_printerr (_("Empty schema name given\n"));
 788           return 1;
 789         }
 790
 791       parts = g_strsplit (argv[2], ":", 2);
 792
 793       schema = g_settings_schema_source_lookup (schema_source, parts[0], TRUE);
 794       if (parts[1])
 795         {
 796           if (!check_relocatable_schema (schema, parts[0]) || !check_path (parts[1]))
 797             return 1;
 798
 799           settings = g_settings_new_full (schema, NULL, parts[1]);
 800         }
 801       else
 802         {
 803           if (!check_schema (schema, parts[0]))
 804             return 1;
 805
 806           settings = g_settings_new_full (schema, NULL, NULL);
 807         }
 808
 809       g_strfreev (parts);
 810     }
 811   else
 812     {
 813       settings = NULL;
 814       schema = NULL;
 815     }
 816
 817   if (argc > 3)
 818     {
 819       if (!check_key (settings, argv[3]))
 820         return 1;
 821
 822       key = argv[3];
 823     }
 824   else
 825     key = NULL;
 826
 827   (* function) (settings, key, argc > 4 ? argv[4] : NULL);
 828
 829   if (settings != NULL)
 830     g_object_unref (settings);
 831   if (schema != NULL)
 832     g_settings_schema_unref (schema);
 833
 834   g_settings_schema_source_unref (schema_source);
 835
 836   return 0;
 837 }