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   GVariant *reply;
 350   guint32 rval;
 351
 352   if (org_gtk_Application == NULL)
 353     {
 354       GError *error = NULL;
 355       GDBusNodeInfo *info;
 356
 357       info = g_dbus_node_info_new_for_xml (org_gtk_Application_xml, &error);
 358       if G_UNLIKELY (info == NULL)
 359         g_error ("%s", error->message);
 360       org_gtk_Application = g_dbus_node_info_lookup_interface (info, "org.gtk.Application");
 361       g_assert (org_gtk_Application != NULL);
 362       g_dbus_interface_info_ref (org_gtk_Application);
 363       g_dbus_node_info_unref (info);
 364
 365       info = g_dbus_node_info_new_for_xml (org_freedesktop_Application_xml, &error);
 366       if G_UNLIKELY (info == NULL)
 367         g_error ("%s", error->message);
 368       org_freedesktop_Application = g_dbus_node_info_lookup_interface (info, "org.freedesktop.Application");
 369       g_assert (org_freedesktop_Application != NULL);
 370       g_dbus_interface_info_ref (org_freedesktop_Application);
 371       g_dbus_node_info_unref (info);
 372     }
 373
 374   /* We could possibly have been D-Bus activated as a result of incoming
 375    * requests on either the application or actiongroup interfaces.
 376    * Because of how GDBus dispatches messages, we need to ensure that
 377    * both of those things are registered before we attempt to request
 378    * our name.
 379    *
 380    * The action group need not be populated yet, as long as it happens
 381    * before we return to the mainloop.  The reason for that is because
 382    * GDBus does the check to make sure the object exists from the worker
 383    * thread but doesn't actually dispatch the action invocation until we
 384    * hit the mainloop in this thread.  There is also no danger of
 385    * receiving 'activate' or 'open' signals until after 'startup' runs,
 386    * for the same reason.
 387    */
 388   impl->object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
 389                                                        org_gtk_Application, &vtable, impl, NULL, error);
 390
 391   if (impl->object_id == 0)
 392     return FALSE;
 393
 394   impl->fdo_object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
 395                                                            org_freedesktop_Application, &vtable, impl, NULL, error);
 396
 397   if (impl->fdo_object_id == 0)
 398     return FALSE;
 399
 400   impl->actions_id = g_dbus_connection_export_action_group (impl->session_bus, impl->object_path,
 401                                                             impl->exported_actions, error);
 402
 403   if (impl->actions_id == 0)
 404     return FALSE;
 405
 406   if (!app_class->dbus_register (impl->app,
 407                                  impl->session_bus,
 408                                  impl->object_path,
 409                                  error))
 410     return FALSE;
 411
 412   if (impl->bus_name == NULL)
 413     {
 414       /* If this is a non-unique application then it is sufficient to
 415        * have our object paths registered. We can return now.
 416        *
 417        * Note: non-unique applications always act as primary-instance.
 418        */
 419       impl->primary = TRUE;
 420       return TRUE;
 421     }
 422
 423   /* If this is a unique application then we need to attempt to own
 424    * the well-known name and fall back to remote mode (!is_primary)
 425    * in the case that we can't do that.
 426    */
 427   /* DBUS_NAME_FLAG_DO_NOT_QUEUE: 0x4 */
 428   reply = g_dbus_connection_call_sync (impl->session_bus, "org.freedesktop.DBus", "/org/freedesktop/DBus",
 429                                        "org.freedesktop.DBus", "RequestName",
 430                                        g_variant_new ("(su)", impl->bus_name, 0x4), G_VARIANT_TYPE ("(u)"),
 431                                        0, -1, cancellable, error);
 432
 433   if (reply == NULL)
 434     return FALSE;
 435
 436   g_variant_get (reply, "(u)", &rval);
 437   g_variant_unref (reply);
 438
 439   /* DBUS_REQUEST_NAME_REPLY_EXISTS: 3 */
 440   impl->primary = (rval != 3);
 441
 442   return TRUE;
 443 }
 444
 445 /* Stop doing the things that the primary instance does.
 446  *
 447  * This should be called if attempting to become the primary instance
 448  * failed (in order to clean up any partial success) and should also
 449  * be called when freeing the GApplication.
 450  *
 451  * It is safe to call this multiple times.
 452  */
 453 static void
 454 g_application_impl_stop_primary (GApplicationImpl *impl)
 455 {
 456   GApplicationClass *app_class = G_APPLICATION_GET_CLASS (impl->app);
 457
 458   app_class->dbus_unregister (impl->app,
 459                               impl->session_bus,
 460                               impl->object_path);
 461
 462   if (impl->object_id)
 463     {
 464       g_dbus_connection_unregister_object (impl->session_bus, impl->object_id);
 465       impl->object_id = 0;
 466     }
 467
 468   if (impl->fdo_object_id)
 469     {
 470       g_dbus_connection_unregister_object (impl->session_bus, impl->fdo_object_id);
 471       impl->fdo_object_id = 0;
 472     }
 473
 474   if (impl->actions_id)
 475     {
 476       g_dbus_connection_unexport_action_group (impl->session_bus, impl->actions_id);
 477       impl->actions_id = 0;
 478     }
 479
 480   if (impl->primary && impl->bus_name)
 481     {
 482       g_dbus_connection_call (impl->session_bus, "org.freedesktop.DBus",
 483                               "/org/freedesktop/DBus", "org.freedesktop.DBus",
 484                               "ReleaseName", g_variant_new ("(s)", impl->bus_name),
 485                               NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 486       impl->primary = FALSE;
 487     }
 488 }
 489
 490 void
 491 g_application_impl_set_busy_state (GApplicationImpl *impl,
 492                                    gboolean          busy)
 493 {
 494   if (impl->busy != busy)
 495     {
 496       impl->busy = busy;
 497       send_property_change (impl);
 498     }
 499 }
 500
 501 void
 502 g_application_impl_destroy (GApplicationImpl *impl)
 503 {
 504   g_application_impl_stop_primary (impl);
 505
 506   if (impl->session_bus)
 507     g_object_unref (impl->session_bus);
 508
 509   g_free (impl->object_path);
 510
 511   g_slice_free (GApplicationImpl, impl);
 512 }
 513
 514 GApplicationImpl *
 515 g_application_impl_register (GApplication        *application,
 516                              const gchar         *appid,
 517                              GApplicationFlags    flags,
 518                              GActionGroup        *exported_actions,
 519                              GRemoteActionGroup **remote_actions,
 520                              GCancellable        *cancellable,
 521                              GError             **error)
 522 {
 523   GDBusActionGroup *actions;
 524   GApplicationImpl *impl;
 525
 526   g_assert ((flags & G_APPLICATION_NON_UNIQUE) || appid != NULL);
 527
 528   impl = g_slice_new0 (GApplicationImpl);
 529
 530   impl->app = application;
 531   impl->exported_actions = exported_actions;
 532
 533   /* non-unique applications do not attempt to acquire a bus name */
 534   if (~flags & G_APPLICATION_NON_UNIQUE)
 535     impl->bus_name = appid;
 536
 537   impl->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, NULL);
 538
 539   if (impl->session_bus == NULL)
 540     {
 541       /* If we can't connect to the session bus, proceed as a normal
 542        * non-unique application.
 543        */
 544       *remote_actions = NULL;
 545       return impl;
 546     }
 547
 548   impl->object_path = application_path_from_appid (appid);
 549
 550   /* Only try to be the primary instance if
 551    * G_APPLICATION_IS_LAUNCHER was not specified.
 552    */
 553   if (~flags & G_APPLICATION_IS_LAUNCHER)
 554     {
 555       if (!g_application_impl_attempt_primary (impl, cancellable, error))
 556         {
 557           g_application_impl_destroy (impl);
 558           return NULL;
 559         }
 560
 561       if (impl->primary)
 562         return impl;
 563
 564       /* We didn't make it.  Drop our service-side stuff. */
 565       g_application_impl_stop_primary (impl);
 566
 567       if (flags & G_APPLICATION_IS_SERVICE)
 568         {
 569           g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
 570                        "Unable to acquire bus name '%s'", appid);
 571           g_application_impl_destroy (impl);
 572
 573           return NULL;
 574         }
 575     }
 576
 577   /* We are non-primary.  Try to get the primary's list of actions.
 578    * This also serves as a mechanism to ensure that the primary exists
 579    * (ie: DBus service files installed correctly, etc).
 580    */
 581   actions = g_dbus_action_group_get (impl->session_bus, impl->bus_name, impl->object_path);
 582   if (!g_dbus_action_group_sync (actions, cancellable, error))
 583     {
 584       /* The primary appears not to exist.  Fail the registration. */
 585       g_application_impl_destroy (impl);
 586       g_object_unref (actions);
 587
 588       return NULL;
 589     }
 590
 591   *remote_actions = G_REMOTE_ACTION_GROUP (actions);
 592
 593   return impl;
 594 }
 595
 596 void
 597 g_application_impl_activate (GApplicationImpl *impl,
 598                              GVariant         *platform_data)
 599 {
 600   g_dbus_connection_call (impl->session_bus,
 601                           impl->bus_name,
 602                           impl->object_path,
 603                           "org.gtk.Application",
 604                           "Activate",
 605                           g_variant_new ("(@a{sv})", platform_data),
 606                           NULL, 0, -1, NULL, NULL, NULL);
 607 }
 608
 609 void
 610 g_application_impl_open (GApplicationImpl  *impl,
 611                          GFile            **files,
 612                          gint               n_files,
 613                          const gchar       *hint,
 614                          GVariant          *platform_data)
 615 {
 616   GVariantBuilder builder;
 617   gint i;
 618
 619   g_variant_builder_init (&builder, G_VARIANT_TYPE ("(assa{sv})"));
 620   g_variant_builder_open (&builder, G_VARIANT_TYPE_STRING_ARRAY);
 621   for (i = 0; i < n_files; i++)
 622     {
 623       gchar *uri = g_file_get_uri (files[i]);
 624       g_variant_builder_add (&builder, "s", uri);
 625       g_free (uri);
 626     }
 627   g_variant_builder_close (&builder);
 628   g_variant_builder_add (&builder, "s", hint);
 629   g_variant_builder_add_value (&builder, platform_data);
 630
 631   g_dbus_connection_call (impl->session_bus,
 632                           impl->bus_name,
 633                           impl->object_path,
 634                           "org.gtk.Application",
 635                           "Open",
 636                           g_variant_builder_end (&builder),
 637                           NULL, 0, -1, NULL, NULL, NULL);
 638 }
 639
 640 static void
 641 g_application_impl_cmdline_method_call (GDBusConnection       *connection,
 642                                         const gchar           *sender,
 643                                         const gchar           *object_path,
 644                                         const gchar           *interface_name,
 645                                         const gchar           *method_name,
 646                                         GVariant              *parameters,
 647                                         GDBusMethodInvocation *invocation,
 648                                         gpointer               user_data)
 649 {
 650   const gchar *message;
 651
 652   g_variant_get_child (parameters, 0, "&s", &message);
 653
 654   if (strcmp (method_name, "Print") == 0)
 655     g_print ("%s", message);
 656   else if (strcmp (method_name, "PrintError") == 0)
 657     g_printerr ("%s", message);
 658   else
 659     g_assert_not_reached ();
 660
 661   g_dbus_method_invocation_return_value (invocation, NULL);
 662 }
 663
 664 typedef struct
 665 {
 666   GMainLoop *loop;
 667   int status;
 668 } CommandLineData;
 669
 670 static void
 671 g_application_impl_cmdline_done (GObject      *source,
 672                                  GAsyncResult *result,
 673                                  gpointer      user_data)
 674 {
 675   CommandLineData *data = user_data;
 676   GError *error = NULL;
 677   GVariant *reply;
 678
 679 #ifdef G_OS_UNIX
 680   reply = g_dbus_connection_call_with_unix_fd_list_finish (G_DBUS_CONNECTION (source), NULL, result, &error);
 681 #else
 682   reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
 683 #endif
 684
 685
 686   if (reply != NULL)
 687     {
 688       g_variant_get (reply, "(i)", &data->status);
 689       g_variant_unref (reply);
 690     }
 691
 692   else
 693     {
 694       g_printerr ("%s\n", error->message);
 695       g_error_free (error);
 696       data->status = 1;
 697     }
 698
 699   g_main_loop_quit (data->loop);
 700 }
 701
 702 int
 703 g_application_impl_command_line (GApplicationImpl    *impl,
 704                                  const gchar * const *arguments,
 705                                  GVariant            *platform_data)
 706 {
 707   const static GDBusInterfaceVTable vtable = {
 708     g_application_impl_cmdline_method_call
 709   };
 710   const gchar *object_path = "/org/gtk/Application/CommandLine";
 711   GMainContext *context;
 712   CommandLineData data;
 713   guint object_id;
 714
 715   context = g_main_context_new ();
 716   data.loop = g_main_loop_new (context, FALSE);
 717   g_main_context_push_thread_default (context);
 718
 719   if (org_gtk_private_CommandLine == NULL)
 720     {
 721       GError *error = NULL;
 722       GDBusNodeInfo *info;
 723
 724       info = g_dbus_node_info_new_for_xml (org_gtk_private_CommandLine_xml, &error);
 725       if G_UNLIKELY (info == NULL)
 726         g_error ("%s", error->message);
 727       org_gtk_private_CommandLine = g_dbus_node_info_lookup_interface (info, "org.gtk.private.CommandLine");
 728       g_assert (org_gtk_private_CommandLine != NULL);
 729       g_dbus_interface_info_ref (org_gtk_private_CommandLine);
 730       g_dbus_node_info_unref (info);
 731     }
 732
 733   object_id = g_dbus_connection_register_object (impl->session_bus, object_path,
 734                                                  org_gtk_private_CommandLine,
 735                                                  &vtable, &data, NULL, NULL);
 736   /* In theory we should try other paths... */
 737   g_assert (object_id != 0);
 738
 739 #ifdef G_OS_UNIX
 740   {
 741     GError *error = NULL;
 742     GUnixFDList *fd_list;
 743
 744     /* send along the stdin in case
 745      * g_application_command_line_get_stdin_data() is called
 746      */
 747     fd_list = g_unix_fd_list_new ();
 748     g_unix_fd_list_append (fd_list, 0, &error);
 749     g_assert_no_error (error);
 750
 751     g_dbus_connection_call_with_unix_fd_list (impl->session_bus, impl->bus_name, impl->object_path,
 752                                               "org.gtk.Application", "CommandLine",
 753                                               g_variant_new ("(o^aay@a{sv})", object_path, arguments, platform_data),
 754                                               G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, fd_list, NULL,
 755                                               g_application_impl_cmdline_done, &data);
 756     g_object_unref (fd_list);
 757   }
 758 #else
 759   g_dbus_connection_call (impl->session_bus, impl->bus_name, impl->object_path,
 760                           "org.gtk.Application", "CommandLine",
 761                           g_variant_new ("(o^aay@a{sv})", object_path, arguments, platform_data),
 762                           G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, NULL,
 763                           g_application_impl_cmdline_done, &data);
 764 #endif
 765
 766   g_main_loop_run (data.loop);
 767
 768   g_main_context_pop_thread_default (context);
 769   g_main_context_unref (context);
 770   g_main_loop_unref (data.loop);
 771
 772   return data.status;
 773 }
 774
 775 void
 776 g_application_impl_flush (GApplicationImpl *impl)
 777 {
 778   if (impl->session_bus)
 779     g_dbus_connection_flush_sync (impl->session_bus, NULL, NULL);
 780 }
 781
 782 GDBusConnection *
 783 g_application_impl_get_dbus_connection (GApplicationImpl *impl)
 784 {
 785   return impl->session_bus;
 786 }
 787
 788 const gchar *
 789 g_application_impl_get_dbus_object_path (GApplicationImpl *impl)
 790 {
 791   return impl->object_path;
 792 }
 793
 794 /* GDBusCommandLine implementation {{{1 */
 795
 796 typedef GApplicationCommandLineClass GDBusCommandLineClass;
 797 static GType g_dbus_command_line_get_type (void);
 798 typedef struct
 799 {
 800   GApplicationCommandLine  parent_instance;
 801   GDBusMethodInvocation   *invocation;
 802
 803   GDBusConnection *connection;
 804   const gchar     *bus_name;
 805   const gchar     *object_path;
 806 } GDBusCommandLine;
 807
 808
 809 G_DEFINE_TYPE (GDBusCommandLine,
 810                g_dbus_command_line,
 811                G_TYPE_APPLICATION_COMMAND_LINE)
 812
 813 static void
 814 g_dbus_command_line_print_literal (GApplicationCommandLine *cmdline,
 815                                    const gchar             *message)
 816 {
 817   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 818
 819   g_dbus_connection_call (gdbcl->connection,
 820                           gdbcl->bus_name,
 821                           gdbcl->object_path,
 822                           "org.gtk.private.CommandLine", "Print",
 823                           g_variant_new ("(s)", message),
 824                           NULL, 0, -1, NULL, NULL, NULL);
 825 }
 826
 827 static void
 828 g_dbus_command_line_printerr_literal (GApplicationCommandLine *cmdline,
 829                                       const gchar             *message)
 830 {
 831   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 832
 833   g_dbus_connection_call (gdbcl->connection,
 834                           gdbcl->bus_name,
 835                           gdbcl->object_path,
 836                           "org.gtk.private.CommandLine", "PrintError",
 837                           g_variant_new ("(s)", message),
 838                           NULL, 0, -1, NULL, NULL, NULL);
 839 }
 840
 841 static GInputStream *
 842 g_dbus_command_line_get_stdin (GApplicationCommandLine *cmdline)
 843 {
 844 #ifdef G_OS_UNIX
 845   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 846   GInputStream *result = NULL;
 847   GDBusMessage *message;
 848   GUnixFDList *fd_list;
 849
 850   message = g_dbus_method_invocation_get_message (gdbcl->invocation);
 851   fd_list = g_dbus_message_get_unix_fd_list (message);
 852
 853   if (fd_list && g_unix_fd_list_get_length (fd_list))
 854     {
 855       gint *fds, n_fds, i;
 856
 857       fds = g_unix_fd_list_steal_fds (fd_list, &n_fds);
 858       result = g_unix_input_stream_new (fds[0], TRUE);
 859       for (i = 1; i < n_fds; i++)
 860         (void) g_close (fds[i], NULL);
 861       g_free (fds);
 862     }
 863
 864   return result;
 865 #else
 866   return NULL;
 867 #endif
 868 }
 869
 870 static void
 871 g_dbus_command_line_finalize (GObject *object)
 872 {
 873   GApplicationCommandLine *cmdline = G_APPLICATION_COMMAND_LINE (object);
 874   GDBusCommandLine *gdbcl = (GDBusCommandLine *) object;
 875   gint status;
 876
 877   status = g_application_command_line_get_exit_status (cmdline);
 878
 879   g_dbus_method_invocation_return_value (gdbcl->invocation,
 880                                          g_variant_new ("(i)", status));
 881   g_object_unref (gdbcl->invocation);
 882
 883   G_OBJECT_CLASS (g_dbus_command_line_parent_class)
 884     ->finalize (object);
 885 }
 886
 887 static void
 888 g_dbus_command_line_init (GDBusCommandLine *gdbcl)
 889 {
 890 }
 891
 892 static void
 893 g_dbus_command_line_class_init (GApplicationCommandLineClass *class)
 894 {
 895   GObjectClass *object_class = G_OBJECT_CLASS (class);
 896
 897   object_class->finalize = g_dbus_command_line_finalize;
 898   class->printerr_literal = g_dbus_command_line_printerr_literal;
 899   class->print_literal = g_dbus_command_line_print_literal;
 900   class->get_stdin = g_dbus_command_line_get_stdin;
 901 }
 902
 903 static GApplicationCommandLine *
 904 g_dbus_command_line_new (GDBusMethodInvocation *invocation)
 905 {
 906   GDBusCommandLine *gdbcl;
 907   GVariant *args;
 908   GVariant *arguments, *platform_data;
 909
 910   args = g_dbus_method_invocation_get_parameters (invocation);
 911
 912   arguments = g_variant_get_child_value (args, 1);
 913   platform_data = g_variant_get_child_value (args, 2);
 914   gdbcl = g_object_new (g_dbus_command_line_get_type (),
 915                         "arguments", arguments,
 916                         "platform-data", platform_data,
 917                         NULL);
 918   g_variant_unref (arguments);
 919   g_variant_unref (platform_data);
 920
 921   gdbcl->connection = g_dbus_method_invocation_get_connection (invocation);
 922   gdbcl->bus_name = g_dbus_method_invocation_get_sender (invocation);
 923   g_variant_get_child (args, 0, "&o", &gdbcl->object_path);
 924   gdbcl->invocation = g_object_ref (invocation);
 925
 926   return G_APPLICATION_COMMAND_LINE (gdbcl);
 927 }
 928
 929 /* Epilogue {{{1 */
 930
 931 /* vim:set foldmethod=marker: */