| /* GDBus - GLib D-Bus Library | |
| * | |
| * Copyright (C) 2008-2010 Red Hat, Inc. | |
| * | |
| * SPDX-License-Identifier: LGPL-2.1-or-later | |
| * | |
| * 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/>. | |
| * | |
| * Author: David Zeuthen <davidz@redhat.com> | |
| */ | |
| #include "config.h" | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <stdio.h> | |
| #include <locale.h> | |
| #include <gio/gio.h> | |
| #ifdef G_OS_UNIX | |
| #include <gio/gunixfdlist.h> | |
| #endif | |
| #include <gi18n.h> | |
| #ifdef G_OS_WIN32 | |
| #include "glib/glib-private.h" | |
| #endif | |
| #include "gdbusprivate.h" | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| /* Escape values for console colors */ | |
| #define UNDERLINE "\033[4m" | |
| #define BLUE "\033[34m" | |
| #define CYAN "\033[36m" | |
| #define GREEN "\033[32m" | |
| #define MAGENTA "\033[35m" | |
| #define RED "\033[31m" | |
| #define YELLOW "\033[33m" | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| G_GNUC_UNUSED static void completion_debug (const gchar *format, ...); | |
| /* Uncomment to get debug traces in /tmp/gdbus-completion-debug.txt (nice | |
| * to not have it interfere with stdout/stderr) | |
| */ | |
| #if 0 | |
| G_GNUC_UNUSED static void | |
| completion_debug (const gchar *format, ...) | |
| { | |
| va_list var_args; | |
| gchar *s; | |
| static FILE *f = NULL; | |
| va_start (var_args, format); | |
| s = g_strdup_vprintf (format, var_args); | |
| if (f == NULL) | |
| { | |
| f = fopen ("/tmp/gdbus-completion-debug.txt", "a+"); | |
| } | |
| fprintf (f, "%s\n", s); | |
| g_free (s); | |
| } | |
| #else | |
| static void | |
| completion_debug (const gchar *format, ...) | |
| { | |
| } | |
| #endif | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static void | |
| remove_arg (gint num, gint *argc, gchar **argv[]) | |
| { | |
| gint n; | |
| g_assert (num <= (*argc)); | |
| for (n = num; (*argv)[n] != NULL; n++) | |
| (*argv)[n] = (*argv)[n+1]; | |
| (*argv)[n] = NULL; | |
| (*argc) = (*argc) - 1; | |
| } | |
| static void | |
| usage (gint *argc, gchar **argv[], gboolean use_stdout) | |
| { | |
| GOptionContext *o; | |
| gchar *s; | |
| gchar *program_name; | |
| o = g_option_context_new (_("COMMAND")); | |
| g_option_context_set_help_enabled (o, FALSE); | |
| /* Ignore parsing result */ | |
| g_option_context_parse (o, argc, argv, NULL); | |
| program_name = (*argc > 0) ? g_path_get_basename ((*argv)[0]) : g_strdup ("gdbus-tool"); | |
| s = g_strdup_printf (_("Commands:\n" | |
| " help Shows this information\n" | |
| " introspect Introspect a remote object\n" | |
| " monitor Monitor a remote object\n" | |
| " call Invoke a method on a remote object\n" | |
| " emit Emit a signal\n" | |
| " wait Wait for a bus name to appear\n" | |
| "\n" | |
| "Use “%s COMMAND --help” to get help on each command.\n"), | |
| program_name); | |
| g_free (program_name); | |
| g_option_context_set_description (o, s); | |
| g_free (s); | |
| s = g_option_context_get_help (o, FALSE, NULL); | |
| if (use_stdout) | |
| g_print ("%s", s); | |
| else | |
| g_printerr ("%s", s); | |
| g_free (s); | |
| g_option_context_free (o); | |
| } | |
| static void | |
| modify_argv0_for_command (gint *argc, gchar **argv[], const gchar *command) | |
| { | |
| gchar *s; | |
| gchar *program_name; | |
| /* TODO: | |
| * 1. get a g_set_prgname() ?; or | |
| * 2. save old argv[0] and restore later | |
| */ | |
| g_assert (*argc > 1); | |
| g_assert (g_strcmp0 ((*argv)[1], command) == 0); | |
| remove_arg (1, argc, argv); | |
| program_name = g_path_get_basename ((*argv)[0]); | |
| s = g_strdup_printf ("%s %s", program_name, command); | |
| (*argv)[0] = s; | |
| g_free (program_name); | |
| } | |
| static GOptionContext * | |
| command_option_context_new (const gchar *parameter_string, | |
| const gchar *summary, | |
| const GOptionEntry *entries, | |
| gboolean request_completion) | |
| { | |
| GOptionContext *o = NULL; | |
| o = g_option_context_new (parameter_string); | |
| if (request_completion) | |
| g_option_context_set_ignore_unknown_options (o, TRUE); | |
| g_option_context_set_help_enabled (o, FALSE); | |
| g_option_context_set_summary (o, summary); | |
| g_option_context_add_main_entries (o, entries, GETTEXT_PACKAGE); | |
| return g_steal_pointer (&o); | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static void | |
| print_methods_and_signals (GDBusConnection *c, | |
| const gchar *name, | |
| const gchar *path, | |
| gboolean print_methods, | |
| gboolean print_signals) | |
| { | |
| GVariant *result; | |
| GError *error; | |
| const gchar *xml_data; | |
| GDBusNodeInfo *node; | |
| guint n; | |
| guint m; | |
| error = NULL; | |
| result = g_dbus_connection_call_sync (c, | |
| name, | |
| path, | |
| DBUS_INTERFACE_INTROSPECTABLE, | |
| "Introspect", | |
| NULL, | |
| G_VARIANT_TYPE ("(s)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, /* 3 secs */ | |
| NULL, | |
| &error); | |
| if (result == NULL) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| g_variant_get (result, "(&s)", &xml_data); | |
| error = NULL; | |
| node = g_dbus_node_info_new_for_xml (xml_data, &error); | |
| g_variant_unref (result); | |
| if (node == NULL) | |
| { | |
| g_printerr (_("Error parsing introspection XML: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| for (n = 0; node->interfaces != NULL && node->interfaces[n] != NULL; n++) | |
| { | |
| const GDBusInterfaceInfo *iface = node->interfaces[n]; | |
| for (m = 0; print_methods && iface->methods != NULL && iface->methods[m] != NULL; m++) | |
| { | |
| const GDBusMethodInfo *method = iface->methods[m]; | |
| g_print ("%s.%s \n", iface->name, method->name); | |
| } | |
| for (m = 0; print_signals && iface->signals != NULL && iface->signals[m] != NULL; m++) | |
| { | |
| const GDBusSignalInfo *signal = iface->signals[m]; | |
| g_print ("%s.%s \n", iface->name, signal->name); | |
| } | |
| } | |
| g_dbus_node_info_unref (node); | |
| out: | |
| ; | |
| } | |
| static void | |
| print_paths (GDBusConnection *c, | |
| const gchar *name, | |
| const gchar *path) | |
| { | |
| GVariant *result; | |
| GError *error; | |
| const gchar *xml_data; | |
| GDBusNodeInfo *node; | |
| guint n; | |
| if (!g_dbus_is_name (name)) | |
| { | |
| g_printerr (_("Error: %s is not a valid name\n"), name); | |
| goto out; | |
| } | |
| if (!g_variant_is_object_path (path)) | |
| { | |
| g_printerr (_("Error: %s is not a valid object path\n"), path); | |
| goto out; | |
| } | |
| error = NULL; | |
| result = g_dbus_connection_call_sync (c, | |
| name, | |
| path, | |
| DBUS_INTERFACE_INTROSPECTABLE, | |
| "Introspect", | |
| NULL, | |
| G_VARIANT_TYPE ("(s)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, /* 3 secs */ | |
| NULL, | |
| &error); | |
| if (result == NULL) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| g_variant_get (result, "(&s)", &xml_data); | |
| //g_printerr ("xml='%s'", xml_data); | |
| error = NULL; | |
| node = g_dbus_node_info_new_for_xml (xml_data, &error); | |
| g_variant_unref (result); | |
| if (node == NULL) | |
| { | |
| g_printerr (_("Error parsing introspection XML: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| //g_printerr ("bar '%s'\n", path); | |
| if (node->interfaces != NULL) | |
| g_print ("%s \n", path); | |
| for (n = 0; node->nodes != NULL && node->nodes[n] != NULL; n++) | |
| { | |
| gchar *s; | |
| //g_printerr ("foo '%s'\n", node->nodes[n].path); | |
| if (g_strcmp0 (path, "/") == 0) | |
| s = g_strdup_printf ("/%s", node->nodes[n]->path); | |
| else | |
| s = g_strdup_printf ("%s/%s", path, node->nodes[n]->path); | |
| print_paths (c, name, s); | |
| g_free (s); | |
| } | |
| g_dbus_node_info_unref (node); | |
| out: | |
| ; | |
| } | |
| static void | |
| print_names (GDBusConnection *c, | |
| gboolean include_unique_names) | |
| { | |
| GVariant *result; | |
| GError *error; | |
| GVariantIter *iter; | |
| gchar *str; | |
| GHashTable *name_set; | |
| GPtrArray *keys; | |
| name_set = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); | |
| error = NULL; | |
| result = g_dbus_connection_call_sync (c, | |
| DBUS_SERVICE_DBUS, | |
| DBUS_PATH_DBUS, | |
| DBUS_INTERFACE_DBUS, | |
| "ListNames", | |
| NULL, | |
| G_VARIANT_TYPE ("(as)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, /* 3 secs */ | |
| NULL, | |
| &error); | |
| if (result == NULL) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| g_variant_get (result, "(as)", &iter); | |
| while (g_variant_iter_loop (iter, "s", &str)) | |
| g_hash_table_add (name_set, g_strdup (str)); | |
| g_variant_iter_free (iter); | |
| g_variant_unref (result); | |
| error = NULL; | |
| result = g_dbus_connection_call_sync (c, | |
| DBUS_SERVICE_DBUS, | |
| DBUS_PATH_DBUS, | |
| DBUS_INTERFACE_DBUS, | |
| "ListActivatableNames", | |
| NULL, | |
| G_VARIANT_TYPE ("(as)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, /* 3 secs */ | |
| NULL, | |
| &error); | |
| if (result == NULL) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| g_variant_get (result, "(as)", &iter); | |
| while (g_variant_iter_loop (iter, "s", &str)) | |
| g_hash_table_add (name_set, g_strdup (str)); | |
| g_variant_iter_free (iter); | |
| g_variant_unref (result); | |
| keys = g_hash_table_steal_all_keys (name_set); | |
| g_ptr_array_sort_values (keys, (GCompareFunc) g_strcmp0); | |
| for (guint i = 0; i < keys->len; ++i) | |
| { | |
| const gchar *name = g_ptr_array_index (keys, i); | |
| if (!include_unique_names && g_str_has_prefix (name, ":")) | |
| continue; | |
| g_print ("%s \n", name); | |
| } | |
| g_clear_pointer (&keys, g_ptr_array_unref); | |
| out: | |
| g_hash_table_unref (name_set); | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gboolean opt_connection_system = FALSE; | |
| static gboolean opt_connection_session = FALSE; | |
| static gchar *opt_connection_address = NULL; | |
| static const GOptionEntry connection_entries[] = | |
| { | |
| { "system", 'y', 0, G_OPTION_ARG_NONE, &opt_connection_system, N_("Connect to the system bus"), NULL}, | |
| { "session", 'e', 0, G_OPTION_ARG_NONE, &opt_connection_session, N_("Connect to the session bus"), NULL}, | |
| { "address", 'a', 0, G_OPTION_ARG_STRING, &opt_connection_address, N_("Connect to given D-Bus address"), N_("ADDRESS") }, | |
| G_OPTION_ENTRY_NULL | |
| }; | |
| static GOptionGroup * | |
| connection_get_group (void) | |
| { | |
| static GOptionGroup *g; | |
| g = g_option_group_new ("connection", | |
| N_("Connection Endpoint Options:"), | |
| N_("Options specifying the connection endpoint"), | |
| NULL, | |
| NULL); | |
| g_option_group_set_translation_domain (g, GETTEXT_PACKAGE); | |
| g_option_group_add_entries (g, connection_entries); | |
| return g; | |
| } | |
| static GDBusConnection * | |
| connection_get_dbus_connection (gboolean require_message_bus, | |
| GError **error) | |
| { | |
| GDBusConnection *c; | |
| c = NULL; | |
| /* First, ensure we have exactly one connect */ | |
| if (!opt_connection_system && !opt_connection_session && opt_connection_address == NULL) | |
| { | |
| g_set_error (error, | |
| G_IO_ERROR, | |
| G_IO_ERROR_FAILED, | |
| _("No connection endpoint specified")); | |
| goto out; | |
| } | |
| else if ((opt_connection_system && (opt_connection_session || opt_connection_address != NULL)) || | |
| (opt_connection_session && (opt_connection_system || opt_connection_address != NULL)) || | |
| (opt_connection_address != NULL && (opt_connection_system || opt_connection_session))) | |
| { | |
| g_set_error (error, | |
| G_IO_ERROR, | |
| G_IO_ERROR_FAILED, | |
| _("Multiple connection endpoints specified")); | |
| goto out; | |
| } | |
| if (opt_connection_system) | |
| { | |
| c = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, error); | |
| } | |
| else if (opt_connection_session) | |
| { | |
| c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, error); | |
| } | |
| else if (opt_connection_address != NULL) | |
| { | |
| GDBusConnectionFlags flags = G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT; | |
| if (require_message_bus) | |
| flags |= G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION; | |
| c = g_dbus_connection_new_for_address_sync (opt_connection_address, | |
| flags, | |
| NULL, /* GDBusAuthObserver */ | |
| NULL, /* GCancellable */ | |
| error); | |
| } | |
| out: | |
| return c; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static GPtrArray * | |
| call_helper_get_method_in_signature (GDBusConnection *c, | |
| const gchar *dest, | |
| const gchar *path, | |
| const gchar *interface_name, | |
| const gchar *method_name, | |
| GError **error) | |
| { | |
| GPtrArray *ret; | |
| GVariant *result; | |
| GDBusNodeInfo *node_info; | |
| const gchar *xml_data; | |
| GDBusInterfaceInfo *interface_info; | |
| GDBusMethodInfo *method_info; | |
| guint n; | |
| ret = NULL; | |
| result = NULL; | |
| node_info = NULL; | |
| result = g_dbus_connection_call_sync (c, | |
| dest, | |
| path, | |
| DBUS_INTERFACE_INTROSPECTABLE, | |
| "Introspect", | |
| NULL, | |
| G_VARIANT_TYPE ("(s)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, /* 3 secs */ | |
| NULL, | |
| error); | |
| if (result == NULL) | |
| goto out; | |
| g_variant_get (result, "(&s)", &xml_data); | |
| node_info = g_dbus_node_info_new_for_xml (xml_data, error); | |
| if (node_info == NULL) | |
| goto out; | |
| interface_info = g_dbus_node_info_lookup_interface (node_info, interface_name); | |
| if (interface_info == NULL) | |
| { | |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, | |
| _("Warning: According to introspection data, interface “%s” does not exist\n"), | |
| interface_name); | |
| goto out; | |
| } | |
| method_info = g_dbus_interface_info_lookup_method (interface_info, method_name); | |
| if (method_info == NULL) | |
| { | |
| g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, | |
| _("Warning: According to introspection data, method “%s” does not exist on interface “%s”\n"), | |
| method_name, | |
| interface_name); | |
| goto out; | |
| } | |
| ret = g_ptr_array_new_with_free_func ((GDestroyNotify) g_variant_type_free); | |
| for (n = 0; method_info->in_args != NULL && method_info->in_args[n] != NULL; n++) | |
| { | |
| g_ptr_array_add (ret, g_variant_type_new (method_info->in_args[n]->signature)); | |
| } | |
| out: | |
| if (node_info != NULL) | |
| g_dbus_node_info_unref (node_info); | |
| if (result != NULL) | |
| g_variant_unref (result); | |
| return ret; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static GVariant * | |
| _g_variant_parse_me_harder (GVariantType *type, | |
| const gchar *given_str, | |
| GError **error) | |
| { | |
| GVariant *value; | |
| gchar *s; | |
| guint n; | |
| GString *str; | |
| str = g_string_new ("\""); | |
| for (n = 0; given_str[n] != '\0'; n++) | |
| { | |
| if (G_UNLIKELY (given_str[n] == '\"')) | |
| g_string_append (str, "\\\""); | |
| else | |
| g_string_append_c (str, given_str[n]); | |
| } | |
| g_string_append_c (str, '"'); | |
| s = g_string_free (str, FALSE); | |
| value = g_variant_parse (type, | |
| s, | |
| NULL, | |
| NULL, | |
| error); | |
| g_free (s); | |
| return value; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gchar *opt_emit_dest = NULL; | |
| static gchar *opt_emit_object_path = NULL; | |
| static gchar *opt_emit_signal = NULL; | |
| static const GOptionEntry emit_entries[] = | |
| { | |
| { "dest", 'd', 0, G_OPTION_ARG_STRING, &opt_emit_dest, N_("Optional destination for signal (unique name)"), NULL}, | |
| { "object-path", 'o', 0, G_OPTION_ARG_STRING, &opt_emit_object_path, N_("Object path to emit signal on"), NULL}, | |
| { "signal", 's', 0, G_OPTION_ARG_STRING, &opt_emit_signal, N_("Signal and interface name"), NULL}, | |
| G_OPTION_ENTRY_NULL | |
| }; | |
| static gboolean | |
| handle_emit (gint *argc, | |
| gchar **argv[], | |
| gboolean request_completion, | |
| const gchar *completion_cur, | |
| const gchar *completion_prev) | |
| { | |
| gint ret; | |
| GOptionContext *o; | |
| gchar *s; | |
| GError *error; | |
| GDBusConnection *c; | |
| GVariant *parameters; | |
| gchar *interface_name; | |
| gchar *signal_name; | |
| GVariantBuilder builder; | |
| gboolean skip_dashes; | |
| guint parm; | |
| guint n; | |
| gboolean complete_names, complete_paths, complete_signals; | |
| ret = FALSE; | |
| c = NULL; | |
| parameters = NULL; | |
| interface_name = NULL; | |
| signal_name = NULL; | |
| modify_argv0_for_command (argc, argv, "emit"); | |
| o = command_option_context_new (NULL, _("Emit a signal."), | |
| emit_entries, request_completion); | |
| g_option_context_add_group (o, connection_get_group ()); | |
| complete_names = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--dest") == 0) | |
| { | |
| complete_names = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| complete_paths = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--object-path") == 0) | |
| { | |
| complete_paths = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| complete_signals = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--signal") == 0) | |
| { | |
| complete_signals = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| if (!g_option_context_parse (o, argc, argv, NULL)) | |
| { | |
| if (!request_completion) | |
| { | |
| s = g_option_context_get_help (o, FALSE, NULL); | |
| g_printerr ("%s", s); | |
| g_free (s); | |
| goto out; | |
| } | |
| } | |
| error = NULL; | |
| c = connection_get_dbus_connection ((opt_emit_dest != NULL), &error); | |
| if (c == NULL) | |
| { | |
| if (request_completion) | |
| { | |
| if (g_strcmp0 (completion_prev, "--address") == 0) | |
| { | |
| g_print ("unix:\n" | |
| "tcp:\n" | |
| "nonce-tcp:\n"); | |
| } | |
| else | |
| { | |
| g_print ("--system \n--session \n--address \n"); | |
| } | |
| } | |
| else | |
| { | |
| g_printerr (_("Error connecting: %s\n"), error->message); | |
| } | |
| g_error_free (error); | |
| goto out; | |
| } | |
| /* validate and complete destination (bus name) */ | |
| if (complete_names) | |
| { | |
| print_names (c, FALSE); | |
| goto out; | |
| } | |
| if (request_completion && opt_emit_dest != NULL && g_strcmp0 ("--dest", completion_prev) == 0) | |
| { | |
| print_names (c, g_str_has_prefix (opt_emit_dest, ":")); | |
| goto out; | |
| } | |
| if (!request_completion && opt_emit_dest != NULL && !g_dbus_is_unique_name (opt_emit_dest)) | |
| { | |
| g_printerr (_("Error: %s is not a valid unique bus name.\n"), opt_emit_dest); | |
| goto out; | |
| } | |
| if (opt_emit_dest == NULL && opt_emit_object_path == NULL && request_completion) | |
| { | |
| g_print ("--dest \n"); | |
| } | |
| /* validate and complete object path */ | |
| if (opt_emit_dest != NULL && complete_paths) | |
| { | |
| print_paths (c, opt_emit_dest, "/"); | |
| goto out; | |
| } | |
| if (opt_emit_object_path == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--object-path \n"); | |
| else | |
| g_printerr (_("Error: Object path is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--object-path", completion_prev) == 0) | |
| { | |
| if (opt_emit_dest != NULL) | |
| { | |
| gchar *p; | |
| s = g_strdup (opt_emit_object_path); | |
| p = strrchr (s, '/'); | |
| if (p != NULL) | |
| { | |
| if (p == s) | |
| p++; | |
| *p = '\0'; | |
| } | |
| print_paths (c, opt_emit_dest, s); | |
| g_free (s); | |
| } | |
| goto out; | |
| } | |
| if (!request_completion && !g_variant_is_object_path (opt_emit_object_path)) | |
| { | |
| g_printerr (_("Error: %s is not a valid object path\n"), opt_emit_object_path); | |
| goto out; | |
| } | |
| /* validate and complete signal (interface + signal name) */ | |
| if (opt_emit_dest != NULL && opt_emit_object_path != NULL && complete_signals) | |
| { | |
| print_methods_and_signals (c, opt_emit_dest, opt_emit_object_path, FALSE, TRUE); | |
| goto out; | |
| } | |
| if (opt_emit_signal == NULL) | |
| { | |
| /* don't keep repeatedly completing --signal */ | |
| if (request_completion) | |
| { | |
| if (g_strcmp0 ("--signal", completion_prev) != 0) | |
| g_print ("--signal \n"); | |
| } | |
| else | |
| { | |
| g_printerr (_("Error: Signal name is not specified\n")); | |
| } | |
| goto out; | |
| } | |
| if (request_completion && opt_emit_dest != NULL && opt_emit_object_path != NULL && | |
| g_strcmp0 ("--signal", completion_prev) == 0) | |
| { | |
| print_methods_and_signals (c, opt_emit_dest, opt_emit_object_path, FALSE, TRUE); | |
| goto out; | |
| } | |
| s = strrchr (opt_emit_signal, '.'); | |
| if (!request_completion && s == NULL) | |
| { | |
| g_printerr (_("Error: Signal name “%s” is invalid\n"), opt_emit_signal); | |
| goto out; | |
| } | |
| signal_name = g_strdup (s + 1); | |
| interface_name = g_strndup (opt_emit_signal, s - opt_emit_signal); | |
| /* All done with completion now */ | |
| if (request_completion) | |
| goto out; | |
| if (!g_dbus_is_interface_name (interface_name)) | |
| { | |
| g_printerr (_("Error: %s is not a valid interface name\n"), interface_name); | |
| goto out; | |
| } | |
| if (!g_dbus_is_member_name (signal_name)) | |
| { | |
| g_printerr (_("Error: %s is not a valid member name\n"), signal_name); | |
| goto out; | |
| } | |
| /* Read parameters */ | |
| g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE); | |
| skip_dashes = TRUE; | |
| parm = 0; | |
| for (n = 1; n < (guint) *argc; n++) | |
| { | |
| GVariant *value; | |
| /* Under certain conditions, g_option_context_parse returns the "--" | |
| itself (setting off unparsed arguments), too: */ | |
| if (skip_dashes && g_strcmp0 ((*argv)[n], "--") == 0) | |
| { | |
| skip_dashes = FALSE; | |
| continue; | |
| } | |
| error = NULL; | |
| value = g_variant_parse (NULL, | |
| (*argv)[n], | |
| NULL, | |
| NULL, | |
| &error); | |
| if (value == NULL) | |
| { | |
| gchar *context; | |
| context = g_variant_parse_error_print_context (error, (*argv)[n]); | |
| g_error_free (error); | |
| error = NULL; | |
| value = _g_variant_parse_me_harder (NULL, (*argv)[n], &error); | |
| if (value == NULL) | |
| { | |
| /* Use the original non-"parse-me-harder" error */ | |
| g_printerr (_("Error parsing parameter %d: %s\n"), | |
| parm + 1, | |
| context); | |
| g_error_free (error); | |
| g_free (context); | |
| g_variant_builder_clear (&builder); | |
| goto out; | |
| } | |
| g_free (context); | |
| } | |
| g_variant_builder_add_value (&builder, value); | |
| ++parm; | |
| } | |
| parameters = g_variant_builder_end (&builder); | |
| if (parameters != NULL) | |
| parameters = g_variant_ref_sink (parameters); | |
| if (!g_dbus_connection_emit_signal (c, | |
| opt_emit_dest, | |
| opt_emit_object_path, | |
| interface_name, | |
| signal_name, | |
| parameters, | |
| &error)) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| if (!g_dbus_connection_flush_sync (c, NULL, &error)) | |
| { | |
| g_printerr (_("Error flushing connection: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| ret = TRUE; | |
| out: | |
| if (c != NULL) | |
| g_object_unref (c); | |
| if (parameters != NULL) | |
| g_variant_unref (parameters); | |
| g_free (interface_name); | |
| g_free (signal_name); | |
| g_option_context_free (o); | |
| return ret; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gchar *opt_call_dest = NULL; | |
| static gchar *opt_call_object_path = NULL; | |
| static gchar *opt_call_method = NULL; | |
| static gint opt_call_timeout = -1; | |
| static gboolean opt_call_interactive = FALSE; | |
| static const GOptionEntry call_entries[] = | |
| { | |
| { "dest", 'd', 0, G_OPTION_ARG_STRING, &opt_call_dest, N_("Destination name to invoke method on"), NULL}, | |
| { "object-path", 'o', 0, G_OPTION_ARG_STRING, &opt_call_object_path, N_("Object path to invoke method on"), NULL}, | |
| { "method", 'm', 0, G_OPTION_ARG_STRING, &opt_call_method, N_("Method and interface name"), NULL}, | |
| { "timeout", 't', 0, G_OPTION_ARG_INT, &opt_call_timeout, N_("Timeout in seconds"), NULL}, | |
| { "interactive", 'i', 0, G_OPTION_ARG_NONE, &opt_call_interactive, N_("Allow interactive authorization"), NULL}, | |
| G_OPTION_ENTRY_NULL | |
| }; | |
| static gboolean | |
| handle_call (gint *argc, | |
| gchar **argv[], | |
| gboolean request_completion, | |
| const gchar *completion_cur, | |
| const gchar *completion_prev) | |
| { | |
| gint ret; | |
| GOptionContext *o; | |
| gchar *s; | |
| GError *error; | |
| GDBusConnection *c; | |
| GVariant *parameters; | |
| gchar *interface_name; | |
| gchar *method_name; | |
| GVariant *result; | |
| GPtrArray *in_signature_types; | |
| #ifdef G_OS_UNIX | |
| GUnixFDList *fd_list; | |
| gint fd_id; | |
| #endif | |
| gboolean complete_names; | |
| gboolean complete_paths; | |
| gboolean complete_methods; | |
| GVariantBuilder builder; | |
| gboolean skip_dashes; | |
| guint parm; | |
| guint n; | |
| GDBusCallFlags flags; | |
| ret = FALSE; | |
| c = NULL; | |
| parameters = NULL; | |
| interface_name = NULL; | |
| method_name = NULL; | |
| result = NULL; | |
| in_signature_types = NULL; | |
| #ifdef G_OS_UNIX | |
| fd_list = NULL; | |
| #endif | |
| modify_argv0_for_command (argc, argv, "call"); | |
| o = command_option_context_new (NULL, _("Invoke a method on a remote object."), | |
| call_entries, request_completion); | |
| g_option_context_add_group (o, connection_get_group ()); | |
| complete_names = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--dest") == 0) | |
| { | |
| complete_names = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| complete_paths = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--object-path") == 0) | |
| { | |
| complete_paths = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| complete_methods = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--method") == 0) | |
| { | |
| complete_methods = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| if (!g_option_context_parse (o, argc, argv, NULL)) | |
| { | |
| if (!request_completion) | |
| { | |
| s = g_option_context_get_help (o, FALSE, NULL); | |
| g_printerr ("%s", s); | |
| g_free (s); | |
| goto out; | |
| } | |
| } | |
| error = NULL; | |
| c = connection_get_dbus_connection (TRUE, &error); | |
| if (c == NULL) | |
| { | |
| if (request_completion) | |
| { | |
| if (g_strcmp0 (completion_prev, "--address") == 0) | |
| { | |
| g_print ("unix:\n" | |
| "tcp:\n" | |
| "nonce-tcp:\n"); | |
| } | |
| else | |
| { | |
| g_print ("--system \n--session \n--address \n"); | |
| } | |
| } | |
| else | |
| { | |
| g_printerr (_("Error connecting: %s\n"), error->message); | |
| } | |
| g_error_free (error); | |
| goto out; | |
| } | |
| /* validate and complete destination (bus name) */ | |
| if (complete_names) | |
| { | |
| print_names (c, FALSE); | |
| goto out; | |
| } | |
| if (opt_call_dest == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--dest \n"); | |
| else | |
| g_printerr (_("Error: Destination is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--dest", completion_prev) == 0) | |
| { | |
| print_names (c, g_str_has_prefix (opt_call_dest, ":")); | |
| goto out; | |
| } | |
| if (!request_completion && !g_dbus_is_name (opt_call_dest)) | |
| { | |
| g_printerr (_("Error: %s is not a valid bus name\n"), opt_call_dest); | |
| goto out; | |
| } | |
| /* validate and complete object path */ | |
| if (complete_paths) | |
| { | |
| print_paths (c, opt_call_dest, "/"); | |
| goto out; | |
| } | |
| if (opt_call_object_path == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--object-path \n"); | |
| else | |
| g_printerr (_("Error: Object path is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--object-path", completion_prev) == 0) | |
| { | |
| gchar *p; | |
| s = g_strdup (opt_call_object_path); | |
| p = strrchr (s, '/'); | |
| if (p != NULL) | |
| { | |
| if (p == s) | |
| p++; | |
| *p = '\0'; | |
| } | |
| print_paths (c, opt_call_dest, s); | |
| g_free (s); | |
| goto out; | |
| } | |
| if (!request_completion && !g_variant_is_object_path (opt_call_object_path)) | |
| { | |
| g_printerr (_("Error: %s is not a valid object path\n"), opt_call_object_path); | |
| goto out; | |
| } | |
| /* validate and complete method (interface + method name) */ | |
| if (complete_methods) | |
| { | |
| print_methods_and_signals (c, opt_call_dest, opt_call_object_path, TRUE, FALSE); | |
| goto out; | |
| } | |
| if (opt_call_method == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--method \n"); | |
| else | |
| g_printerr (_("Error: Method name is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--method", completion_prev) == 0) | |
| { | |
| print_methods_and_signals (c, opt_call_dest, opt_call_object_path, TRUE, FALSE); | |
| goto out; | |
| } | |
| s = strrchr (opt_call_method, '.'); | |
| if (!request_completion && s == NULL) | |
| { | |
| g_printerr (_("Error: Method name “%s” is invalid\n"), opt_call_method); | |
| goto out; | |
| } | |
| method_name = g_strdup (s + 1); | |
| interface_name = g_strndup (opt_call_method, s - opt_call_method); | |
| /* All done with completion now */ | |
| if (request_completion) | |
| goto out; | |
| /* Introspect, for easy conversion - it's not fatal if we can't do this */ | |
| in_signature_types = call_helper_get_method_in_signature (c, | |
| opt_call_dest, | |
| opt_call_object_path, | |
| interface_name, | |
| method_name, | |
| &error); | |
| if (in_signature_types == NULL) | |
| { | |
| //g_printerr ("Error getting introspection data: %s\n", error->message); | |
| g_error_free (error); | |
| error = NULL; | |
| } | |
| /* Read parameters */ | |
| g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE); | |
| skip_dashes = TRUE; | |
| parm = 0; | |
| for (n = 1; n < (guint) *argc; n++) | |
| { | |
| GVariant *value; | |
| GVariantType *type; | |
| /* Under certain conditions, g_option_context_parse returns the "--" | |
| itself (setting off unparsed arguments), too: */ | |
| if (skip_dashes && g_strcmp0 ((*argv)[n], "--") == 0) | |
| { | |
| skip_dashes = FALSE; | |
| continue; | |
| } | |
| type = NULL; | |
| if (in_signature_types != NULL) | |
| { | |
| if (parm >= in_signature_types->len) | |
| { | |
| /* Only warn for the first param */ | |
| if (parm == in_signature_types->len) | |
| { | |
| g_printerr ("Warning: Introspection data indicates %d parameters but more was passed\n", | |
| in_signature_types->len); | |
| } | |
| } | |
| else | |
| { | |
| type = in_signature_types->pdata[parm]; | |
| } | |
| } | |
| error = NULL; | |
| value = g_variant_parse (type, | |
| (*argv)[n], | |
| NULL, | |
| NULL, | |
| &error); | |
| if (value == NULL) | |
| { | |
| gchar *context; | |
| context = g_variant_parse_error_print_context (error, (*argv)[n]); | |
| g_error_free (error); | |
| error = NULL; | |
| value = _g_variant_parse_me_harder (type, (*argv)[n], &error); | |
| if (value == NULL) | |
| { | |
| if (type != NULL) | |
| { | |
| s = g_variant_type_dup_string (type); | |
| g_printerr (_("Error parsing parameter %d of type “%s”: %s\n"), | |
| parm + 1, | |
| s, | |
| context); | |
| g_free (s); | |
| } | |
| else | |
| { | |
| g_printerr (_("Error parsing parameter %d: %s\n"), | |
| parm + 1, | |
| context); | |
| } | |
| g_error_free (error); | |
| g_variant_builder_clear (&builder); | |
| g_free (context); | |
| goto out; | |
| } | |
| g_free (context); | |
| } | |
| #ifdef G_OS_UNIX | |
| if (g_variant_is_of_type (value, G_VARIANT_TYPE_HANDLE)) | |
| { | |
| if (!fd_list) | |
| fd_list = g_unix_fd_list_new (); | |
| if ((fd_id = g_unix_fd_list_append (fd_list, g_variant_get_handle (value), &error)) == -1) | |
| { | |
| g_printerr (_("Error adding handle %d: %s\n"), | |
| g_variant_get_handle (value), error->message); | |
| g_variant_builder_clear (&builder); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| g_variant_unref (value); | |
| value = g_variant_new_handle (fd_id); | |
| } | |
| #endif | |
| g_variant_builder_add_value (&builder, value); | |
| ++parm; | |
| } | |
| parameters = g_variant_builder_end (&builder); | |
| if (parameters != NULL) | |
| parameters = g_variant_ref_sink (parameters); | |
| flags = G_DBUS_CALL_FLAGS_NONE; | |
| if (opt_call_interactive) | |
| flags |= G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION; | |
| #ifdef G_OS_UNIX | |
| result = g_dbus_connection_call_with_unix_fd_list_sync (c, | |
| opt_call_dest, | |
| opt_call_object_path, | |
| interface_name, | |
| method_name, | |
| parameters, | |
| NULL, | |
| flags, | |
| opt_call_timeout > 0 ? opt_call_timeout * 1000 : opt_call_timeout, | |
| fd_list, | |
| NULL, | |
| NULL, | |
| &error); | |
| #else | |
| result = g_dbus_connection_call_sync (c, | |
| opt_call_dest, | |
| opt_call_object_path, | |
| interface_name, | |
| method_name, | |
| parameters, | |
| NULL, | |
| flags, | |
| opt_call_timeout > 0 ? opt_call_timeout * 1000 : opt_call_timeout, | |
| NULL, | |
| &error); | |
| #endif | |
| if (result == NULL) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS) && in_signature_types != NULL) | |
| { | |
| if (in_signature_types->len > 0) | |
| { | |
| GString *str; | |
| str = g_string_new (NULL); | |
| for (n = 0; n < in_signature_types->len; n++) | |
| { | |
| GVariantType *type = in_signature_types->pdata[n]; | |
| g_string_append_len (str, | |
| g_variant_type_peek_string (type), | |
| g_variant_type_get_string_length (type)); | |
| } | |
| g_printerr ("(According to introspection data, you need to pass '%s')\n", str->str); | |
| g_string_free (str, TRUE); | |
| } | |
| else | |
| g_printerr ("(According to introspection data, you need to pass no arguments)\n"); | |
| } | |
| g_error_free (error); | |
| goto out; | |
| } | |
| s = g_variant_print (result, TRUE); | |
| g_print ("%s\n", s); | |
| g_free (s); | |
| ret = TRUE; | |
| out: | |
| if (in_signature_types != NULL) | |
| g_ptr_array_unref (in_signature_types); | |
| if (result != NULL) | |
| g_variant_unref (result); | |
| if (c != NULL) | |
| g_object_unref (c); | |
| if (parameters != NULL) | |
| g_variant_unref (parameters); | |
| g_free (interface_name); | |
| g_free (method_name); | |
| g_option_context_free (o); | |
| #ifdef G_OS_UNIX | |
| g_clear_object (&fd_list); | |
| #endif | |
| return ret; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gchar *opt_introspect_dest = NULL; | |
| static gchar *opt_introspect_object_path = NULL; | |
| static gboolean opt_introspect_xml = FALSE; | |
| static gboolean opt_introspect_recurse = FALSE; | |
| static gboolean opt_introspect_only_properties = FALSE; | |
| /* Introspect colors */ | |
| #define RESET_COLOR (use_colors? "\033[0m": "") | |
| #define INTROSPECT_TITLE_COLOR (use_colors? UNDERLINE: "") | |
| #define INTROSPECT_NODE_COLOR (use_colors? RESET_COLOR: "") | |
| #define INTROSPECT_INTERFACE_COLOR (use_colors? YELLOW: "") | |
| #define INTROSPECT_METHOD_COLOR (use_colors? BLUE: "") | |
| #define INTROSPECT_SIGNAL_COLOR (use_colors? BLUE: "") | |
| #define INTROSPECT_PROPERTY_COLOR (use_colors? MAGENTA: "") | |
| #define INTROSPECT_INOUT_COLOR (use_colors? RESET_COLOR: "") | |
| #define INTROSPECT_TYPE_COLOR (use_colors? GREEN: "") | |
| #define INTROSPECT_ANNOTATION_COLOR (use_colors? RESET_COLOR: "") | |
| static void | |
| dump_annotation (const GDBusAnnotationInfo *o, | |
| guint indent, | |
| gboolean ignore_indent, | |
| gboolean use_colors) | |
| { | |
| guint n; | |
| g_print ("%*s%s@%s(\"%s\")%s\n", | |
| ignore_indent ? 0 : indent, "", | |
| INTROSPECT_ANNOTATION_COLOR, o->key, o->value, RESET_COLOR); | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| dump_annotation (o->annotations[n], indent + 2, FALSE, use_colors); | |
| } | |
| static void | |
| dump_arg (const GDBusArgInfo *o, | |
| guint indent, | |
| const gchar *direction, | |
| gboolean ignore_indent, | |
| gboolean include_newline, | |
| gboolean use_colors) | |
| { | |
| guint n; | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| { | |
| dump_annotation (o->annotations[n], indent, ignore_indent, use_colors); | |
| ignore_indent = FALSE; | |
| } | |
| g_print ("%*s%s%s%s%s%s%s %s%s", | |
| ignore_indent ? 0 : indent, "", | |
| INTROSPECT_INOUT_COLOR, direction, RESET_COLOR, | |
| INTROSPECT_TYPE_COLOR, o->signature, RESET_COLOR, | |
| o->name, | |
| include_newline ? ",\n" : ""); | |
| } | |
| static guint | |
| count_args (GDBusArgInfo **args) | |
| { | |
| guint n; | |
| n = 0; | |
| if (args == NULL) | |
| goto out; | |
| while (args[n] != NULL) | |
| n++; | |
| out: | |
| return n; | |
| } | |
| static void | |
| dump_method (const GDBusMethodInfo *o, | |
| guint indent, | |
| gboolean use_colors) | |
| { | |
| guint n; | |
| guint m; | |
| size_t name_len; | |
| guint total_num_args; | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| dump_annotation (o->annotations[n], indent, FALSE, use_colors); | |
| g_print ("%*s%s%s%s(", | |
| indent, "", | |
| INTROSPECT_METHOD_COLOR, o->name, RESET_COLOR); | |
| name_len = strlen (o->name); | |
| total_num_args = count_args (o->in_args) + count_args (o->out_args); | |
| for (n = 0, m = 0; o->in_args != NULL && o->in_args[n] != NULL; n++, m++) | |
| { | |
| gboolean ignore_indent = (m == 0); | |
| gboolean include_newline = (m != total_num_args - 1); | |
| dump_arg (o->in_args[n], | |
| indent + name_len + 1, | |
| "in ", | |
| ignore_indent, | |
| include_newline, | |
| use_colors); | |
| } | |
| for (n = 0; o->out_args != NULL && o->out_args[n] != NULL; n++, m++) | |
| { | |
| gboolean ignore_indent = (m == 0); | |
| gboolean include_newline = (m != total_num_args - 1); | |
| dump_arg (o->out_args[n], | |
| indent + name_len + 1, | |
| "out ", | |
| ignore_indent, | |
| include_newline, | |
| use_colors); | |
| } | |
| g_print (");\n"); | |
| } | |
| static void | |
| dump_signal (const GDBusSignalInfo *o, | |
| guint indent, | |
| gboolean use_colors) | |
| { | |
| guint n; | |
| guint name_len; | |
| guint total_num_args; | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| dump_annotation (o->annotations[n], indent, FALSE, use_colors); | |
| g_print ("%*s%s%s%s(", | |
| indent, "", | |
| INTROSPECT_SIGNAL_COLOR, o->name, RESET_COLOR); | |
| name_len = strlen (o->name); | |
| total_num_args = count_args (o->args); | |
| for (n = 0; o->args != NULL && o->args[n] != NULL; n++) | |
| { | |
| gboolean ignore_indent = (n == 0); | |
| gboolean include_newline = (n != total_num_args - 1); | |
| dump_arg (o->args[n], | |
| indent + name_len + 1, | |
| "", | |
| ignore_indent, | |
| include_newline, | |
| use_colors); | |
| } | |
| g_print (");\n"); | |
| } | |
| static void | |
| dump_property (const GDBusPropertyInfo *o, | |
| guint indent, | |
| gboolean use_colors, | |
| GVariant *value) | |
| { | |
| const gchar *access; | |
| guint n; | |
| if (o->flags == G_DBUS_PROPERTY_INFO_FLAGS_READABLE) | |
| access = "readonly"; | |
| else if (o->flags == G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE) | |
| access = "writeonly"; | |
| else if (o->flags == (G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE)) | |
| access = "readwrite"; | |
| else | |
| g_assert_not_reached (); | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| dump_annotation (o->annotations[n], indent, FALSE, use_colors); | |
| if (value != NULL) | |
| { | |
| gchar *s = g_variant_print (value, FALSE); | |
| g_print ("%*s%s %s%s%s %s%s%s = %s;\n", indent, "", access, | |
| INTROSPECT_TYPE_COLOR, o->signature, RESET_COLOR, | |
| INTROSPECT_PROPERTY_COLOR, o->name, RESET_COLOR, | |
| s); | |
| g_free (s); | |
| } | |
| else | |
| { | |
| g_print ("%*s%s %s %s;\n", indent, "", access, o->signature, o->name); | |
| } | |
| } | |
| static void | |
| dump_interface (GDBusConnection *c, | |
| const gchar *name, | |
| const GDBusInterfaceInfo *o, | |
| guint indent, | |
| gboolean use_colors, | |
| const gchar *object_path) | |
| { | |
| guint n; | |
| GHashTable *properties; | |
| properties = g_hash_table_new_full (g_str_hash, | |
| g_str_equal, | |
| g_free, | |
| (GDestroyNotify) g_variant_unref); | |
| /* Try to get properties */ | |
| if (c != NULL && name != NULL && object_path != NULL && o->properties != NULL) | |
| { | |
| GVariant *result; | |
| result = g_dbus_connection_call_sync (c, | |
| name, | |
| object_path, | |
| DBUS_INTERFACE_PROPERTIES, | |
| "GetAll", | |
| g_variant_new ("(s)", o->name), | |
| NULL, | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, | |
| NULL, | |
| NULL); | |
| if (result != NULL) | |
| { | |
| if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(a{sv})"))) | |
| { | |
| GVariantIter *iter; | |
| GVariant *item; | |
| g_variant_get (result, | |
| "(a{sv})", | |
| &iter); | |
| while ((item = g_variant_iter_next_value (iter))) | |
| { | |
| gchar *key; | |
| GVariant *value; | |
| g_variant_get (item, | |
| "{sv}", | |
| &key, | |
| &value); | |
| g_hash_table_insert (properties, key, g_variant_ref (value)); | |
| } | |
| } | |
| g_variant_unref (result); | |
| } | |
| else | |
| { | |
| for (n = 0; o->properties != NULL && o->properties[n] != NULL; n++) | |
| { | |
| result = g_dbus_connection_call_sync (c, | |
| name, | |
| object_path, | |
| DBUS_INTERFACE_PROPERTIES, | |
| "Get", | |
| g_variant_new ("(ss)", o->name, o->properties[n]->name), | |
| G_VARIANT_TYPE ("(v)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, | |
| NULL, | |
| NULL); | |
| if (result != NULL) | |
| { | |
| GVariant *property_value; | |
| g_variant_get (result, | |
| "(v)", | |
| &property_value); | |
| g_hash_table_insert (properties, | |
| g_strdup (o->properties[n]->name), | |
| g_variant_ref (property_value)); | |
| g_variant_unref (result); | |
| } | |
| } | |
| } | |
| } | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| dump_annotation (o->annotations[n], indent, FALSE, use_colors); | |
| g_print ("%*s%sinterface %s%s {\n", | |
| indent, "", | |
| INTROSPECT_INTERFACE_COLOR, o->name, RESET_COLOR); | |
| if (o->methods != NULL && !opt_introspect_only_properties) | |
| { | |
| g_print ("%*s %smethods%s:\n", | |
| indent, "", | |
| INTROSPECT_TITLE_COLOR, RESET_COLOR); | |
| for (n = 0; o->methods[n] != NULL; n++) | |
| dump_method (o->methods[n], indent + 4, use_colors); | |
| } | |
| if (o->signals != NULL && !opt_introspect_only_properties) | |
| { | |
| g_print ("%*s %ssignals%s:\n", | |
| indent, "", | |
| INTROSPECT_TITLE_COLOR, RESET_COLOR); | |
| for (n = 0; o->signals[n] != NULL; n++) | |
| dump_signal (o->signals[n], indent + 4, use_colors); | |
| } | |
| if (o->properties != NULL) | |
| { | |
| g_print ("%*s %sproperties%s:\n", | |
| indent, "", | |
| INTROSPECT_TITLE_COLOR, RESET_COLOR); | |
| for (n = 0; o->properties[n] != NULL; n++) | |
| { | |
| dump_property (o->properties[n], | |
| indent + 4, | |
| use_colors, | |
| g_hash_table_lookup (properties, (o->properties[n])->name)); | |
| } | |
| } | |
| g_print ("%*s};\n", | |
| indent, ""); | |
| g_hash_table_unref (properties); | |
| } | |
| static gboolean | |
| introspect_do (GDBusConnection *c, | |
| const gchar *object_path, | |
| guint indent, | |
| gboolean use_colors); | |
| static void | |
| dump_node (GDBusConnection *c, | |
| const gchar *name, | |
| const GDBusNodeInfo *o, | |
| guint indent, | |
| gboolean use_colors, | |
| const gchar *object_path, | |
| gboolean recurse) | |
| { | |
| guint n; | |
| const gchar *object_path_to_print; | |
| object_path_to_print = object_path; | |
| if (o->path != NULL) | |
| object_path_to_print = o->path; | |
| for (n = 0; o->annotations != NULL && o->annotations[n] != NULL; n++) | |
| dump_annotation (o->annotations[n], indent, FALSE, use_colors); | |
| g_print ("%*s%snode %s%s", | |
| indent, "", | |
| INTROSPECT_NODE_COLOR, | |
| object_path_to_print != NULL ? object_path_to_print : "(not set)", | |
| RESET_COLOR); | |
| if (o->interfaces != NULL || o->nodes != NULL) | |
| { | |
| g_print (" {\n"); | |
| for (n = 0; o->interfaces != NULL && o->interfaces[n] != NULL; n++) | |
| { | |
| if (opt_introspect_only_properties) | |
| { | |
| if (o->interfaces[n]->properties != NULL && o->interfaces[n]->properties[0] != NULL) | |
| dump_interface (c, name, o->interfaces[n], indent + 2, use_colors, object_path); | |
| } | |
| else | |
| { | |
| dump_interface (c, name, o->interfaces[n], indent + 2, use_colors, object_path); | |
| } | |
| } | |
| for (n = 0; o->nodes != NULL && o->nodes[n] != NULL; n++) | |
| { | |
| if (recurse) | |
| { | |
| gchar *child_path; | |
| if (g_variant_is_object_path (o->nodes[n]->path)) | |
| { | |
| child_path = g_strdup (o->nodes[n]->path); | |
| /* avoid infinite loops */ | |
| if (g_str_has_prefix (child_path, object_path)) | |
| { | |
| introspect_do (c, child_path, indent + 2, use_colors); | |
| } | |
| else | |
| { | |
| g_print ("Skipping path %s that is not enclosed by parent %s\n", | |
| child_path, object_path); | |
| } | |
| } | |
| else | |
| { | |
| if (g_strcmp0 (object_path, "/") == 0) | |
| child_path = g_strdup_printf ("/%s", o->nodes[n]->path); | |
| else | |
| child_path = g_strdup_printf ("%s/%s", object_path, o->nodes[n]->path); | |
| introspect_do (c, child_path, indent + 2, use_colors); | |
| } | |
| g_free (child_path); | |
| } | |
| else | |
| { | |
| dump_node (NULL, NULL, o->nodes[n], indent + 2, use_colors, NULL, recurse); | |
| } | |
| } | |
| g_print ("%*s};\n", | |
| indent, ""); | |
| } | |
| else | |
| { | |
| g_print ("\n"); | |
| } | |
| } | |
| static const GOptionEntry introspect_entries[] = | |
| { | |
| { "dest", 'd', 0, G_OPTION_ARG_STRING, &opt_introspect_dest, N_("Destination name to introspect"), NULL}, | |
| { "object-path", 'o', 0, G_OPTION_ARG_STRING, &opt_introspect_object_path, N_("Object path to introspect"), NULL}, | |
| { "xml", 'x', 0, G_OPTION_ARG_NONE, &opt_introspect_xml, N_("Print XML"), NULL}, | |
| { "recurse", 'r', 0, G_OPTION_ARG_NONE, &opt_introspect_recurse, N_("Introspect children"), NULL}, | |
| { "only-properties", 'p', 0, G_OPTION_ARG_NONE, &opt_introspect_only_properties, N_("Only print properties"), NULL}, | |
| G_OPTION_ENTRY_NULL | |
| }; | |
| static gboolean | |
| introspect_do (GDBusConnection *c, | |
| const gchar *object_path, | |
| guint indent, | |
| gboolean use_colors) | |
| { | |
| GError *error; | |
| GVariant *result; | |
| GDBusNodeInfo *node; | |
| gboolean ret; | |
| const gchar *xml_data; | |
| ret = FALSE; | |
| node = NULL; | |
| result = NULL; | |
| error = NULL; | |
| result = g_dbus_connection_call_sync (c, | |
| opt_introspect_dest, | |
| object_path, | |
| DBUS_INTERFACE_INTROSPECTABLE, | |
| "Introspect", | |
| NULL, | |
| G_VARIANT_TYPE ("(s)"), | |
| G_DBUS_CALL_FLAGS_NONE, | |
| 3000, /* 3 sec */ | |
| NULL, | |
| &error); | |
| if (result == NULL) | |
| { | |
| g_printerr (_("Error: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| g_variant_get (result, "(&s)", &xml_data); | |
| if (opt_introspect_xml) | |
| { | |
| g_print ("%s", xml_data); | |
| } | |
| else | |
| { | |
| error = NULL; | |
| node = g_dbus_node_info_new_for_xml (xml_data, &error); | |
| if (node == NULL) | |
| { | |
| g_printerr (_("Error parsing introspection XML: %s\n"), error->message); | |
| g_error_free (error); | |
| goto out; | |
| } | |
| dump_node (c, opt_introspect_dest, node, indent, use_colors, object_path, opt_introspect_recurse); | |
| } | |
| ret = TRUE; | |
| out: | |
| if (node != NULL) | |
| g_dbus_node_info_unref (node); | |
| if (result != NULL) | |
| g_variant_unref (result); | |
| return ret; | |
| } | |
| static gboolean | |
| handle_introspect (gint *argc, | |
| gchar **argv[], | |
| gboolean request_completion, | |
| const gchar *completion_cur, | |
| const gchar *completion_prev) | |
| { | |
| gint ret; | |
| GOptionContext *o; | |
| gchar *s; | |
| GError *error; | |
| GDBusConnection *c; | |
| gboolean complete_names; | |
| gboolean complete_paths; | |
| gboolean color_support; | |
| ret = FALSE; | |
| c = NULL; | |
| modify_argv0_for_command (argc, argv, "introspect"); | |
| o = command_option_context_new (NULL, _("Introspect a remote object."), | |
| introspect_entries, request_completion); | |
| g_option_context_add_group (o, connection_get_group ()); | |
| complete_names = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--dest") == 0) | |
| { | |
| complete_names = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| complete_paths = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--object-path") == 0) | |
| { | |
| complete_paths = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| if (!g_option_context_parse (o, argc, argv, NULL)) | |
| { | |
| if (!request_completion) | |
| { | |
| s = g_option_context_get_help (o, FALSE, NULL); | |
| g_printerr ("%s", s); | |
| g_free (s); | |
| goto out; | |
| } | |
| } | |
| error = NULL; | |
| c = connection_get_dbus_connection (TRUE, &error); | |
| if (c == NULL) | |
| { | |
| if (request_completion) | |
| { | |
| if (g_strcmp0 (completion_prev, "--address") == 0) | |
| { | |
| g_print ("unix:\n" | |
| "tcp:\n" | |
| "nonce-tcp:\n"); | |
| } | |
| else | |
| { | |
| g_print ("--system \n--session \n--address \n"); | |
| } | |
| } | |
| else | |
| { | |
| g_printerr (_("Error connecting: %s\n"), error->message); | |
| } | |
| g_error_free (error); | |
| goto out; | |
| } | |
| if (complete_names) | |
| { | |
| print_names (c, FALSE); | |
| goto out; | |
| } | |
| /* this only makes sense on message bus connections */ | |
| if (opt_introspect_dest == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--dest \n"); | |
| else | |
| g_printerr (_("Error: Destination is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--dest", completion_prev) == 0) | |
| { | |
| print_names (c, g_str_has_prefix (opt_introspect_dest, ":")); | |
| goto out; | |
| } | |
| if (complete_paths) | |
| { | |
| print_paths (c, opt_introspect_dest, "/"); | |
| goto out; | |
| } | |
| if (!request_completion && !g_dbus_is_name (opt_introspect_dest)) | |
| { | |
| g_printerr (_("Error: %s is not a valid bus name\n"), opt_introspect_dest); | |
| goto out; | |
| } | |
| if (opt_introspect_object_path == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--object-path \n"); | |
| else | |
| g_printerr (_("Error: Object path is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--object-path", completion_prev) == 0) | |
| { | |
| gchar *p; | |
| s = g_strdup (opt_introspect_object_path); | |
| p = strrchr (s, '/'); | |
| if (p != NULL) | |
| { | |
| if (p == s) | |
| p++; | |
| *p = '\0'; | |
| } | |
| print_paths (c, opt_introspect_dest, s); | |
| g_free (s); | |
| goto out; | |
| } | |
| if (!request_completion && !g_variant_is_object_path (opt_introspect_object_path)) | |
| { | |
| g_printerr (_("Error: %s is not a valid object path\n"), opt_introspect_object_path); | |
| goto out; | |
| } | |
| if (request_completion && opt_introspect_object_path != NULL && !opt_introspect_recurse) | |
| { | |
| g_print ("--recurse \n"); | |
| } | |
| if (request_completion && opt_introspect_object_path != NULL && !opt_introspect_only_properties) | |
| { | |
| g_print ("--only-properties \n"); | |
| } | |
| /* All done with completion now */ | |
| if (request_completion) | |
| goto out; | |
| /* Before we start printing the actual info, check if we can do colors*/ | |
| color_support = g_log_writer_supports_color (fileno (stdout)); | |
| if (!introspect_do (c, opt_introspect_object_path, 0, color_support)) | |
| goto out; | |
| ret = TRUE; | |
| out: | |
| if (c != NULL) | |
| g_object_unref (c); | |
| g_option_context_free (o); | |
| return ret; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gchar *opt_monitor_dest = NULL; | |
| static gchar *opt_monitor_object_path = NULL; | |
| static guint monitor_filter_id = 0; | |
| static void | |
| monitor_signal_cb (GDBusConnection *connection, | |
| const gchar *sender_name, | |
| const gchar *object_path, | |
| const gchar *interface_name, | |
| const gchar *signal_name, | |
| GVariant *parameters, | |
| gpointer user_data) | |
| { | |
| gchar *s; | |
| s = g_variant_print (parameters, TRUE); | |
| g_print ("%s: %s.%s %s\n", | |
| object_path, | |
| interface_name, | |
| signal_name, | |
| s); | |
| g_free (s); | |
| } | |
| static void | |
| monitor_on_name_appeared (GDBusConnection *connection, | |
| const gchar *name, | |
| const gchar *name_owner, | |
| gpointer user_data) | |
| { | |
| g_print ("The name %s is owned by %s\n", name, name_owner); | |
| g_assert (monitor_filter_id == 0); | |
| monitor_filter_id = g_dbus_connection_signal_subscribe (connection, | |
| name_owner, | |
| NULL, /* any interface */ | |
| NULL, /* any member */ | |
| opt_monitor_object_path, | |
| NULL, /* arg0 */ | |
| G_DBUS_SIGNAL_FLAGS_NONE, | |
| monitor_signal_cb, | |
| NULL, /* user_data */ | |
| NULL); /* user_data destroy notify */ | |
| } | |
| static void | |
| monitor_on_name_vanished (GDBusConnection *connection, | |
| const gchar *name, | |
| gpointer user_data) | |
| { | |
| g_print ("The name %s does not have an owner\n", name); | |
| if (monitor_filter_id != 0) | |
| { | |
| g_dbus_connection_signal_unsubscribe (connection, monitor_filter_id); | |
| monitor_filter_id = 0; | |
| } | |
| } | |
| static const GOptionEntry monitor_entries[] = | |
| { | |
| { "dest", 'd', 0, G_OPTION_ARG_STRING, &opt_monitor_dest, N_("Destination name to monitor"), NULL}, | |
| { "object-path", 'o', 0, G_OPTION_ARG_STRING, &opt_monitor_object_path, N_("Object path to monitor"), NULL}, | |
| G_OPTION_ENTRY_NULL | |
| }; | |
| static gboolean | |
| handle_monitor (gint *argc, | |
| gchar **argv[], | |
| gboolean request_completion, | |
| const gchar *completion_cur, | |
| const gchar *completion_prev) | |
| { | |
| gint ret; | |
| GOptionContext *o; | |
| gchar *s; | |
| GError *error; | |
| GDBusConnection *c; | |
| gboolean complete_names; | |
| gboolean complete_paths; | |
| GMainLoop *loop; | |
| ret = FALSE; | |
| c = NULL; | |
| modify_argv0_for_command (argc, argv, "monitor"); | |
| o = command_option_context_new (NULL, _("Monitor a remote object."), | |
| monitor_entries, request_completion); | |
| g_option_context_add_group (o, connection_get_group ()); | |
| complete_names = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--dest") == 0) | |
| { | |
| complete_names = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| complete_paths = FALSE; | |
| if (request_completion && *argc > 1 && g_strcmp0 ((*argv)[(*argc)-1], "--object-path") == 0) | |
| { | |
| complete_paths = TRUE; | |
| remove_arg ((*argc) - 1, argc, argv); | |
| } | |
| if (!g_option_context_parse (o, argc, argv, NULL)) | |
| { | |
| if (!request_completion) | |
| { | |
| s = g_option_context_get_help (o, FALSE, NULL); | |
| g_printerr ("%s", s); | |
| g_free (s); | |
| goto out; | |
| } | |
| } | |
| error = NULL; | |
| c = connection_get_dbus_connection (TRUE, &error); | |
| if (c == NULL) | |
| { | |
| if (request_completion) | |
| { | |
| if (g_strcmp0 (completion_prev, "--address") == 0) | |
| { | |
| g_print ("unix:\n" | |
| "tcp:\n" | |
| "nonce-tcp:\n"); | |
| } | |
| else | |
| { | |
| g_print ("--system \n--session \n--address \n"); | |
| } | |
| } | |
| else | |
| { | |
| g_printerr (_("Error connecting: %s\n"), error->message); | |
| } | |
| g_error_free (error); | |
| goto out; | |
| } | |
| /* Monitoring doesn’t make sense on a non-message-bus connection. */ | |
| if (g_dbus_connection_get_unique_name (c) == NULL) | |
| { | |
| if (!request_completion) | |
| g_printerr (_("Error: can’t monitor a non-message-bus connection\n")); | |
| goto out; | |
| } | |
| if (complete_names) | |
| { | |
| print_names (c, FALSE); | |
| goto out; | |
| } | |
| /* this only makes sense on message bus connections */ | |
| if (opt_monitor_dest == NULL) | |
| { | |
| if (request_completion) | |
| g_print ("--dest \n"); | |
| else | |
| g_printerr (_("Error: Destination is not specified\n")); | |
| goto out; | |
| } | |
| if (request_completion && g_strcmp0 ("--dest", completion_prev) == 0) | |
| { | |
| print_names (c, g_str_has_prefix (opt_monitor_dest, ":")); | |
| goto out; | |
| } | |
| if (!request_completion && !g_dbus_is_name (opt_monitor_dest)) | |
| { | |
| g_printerr (_("Error: %s is not a valid bus name\n"), opt_monitor_dest); | |
| goto out; | |
| } | |
| if (complete_paths) | |
| { | |
| print_paths (c, opt_monitor_dest, "/"); | |
| goto out; | |
| } | |
| if (opt_monitor_object_path == NULL) | |
| { | |
| if (request_completion) | |
| { | |
| g_print ("--object-path \n"); | |
| goto out; | |
| } | |
| /* it's fine to not have an object path */ | |
| } | |
| if (request_completion && g_strcmp0 ("--object-path", completion_prev) == 0) | |
| { | |
| gchar *p; | |
| s = g_strdup (opt_monitor_object_path); | |
| p = strrchr (s, '/'); | |
| if (p != NULL) | |
| { | |
| if (p == s) | |
| p++; | |
| *p = '\0'; | |
| } | |
| print_paths (c, opt_monitor_dest, s); | |
| g_free (s); | |
| goto out; | |
| } | |
| if (!request_completion && (opt_monitor_object_path != NULL && !g_variant_is_object_path (opt_monitor_object_path))) | |
| { | |
| g_printerr (_("Error: %s is not a valid object path\n"), opt_monitor_object_path); | |
| goto out; | |
| } | |
| /* All done with completion now */ | |
| if (request_completion) | |
| goto out; | |
| if (opt_monitor_object_path != NULL) | |
| g_print ("Monitoring signals on object %s owned by %s\n", opt_monitor_object_path, opt_monitor_dest); | |
| else | |
| g_print ("Monitoring signals from all objects owned by %s\n", opt_monitor_dest); | |
| loop = g_main_loop_new (NULL, FALSE); | |
| g_bus_watch_name_on_connection (c, | |
| opt_monitor_dest, | |
| G_BUS_NAME_WATCHER_FLAGS_AUTO_START, | |
| monitor_on_name_appeared, | |
| monitor_on_name_vanished, | |
| NULL, | |
| NULL); | |
| g_main_loop_run (loop); | |
| g_main_loop_unref (loop); | |
| ret = TRUE; | |
| out: | |
| if (c != NULL) | |
| g_object_unref (c); | |
| g_option_context_free (o); | |
| return ret; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gboolean opt_wait_activate_set = FALSE; | |
| static gchar *opt_wait_activate_name = NULL; | |
| static gint64 opt_wait_timeout_secs = 0; /* no timeout */ | |
| typedef enum { | |
| WAIT_STATE_RUNNING, /* waiting to see the service */ | |
| WAIT_STATE_SUCCESS, /* seen it successfully */ | |
| WAIT_STATE_TIMEOUT, /* timed out before seeing it */ | |
| } WaitState; | |
| static gboolean | |
| opt_wait_activate_cb (const gchar *option_name, | |
| const gchar *value, | |
| gpointer data, | |
| GError **error) | |
| { | |
| /* @value may be NULL */ | |
| opt_wait_activate_set = TRUE; | |
| opt_wait_activate_name = g_strdup (value); | |
| return TRUE; | |
| } | |
| static const GOptionEntry wait_entries[] = | |
| { | |
| { "activate", 'a', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, | |
| opt_wait_activate_cb, | |
| N_("Service to activate before waiting for the other one (well-known name)"), | |
| "[NAME]" }, | |
| { "timeout", 't', 0, G_OPTION_ARG_INT64, &opt_wait_timeout_secs, | |
| N_("Timeout to wait for before exiting with an error (seconds); 0 for " | |
| "no timeout (default)"), "SECS" }, | |
| G_OPTION_ENTRY_NULL | |
| }; | |
| static void | |
| wait_name_appeared_cb (GDBusConnection *connection, | |
| const gchar *name, | |
| const gchar *name_owner, | |
| gpointer user_data) | |
| { | |
| WaitState *wait_state = user_data; | |
| *wait_state = WAIT_STATE_SUCCESS; | |
| } | |
| static gboolean | |
| wait_timeout_cb (gpointer user_data) | |
| { | |
| WaitState *wait_state = user_data; | |
| *wait_state = WAIT_STATE_TIMEOUT; | |
| /* Removed in handle_wait(). */ | |
| return G_SOURCE_CONTINUE; | |
| } | |
| static gboolean | |
| handle_wait (gint *argc, | |
| gchar **argv[], | |
| gboolean request_completion, | |
| const gchar *completion_cur, | |
| const gchar *completion_prev) | |
| { | |
| gint ret; | |
| GOptionContext *o; | |
| gchar *s; | |
| GError *error; | |
| GDBusConnection *c; | |
| guint watch_id, timer_id = 0, activate_watch_id; | |
| const gchar *activate_service, *wait_service; | |
| WaitState wait_state = WAIT_STATE_RUNNING; | |
| ret = FALSE; | |
| c = NULL; | |
| modify_argv0_for_command (argc, argv, "wait"); | |
| o = command_option_context_new (_("[OPTION…] BUS-NAME"), | |
| _("Wait for a bus name to appear."), | |
| wait_entries, request_completion); | |
| g_option_context_add_group (o, connection_get_group ()); | |
| if (!g_option_context_parse (o, argc, argv, NULL)) | |
| { | |
| if (!request_completion) | |
| { | |
| s = g_option_context_get_help (o, FALSE, NULL); | |
| g_printerr ("%s", s); | |
| g_free (s); | |
| goto out; | |
| } | |
| } | |
| error = NULL; | |
| c = connection_get_dbus_connection (TRUE, &error); | |
| if (c == NULL) | |
| { | |
| if (request_completion) | |
| { | |
| if (g_strcmp0 (completion_prev, "--address") == 0) | |
| { | |
| g_print ("unix:\n" | |
| "tcp:\n" | |
| "nonce-tcp:\n"); | |
| } | |
| else | |
| { | |
| g_print ("--system \n--session \n--address \n"); | |
| } | |
| } | |
| else | |
| { | |
| g_printerr (_("Error connecting: %s\n"), error->message); | |
| } | |
| g_error_free (error); | |
| goto out; | |
| } | |
| /* All done with completion now */ | |
| if (request_completion) | |
| goto out; | |
| /* | |
| * Try and disentangle the command line arguments, with the aim of supporting: | |
| * gdbus wait --session --activate ActivateName WaitName | |
| * gdbus wait --session --activate ActivateAndWaitName | |
| * gdbus wait --activate --session ActivateAndWaitName | |
| * gdbus wait --session WaitName | |
| */ | |
| if (*argc == 2 && opt_wait_activate_set && opt_wait_activate_name != NULL) | |
| { | |
| activate_service = opt_wait_activate_name; | |
| wait_service = (*argv)[1]; | |
| } | |
| else if (*argc == 2 && | |
| opt_wait_activate_set && opt_wait_activate_name == NULL) | |
| { | |
| activate_service = (*argv)[1]; | |
| wait_service = (*argv)[1]; | |
| } | |
| else if (*argc == 2 && !opt_wait_activate_set) | |
| { | |
| activate_service = NULL; /* disabled */ | |
| wait_service = (*argv)[1]; | |
| } | |
| else if (*argc == 1 && | |
| opt_wait_activate_set && opt_wait_activate_name != NULL) | |
| { | |
| activate_service = opt_wait_activate_name; | |
| wait_service = opt_wait_activate_name; | |
| } | |
| else if (*argc == 1 && | |
| opt_wait_activate_set && opt_wait_activate_name == NULL) | |
| { | |
| g_printerr (_("Error: A service to activate for must be specified.\n")); | |
| goto out; | |
| } | |
| else if (*argc == 1 && !opt_wait_activate_set) | |
| { | |
| g_printerr (_("Error: A service to wait for must be specified.\n")); | |
| goto out; | |
| } | |
| else /* if (*argc > 2) */ | |
| { | |
| g_printerr (_("Error: Too many arguments.\n")); | |
| goto out; | |
| } | |
| if (activate_service != NULL && | |
| (!g_dbus_is_name (activate_service) || | |
| g_dbus_is_unique_name (activate_service))) | |
| { | |
| g_printerr (_("Error: %s is not a valid well-known bus name.\n"), | |
| activate_service); | |
| goto out; | |
| } | |
| if (!g_dbus_is_name (wait_service) || g_dbus_is_unique_name (wait_service)) | |
| { | |
| g_printerr (_("Error: %s is not a valid well-known bus name.\n"), | |
| wait_service); | |
| goto out; | |
| } | |
| /* Start the prerequisite service if needed. */ | |
| if (activate_service != NULL) | |
| { | |
| activate_watch_id = g_bus_watch_name_on_connection (c, activate_service, | |
| G_BUS_NAME_WATCHER_FLAGS_AUTO_START, | |
| NULL, NULL, | |
| NULL, NULL); | |
| } | |
| else | |
| { | |
| activate_watch_id = 0; | |
| } | |
| /* Wait for the expected name to appear. */ | |
| watch_id = g_bus_watch_name_on_connection (c, | |
| wait_service, | |
| G_BUS_NAME_WATCHER_FLAGS_NONE, | |
| wait_name_appeared_cb, | |
| NULL, &wait_state, NULL); | |
| /* Safety timeout. */ | |
| if (opt_wait_timeout_secs > 0) | |
| timer_id = g_timeout_add_seconds (opt_wait_timeout_secs, wait_timeout_cb, &wait_state); | |
| while (wait_state == WAIT_STATE_RUNNING) | |
| g_main_context_iteration (NULL, TRUE); | |
| g_bus_unwatch_name (watch_id); | |
| if (timer_id != 0) | |
| g_source_remove (timer_id); | |
| if (activate_watch_id != 0) | |
| g_bus_unwatch_name (activate_watch_id); | |
| ret = (wait_state == WAIT_STATE_SUCCESS); | |
| out: | |
| g_clear_object (&c); | |
| g_option_context_free (o); | |
| g_free (opt_wait_activate_name); | |
| opt_wait_activate_name = NULL; | |
| return ret; | |
| } | |
| /* ---------------------------------------------------------------------------------------------------- */ | |
| static gchar * | |
| pick_word_at (const gchar *s, | |
| gint cursor, | |
| gint *out_word_begins_at) | |
| { | |
| gint begin; | |
| gint end; | |
| if (s[0] == '\0') | |
| { | |
| if (out_word_begins_at != NULL) | |
| *out_word_begins_at = -1; | |
| return NULL; | |
| } | |
| if (g_ascii_isspace (s[cursor]) && ((cursor > 0 && g_ascii_isspace(s[cursor-1])) || cursor == 0)) | |
| { | |
| if (out_word_begins_at != NULL) | |
| *out_word_begins_at = cursor; | |
| return g_strdup (""); | |
| } | |
| while (!g_ascii_isspace (s[cursor - 1]) && cursor > 0) | |
| cursor--; | |
| begin = cursor; | |
| end = begin; | |
| while (!g_ascii_isspace (s[end]) && s[end] != '\0') | |
| end++; | |
| if (out_word_begins_at != NULL) | |
| *out_word_begins_at = begin; | |
| return g_strndup (s + begin, end - begin); | |
| } | |
| gint | |
| main (gint argc, gchar *argv[]) | |
| { | |
| gint ret; | |
| const gchar *command; | |
| gboolean request_completion; | |
| gchar *completion_cur; | |
| gchar *completion_prev; | |
| #ifdef G_OS_WIN32 | |
| gchar *tmp; | |
| #endif | |
| setlocale (LC_ALL, ""); | |
| textdomain (GETTEXT_PACKAGE); | |
| #ifdef G_OS_WIN32 | |
| tmp = _glib_get_locale_dir (); | |
| bindtextdomain (GETTEXT_PACKAGE, tmp); | |
| g_free (tmp); | |
| #else | |
| bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR); | |
| #endif | |
| #ifdef HAVE_BIND_TEXTDOMAIN_CODESET | |
| bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); | |
| #endif | |
| ret = 1; | |
| completion_cur = NULL; | |
| completion_prev = NULL; | |
| if (argc < 2) | |
| { | |
| usage (&argc, &argv, FALSE); | |
| goto out; | |
| } | |
| request_completion = FALSE; | |
| //completion_debug ("---- argc=%d --------------------------------------------------------", argc); | |
| again: | |
| command = argv[1]; | |
| if (g_strcmp0 (command, "help") == 0) | |
| { | |
| if (request_completion) | |
| { | |
| /* do nothing */ | |
| } | |
| else | |
| { | |
| usage (&argc, &argv, TRUE); | |
| ret = 0; | |
| } | |
| goto out; | |
| } | |
| else if (g_strcmp0 (command, "emit") == 0) | |
| { | |
| if (handle_emit (&argc, | |
| &argv, | |
| request_completion, | |
| completion_cur, | |
| completion_prev)) | |
| ret = 0; | |
| goto out; | |
| } | |
| else if (g_strcmp0 (command, "call") == 0) | |
| { | |
| if (handle_call (&argc, | |
| &argv, | |
| request_completion, | |
| completion_cur, | |
| completion_prev)) | |
| ret = 0; | |
| goto out; | |
| } | |
| else if (g_strcmp0 (command, "introspect") == 0) | |
| { | |
| if (handle_introspect (&argc, | |
| &argv, | |
| request_completion, | |
| completion_cur, | |
| completion_prev)) | |
| ret = 0; | |
| goto out; | |
| } | |
| else if (g_strcmp0 (command, "monitor") == 0) | |
| { | |
| if (handle_monitor (&argc, | |
| &argv, | |
| request_completion, | |
| completion_cur, | |
| completion_prev)) | |
| ret = 0; | |
| goto out; | |
| } | |
| else if (g_strcmp0 (command, "wait") == 0) | |
| { | |
| if (handle_wait (&argc, | |
| &argv, | |
| request_completion, | |
| completion_cur, | |
| completion_prev)) | |
| ret = 0; | |
| goto out; | |
| } | |
| #ifdef G_OS_WIN32 | |
| else if (g_strcmp0 (command, _GDBUS_ARG_WIN32_RUN_SESSION_BUS) == 0) | |
| { | |
| g_win32_run_session_bus (NULL, NULL, NULL, 0); | |
| ret = 0; | |
| goto out; | |
| } | |
| #endif | |
| else if (g_strcmp0 (command, "complete") == 0 && argc == 4 && !request_completion) | |
| { | |
| const gchar *completion_line; | |
| gchar **completion_argv; | |
| gint completion_argc; | |
| gint completion_point; | |
| gchar *endp; | |
| gint cur_begin; | |
| request_completion = TRUE; | |
| completion_line = argv[2]; | |
| completion_point = strtol (argv[3], &endp, 10); | |
| if (endp == argv[3] || *endp != '\0') | |
| goto out; | |
| #if 0 | |
| completion_debug ("completion_point=%d", completion_point); | |
| completion_debug ("----"); | |
| completion_debug (" 0123456789012345678901234567890123456789012345678901234567890123456789"); | |
| completion_debug ("'%s'", completion_line); | |
| completion_debug (" %*s^", | |
| completion_point, ""); | |
| completion_debug ("----"); | |
| #endif | |
| if (!g_shell_parse_argv (completion_line, | |
| &completion_argc, | |
| &completion_argv, | |
| NULL)) | |
| { | |
| /* it's very possible the command line can't be parsed (for | |
| * example, missing quotes etc) - in that case, we just | |
| * don't autocomplete at all | |
| */ | |
| goto out; | |
| } | |
| /* compute cur and prev */ | |
| completion_prev = NULL; | |
| completion_cur = pick_word_at (completion_line, completion_point, &cur_begin); | |
| if (cur_begin > 0) | |
| { | |
| gint prev_end; | |
| for (prev_end = cur_begin - 1; prev_end >= 0; prev_end--) | |
| { | |
| if (!g_ascii_isspace (completion_line[prev_end])) | |
| { | |
| completion_prev = pick_word_at (completion_line, prev_end, NULL); | |
| break; | |
| } | |
| } | |
| } | |
| #if 0 | |
| completion_debug (" cur='%s'", completion_cur); | |
| completion_debug ("prev='%s'", completion_prev); | |
| #endif | |
| argc = completion_argc; | |
| argv = completion_argv; | |
| ret = 0; | |
| goto again; | |
| } | |
| else | |
| { | |
| if (request_completion) | |
| { | |
| g_print ("help \nemit \ncall \nintrospect \nmonitor \nwait \n"); | |
| ret = 0; | |
| goto out; | |
| } | |
| else | |
| { | |
| g_printerr ("Unknown command '%s'\n", command); | |
| usage (&argc, &argv, FALSE); | |
| goto out; | |
| } | |
| } | |
| out: | |
| g_free (completion_cur); | |
| g_free (completion_prev); | |
| return ret; | |
| } |