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