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