gio/gapplicationimpl-dbus.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General
  15  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Authors: Ryan Lortie <desrt@desrt.ca>
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gapplicationimpl.h"
  23
  24 #include "gactiongroup.h"
  25 #include "gactiongroupexporter.h"
  26 #include "gremoteactiongroup.h"
  27 #include "gdbusactiongroup-private.h"
  28 #include "gapplication.h"
  29 #include "gfile.h"
  30 #include "gdbusconnection.h"
  31 #include "gdbusintrospection.h"
  32 #include "gdbuserror.h"
  33 #include "glib/gstdio.h"
  34
  35 #include <string.h>
  36 #include <stdio.h>
  37
  38 #include "gapplicationcommandline.h"
  39 #include "gdbusmethodinvocation.h"
  40
  41 #ifdef G_OS_UNIX
  42 #include "gunixinputstream.h"
  43 #include "gunixfdlist.h"
  44 #endif
  45
  46 /* DBus Interface definition {{{1 */
  47
  48 /* For documentation of these interfaces, see
  49  * https://wiki.gnome.org/Projects/GLib/GApplication/DBusAPI
  50  */
  51 static const gchar org_gtk_Application_xml[] =
  52   "<node>"
  53     "<interface name='org.gtk.Application'>"
  54       "<method name='Activate'>"
  55         "<arg type='a{sv}' name='platform-data' direction='in'/>"
  56       "</method>"
  57       "<method name='Open'>"
  58         "<arg type='as' name='uris' direction='in'/>"
  59         "<arg type='s' name='hint' direction='in'/>"
  60         "<arg type='a{sv}' name='platform-data' direction='in'/>"
  61       "</method>"
  62       "<method name='CommandLine'>"
  63         "<arg type='o' name='path' direction='in'/>"
  64         "<arg type='aay' name='arguments' direction='in'/>"
  65         "<arg type='a{sv}' name='platform-data' direction='in'/>"
  66         "<arg type='i' name='exit-status' direction='out'/>"
  67       "</method>"
  68     "<property name='Busy' type='b' access='read'/>"
  69     "</interface>"
  70   "</node>";
  71
  72 static GDBusInterfaceInfo *org_gtk_Application;
  73
  74 static const gchar org_freedesktop_Application_xml[] =
  75   "<node>"
  76     "<interface name='org.freedesktop.Application'>"
  77       "<method name='Activate'>"
  78         "<arg type='a{sv}' name='platform-data' direction='in'/>"
  79       "</method>"
  80       "<method name='Open'>"
  81         "<arg type='as' name='uris' direction='in'/>"
  82         "<arg type='a{sv}' name='platform-data' direction='in'/>"
  83       "</method>"
  84       "<method name='ActivateAction'>"
  85         "<arg type='s' name='action-name' direction='in'/>"
  86         "<arg type='av' name='parameter' direction='in'/>"
  87         "<arg type='a{sv}' name='platform-data' direction='in'/>"
  88       "</method>"
  89     "</interface>"
  90   "</node>";
  91
  92 static GDBusInterfaceInfo *org_freedesktop_Application;
  93
  94 static const gchar org_gtk_private_CommandLine_xml[] =
  95   "<node>"
  96     "<interface name='org.gtk.private.CommandLine'>"
  97       "<method name='Print'>"
  98         "<arg type='s' name='message' direction='in'/>"
  99       "</method>"
 100       "<method name='PrintError'>"
 101         "<arg type='s' name='message' direction='in'/>"
 102       "</method>"
 103     "</interface>"
 104   "</node>";
 105
 106 static GDBusInterfaceInfo *org_gtk_private_CommandLine;
 107
 108 /* GApplication implementation {{{1 */
 109 struct _GApplicationImpl
 110 {
 111   GDBusConnection *session_bus;
 112   GActionGroup    *exported_actions;
 113   const gchar     *bus_name;
 114
 115   gchar           *object_path;
 116   guint            object_id;
 117   guint            fdo_object_id;
 118   guint            actions_id;
 119
 120   gboolean         properties_live;
 121   gboolean         primary;
 122   gboolean         busy;
 123   GApplication    *app;
 124 };
 125
 126
 127 static GApplicationCommandLine *
 128 g_dbus_command_line_new (GDBusMethodInvocation *invocation);
 129
 130 static GVariant *
 131 g_application_impl_get_property (GDBusConnection *connection,
 132                                  const gchar  *sender,
 133                                  const gchar  *object_path,
 134                                  const gchar  *interface_name,
 135                                  const gchar  *property_name,
 136                                  GError      **error,
 137                                  gpointer      user_data)
 138 {
 139   GApplicationImpl *impl = user_data;
 140
 141   if (strcmp (property_name, "Busy") == 0)
 142     return g_variant_new_boolean (impl->busy);
 143
 144   g_assert_not_reached ();
 145
 146   return NULL;
 147 }
 148
 149 static void
 150 send_property_change (GApplicationImpl *impl)
 151 {
 152   GVariantBuilder builder;
 153
 154   g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
 155   g_variant_builder_add (&builder,
 156                          "{sv}",
 157                          "Busy", g_variant_new_boolean (impl->busy));
 158
 159   g_dbus_connection_emit_signal (impl->session_bus,
 160                                  NULL,
 161                                  impl->object_path,
 162                                  "org.freedesktop.DBus.Properties",
 163                                  "PropertiesChanged",
 164                                  g_variant_new ("(sa{sv}as)",
 165                                                 "org.gtk.Application",
 166                                                 &builder,
 167                                                 NULL),
 168                                  NULL);
 169 }
 170
 171 static void
 172 g_application_impl_method_call (GDBusConnection       *connection,
 173                                 const gchar           *sender,
 174                                 const gchar           *object_path,
 175                                 const gchar           *interface_name,
 176                                 const gchar           *method_name,
 177                                 GVariant              *parameters,
 178                                 GDBusMethodInvocation *invocation,
 179                                 gpointer               user_data)
 180 {
 181   GApplicationImpl *impl = user_data;
 182   GApplicationClass *class;
 183
 184   class = G_APPLICATION_GET_CLASS (impl->app);
 185
 186   if (strcmp (method_name, "Activate") == 0)
 187     {
 188       GVariant *platform_data;
 189
 190       /* Completely the same for both freedesktop and gtk interfaces */
 191
 192       g_variant_get (parameters, "(@a{sv})", &platform_data);
 193
 194       class->before_emit (impl->app, platform_data);
 195       g_signal_emit_by_name (impl->app, "activate");
 196       class->after_emit (impl->app, platform_data);
 197       g_variant_unref (platform_data);
 198
 199       g_dbus_method_invocation_return_value (invocation, NULL);
 200     }
 201
 202   else if (strcmp (method_name, "Open") == 0)
 203     {
 204       GApplicationFlags flags;
 205       GVariant *platform_data;
 206       const gchar *hint;
 207       GVariant *array;
 208       GFile **files;
 209       gint n, i;
 210
 211       flags = g_application_get_flags (impl->app);
 212       if ((flags & G_APPLICATION_HANDLES_OPEN) == 0)
 213         {
 214           g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Application does not open files");
 215           return;
 216         }
 217
 218       /* freedesktop interface has no hint parameter */
 219       if (g_str_equal (interface_name, "org.freedesktop.Application"))
 220         {
 221           g_variant_get (parameters, "(@as@a{sv})", &array, &platform_data);
 222           hint = "";
 223         }
 224       else
 225         g_variant_get (parameters, "(@as&s@a{sv})", &array, &hint, &platform_data);
 226
 227       n = g_variant_n_children (array);
 228       files = g_new (GFile *, n + 1);
 229
 230       for (i = 0; i < n; i++)
 231         {
 232           const gchar *uri;
 233
 234           g_variant_get_child (array, i, "&s", &uri);
 235           files[i] = g_file_new_for_uri (uri);
 236         }
 237       g_variant_unref (array);
 238       files[n] = NULL;
 239
 240       class->before_emit (impl->app, platform_data);
 241       g_signal_emit_by_name (impl->app, "open", files, n, hint);
 242       class->after_emit (impl->app, platform_data);
 243
 244       g_variant_unref (platform_data);
 245
 246       for (i = 0; i < n; i++)
 247         g_object_unref (files[i]);
 248       g_free (files);
 249
 250       g_dbus_method_invocation_return_value (invocation, NULL);
 251     }
 252
 253   else if (strcmp (method_name, "CommandLine") == 0)
 254     {
 255       GApplicationFlags flags;
 256       GApplicationCommandLine *cmdline;
 257       GVariant *platform_data;
 258       int status;
 259
 260       flags = g_application_get_flags (impl->app);
 261       if ((flags & G_APPLICATION_HANDLES_COMMAND_LINE) == 0)
 262         {
 263           g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED,
 264                                                  "Application does not handle command line arguments");
 265           return;
 266         }
 267
 268       /* Only on the GtkApplication interface */
 269
 270       cmdline = g_dbus_command_line_new (invocation);
 271       platform_data = g_variant_get_child_value (parameters, 2);
 272       class->before_emit (impl->app, platform_data);
 273       g_signal_emit_by_name (impl->app, "command-line", cmdline, &status);
 274       g_application_command_line_set_exit_status (cmdline, status);
 275       class->after_emit (impl->app, platform_data);
 276       g_variant_unref (platform_data);
 277       g_object_unref (cmdline);
 278     }
 279   else if (g_str_equal (method_name, "ActivateAction"))
 280     {
 281       GVariant *parameter = NULL;
 282       GVariant *platform_data;
 283       GVariantIter *iter;
 284       const gchar *name;
 285
 286       /* Only on the freedesktop interface */
 287
 288       g_variant_get (parameters, "(&sav@a{sv})", &name, &iter, &platform_data);
 289       g_variant_iter_next (iter, "v", &parameter);
 290       g_variant_iter_free (iter);
 291
 292       class->before_emit (impl->app, platform_data);
 293       g_action_group_activate_action (impl->exported_actions, name, parameter);
 294       class->after_emit (impl->app, platform_data);
 295
 296       if (parameter)
 297         g_variant_unref (parameter);
 298
 299       g_variant_unref (platform_data);
 300
 301       g_dbus_method_invocation_return_value (invocation, NULL);
 302     }
 303   else
 304     g_assert_not_reached ();
 305 }
 306
 307 static gchar *
 308 application_path_from_appid (const gchar *appid)
 309 {
 310   gchar *appid_path, *iter;
 311
 312   if (appid == NULL)
 313     /* this is a private implementation detail */
 314     return g_strdup ("/org/gtk/Application/anonymous");
 315
 316   appid_path = g_strconcat ("/", appid, NULL);
 317   for (iter = appid_path; *iter; iter++)
 318     {
 319       if (*iter == '.')
 320         *iter = '/';
 321
 322       if (*iter == '-')
 323         *iter = '_';
 324     }
 325
 326   return appid_path;
 327 }
 328
 329 /* Attempt to become the primary instance.
 330  *
 331  * Returns %TRUE if everything went OK, regardless of if we became the
 332  * primary instance or not.  %FALSE is reserved for when something went
 333  * seriously wrong (and @error will be set too, in that case).
 334  *
 335  * After a %TRUE return, impl->primary will be TRUE if we were
 336  * successful.
 337  */
 338 static gboolean
 339 g_application_impl_attempt_primary (GApplicationImpl  *impl,
 340                                     GCancellable      *cancellable,
 341                                     GError           **error)
 342 {
 343   const static GDBusInterfaceVTable vtable = {
 344     g_application_impl_method_call,
 345     g_application_impl_get_property,
 346     NULL /* set_property */
 347   };
 348   GApplicationClass *app_class = G_APPLICATION_GET_CLASS (impl->app);
 349   guint32 rval;
 350
 351   if (org_gtk_Application == NULL)
 352     {
 353       GError *error = NULL;
 354       GDBusNodeInfo *info;
 355
 356       info = g_dbus_node_info_new_for_xml (org_gtk_Application_xml, &error);
 357       if G_UNLIKELY (info == NULL)
 358         g_error ("%s", error->message);
 359       org_gtk_Application = g_dbus_node_info_lookup_interface (info, "org.gtk.Application");
 360       g_assert (org_gtk_Application != NULL);
 361       g_dbus_interface_info_ref (org_gtk_Application);
 362       g_dbus_node_info_unref (info);
 363
 364       info = g_dbus_node_info_new_for_xml (org_freedesktop_Application_xml, &error);
 365       if G_UNLIKELY (info == NULL)
 366         g_error ("%s", error->message);
 367       org_freedesktop_Application = g_dbus_node_info_lookup_interface (info, "org.freedesktop.Application");
 368       g_assert (org_freedesktop_Application != NULL);
 369       g_dbus_interface_info_ref (org_freedesktop_Application);
 370       g_dbus_node_info_unref (info);
 371     }
 372
 373   /* We could possibly have been D-Bus activated as a result of incoming
 374    * requests on either the application or actiongroup interfaces.
 375    * Because of how GDBus dispatches messages, we need to ensure that
 376    * both of those things are registered before we attempt to request
 377    * our name.
 378    *
 379    * The action group need not be populated yet, as long as it happens
 380    * before we return to the mainloop.  The reason for that is because
 381    * GDBus does the check to make sure the object exists from the worker
 382    * thread but doesn't actually dispatch the action invocation until we
 383    * hit the mainloop in this thread.  There is also no danger of
 384    * receiving 'activate' or 'open' signals until after 'startup' runs,
 385    * for the same reason.
 386    */
 387   impl->object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
 388                                                        org_gtk_Application, &vtable, impl, NULL, error);
 389
 390   if (impl->object_id == 0)
 391     return FALSE;
 392
 393   impl->fdo_object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
 394                                                            org_freedesktop_Application, &vtable, impl, NULL, error);
 395
 396   if (impl->fdo_object_id == 0)
 397     return FALSE;
 398
 399   impl->actions_id = g_dbus_connection_export_action_group (impl->session_bus, impl->object_path,
 400                                                             impl->exported_actions, error);
 401
 402   if (impl->actions_id == 0)
 403     return FALSE;
 404
 405   if (!app_class->dbus_register (impl->app,
 406                                  impl->session_bus,
 407                                  impl->object_path,
 408                                  error))
 409     return FALSE;
 410
 411   if (impl->bus_name == NULL)
 412     {
 413       /* If this is a non-unique application then it is sufficient to
 414        * have our object paths registered. We can return now.
 415        *
 416        * Note: non-unique applications always act as primary-instance.
 417        */
 418       impl->primary = TRUE;
 419       return TRUE;
 420     }
 421
 422   /* If this is a unique application then we need to attempt to own
 423    * the well-known name and fall back to remote mode (!is_primary)
 424    * in the case that we can't do that.
 425    */
 426   /* DBUS_NAME_FLAG_DO_NOT_QUEUE: 0x4 */
 427   rval = g_dbus_request_name (impl->session_bus, impl->bus_name, G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE, error);
 428
 429   if (rval == G_BUS_REQUEST_NAME_FLAGS_ERROR)
 430     return FALSE;
 431
 432   /* DBUS_REQUEST_NAME_REPLY_EXISTS: 3 */
 433   impl->primary = (rval != 3);
 434
 435   return TRUE;
 436 }
 437
 438 /* Stop doing the things that the primary instance does.
 439  *
 440  * This should be called if attempting to become the primary instance
 441  * failed (in order to clean up any partial success) and should also
 442  * be called when freeing the GApplication.
 443  *
 444  * It is safe to call this multiple times.
 445  */
 446 static void
 447 g_application_impl_stop_primary (GApplicationImpl *impl)
 448 {
 449   GApplicationClass *app_class = G_APPLICATION_GET_CLASS (impl->app);
 450
 451   app_class->dbus_unregister (impl->app,
 452                               impl->session_bus,
 453                               impl->object_path);
 454
 455   if (impl->object_id)
 456     {
 457       g_dbus_connection_unregister_object (impl->session_bus, impl->object_id);
 458       impl->object_id = 0;
 459     }
 460
 461   if (impl->fdo_object_id)
 462     {
 463       g_dbus_connection_unregister_object (impl->session_bus, impl->fdo_object_id);
 464       impl->fdo_object_id = 0;
 465     }
 466
 467   if (impl->actions_id)
 468     {
 469       g_dbus_connection_unexport_action_group (impl->session_bus, impl->actions_id);
 470       impl->actions_id = 0;
 471     }
 472
 473   if (impl->primary && impl->bus_name)
 474     {
 475       g_dbus_release_name (impl->session_bus, impl->bus_name, NULL);
 476       impl->primary = FALSE;
 477     }
 478 }
 479
 480 void
 481 g_application_impl_set_busy_state (GApplicationImpl *impl,
 482                                    gboolean          busy)
 483 {
 484   if (impl->busy != busy)
 485     {
 486       impl->busy = busy;
 487       send_property_change (impl);
 488     }
 489 }
 490
 491 void
 492 g_application_impl_destroy (GApplicationImpl *impl)
 493 {
 494   g_application_impl_stop_primary (impl);
 495
 496   if (impl->session_bus)
 497     g_object_unref (impl->session_bus);
 498
 499   g_free (impl->object_path);
 500
 501   g_slice_free (GApplicationImpl, impl);
 502 }
 503
 504 GApplicationImpl *
 505 g_application_impl_register (GApplication        *application,
 506                              const gchar         *appid,
 507                              GApplicationFlags    flags,
 508                              GActionGroup        *exported_actions,
 509                              GRemoteActionGroup **remote_actions,
 510                              GCancellable        *cancellable,
 511                              GError             **error)
 512 {
 513   GDBusActionGroup *actions;
 514   GApplicationImpl *impl;
 515
 516   g_assert ((flags & G_APPLICATION_NON_UNIQUE) || appid != NULL);
 517
 518   impl = g_slice_new0 (GApplicationImpl);
 519
 520   impl->app = application;
 521   impl->exported_actions = exported_actions;
 522
 523   /* non-unique applications do not attempt to acquire a bus name */
 524   if (~flags & G_APPLICATION_NON_UNIQUE)
 525     impl->bus_name = appid;
 526
 527   impl->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, NULL);
 528
 529   if (impl->session_bus == NULL)
 530     {
 531       /* If we can't connect to the session bus, proceed as a normal
 532        * non-unique application.
 533        */
 534       *remote_actions = NULL;
 535       return impl;
 536     }
 537
 538   impl->object_path = application_path_from_appid (appid);
 539
 540   /* Only try to be the primary instance if
 541    * G_APPLICATION_IS_LAUNCHER was not specified.
 542    */
 543   if (~flags & G_APPLICATION_IS_LAUNCHER)
 544     {
 545       if (!g_application_impl_attempt_primary (impl, cancellable, error))
 546         {
 547           g_application_impl_destroy (impl);
 548           return NULL;
 549         }
 550
 551       if (impl->primary)
 552         return impl;
 553
 554       /* We didn't make it.  Drop our service-side stuff. */
 555       g_application_impl_stop_primary (impl);
 556
 557       if (flags & G_APPLICATION_IS_SERVICE)
 558         {
 559           g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
 560                        "Unable to acquire bus name '%s'", appid);
 561           g_application_impl_destroy (impl);
 562
 563           return NULL;
 564         }
 565     }
 566
 567   /* We are non-primary.  Try to get the primary's list of actions.
 568    * This also serves as a mechanism to ensure that the primary exists
 569    * (ie: DBus service files installed correctly, etc).
 570    */
 571   actions = g_dbus_action_group_get (impl->session_bus, impl->bus_name, impl->object_path);
 572   if (!g_dbus_action_group_sync (actions, cancellable, error))
 573     {
 574       /* The primary appears not to exist.  Fail the registration. */
 575       g_application_impl_destroy (impl);
 576       g_object_unref (actions);
 577
 578       return NULL;
 579     }
 580
 581   *remote_actions = G_REMOTE_ACTION_GROUP (actions);
 582
 583   return impl;
 584 }
 585
 586 void
 587 g_application_impl_activate (GApplicationImpl *impl,
 588                              GVariant         *platform_data)
 589 {
 590   g_dbus_connection_call (impl->session_bus,
 591                           impl->bus_name,
 592                           impl->object_path,
 593                           "org.gtk.Application",
 594                           "Activate",
 595                           g_variant_new ("(@a{sv})", platform_data),
 596                           NULL, 0, -1, NULL, NULL, NULL);
 597 }
 598
 599 void
 600 g_application_impl_open (GApplicationImpl  *impl,
 601                          GFile            **files,
 602                          gint               n_files,
 603                          const gchar       *hint,
 604                          GVariant          *platform_data)
 605 {
 606   GVariantBuilder builder;
 607   gint i;
 608
 609   g_variant_builder_init (&builder, G_VARIANT_TYPE ("(assa{sv})"));
 610   g_variant_builder_open (&builder, G_VARIANT_TYPE_STRING_ARRAY);
 611   for (i = 0; i < n_files; i++)
 612     {
 613       gchar *uri = g_file_get_uri (files[i]);
 614       g_variant_builder_add (&builder, "s", uri);
 615       g_free (uri);
 616     }
 617   g_variant_builder_close (&builder);
 618   g_variant_builder_add (&builder, "s", hint);
 619   g_variant_builder_add_value (&builder, platform_data);
 620
 621   g_dbus_connection_call (impl->session_bus,
 622                           impl->bus_name,
 623                           impl->object_path,
 624                           "org.gtk.Application",
 625                           "Open",
 626                           g_variant_builder_end (&builder),
 627                           NULL, 0, -1, NULL, NULL, NULL);
 628 }
 629
 630 static void
 631 g_application_impl_cmdline_method_call (GDBusConnection       *connection,
 632                                         const gchar           *sender,
 633                                         const gchar           *object_path,
 634                                         const gchar           *interface_name,
 635                                         const gchar           *method_name,
 636                                         GVariant              *parameters,
 637                                         GDBusMethodInvocation *invocation,
 638                                         gpointer               user_data)
 639 {
 640   const gchar *message;
 641
 642   g_variant_get_child (parameters, 0, "&s", &message);
 643
 644   if (strcmp (method_name, "Print") == 0)
 645     g_print ("%s", message);
 646   else if (strcmp (method_name, "PrintError") == 0)
 647     g_printerr ("%s", message);
 648   else
 649     g_assert_not_reached ();
 650
 651   g_dbus_method_invocation_return_value (invocation, NULL);
 652 }
 653
 654 typedef struct
 655 {
 656   GMainLoop *loop;
 657   int status;
 658 } CommandLineData;
 659
 660 static void
 661 g_application_impl_cmdline_done (GObject      *source,
 662                                  GAsyncResult *result,
 663                                  gpointer      user_data)
 664 {
 665   CommandLineData *data = user_data;
 666   GError *error = NULL;
 667   GVariant *reply;
 668
 669 #ifdef G_OS_UNIX
 670   reply = g_dbus_connection_call_with_unix_fd_list_finish (G_DBUS_CONNECTION (source), NULL, result, &error);
 671 #else
 672   reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
 673 #endif
 674
 675
 676   if (reply != NULL)
 677     {
 678       g_variant_get (reply, "(i)", &data->status);
 679       g_variant_unref (reply);
 680     }
 681
 682   else
 683     {
 684       g_printerr ("%s\n", error->message);
 685       g_error_free (error);
 686       data->status = 1;
 687     }
 688
 689   g_main_loop_quit (data->loop);
 690 }
 691
 692 int
 693 g_application_impl_command_line (GApplicationImpl    *impl,
 694                                  const gchar * const *arguments,
 695                                  GVariant            *platform_data)
 696 {
 697   const static GDBusInterfaceVTable vtable = {
 698     g_application_impl_cmdline_method_call
 699   };
 700   const gchar *object_path = "/org/gtk/Application/CommandLine";
 701   GMainContext *context;
 702   CommandLineData data;
 703   guint object_id;
 704
 705   context = g_main_context_new ();
 706   data.loop = g_main_loop_new (context, FALSE);
 707   g_main_context_push_thread_default (context);
 708
 709   if (org_gtk_private_CommandLine == NULL)
 710     {
 711       GError *error = NULL;
 712       GDBusNodeInfo *info;
 713
 714       info = g_dbus_node_info_new_for_xml (org_gtk_private_CommandLine_xml, &error);
 715       if G_UNLIKELY (info == NULL)
 716         g_error ("%s", error->message);
 717       org_gtk_private_CommandLine = g_dbus_node_info_lookup_interface (info, "org.gtk.private.CommandLine");
 718       g_assert (org_gtk_private_CommandLine != NULL);
 719       g_dbus_interface_info_ref (org_gtk_private_CommandLine);
 720       g_dbus_node_info_unref (info);
 721     }
 722
 723   object_id = g_dbus_connection_register_object (impl->session_bus, object_path,
 724                                                  org_gtk_private_CommandLine,
 725                                                  &vtable, &data, NULL, NULL);
 726   /* In theory we should try other paths... */
 727   g_assert (object_id != 0);
 728
 729 #ifdef G_OS_UNIX
 730   {
 731     GError *error = NULL;
 732     GUnixFDList *fd_list;
 733
 734     /* send along the stdin in case
 735      * g_application_command_line_get_stdin_data() is called
 736      */
 737     fd_list = g_unix_fd_list_new ();
 738     g_unix_fd_list_append (fd_list, 0, &error);
 739     g_assert_no_error (error);
 740
 741     g_dbus_connection_call_with_unix_fd_list (impl->session_bus, impl->bus_name, impl->object_path,
 742                                               "org.gtk.Application", "CommandLine",
 743                                               g_variant_new ("(o^aay@a{sv})", object_path, arguments, platform_data),
 744                                               G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, fd_list, NULL,
 745                                               g_application_impl_cmdline_done, &data);
 746     g_object_unref (fd_list);
 747   }
 748 #else
 749   g_dbus_connection_call (impl->session_bus, impl->bus_name, impl->object_path,
 750                           "org.gtk.Application", "CommandLine",
 751                           g_variant_new ("(o^aay@a{sv})", object_path, arguments, platform_data),
 752                           G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, NULL,
 753                           g_application_impl_cmdline_done, &data);
 754 #endif
 755
 756   g_main_loop_run (data.loop);
 757
 758   g_main_context_pop_thread_default (context);
 759   g_main_context_unref (context);
 760   g_main_loop_unref (data.loop);
 761
 762   return data.status;
 763 }
 764
 765 void
 766 g_application_impl_flush (GApplicationImpl *impl)
 767 {
 768   if (impl->session_bus)
 769     g_dbus_connection_flush_sync (impl->session_bus, NULL, NULL);
 770 }
 771
 772 GDBusConnection *
 773 g_application_impl_get_dbus_connection (GApplicationImpl *impl)
 774 {
 775   return impl->session_bus;
 776 }
 777
 778 const gchar *
 779 g_application_impl_get_dbus_object_path (GApplicationImpl *impl)
 780 {
 781   return impl->object_path;
 782 }
 783
 784 /* GDBusCommandLine implementation {{{1 */
 785
 786 typedef GApplicationCommandLineClass GDBusCommandLineClass;
 787 static GType g_dbus_command_line_get_type (void);
 788 typedef struct
 789 {
 790   GApplicationCommandLine  parent_instance;
 791   GDBusMethodInvocation   *invocation;
 792
 793   GDBusConnection *connection;
 794   const gchar     *bus_name;
 795   const gchar     *object_path;
 796 } GDBusCommandLine;
 797
 798
 799 G_DEFINE_TYPE (GDBusCommandLine,
 800                g_dbus_command_line,
 801                G_TYPE_APPLICATION_COMMAND_LINE)
 802
 803 static void
 804 g_dbus_command_line_print_literal (GApplicationCommandLine *cmdline,
 805                                    const gchar             *message)
 806 {
 807   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 808
 809   g_dbus_connection_call (gdbcl->connection,
 810                           gdbcl->bus_name,
 811                           gdbcl->object_path,
 812                           "org.gtk.private.CommandLine", "Print",
 813                           g_variant_new ("(s)", message),
 814                           NULL, 0, -1, NULL, NULL, NULL);
 815 }
 816
 817 static void
 818 g_dbus_command_line_printerr_literal (GApplicationCommandLine *cmdline,
 819                                       const gchar             *message)
 820 {
 821   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 822
 823   g_dbus_connection_call (gdbcl->connection,
 824                           gdbcl->bus_name,
 825                           gdbcl->object_path,
 826                           "org.gtk.private.CommandLine", "PrintError",
 827                           g_variant_new ("(s)", message),
 828                           NULL, 0, -1, NULL, NULL, NULL);
 829 }
 830
 831 static GInputStream *
 832 g_dbus_command_line_get_stdin (GApplicationCommandLine *cmdline)
 833 {
 834 #ifdef G_OS_UNIX
 835   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 836   GInputStream *result = NULL;
 837   GDBusMessage *message;
 838   GUnixFDList *fd_list;
 839
 840   message = g_dbus_method_invocation_get_message (gdbcl->invocation);
 841   fd_list = g_dbus_message_get_unix_fd_list (message);
 842
 843   if (fd_list && g_unix_fd_list_get_length (fd_list))
 844     {
 845       const gint *fds;
 846
 847       fds = g_unix_fd_list_peek_fds (fd_list, NULL);
 848       result = g_unix_input_stream_new (fds[0], FALSE);
 849       g_object_weak_ref (G_OBJECT (result),
 850                          (GWeakNotify) g_object_unref,
 851                          g_object_ref (fd_list));
 852     }
 853
 854   return result;
 855 #else
 856   return NULL;
 857 #endif
 858 }
 859
 860 static void
 861 g_dbus_command_line_finalize (GObject *object)
 862 {
 863   GApplicationCommandLine *cmdline = G_APPLICATION_COMMAND_LINE (object);
 864   GDBusCommandLine *gdbcl = (GDBusCommandLine *) object;
 865   gint status;
 866
 867   status = g_application_command_line_get_exit_status (cmdline);
 868
 869   g_dbus_method_invocation_return_value (gdbcl->invocation,
 870                                          g_variant_new ("(i)", status));
 871   g_object_unref (gdbcl->invocation);
 872
 873   G_OBJECT_CLASS (g_dbus_command_line_parent_class)
 874     ->finalize (object);
 875 }
 876
 877 static void
 878 g_dbus_command_line_init (GDBusCommandLine *gdbcl)
 879 {
 880 }
 881
 882 static void
 883 g_dbus_command_line_class_init (GApplicationCommandLineClass *class)
 884 {
 885   GObjectClass *object_class = G_OBJECT_CLASS (class);
 886
 887   object_class->finalize = g_dbus_command_line_finalize;
 888   class->printerr_literal = g_dbus_command_line_printerr_literal;
 889   class->print_literal = g_dbus_command_line_print_literal;
 890   class->get_stdin = g_dbus_command_line_get_stdin;
 891 }
 892
 893 static GApplicationCommandLine *
 894 g_dbus_command_line_new (GDBusMethodInvocation *invocation)
 895 {
 896   GDBusCommandLine *gdbcl;
 897   GVariant *args;
 898   GVariant *arguments, *platform_data;
 899
 900   args = g_dbus_method_invocation_get_parameters (invocation);
 901
 902   arguments = g_variant_get_child_value (args, 1);
 903   platform_data = g_variant_get_child_value (args, 2);
 904   gdbcl = g_object_new (g_dbus_command_line_get_type (),
 905                         "arguments", arguments,
 906                         "platform-data", platform_data,
 907                         NULL);
 908   g_variant_unref (arguments);
 909   g_variant_unref (platform_data);
 910
 911   gdbcl->connection = g_dbus_method_invocation_get_connection (invocation);
 912   gdbcl->bus_name = g_dbus_method_invocation_get_sender (invocation);
 913   g_variant_get_child (args, 0, "&o", &gdbcl->object_path);
 914   gdbcl->invocation = g_object_ref (invocation);
 915
 916   return G_APPLICATION_COMMAND_LINE (gdbcl);
 917 }
 918
 919 /* Epilogue {{{1 */
 920
 921 /* vim:set foldmethod=marker: */