/* GDBus - GLib D-Bus Library

 *

 * Copyright (C) 2008-2010 Red Hat, Inc.

 *

 * 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>

#include <gi18n.h>

#ifdef G_OS_WIN32

#include "glib/glib-private.h"

#endif

/* ---------------------------------------------------------------------------------------------------- */

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 = g_path_get_basename ((*argv)[0]);

  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 (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", (*argv)[0], 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,

                                        "org.freedesktop.DBus.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;

    }

  error = NULL;

  result = g_dbus_connection_call_sync (c,

                                        name,

                                        path,

                                        "org.freedesktop.DBus.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;

  GList *keys;

  GList *l;

  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,

                                        "org.freedesktop.DBus",

                                        "/org/freedesktop/DBus",

                                        "org.freedesktop.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,

                                        "org.freedesktop.DBus",

                                        "/org/freedesktop/DBus",

                                        "org.freedesktop.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_get_keys (name_set);

  keys = g_list_sort (keys, (GCompareFunc) g_strcmp0);

  for (l = keys; l != NULL; l = l->next)

    {

      const gchar *name = l->data;

      if (!include_unique_names && g_str_has_prefix (name, ":"))

        continue;

      g_print ("%s \n", name);

    }

  g_list_free (keys);

 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"), NULL},

  { 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 (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)

    {

      c = g_dbus_connection_new_for_address_sync (opt_connection_address,

                                                  G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,

                                                  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,

                                        "org.freedesktop.DBus.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},

  { 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 (&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 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},

  { NULL }

};

static gboolean

handle_call (gint        *argc,

             gchar      **argv[],

             gboolean     request_completion,

             const gchar *completion_cur,

             const gchar *completion_prev)