X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gio%2Fgapplicationimpl-dbus.c;h=94cf6ea262b70e9c942e6e93ef5ccc908e13c116;hb=627b49b39039d43a784fa9890f473d1ca8d52417;hp=c271f37791bf40a7e7059d981735c9d26c0bb58e;hpb=a7923a4aa3ff6d67672c6c69cd1b7d70fba9c57d;p=platform%2Fupstream%2Fglib.git

diff --git a/gio/gapplicationimpl-dbus.c b/gio/gapplicationimpl-dbus.c
index c271f37..94cf6ea 100644
--- a/gio/gapplicationimpl-dbus.c
+++ b/gio/gapplicationimpl-dbus.c
@@ -12,37 +12,162 @@
  * 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, write to the
- * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  *
  * Authors: Ryan Lortie <desrt@desrt.ca>
  */
 
+#include "config.h"
+
 #include "gapplicationimpl.h"
 
+#include "gactiongroup.h"
+#include "gactiongroupexporter.h"
+#include "gremoteactiongroup.h"
+#include "gdbusactiongroup-private.h"
 #include "gapplication.h"
 #include "gfile.h"
 #include "gdbusconnection.h"
 #include "gdbusintrospection.h"
 #include "gdbuserror.h"
+#include "glib/gstdio.h"
 
 #include <string.h>
+#include <stdio.h>
+
+#include "gapplicationcommandline.h"
+#include "gdbusmethodinvocation.h"
 
+#ifdef G_OS_UNIX
+#include "gunixinputstream.h"
+#include "gunixfdlist.h"
+#endif
 
-#include "gapplicationimpl-dbus-interface.c"
+/* DBus Interface definition {{{1 */
 
+/* For documentation of these interfaces, see
+ * https://wiki.gnome.org/Projects/GLib/GApplication/DBusAPI
+ */
+static const gchar org_gtk_Application_xml[] =
+  "<node>"
+    "<interface name='org.gtk.Application'>"
+      "<method name='Activate'>"
+        "<arg type='a{sv}' name='platform-data' direction='in'/>"
+      "</method>"
+      "<method name='Open'>"
+        "<arg type='as' name='uris' direction='in'/>"
+        "<arg type='s' name='hint' direction='in'/>"
+        "<arg type='a{sv}' name='platform-data' direction='in'/>"
+      "</method>"
+      "<method name='CommandLine'>"
+        "<arg type='o' name='path' direction='in'/>"
+        "<arg type='aay' name='arguments' direction='in'/>"
+        "<arg type='a{sv}' name='platform-data' direction='in'/>"
+        "<arg type='i' name='exit-status' direction='out'/>"
+      "</method>"
+    "<property name='Busy' type='b' access='read'/>"
+    "</interface>"
+  "</node>";
+
+static GDBusInterfaceInfo *org_gtk_Application;
+
+static const gchar org_freedesktop_Application_xml[] =
+  "<node>"
+    "<interface name='org.freedesktop.Application'>"
+      "<method name='Activate'>"
+        "<arg type='a{sv}' name='platform-data' direction='in'/>"
+      "</method>"
+      "<method name='Open'>"
+        "<arg type='as' name='uris' direction='in'/>"
+        "<arg type='a{sv}' name='platform-data' direction='in'/>"
+      "</method>"
+      "<method name='ActivateAction'>"
+        "<arg type='s' name='action-name' direction='in'/>"
+        "<arg type='av' name='parameter' direction='in'/>"
+        "<arg type='a{sv}' name='platform-data' direction='in'/>"
+      "</method>"
+    "</interface>"
+  "</node>";
+
+static GDBusInterfaceInfo *org_freedesktop_Application;
+
+static const gchar org_gtk_private_CommandLine_xml[] =
+  "<node>"
+    "<interface name='org.gtk.private.CommandLine'>"
+      "<method name='Print'>"
+        "<arg type='s' name='message' direction='in'/>"
+      "</method>"
+      "<method name='PrintError'>"
+        "<arg type='s' name='message' direction='in'/>"
+      "</method>"
+    "</interface>"
+  "</node>";
+
+static GDBusInterfaceInfo *org_gtk_private_CommandLine;
+
+/* GApplication implementation {{{1 */
 struct _GApplicationImpl
 {
   GDBusConnection *session_bus;
+  GActionGroup    *exported_actions;
   const gchar     *bus_name;
+
   gchar           *object_path;
   guint            object_id;
-  gpointer         app;
+  guint            fdo_object_id;
+  guint            actions_id;
 
-  GMainLoop       *cmdline_mainloop;
+  gboolean         properties_live;
+  gboolean         primary;
+  gboolean         busy;
+  GApplication    *app;
 };
 
+
+static GApplicationCommandLine *
+g_dbus_command_line_new (GDBusMethodInvocation *invocation);
+
+static GVariant *
+g_application_impl_get_property (GDBusConnection *connection,
+                                 const gchar  *sender,
+                                 const gchar  *object_path,
+                                 const gchar  *interface_name,
+                                 const gchar  *property_name,
+                                 GError      **error,
+                                 gpointer      user_data)
+{
+  GApplicationImpl *impl = user_data;
+
+  if (strcmp (property_name, "Busy") == 0)
+    return g_variant_new_boolean (impl->busy);
+
+  g_assert_not_reached ();
+
+  return NULL;
+}
+
+static void
+send_property_change (GApplicationImpl *impl)
+{
+  GVariantBuilder builder;
+
+  g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
+  g_variant_builder_add (&builder,
+                         "{sv}",
+                         "Busy", g_variant_new_boolean (impl->busy));
+
+  g_dbus_connection_emit_signal (impl->session_bus,
+                                 NULL,
+                                 impl->object_path,
+                                 "org.freedesktop.DBus.Properties",
+                                 "PropertiesChanged",
+                                 g_variant_new ("(sa{sv}as)",
+                                                "org.gtk.Application",
+                                                &builder,
+                                                NULL),
+                                 NULL);
+}
+
 static void
 g_application_impl_method_call (GDBusConnection       *connection,
                                 const gchar           *sender,
@@ -62,23 +187,42 @@ g_application_impl_method_call (GDBusConnection       *connection,
     {
       GVariant *platform_data;
 
+      /* Completely the same for both freedesktop and gtk interfaces */
+
       g_variant_get (parameters, "(@a{sv})", &platform_data);
+
       class->before_emit (impl->app, platform_data);
       g_signal_emit_by_name (impl->app, "activate");
       class->after_emit (impl->app, platform_data);
       g_variant_unref (platform_data);
+
+      g_dbus_method_invocation_return_value (invocation, NULL);
     }
 
   else if (strcmp (method_name, "Open") == 0)
     {
+      GApplicationFlags flags;
       GVariant *platform_data;
       const gchar *hint;
       GVariant *array;
       GFile **files;
       gint n, i;
 
-      g_variant_get (parameters, "(@ass@a{sv})",
-                     &array, &hint, &platform_data);
+      flags = g_application_get_flags (impl->app);
+      if ((flags & G_APPLICATION_HANDLES_OPEN) == 0)
+        {
+          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Application does not open files");
+          return;
+        }
+
+      /* freedesktop interface has no hint parameter */
+      if (g_str_equal (interface_name, "org.freedesktop.Application"))
+        {
+          g_variant_get (parameters, "(@as@a{sv})", &array, &platform_data);
+          hint = "";
+        }
+      else
+        g_variant_get (parameters, "(@as&s@a{sv})", &array, &hint, &platform_data);
 
       n = g_variant_n_children (array);
       files = g_new (GFile *, n + 1);
@@ -102,8 +246,60 @@ g_application_impl_method_call (GDBusConnection       *connection,
       for (i = 0; i < n; i++)
         g_object_unref (files[i]);
       g_free (files);
+
+      g_dbus_method_invocation_return_value (invocation, NULL);
     }
 
+  else if (strcmp (method_name, "CommandLine") == 0)
+    {
+      GApplicationFlags flags;
+      GApplicationCommandLine *cmdline;
+      GVariant *platform_data;
+      int status;
+
+      flags = g_application_get_flags (impl->app);
+      if ((flags & G_APPLICATION_HANDLES_COMMAND_LINE) == 0)
+        {
+          g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED,
+                                                 "Application does not handle command line arguments");
+          return;
+        }
+
+      /* Only on the GtkApplication interface */
+
+      cmdline = g_dbus_command_line_new (invocation);
+      platform_data = g_variant_get_child_value (parameters, 2);
+      class->before_emit (impl->app, platform_data);
+      g_signal_emit_by_name (impl->app, "command-line", cmdline, &status);
+      g_application_command_line_set_exit_status (cmdline, status);
+      class->after_emit (impl->app, platform_data);
+      g_variant_unref (platform_data);
+      g_object_unref (cmdline);
+    }
+  else if (g_str_equal (method_name, "ActivateAction"))
+    {
+      GVariant *parameter = NULL;
+      GVariant *platform_data;
+      GVariantIter *iter;
+      const gchar *name;
+
+      /* Only on the freedesktop interface */
+
+      g_variant_get (parameters, "(&sav@a{sv})", &name, &iter, &platform_data);
+      g_variant_iter_next (iter, "v", &parameter);
+      g_variant_iter_free (iter);
+
+      class->before_emit (impl->app, platform_data);
+      g_action_group_activate_action (impl->exported_actions, name, parameter);
+      class->after_emit (impl->app, platform_data);
+
+      if (parameter)
+        g_variant_unref (parameter);
+
+      g_variant_unref (platform_data);
+
+      g_dbus_method_invocation_return_value (invocation, NULL);
+    }
   else
     g_assert_not_reached ();
 }
@@ -113,143 +309,287 @@ application_path_from_appid (const gchar *appid)
 {
   gchar *appid_path, *iter;
 
+  if (appid == NULL)
+    /* this is a private implementation detail */
+    return g_strdup ("/org/gtk/Application/anonymous");
+
   appid_path = g_strconcat ("/", appid, NULL);
   for (iter = appid_path; *iter; iter++)
     {
       if (*iter == '.')
         *iter = '/';
+
+      if (*iter == '-')
+        *iter = '_';
     }
 
   return appid_path;
 }
 
-void
-g_application_impl_destroy (GApplicationImpl *impl)
+/* Attempt to become the primary instance.
+ *
+ * Returns %TRUE if everything went OK, regardless of if we became the
+ * primary instance or not.  %FALSE is reserved for when something went
+ * seriously wrong (and @error will be set too, in that case).
+ *
+ * After a %TRUE return, impl->primary will be TRUE if we were
+ * successful.
+ */
+static gboolean
+g_application_impl_attempt_primary (GApplicationImpl  *impl,
+                                    GCancellable      *cancellable,
+                                    GError           **error)
 {
-  if (impl->session_bus)
-    {
-      if (impl->object_id)
-        g_dbus_connection_unregister_object (impl->session_bus,
-                                             impl->object_id);
+  const static GDBusInterfaceVTable vtable = {
+    g_application_impl_method_call,
+    g_application_impl_get_property,
+    NULL /* set_property */
+  };
+  GApplicationClass *app_class = G_APPLICATION_GET_CLASS (impl->app);
+  GVariant *reply;
+  guint32 rval;
 
-      g_object_unref (impl->session_bus);
-      g_free (impl->object_path);
-    }
-  else
+  if (org_gtk_Application == NULL)
     {
-      g_assert (impl->object_path == NULL);
-      g_assert (impl->object_id == 0);
+      GError *error = NULL;
+      GDBusNodeInfo *info;
+
+      info = g_dbus_node_info_new_for_xml (org_gtk_Application_xml, &error);
+      if G_UNLIKELY (info == NULL)
+        g_error ("%s", error->message);
+      org_gtk_Application = g_dbus_node_info_lookup_interface (info, "org.gtk.Application");
+      g_assert (org_gtk_Application != NULL);
+      g_dbus_interface_info_ref (org_gtk_Application);
+      g_dbus_node_info_unref (info);
+
+      info = g_dbus_node_info_new_for_xml (org_freedesktop_Application_xml, &error);
+      if G_UNLIKELY (info == NULL)
+        g_error ("%s", error->message);
+      org_freedesktop_Application = g_dbus_node_info_lookup_interface (info, "org.freedesktop.Application");
+      g_assert (org_freedesktop_Application != NULL);
+      g_dbus_interface_info_ref (org_freedesktop_Application);
+      g_dbus_node_info_unref (info);
     }
 
-  g_slice_free (GApplicationImpl, impl);
-}
+  /* We could possibly have been D-Bus activated as a result of incoming
+   * requests on either the application or actiongroup interfaces.
+   * Because of how GDBus dispatches messages, we need to ensure that
+   * both of those things are registered before we attempt to request
+   * our name.
+   *
+   * The action group need not be populated yet, as long as it happens
+   * before we return to the mainloop.  The reason for that is because
+   * GDBus does the check to make sure the object exists from the worker
+   * thread but doesn't actually dispatch the action invocation until we
+   * hit the mainloop in this thread.  There is also no danger of
+   * receiving 'activate' or 'open' signals until after 'startup' runs,
+   * for the same reason.
+   */
+  impl->object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
+                                                       org_gtk_Application, &vtable, impl, NULL, error);
 
-GApplicationImpl *
-g_application_impl_register (GApplication       *application,
-                             const gchar        *appid,
-                             GApplicationFlags   flags,
-                             gboolean           *is_remote,
-                             GCancellable       *cancellable,
-                             GError            **error)
-{
-  const static GDBusInterfaceVTable vtable = {
-    g_application_impl_method_call
-  };
-  GApplicationImpl *impl;
-  GVariant *reply;
-  guint32 rval;
+  if (impl->object_id == 0)
+    return FALSE;
 
-  impl = g_slice_new (GApplicationImpl);
+  impl->fdo_object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
+                                                           org_freedesktop_Application, &vtable, impl, NULL, error);
 
-  impl->app = application;
-  impl->bus_name = appid;
+  if (impl->fdo_object_id == 0)
+    return FALSE;
 
-  impl->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION,
-                                      cancellable, error);
+  impl->actions_id = g_dbus_connection_export_action_group (impl->session_bus, impl->object_path,
+                                                            impl->exported_actions, error);
 
-  if (impl->session_bus == NULL)
+  if (impl->actions_id == 0)
+    return FALSE;
+
+  if (!app_class->dbus_register (impl->app,
+                                 impl->session_bus,
+                                 impl->object_path,
+                                 error))
+    return FALSE;
+
+  if (impl->bus_name == NULL)
     {
-      g_slice_free (GApplicationImpl, impl);
-      return NULL;
+      /* If this is a non-unique application then it is sufficient to
+       * have our object paths registered. We can return now.
+       *
+       * Note: non-unique applications always act as primary-instance.
+       */
+      impl->primary = TRUE;
+      return TRUE;
     }
 
-  impl->object_path = application_path_from_appid (appid);
+  /* If this is a unique application then we need to attempt to own
+   * the well-known name and fall back to remote mode (!is_primary)
+   * in the case that we can't do that.
+   */
+  /* DBUS_NAME_FLAG_DO_NOT_QUEUE: 0x4 */
+  reply = g_dbus_connection_call_sync (impl->session_bus, "org.freedesktop.DBus", "/org/freedesktop/DBus",
+                                       "org.freedesktop.DBus", "RequestName",
+                                       g_variant_new ("(su)", impl->bus_name, 0x4), G_VARIANT_TYPE ("(u)"),
+                                       0, -1, cancellable, error);
+
+  if (reply == NULL)
+    return FALSE;
+
+  g_variant_get (reply, "(u)", &rval);
+  g_variant_unref (reply);
+
+  /* DBUS_REQUEST_NAME_REPLY_EXISTS: 3 */
+  impl->primary = (rval != 3);
+
+  return TRUE;
+}
 
-  if (flags & G_APPLICATION_FLAGS_IS_LAUNCHER)
+/* Stop doing the things that the primary instance does.
+ *
+ * This should be called if attempting to become the primary instance
+ * failed (in order to clean up any partial success) and should also
+ * be called when freeing the GApplication.
+ *
+ * It is safe to call this multiple times.
+ */
+static void
+g_application_impl_stop_primary (GApplicationImpl *impl)
+{
+  GApplicationClass *app_class = G_APPLICATION_GET_CLASS (impl->app);
+
+  app_class->dbus_unregister (impl->app,
+                              impl->session_bus,
+                              impl->object_path);
+
+  if (impl->object_id)
     {
+      g_dbus_connection_unregister_object (impl->session_bus, impl->object_id);
       impl->object_id = 0;
-      *is_remote = TRUE;
+    }
 
-      return impl;
+  if (impl->fdo_object_id)
+    {
+      g_dbus_connection_unregister_object (impl->session_bus, impl->fdo_object_id);
+      impl->fdo_object_id = 0;
     }
 
-  impl->object_id = g_dbus_connection_register_object (impl->session_bus,
-                                                       impl->object_path,
-                                                       (GDBusInterfaceInfo *)
-                                                         &org_gtk_Application,
-                                                       &vtable,
-                                                       impl, NULL,
-                                                       error);
+  if (impl->actions_id)
+    {
+      g_dbus_connection_unexport_action_group (impl->session_bus, impl->actions_id);
+      impl->actions_id = 0;
+    }
 
-  if (impl->object_id == 0)
+  if (impl->primary && impl->bus_name)
     {
-      g_object_unref (impl->session_bus);
-      g_free (impl->object_path);
-      impl->session_bus = NULL;
-      impl->object_path = NULL;
+      g_dbus_connection_call (impl->session_bus, "org.freedesktop.DBus",
+                              "/org/freedesktop/DBus", "org.freedesktop.DBus",
+                              "ReleaseName", g_variant_new ("(s)", impl->bus_name),
+                              NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
+      impl->primary = FALSE;
+    }
+}
 
-      g_slice_free (GApplicationImpl, impl);
-      return NULL;
+void
+g_application_impl_set_busy_state (GApplicationImpl *impl,
+                                   gboolean          busy)
+{
+  if (impl->busy != busy)
+    {
+      impl->busy = busy;
+      send_property_change (impl);
     }
+}
 
-  reply = g_dbus_connection_call_sync (impl->session_bus,
-                                       "org.freedesktop.DBus",
-                                       "/org/freedesktop/DBus",
-                                       "org.freedesktop.DBus",
-                                       "RequestName",
-                                       g_variant_new ("(su)",
-                                       /* DBUS_NAME_FLAG_DO_NOT_QUEUE: 0x4 */
-                                                      impl->bus_name, 0x4),
-                                       G_VARIANT_TYPE ("(u)"),
-                                       0, -1, cancellable, error);
+void
+g_application_impl_destroy (GApplicationImpl *impl)
+{
+  g_application_impl_stop_primary (impl);
 
-  if (reply == NULL)
-    {
-      g_dbus_connection_unregister_object (impl->session_bus,
-                                           impl->object_id);
-      impl->object_id = 0;
+  if (impl->session_bus)
+    g_object_unref (impl->session_bus);
 
-      g_object_unref (impl->session_bus);
-      g_free (impl->object_path);
-      impl->session_bus = NULL;
-      impl->object_path = NULL;
+  g_free (impl->object_path);
 
-      g_slice_free (GApplicationImpl, impl);
-      return NULL;
+  g_slice_free (GApplicationImpl, impl);
+}
+
+GApplicationImpl *
+g_application_impl_register (GApplication        *application,
+                             const gchar         *appid,
+                             GApplicationFlags    flags,
+                             GActionGroup        *exported_actions,
+                             GRemoteActionGroup **remote_actions,
+                             GCancellable        *cancellable,
+                             GError             **error)
+{
+  GDBusActionGroup *actions;
+  GApplicationImpl *impl;
+
+  g_assert ((flags & G_APPLICATION_NON_UNIQUE) || appid != NULL);
+
+  impl = g_slice_new0 (GApplicationImpl);
+
+  impl->app = application;
+  impl->exported_actions = exported_actions;
+
+  /* non-unique applications do not attempt to acquire a bus name */
+  if (~flags & G_APPLICATION_NON_UNIQUE)
+    impl->bus_name = appid;
+
+  impl->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, NULL);
+
+  if (impl->session_bus == NULL)
+    {
+      /* If we can't connect to the session bus, proceed as a normal
+       * non-unique application.
+       */
+      *remote_actions = NULL;
+      return impl;
     }
 
-  g_variant_get (reply, "(u)", &rval);
-  g_variant_unref (reply);
+  impl->object_path = application_path_from_appid (appid);
 
-  /* DBUS_REQUEST_NAME_REPLY_EXISTS: 3 */
-  if ((*is_remote = (rval == 3)))
+  /* Only try to be the primary instance if
+   * G_APPLICATION_IS_LAUNCHER was not specified.
+   */
+  if (~flags & G_APPLICATION_IS_LAUNCHER)
     {
-      g_dbus_connection_unregister_object (impl->session_bus,
-                                           impl->object_id);
-      impl->object_id = 0;
+      if (!g_application_impl_attempt_primary (impl, cancellable, error))
+        {
+          g_application_impl_destroy (impl);
+          return NULL;
+        }
+
+      if (impl->primary)
+        return impl;
+
+      /* We didn't make it.  Drop our service-side stuff. */
+      g_application_impl_stop_primary (impl);
 
-      if (flags & G_APPLICATION_FLAGS_IS_SERVICE)
+      if (flags & G_APPLICATION_IS_SERVICE)
         {
           g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
-                       "Unable to acquire bus name `%s'", appid);
-          g_object_unref (impl->session_bus);
-          g_free (impl->object_path);
+                       "Unable to acquire bus name '%s'", appid);
+          g_application_impl_destroy (impl);
 
-          g_slice_free (GApplicationImpl, impl);
-          impl = NULL;
+          return NULL;
         }
     }
 
+  /* We are non-primary.  Try to get the primary's list of actions.
+   * This also serves as a mechanism to ensure that the primary exists
+   * (ie: DBus service files installed correctly, etc).
+   */
+  actions = g_dbus_action_group_get (impl->session_bus, impl->bus_name, impl->object_path);
+  if (!g_dbus_action_group_sync (actions, cancellable, error))
+    {
+      /* The primary appears not to exist.  Fail the registration. */
+      g_application_impl_destroy (impl);
+      g_object_unref (actions);
+
+      return NULL;
+    }
+
+  *remote_actions = G_REMOTE_ACTION_GROUP (actions);
+
   return impl;
 }
 
@@ -297,8 +637,295 @@ g_application_impl_open (GApplicationImpl  *impl,
                           NULL, 0, -1, NULL, NULL, NULL);
 }
 
+static void
+g_application_impl_cmdline_method_call (GDBusConnection       *connection,
+                                        const gchar           *sender,
+                                        const gchar           *object_path,
+                                        const gchar           *interface_name,
+                                        const gchar           *method_name,
+                                        GVariant              *parameters,
+                                        GDBusMethodInvocation *invocation,
+                                        gpointer               user_data)
+{
+  const gchar *message;
+
+  g_variant_get_child (parameters, 0, "&s", &message);
+
+  if (strcmp (method_name, "Print") == 0)
+    g_print ("%s", message);
+  else if (strcmp (method_name, "PrintError") == 0)
+    g_printerr ("%s", message);
+  else
+    g_assert_not_reached ();
+
+  g_dbus_method_invocation_return_value (invocation, NULL);
+}
+
+typedef struct
+{
+  GMainLoop *loop;
+  int status;
+} CommandLineData;
+
+static void
+g_application_impl_cmdline_done (GObject      *source,
+                                 GAsyncResult *result,
+                                 gpointer      user_data)
+{
+  CommandLineData *data = user_data;
+  GError *error = NULL;
+  GVariant *reply;
+
+#ifdef G_OS_UNIX
+  reply = g_dbus_connection_call_with_unix_fd_list_finish (G_DBUS_CONNECTION (source), NULL, result, &error);
+#else
+  reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
+#endif
+
+
+  if (reply != NULL)
+    {
+      g_variant_get (reply, "(i)", &data->status);
+      g_variant_unref (reply);
+    }
+
+  else
+    {
+      g_printerr ("%s\n", error->message);
+      g_error_free (error);
+      data->status = 1;
+    }
+
+  g_main_loop_quit (data->loop);
+}
+
+int
+g_application_impl_command_line (GApplicationImpl    *impl,
+                                 const gchar * const *arguments,
+                                 GVariant            *platform_data)
+{
+  const static GDBusInterfaceVTable vtable = {
+    g_application_impl_cmdline_method_call
+  };
+  const gchar *object_path = "/org/gtk/Application/CommandLine";
+  GMainContext *context;
+  CommandLineData data;
+  guint object_id;
+
+  context = g_main_context_new ();
+  data.loop = g_main_loop_new (context, FALSE);
+  g_main_context_push_thread_default (context);
+
+  if (org_gtk_private_CommandLine == NULL)
+    {
+      GError *error = NULL;
+      GDBusNodeInfo *info;
+
+      info = g_dbus_node_info_new_for_xml (org_gtk_private_CommandLine_xml, &error);
+      if G_UNLIKELY (info == NULL)
+        g_error ("%s", error->message);
+      org_gtk_private_CommandLine = g_dbus_node_info_lookup_interface (info, "org.gtk.private.CommandLine");
+      g_assert (org_gtk_private_CommandLine != NULL);
+      g_dbus_interface_info_ref (org_gtk_private_CommandLine);
+      g_dbus_node_info_unref (info);
+    }
+
+  object_id = g_dbus_connection_register_object (impl->session_bus, object_path,
+                                                 org_gtk_private_CommandLine,
+                                                 &vtable, &data, NULL, NULL);
+  /* In theory we should try other paths... */
+  g_assert (object_id != 0);
+
+#ifdef G_OS_UNIX
+  {
+    GError *error = NULL;
+    GUnixFDList *fd_list;
+
+    /* send along the stdin in case
+     * g_application_command_line_get_stdin_data() is called
+     */
+    fd_list = g_unix_fd_list_new ();
+    g_unix_fd_list_append (fd_list, 0, &error);
+    g_assert_no_error (error);
+
+    g_dbus_connection_call_with_unix_fd_list (impl->session_bus, impl->bus_name, impl->object_path,
+                                              "org.gtk.Application", "CommandLine",
+                                              g_variant_new ("(o^aay@a{sv})", object_path, arguments, platform_data),
+                                              G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, fd_list, NULL,
+                                              g_application_impl_cmdline_done, &data);
+    g_object_unref (fd_list);
+  }
+#else
+  g_dbus_connection_call (impl->session_bus, impl->bus_name, impl->object_path,
+                          "org.gtk.Application", "CommandLine",
+                          g_variant_new ("(o^aay@a{sv})", object_path, arguments, platform_data),
+                          G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, NULL,
+                          g_application_impl_cmdline_done, &data);
+#endif
+
+  g_main_loop_run (data.loop);
+
+  g_main_context_pop_thread_default (context);
+  g_main_context_unref (context);
+  g_main_loop_unref (data.loop);
+
+  return data.status;
+}
+
 void
 g_application_impl_flush (GApplicationImpl *impl)
 {
-  g_dbus_connection_flush_sync (impl->session_bus, NULL, NULL);
+  if (impl->session_bus)
+    g_dbus_connection_flush_sync (impl->session_bus, NULL, NULL);
+}
+
+GDBusConnection *
+g_application_impl_get_dbus_connection (GApplicationImpl *impl)
+{
+  return impl->session_bus;
+}
+
+const gchar *
+g_application_impl_get_dbus_object_path (GApplicationImpl *impl)
+{
+  return impl->object_path;
+}
+
+/* GDBusCommandLine implementation {{{1 */
+
+typedef GApplicationCommandLineClass GDBusCommandLineClass;
+static GType g_dbus_command_line_get_type (void);
+typedef struct
+{
+  GApplicationCommandLine  parent_instance;
+  GDBusMethodInvocation   *invocation;
+
+  GDBusConnection *connection;
+  const gchar     *bus_name;
+  const gchar     *object_path;
+} GDBusCommandLine;
+
+
+G_DEFINE_TYPE (GDBusCommandLine,
+               g_dbus_command_line,
+               G_TYPE_APPLICATION_COMMAND_LINE)
+
+static void
+g_dbus_command_line_print_literal (GApplicationCommandLine *cmdline,
+                                   const gchar             *message)
+{
+  GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
+
+  g_dbus_connection_call (gdbcl->connection,
+                          gdbcl->bus_name,
+                          gdbcl->object_path,
+                          "org.gtk.private.CommandLine", "Print",
+                          g_variant_new ("(s)", message),
+                          NULL, 0, -1, NULL, NULL, NULL);
+}
+
+static void
+g_dbus_command_line_printerr_literal (GApplicationCommandLine *cmdline,
+                                      const gchar             *message)
+{
+  GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
+
+  g_dbus_connection_call (gdbcl->connection,
+                          gdbcl->bus_name,
+                          gdbcl->object_path,
+                          "org.gtk.private.CommandLine", "PrintError",
+                          g_variant_new ("(s)", message),
+                          NULL, 0, -1, NULL, NULL, NULL);
 }
+
+static GInputStream *
+g_dbus_command_line_get_stdin (GApplicationCommandLine *cmdline)
+{
+#ifdef G_OS_UNIX
+  GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
+  GInputStream *result = NULL;
+  GDBusMessage *message;
+  GUnixFDList *fd_list;
+
+  message = g_dbus_method_invocation_get_message (gdbcl->invocation);
+  fd_list = g_dbus_message_get_unix_fd_list (message);
+
+  if (fd_list && g_unix_fd_list_get_length (fd_list))
+    {
+      gint *fds, n_fds, i;
+
+      fds = g_unix_fd_list_steal_fds (fd_list, &n_fds);
+      result = g_unix_input_stream_new (fds[0], TRUE);
+      for (i = 1; i < n_fds; i++)
+        (void) g_close (fds[i], NULL);
+      g_free (fds);
+    }
+
+  return result;
+#else
+  return NULL;
+#endif
+}
+
+static void
+g_dbus_command_line_finalize (GObject *object)
+{
+  GApplicationCommandLine *cmdline = G_APPLICATION_COMMAND_LINE (object);
+  GDBusCommandLine *gdbcl = (GDBusCommandLine *) object;
+  gint status;
+
+  status = g_application_command_line_get_exit_status (cmdline);
+
+  g_dbus_method_invocation_return_value (gdbcl->invocation,
+                                         g_variant_new ("(i)", status));
+  g_object_unref (gdbcl->invocation);
+
+  G_OBJECT_CLASS (g_dbus_command_line_parent_class)
+    ->finalize (object);
+}
+
+static void
+g_dbus_command_line_init (GDBusCommandLine *gdbcl)
+{
+}
+
+static void
+g_dbus_command_line_class_init (GApplicationCommandLineClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = g_dbus_command_line_finalize;
+  class->printerr_literal = g_dbus_command_line_printerr_literal;
+  class->print_literal = g_dbus_command_line_print_literal;
+  class->get_stdin = g_dbus_command_line_get_stdin;
+}
+
+static GApplicationCommandLine *
+g_dbus_command_line_new (GDBusMethodInvocation *invocation)
+{
+  GDBusCommandLine *gdbcl;
+  GVariant *args;
+  GVariant *arguments, *platform_data;
+
+  args = g_dbus_method_invocation_get_parameters (invocation);
+
+  arguments = g_variant_get_child_value (args, 1);
+  platform_data = g_variant_get_child_value (args, 2);
+  gdbcl = g_object_new (g_dbus_command_line_get_type (),
+                        "arguments", arguments,
+                        "platform-data", platform_data,
+                        NULL);
+  g_variant_unref (arguments);
+  g_variant_unref (platform_data);
+
+  gdbcl->connection = g_dbus_method_invocation_get_connection (invocation);
+  gdbcl->bus_name = g_dbus_method_invocation_get_sender (invocation);
+  g_variant_get_child (args, 0, "&o", &gdbcl->object_path);
+  gdbcl->invocation = g_object_ref (invocation);
+
+  return G_APPLICATION_COMMAND_LINE (gdbcl);
+}
+
+/* Epilogue {{{1 */
+
+/* vim:set foldmethod=marker: */