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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  *
  19  * Authors: Ryan Lortie <desrt@desrt.ca>
  20  */
  21
  22 #include "gapplicationimpl.h"
  23
  24 #include "gactiongroup.h"
  25 #include "gactiongroupexporter.h"
  26 #include "gremoteactiongroup.h"
  27 #include "gdbusactiongroup.h"
  28 #include "gapplication.h"
  29 #include "gfile.h"
  30 #include "gdbusconnection.h"
  31 #include "gdbusintrospection.h"
  32 #include "gdbuserror.h"
  33
  34 #include <string.h>
  35 #include <stdio.h>
  36
  37 #include "gapplicationcommandline.h"
  38 #include "gdbusmethodinvocation.h"
  39
  40 G_GNUC_INTERNAL gboolean
  41 g_dbus_action_group_sync (GDBusActionGroup  *group,
  42                           GCancellable      *cancellable,
  43                           GError           **error);
  44
  45
  46 /* DBus Interface definition {{{1 */
  47
  48 /* For documentation of these interfaces, see
  49  * http://live.gnome.org/GTK+/GApplication-dbus-apis
  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   "  </interface>"
  69   "</node>";
  70
  71 static GDBusInterfaceInfo *org_gtk_Application;
  72
  73 static const gchar org_gtk_private_CommandLine_xml[] =
  74   "<node>"
  75   "  <interface name='org.gtk.private.CommandLine'>"
  76   "    <method name='Print'>"
  77   "      <arg type='s' name='message' direction='in'/>"
  78   "    </method>"
  79   "    <method name='PrintError'>"
  80   "      <arg type='s' name='message' direction='in'/>"
  81   "    </method>"
  82   "  </interface>"
  83   "</node>";
  84
  85 static GDBusInterfaceInfo *org_gtk_private_CommandLine;
  86
  87 /* GApplication implementation {{{1 */
  88 struct _GApplicationImpl
  89 {
  90   GDBusConnection *session_bus;
  91   GActionGroup    *exported_actions;
  92   const gchar     *bus_name;
  93
  94   gchar           *object_path;
  95   guint            object_id;
  96   guint            actions_id;
  97
  98   gboolean         properties_live;
  99   gboolean         primary;
 100   gpointer         app;
 101 };
 102
 103
 104 static GApplicationCommandLine *
 105 g_dbus_command_line_new (GDBusMethodInvocation *invocation);
 106
 107
 108 static void
 109 g_application_impl_method_call (GDBusConnection       *connection,
 110                                 const gchar           *sender,
 111                                 const gchar           *object_path,
 112                                 const gchar           *interface_name,
 113                                 const gchar           *method_name,
 114                                 GVariant              *parameters,
 115                                 GDBusMethodInvocation *invocation,
 116                                 gpointer               user_data)
 117 {
 118   GApplicationImpl *impl = user_data;
 119   GApplicationClass *class;
 120
 121   class = G_APPLICATION_GET_CLASS (impl->app);
 122
 123   if (strcmp (method_name, "Activate") == 0)
 124     {
 125       GVariant *platform_data;
 126
 127       g_variant_get (parameters, "(@a{sv})", &platform_data);
 128       class->before_emit (impl->app, platform_data);
 129       g_signal_emit_by_name (impl->app, "activate");
 130       class->after_emit (impl->app, platform_data);
 131       g_variant_unref (platform_data);
 132
 133       g_dbus_method_invocation_return_value (invocation, NULL);
 134     }
 135
 136   else if (strcmp (method_name, "Open") == 0)
 137     {
 138       GVariant *platform_data;
 139       const gchar *hint;
 140       GVariant *array;
 141       GFile **files;
 142       gint n, i;
 143
 144       g_variant_get (parameters, "(@ass@a{sv})",
 145                      &array, &hint, &platform_data);
 146
 147       n = g_variant_n_children (array);
 148       files = g_new (GFile *, n + 1);
 149
 150       for (i = 0; i < n; i++)
 151         {
 152           const gchar *uri;
 153
 154           g_variant_get_child (array, i, "&s", &uri);
 155           files[i] = g_file_new_for_uri (uri);
 156         }
 157       g_variant_unref (array);
 158       files[n] = NULL;
 159
 160       class->before_emit (impl->app, platform_data);
 161       g_signal_emit_by_name (impl->app, "open", files, n, hint);
 162       class->after_emit (impl->app, platform_data);
 163
 164       g_variant_unref (platform_data);
 165
 166       for (i = 0; i < n; i++)
 167         g_object_unref (files[i]);
 168       g_free (files);
 169
 170       g_dbus_method_invocation_return_value (invocation, NULL);
 171     }
 172
 173   else if (strcmp (method_name, "CommandLine") == 0)
 174     {
 175       GApplicationCommandLine *cmdline;
 176       GVariant *platform_data;
 177       int status;
 178
 179       cmdline = g_dbus_command_line_new (invocation);
 180       platform_data = g_variant_get_child_value (parameters, 2);
 181       class->before_emit (impl->app, platform_data);
 182       g_signal_emit_by_name (impl->app, "command-line", cmdline, &status);
 183       g_application_command_line_set_exit_status (cmdline, status);
 184       class->after_emit (impl->app, platform_data);
 185       g_variant_unref (platform_data);
 186       g_object_unref (cmdline);
 187     }
 188   else
 189     g_assert_not_reached ();
 190 }
 191
 192 static gchar *
 193 application_path_from_appid (const gchar *appid)
 194 {
 195   gchar *appid_path, *iter;
 196
 197   appid_path = g_strconcat ("/", appid, NULL);
 198   for (iter = appid_path; *iter; iter++)
 199     {
 200       if (*iter == '.')
 201         *iter = '/';
 202
 203       if (*iter == '-')
 204         *iter = '_';
 205     }
 206
 207   return appid_path;
 208 }
 209
 210 /* Attempt to become the primary instance.
 211  *
 212  * Returns %TRUE if everything went OK, regardless of if we became the
 213  * primary instance or not.  %FALSE is reserved for when something went
 214  * seriously wrong (and @error will be set too, in that case).
 215  *
 216  * After a %TRUE return, impl->primary will be TRUE if we were
 217  * successful.
 218  */
 219 static gboolean
 220 g_application_impl_attempt_primary (GApplicationImpl  *impl,
 221                                     GCancellable      *cancellable,
 222                                     GError           **error)
 223 {
 224   const static GDBusInterfaceVTable vtable = {
 225     g_application_impl_method_call,
 226   };
 227   GVariant *reply;
 228   guint32 rval;
 229
 230   if (org_gtk_Application == NULL)
 231     {
 232       GError *error = NULL;
 233       GDBusNodeInfo *info;
 234
 235       info = g_dbus_node_info_new_for_xml (org_gtk_Application_xml, &error);
 236       if G_UNLIKELY (info == NULL)
 237         g_error ("%s", error->message);
 238       org_gtk_Application = g_dbus_node_info_lookup_interface (info, "org.gtk.Application");
 239       g_assert (org_gtk_Application != NULL);
 240       g_dbus_interface_info_ref (org_gtk_Application);
 241       g_dbus_node_info_unref (info);
 242     }
 243
 244   /* We could possibly have been D-Bus activated as a result of incoming
 245    * requests on either the application or actiongroup interfaces.
 246    * Because of how GDBus dispatches messages, we need to ensure that
 247    * both of those things are registered before we attempt to request
 248    * our name.
 249    *
 250    * The action group need not be populated yet, as long as it happens
 251    * before we return to the mainloop.  The reason for that is because
 252    * GDBus does the check to make sure the object exists from the worker
 253    * thread but doesn't actually dispatch the action invocation until we
 254    * hit the mainloop in this thread.  There is also no danger of
 255    * receiving 'activate' or 'open' signals until after 'startup' runs,
 256    * for the same reason.
 257    */
 258   impl->object_id = g_dbus_connection_register_object (impl->session_bus, impl->object_path,
 259                                                        org_gtk_Application, &vtable, impl, NULL, error);
 260
 261   if (impl->object_id == 0)
 262     return FALSE;
 263
 264   impl->actions_id = g_dbus_connection_export_action_group (impl->session_bus, impl->object_path,
 265                                                             impl->exported_actions, error);
 266
 267   if (impl->actions_id == 0)
 268     return FALSE;
 269
 270   /* DBUS_NAME_FLAG_DO_NOT_QUEUE: 0x4 */
 271   reply = g_dbus_connection_call_sync (impl->session_bus, "org.freedesktop.DBus", "/org/freedesktop/DBus",
 272                                        "org.freedesktop.DBus", "RequestName",
 273                                        g_variant_new ("(su)", impl->bus_name, 0x4), G_VARIANT_TYPE ("(u)"),
 274                                        0, -1, cancellable, error);
 275
 276   if (reply == NULL)
 277     return FALSE;
 278
 279   g_variant_get (reply, "(u)", &rval);
 280   g_variant_unref (reply);
 281
 282   /* DBUS_REQUEST_NAME_REPLY_EXISTS: 3 */
 283   impl->primary = (rval != 3);
 284
 285   return TRUE;
 286 }
 287
 288 /* Stop doing the things that the primary instance does.
 289  *
 290  * This should be called if attempting to become the primary instance
 291  * failed (in order to clean up any partial success) and should also
 292  * be called when freeing the GApplication.
 293  *
 294  * It is safe to call this multiple times.
 295  */
 296 static void
 297 g_application_impl_stop_primary (GApplicationImpl *impl)
 298 {
 299   if (impl->object_id)
 300     {
 301       g_dbus_connection_unregister_object (impl->session_bus, impl->object_id);
 302       impl->object_id = 0;
 303     }
 304
 305   if (impl->actions_id)
 306     {
 307       g_dbus_connection_unexport_action_group (impl->session_bus, impl->actions_id);
 308       impl->actions_id = 0;
 309     }
 310
 311   if (impl->primary)
 312     {
 313       g_dbus_connection_call (impl->session_bus, "org.freedesktop.DBus",
 314                               "/org/freedesktop/DBus", "org.freedesktop.DBus",
 315                               "ReleaseName", g_variant_new ("(s)", impl->bus_name),
 316                               NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 317       impl->primary = FALSE;
 318     }
 319 }
 320
 321 void
 322 g_application_impl_destroy (GApplicationImpl *impl)
 323 {
 324   g_application_impl_stop_primary (impl);
 325
 326   if (impl->session_bus)
 327     g_object_unref (impl->session_bus);
 328
 329   g_free (impl->object_path);
 330
 331   g_slice_free (GApplicationImpl, impl);
 332 }
 333
 334 GApplicationImpl *
 335 g_application_impl_register (GApplication        *application,
 336                              const gchar         *appid,
 337                              GApplicationFlags    flags,
 338                              GActionGroup        *exported_actions,
 339                              GRemoteActionGroup **remote_actions,
 340                              GCancellable        *cancellable,
 341                              GError             **error)
 342 {
 343   GDBusActionGroup *actions;
 344   GApplicationImpl *impl;
 345
 346   impl = g_slice_new0 (GApplicationImpl);
 347
 348   impl->app = application;
 349   impl->exported_actions = exported_actions;
 350   impl->bus_name = appid;
 351
 352   impl->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, NULL);
 353
 354   if (impl->session_bus == NULL)
 355     {
 356       /* If we can't connect to the session bus, proceed as a normal
 357        * non-unique application.
 358        */
 359       *remote_actions = NULL;
 360       return impl;
 361     }
 362
 363   impl->object_path = application_path_from_appid (appid);
 364
 365   /* Only try to be the primary instance if
 366    * G_APPLICATION_IS_LAUNCHER was not specified.
 367    */
 368   if (~flags & G_APPLICATION_IS_LAUNCHER)
 369     {
 370       if (!g_application_impl_attempt_primary (impl, cancellable, error))
 371         {
 372           g_application_impl_destroy (impl);
 373           return NULL;
 374         }
 375
 376       if (impl->primary)
 377         return impl;
 378
 379       /* We didn't make it.  Drop our service-side stuff. */
 380       g_application_impl_stop_primary (impl);
 381
 382       if (flags & G_APPLICATION_IS_SERVICE)
 383         {
 384           g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
 385                        "Unable to acquire bus name `%s'", appid);
 386           g_application_impl_destroy (impl);
 387
 388           return NULL;
 389         }
 390     }
 391
 392   /* We are non-primary.  Try to get the primary's list of actions.
 393    * This also serves as a mechanism to ensure that the primary exists
 394    * (ie: DBus service files installed correctly, etc).
 395    */
 396   actions = g_dbus_action_group_get (impl->session_bus, impl->bus_name, impl->object_path);
 397   if (!g_dbus_action_group_sync (actions, cancellable, error))
 398     {
 399       /* The primary appears not to exist.  Fail the registration. */
 400       g_application_impl_destroy (impl);
 401       g_object_unref (actions);
 402
 403       return NULL;
 404     }
 405
 406   *remote_actions = G_REMOTE_ACTION_GROUP (actions);
 407
 408   return impl;
 409 }
 410
 411 void
 412 g_application_impl_activate (GApplicationImpl *impl,
 413                              GVariant         *platform_data)
 414 {
 415   g_dbus_connection_call (impl->session_bus,
 416                           impl->bus_name,
 417                           impl->object_path,
 418                           "org.gtk.Application",
 419                           "Activate",
 420                           g_variant_new ("(@a{sv})", platform_data),
 421                           NULL, 0, -1, NULL, NULL, NULL);
 422 }
 423
 424 void
 425 g_application_impl_open (GApplicationImpl  *impl,
 426                          GFile            **files,
 427                          gint               n_files,
 428                          const gchar       *hint,
 429                          GVariant          *platform_data)
 430 {
 431   GVariantBuilder builder;
 432   gint i;
 433
 434   g_variant_builder_init (&builder, G_VARIANT_TYPE ("(assa{sv})"));
 435   g_variant_builder_open (&builder, G_VARIANT_TYPE_STRING_ARRAY);
 436   for (i = 0; i < n_files; i++)
 437     {
 438       gchar *uri = g_file_get_uri (files[i]);
 439       g_variant_builder_add (&builder, "s", uri);
 440       g_free (uri);
 441     }
 442   g_variant_builder_close (&builder);
 443   g_variant_builder_add (&builder, "s", hint);
 444   g_variant_builder_add_value (&builder, platform_data);
 445
 446   g_dbus_connection_call (impl->session_bus,
 447                           impl->bus_name,
 448                           impl->object_path,
 449                           "org.gtk.Application",
 450                           "Open",
 451                           g_variant_builder_end (&builder),
 452                           NULL, 0, -1, NULL, NULL, NULL);
 453 }
 454
 455 static void
 456 g_application_impl_cmdline_method_call (GDBusConnection       *connection,
 457                                         const gchar           *sender,
 458                                         const gchar           *object_path,
 459                                         const gchar           *interface_name,
 460                                         const gchar           *method_name,
 461                                         GVariant              *parameters,
 462                                         GDBusMethodInvocation *invocation,
 463                                         gpointer               user_data)
 464 {
 465   const gchar *message;
 466
 467   g_variant_get_child (parameters, 0, "&s", &message);
 468
 469   if (strcmp (method_name, "Print") == 0)
 470     g_print ("%s", message);
 471   else if (strcmp (method_name, "PrintError") == 0)
 472     g_printerr ("%s", message);
 473   else
 474     g_assert_not_reached ();
 475
 476   g_dbus_method_invocation_return_value (invocation, NULL);
 477 }
 478
 479 typedef struct
 480 {
 481   GMainLoop *loop;
 482   int status;
 483 } CommandLineData;
 484
 485 static void
 486 g_application_impl_cmdline_done (GObject      *source,
 487                                  GAsyncResult *result,
 488                                  gpointer      user_data)
 489 {
 490   CommandLineData *data = user_data;
 491   GError *error = NULL;
 492   GVariant *reply;
 493
 494   reply = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source),
 495                                          result, &error);
 496
 497   if (reply != NULL)
 498     {
 499       g_variant_get (reply, "(i)", &data->status);
 500       g_variant_unref (reply);
 501     }
 502
 503   else
 504     {
 505       g_printerr ("%s\n", error->message);
 506       g_error_free (error);
 507       data->status = 1;
 508     }
 509
 510   g_main_loop_quit (data->loop);
 511 }
 512
 513 int
 514 g_application_impl_command_line (GApplicationImpl  *impl,
 515                                  gchar            **arguments,
 516                                  GVariant          *platform_data)
 517 {
 518   const static GDBusInterfaceVTable vtable = {
 519     g_application_impl_cmdline_method_call
 520   };
 521   const gchar *object_path = "/org/gtk/Application/CommandLine";
 522   GMainContext *context;
 523   CommandLineData data;
 524   guint object_id;
 525
 526   context = g_main_context_new ();
 527   data.loop = g_main_loop_new (context, FALSE);
 528   g_main_context_push_thread_default (context);
 529
 530   if (org_gtk_private_CommandLine == NULL)
 531     {
 532       GError *error = NULL;
 533       GDBusNodeInfo *info;
 534
 535       info = g_dbus_node_info_new_for_xml (org_gtk_private_CommandLine_xml, &error);
 536       if G_UNLIKELY (info == NULL)
 537         g_error ("%s", error->message);
 538       org_gtk_private_CommandLine = g_dbus_node_info_lookup_interface (info, "org.gtk.private.CommandLine");
 539       g_assert (org_gtk_private_CommandLine != NULL);
 540       g_dbus_interface_info_ref (org_gtk_private_CommandLine);
 541       g_dbus_node_info_unref (info);
 542     }
 543
 544   object_id = g_dbus_connection_register_object (impl->session_bus, object_path,
 545                                                  org_gtk_private_CommandLine,
 546                                                  &vtable, &data, NULL, NULL);
 547   /* In theory we should try other paths... */
 548   g_assert (object_id != 0);
 549
 550   g_dbus_connection_call (impl->session_bus,
 551                           impl->bus_name,
 552                           impl->object_path,
 553                           "org.gtk.Application",
 554                           "CommandLine",
 555                           g_variant_new ("(o^aay@a{sv})", object_path,
 556                                          arguments, platform_data),
 557                           G_VARIANT_TYPE ("(i)"), 0, G_MAXINT, NULL,
 558                           g_application_impl_cmdline_done, &data);
 559
 560   g_main_loop_run (data.loop);
 561
 562   g_main_context_pop_thread_default (context);
 563   g_main_context_unref (context);
 564   g_main_loop_unref (data.loop);
 565
 566   return data.status;
 567 }
 568
 569 void
 570 g_application_impl_flush (GApplicationImpl *impl)
 571 {
 572   if (impl->session_bus)
 573     g_dbus_connection_flush_sync (impl->session_bus, NULL, NULL);
 574 }
 575
 576
 577 /* GDBusCommandLine implementation {{{1 */
 578
 579 typedef GApplicationCommandLineClass GDBusCommandLineClass;
 580 static GType g_dbus_command_line_get_type (void);
 581 typedef struct
 582 {
 583   GApplicationCommandLine  parent_instance;
 584   GDBusMethodInvocation   *invocation;
 585
 586   GDBusConnection *connection;
 587   const gchar     *bus_name;
 588   const gchar     *object_path;
 589 } GDBusCommandLine;
 590
 591
 592 G_DEFINE_TYPE (GDBusCommandLine,
 593                g_dbus_command_line,
 594                G_TYPE_APPLICATION_COMMAND_LINE)
 595
 596 static void
 597 g_dbus_command_line_print_literal (GApplicationCommandLine *cmdline,
 598                                    const gchar             *message)
 599 {
 600   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 601
 602   g_dbus_connection_call (gdbcl->connection,
 603                           gdbcl->bus_name,
 604                           gdbcl->object_path,
 605                           "org.gtk.private.CommandLine", "Print",
 606                           g_variant_new ("(s)", message),
 607                           NULL, 0, -1, NULL, NULL, NULL);
 608 }
 609
 610 static void
 611 g_dbus_command_line_printerr_literal (GApplicationCommandLine *cmdline,
 612                                       const gchar             *message)
 613 {
 614   GDBusCommandLine *gdbcl = (GDBusCommandLine *) cmdline;
 615
 616   g_dbus_connection_call (gdbcl->connection,
 617                           gdbcl->bus_name,
 618                           gdbcl->object_path,
 619                           "org.gtk.private.CommandLine", "PrintError",
 620                           g_variant_new ("(s)", message),
 621                           NULL, 0, -1, NULL, NULL, NULL);
 622 }
 623
 624 static void
 625 g_dbus_command_line_finalize (GObject *object)
 626 {
 627   GApplicationCommandLine *cmdline = G_APPLICATION_COMMAND_LINE (object);
 628   GDBusCommandLine *gdbcl = (GDBusCommandLine *) object;
 629   gint status;
 630
 631   status = g_application_command_line_get_exit_status (cmdline);
 632
 633   g_dbus_method_invocation_return_value (gdbcl->invocation,
 634                                          g_variant_new ("(i)", status));
 635   g_object_unref (gdbcl->invocation);
 636
 637   G_OBJECT_CLASS (g_dbus_command_line_parent_class)
 638     ->finalize (object);
 639 }
 640
 641 static void
 642 g_dbus_command_line_init (GDBusCommandLine *gdbcl)
 643 {
 644 }
 645
 646 static void
 647 g_dbus_command_line_class_init (GApplicationCommandLineClass *class)
 648 {
 649   GObjectClass *object_class = G_OBJECT_CLASS (class);
 650
 651   object_class->finalize = g_dbus_command_line_finalize;
 652   class->printerr_literal = g_dbus_command_line_printerr_literal;
 653   class->print_literal = g_dbus_command_line_print_literal;
 654 }
 655
 656 static GApplicationCommandLine *
 657 g_dbus_command_line_new (GDBusMethodInvocation *invocation)
 658 {
 659   GDBusCommandLine *gdbcl;
 660   GVariant *args;
 661
 662   args = g_dbus_method_invocation_get_parameters (invocation);
 663
 664   gdbcl = g_object_new (g_dbus_command_line_get_type (),
 665                         "arguments", g_variant_get_child_value (args, 1),
 666                         "platform-data", g_variant_get_child_value (args, 2),
 667                         NULL);
 668   gdbcl->connection = g_dbus_method_invocation_get_connection (invocation);
 669   gdbcl->bus_name = g_dbus_method_invocation_get_sender (invocation);
 670   g_variant_get_child (args, 0, "&o", &gdbcl->object_path);
 671   gdbcl->invocation = g_object_ref (invocation);
 672
 673   return G_APPLICATION_COMMAND_LINE (gdbcl);
 674 }
 675
 676 /* Epilogue {{{1 */
 677
 678 /* vim:set foldmethod=marker: */