4b1b5c915f4ca1e40a7af4ea78cf8b3767ed6699
[platform/upstream/glib.git] / 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, i;
856
857       fds = g_unix_fd_list_peek_fds (fd_list, NULL);
858       result = g_unix_input_stream_new (fds[0], FALSE);
859       g_object_weak_ref (G_OBJECT (result),
860                          (GWeakNotify) g_object_unref,
861                          g_object_ref (fd_list));
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: */