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