gio: avoid g_object_ref(NULL) in g_dbus_object_manager_client_finalize
[platform/upstream/glib.git] / gio / gdbusobjectmanagerclient.c
1 /* GDBus - GLib D-Bus Library
2  *
3  * Copyright (C) 2008-2010 Red Hat, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General
16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17  *
18  * Author: David Zeuthen <davidz@redhat.com>
19  */
20
21 #include "config.h"
22
23 #include "gdbusobjectmanager.h"
24 #include "gdbusobjectmanagerclient.h"
25 #include "gdbusobject.h"
26 #include "gdbusprivate.h"
27 #include "gioenumtypes.h"
28 #include "ginitable.h"
29 #include "gasyncresult.h"
30 #include "gsimpleasyncresult.h"
31 #include "gasyncinitable.h"
32 #include "gdbusconnection.h"
33 #include "gdbusutils.h"
34 #include "gdbusobject.h"
35 #include "gdbusobjectproxy.h"
36 #include "gdbusproxy.h"
37 #include "gdbusinterface.h"
38
39 #include "glibintl.h"
40
41 /**
42  * SECTION:gdbusobjectmanagerclient
43  * @short_description: Client-side object manager
44  * @include: gio/gio.h
45  *
46  * #GDBusObjectManagerClient is used to create, monitor and delete object
47  * proxies for remote objects exported by a #GDBusObjectManagerServer (or any
48  * code implementing the
49  * [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
50  * interface).
51  *
52  * Once an instance of this type has been created, you can connect to
53  * the #GDBusObjectManager::object-added and
54  * #GDBusObjectManager::object-removed signals and inspect the
55  * #GDBusObjectProxy objects returned by
56  * g_dbus_object_manager_get_objects().
57  *
58  * If the name for a #GDBusObjectManagerClient is not owned by anyone at
59  * object construction time, the default behavior is to request the
60  * message bus to launch an owner for the name. This behavior can be
61  * disabled using the %G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START
62  * flag. It's also worth noting that this only works if the name of
63  * interest is activatable in the first place. E.g. in some cases it
64  * is not possible to launch an owner for the requested name. In this
65  * case, #GDBusObjectManagerClient object construction still succeeds but
66  * there will be no object proxies
67  * (e.g. g_dbus_object_manager_get_objects() returns the empty list) and
68  * the #GDBusObjectManagerClient:name-owner property is %NULL.
69  *
70  * The owner of the requested name can come and go (for example
71  * consider a system service being restarted) – #GDBusObjectManagerClient
72  * handles this case too; simply connect to the #GObject::notify
73  * signal to watch for changes on the #GDBusObjectManagerClient:name-owner
74  * property. When the name owner vanishes, the behavior is that
75  * #GDBusObjectManagerClient:name-owner is set to %NULL (this includes
76  * emission of the #GObject::notify signal) and then
77  * #GDBusObjectManager::object-removed signals are synthesized
78  * for all currently existing object proxies. Since
79  * #GDBusObjectManagerClient:name-owner is %NULL when this happens, you can
80  * use this information to disambiguate a synthesized signal from a
81  * genuine signal caused by object removal on the remote
82  * #GDBusObjectManager. Similarly, when a new name owner appears,
83  * #GDBusObjectManager::object-added signals are synthesized
84  * while #GDBusObjectManagerClient:name-owner is still %NULL. Only when all
85  * object proxies have been added, the #GDBusObjectManagerClient:name-owner
86  * is set to the new name owner (this includes emission of the
87  * #GObject::notify signal).  Furthermore, you are guaranteed that
88  * #GDBusObjectManagerClient:name-owner will alternate between a name owner
89  * (e.g. `:1.42`) and %NULL even in the case where
90  * the name of interest is atomically replaced
91  *
92  * Ultimately, #GDBusObjectManagerClient is used to obtain #GDBusProxy
93  * instances. All signals (including the
94  * org.freedesktop.DBus.Properties::PropertiesChanged signal)
95  * delivered to #GDBusProxy instances are guaranteed to originate
96  * from the name owner. This guarantee along with the behavior
97  * described above, means that certain race conditions including the
98  * "half the proxy is from the old owner and the other half is from
99  * the new owner" problem cannot happen.
100  *
101  * To avoid having the application connect to signals on the returned
102  * #GDBusObjectProxy and #GDBusProxy objects, the
103  * #GDBusObject::interface-added,
104  * #GDBusObject::interface-removed,
105  * #GDBusProxy::g-properties-changed and
106  * #GDBusProxy::g-signal signals
107  * are also emitted on the #GDBusObjectManagerClient instance managing these
108  * objects. The signals emitted are
109  * #GDBusObjectManager::interface-added,
110  * #GDBusObjectManager::interface-removed,
111  * #GDBusObjectManagerClient::interface-proxy-properties-changed and
112  * #GDBusObjectManagerClient::interface-proxy-signal.
113  *
114  * Note that all callbacks and signals are emitted in the
115  * [thread-default main context][g-main-context-push-thread-default]
116  * that the #GDBusObjectManagerClient object was constructed
117  * in. Additionally, the #GDBusObjectProxy and #GDBusProxy objects
118  * originating from the #GDBusObjectManagerClient object will be created in
119  * the same context and, consequently, will deliver signals in the
120  * same main loop.
121  */
122
123 struct _GDBusObjectManagerClientPrivate
124 {
125   GMutex lock;
126
127   GBusType bus_type;
128   GDBusConnection *connection;
129   gchar *object_path;
130   gchar *name;
131   gchar *name_owner;
132   GDBusObjectManagerClientFlags flags;
133
134   GDBusProxy *control_proxy;
135
136   GHashTable *map_object_path_to_object_proxy;
137
138   guint signal_subscription_id;
139   gchar *match_rule;
140
141   GDBusProxyTypeFunc get_proxy_type_func;
142   gpointer get_proxy_type_user_data;
143   GDestroyNotify get_proxy_type_destroy_notify;
144 };
145
146 enum
147 {
148   PROP_0,
149   PROP_BUS_TYPE,
150   PROP_CONNECTION,
151   PROP_FLAGS,
152   PROP_OBJECT_PATH,
153   PROP_NAME,
154   PROP_NAME_OWNER,
155   PROP_GET_PROXY_TYPE_FUNC,
156   PROP_GET_PROXY_TYPE_USER_DATA,
157   PROP_GET_PROXY_TYPE_DESTROY_NOTIFY
158 };
159
160 enum
161 {
162   INTERFACE_PROXY_SIGNAL_SIGNAL,
163   INTERFACE_PROXY_PROPERTIES_CHANGED_SIGNAL,
164   LAST_SIGNAL
165 };
166
167 static guint signals[LAST_SIGNAL] = { 0 };
168
169 static void initable_iface_init       (GInitableIface *initable_iface);
170 static void async_initable_iface_init (GAsyncInitableIface *async_initable_iface);
171 static void dbus_object_manager_interface_init (GDBusObjectManagerIface *iface);
172
173 G_DEFINE_TYPE_WITH_CODE (GDBusObjectManagerClient, g_dbus_object_manager_client, G_TYPE_OBJECT,
174                          G_ADD_PRIVATE (GDBusObjectManagerClient)
175                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init)
176                          G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, async_initable_iface_init)
177                          G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT_MANAGER, dbus_object_manager_interface_init));
178
179 static void maybe_unsubscribe_signals (GDBusObjectManagerClient *manager);
180
181 static void on_control_proxy_g_signal (GDBusProxy   *proxy,
182                                        const gchar  *sender_name,
183                                        const gchar  *signal_name,
184                                        GVariant     *parameters,
185                                        gpointer      user_data);
186
187 static void process_get_all_result (GDBusObjectManagerClient *manager,
188                                     GVariant          *value,
189                                     const gchar       *name_owner);
190
191 static void
192 g_dbus_object_manager_client_finalize (GObject *object)
193 {
194   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (object);
195
196   maybe_unsubscribe_signals (manager);
197
198   g_hash_table_unref (manager->priv->map_object_path_to_object_proxy);
199
200   if (manager->priv->control_proxy != NULL)
201     {
202       g_signal_handlers_disconnect_by_func (manager->priv->control_proxy,
203                                             on_control_proxy_g_signal,
204                                             manager);
205       g_object_unref (manager->priv->control_proxy);
206     }
207   if (manager->priv->connection != NULL)
208     g_object_unref (manager->priv->connection);
209   g_free (manager->priv->object_path);
210   g_free (manager->priv->name);
211   g_free (manager->priv->name_owner);
212
213   if (manager->priv->get_proxy_type_destroy_notify != NULL)
214     manager->priv->get_proxy_type_destroy_notify (manager->priv->get_proxy_type_user_data);
215
216   g_mutex_clear (&manager->priv->lock);
217
218   if (G_OBJECT_CLASS (g_dbus_object_manager_client_parent_class)->finalize != NULL)
219     G_OBJECT_CLASS (g_dbus_object_manager_client_parent_class)->finalize (object);
220 }
221
222 static void
223 g_dbus_object_manager_client_get_property (GObject    *_object,
224                                            guint       prop_id,
225                                            GValue     *value,
226                                            GParamSpec *pspec)
227 {
228   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (_object);
229
230   switch (prop_id)
231     {
232     case PROP_CONNECTION:
233       g_value_set_object (value, g_dbus_object_manager_client_get_connection (manager));
234       break;
235
236     case PROP_OBJECT_PATH:
237       g_value_set_string (value, g_dbus_object_manager_get_object_path (G_DBUS_OBJECT_MANAGER (manager)));
238       break;
239
240     case PROP_NAME:
241       g_value_set_string (value, g_dbus_object_manager_client_get_name (manager));
242       break;
243
244     case PROP_FLAGS:
245       g_value_set_flags (value, g_dbus_object_manager_client_get_flags (manager));
246       break;
247
248     case PROP_NAME_OWNER:
249       g_value_take_string (value, g_dbus_object_manager_client_get_name_owner (manager));
250       break;
251
252     default:
253       G_OBJECT_WARN_INVALID_PROPERTY_ID (manager, prop_id, pspec);
254       break;
255     }
256 }
257
258 static void
259 g_dbus_object_manager_client_set_property (GObject       *_object,
260                                            guint          prop_id,
261                                            const GValue  *value,
262                                            GParamSpec    *pspec)
263 {
264   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (_object);
265   const gchar *name;
266
267   switch (prop_id)
268     {
269     case PROP_BUS_TYPE:
270       manager->priv->bus_type = g_value_get_enum (value);
271       break;
272
273     case PROP_CONNECTION:
274       if (g_value_get_object (value) != NULL)
275         {
276           g_assert (manager->priv->connection == NULL);
277           g_assert (G_IS_DBUS_CONNECTION (g_value_get_object (value)));
278           manager->priv->connection = g_value_dup_object (value);
279         }
280       break;
281
282     case PROP_OBJECT_PATH:
283       g_assert (manager->priv->object_path == NULL);
284       g_assert (g_variant_is_object_path (g_value_get_string (value)));
285       manager->priv->object_path = g_value_dup_string (value);
286       break;
287
288     case PROP_NAME:
289       g_assert (manager->priv->name == NULL);
290       name = g_value_get_string (value);
291       g_assert (name == NULL || g_dbus_is_name (name));
292       manager->priv->name = g_strdup (name);
293       break;
294
295     case PROP_FLAGS:
296       manager->priv->flags = g_value_get_flags (value);
297       break;
298
299     case PROP_GET_PROXY_TYPE_FUNC:
300       manager->priv->get_proxy_type_func = g_value_get_pointer (value);
301       break;
302
303     case PROP_GET_PROXY_TYPE_USER_DATA:
304       manager->priv->get_proxy_type_user_data = g_value_get_pointer (value);
305       break;
306
307     case PROP_GET_PROXY_TYPE_DESTROY_NOTIFY:
308       manager->priv->get_proxy_type_destroy_notify = g_value_get_pointer (value);
309       break;
310
311     default:
312       G_OBJECT_WARN_INVALID_PROPERTY_ID (manager, prop_id, pspec);
313       break;
314     }
315 }
316
317 static void
318 g_dbus_object_manager_client_class_init (GDBusObjectManagerClientClass *klass)
319 {
320   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
321
322   gobject_class->finalize     = g_dbus_object_manager_client_finalize;
323   gobject_class->set_property = g_dbus_object_manager_client_set_property;
324   gobject_class->get_property = g_dbus_object_manager_client_get_property;
325
326   /**
327    * GDBusObjectManagerClient:connection:
328    *
329    * The #GDBusConnection to use.
330    *
331    * Since: 2.30
332    */
333   g_object_class_install_property (gobject_class,
334                                    PROP_CONNECTION,
335                                    g_param_spec_object ("connection",
336                                                         "Connection",
337                                                         "The connection to use",
338                                                         G_TYPE_DBUS_CONNECTION,
339                                                         G_PARAM_READABLE |
340                                                         G_PARAM_WRITABLE |
341                                                         G_PARAM_CONSTRUCT_ONLY |
342                                                         G_PARAM_STATIC_STRINGS));
343
344   /**
345    * GDBusObjectManagerClient:bus-type:
346    *
347    * If this property is not %G_BUS_TYPE_NONE, then
348    * #GDBusObjectManagerClient:connection must be %NULL and will be set to the
349    * #GDBusConnection obtained by calling g_bus_get() with the value
350    * of this property.
351    *
352    * Since: 2.30
353    */
354   g_object_class_install_property (gobject_class,
355                                    PROP_BUS_TYPE,
356                                    g_param_spec_enum ("bus-type",
357                                                       "Bus Type",
358                                                       "The bus to connect to, if any",
359                                                       G_TYPE_BUS_TYPE,
360                                                       G_BUS_TYPE_NONE,
361                                                       G_PARAM_WRITABLE |
362                                                       G_PARAM_CONSTRUCT_ONLY |
363                                                       G_PARAM_STATIC_NAME |
364                                                       G_PARAM_STATIC_BLURB |
365                                                       G_PARAM_STATIC_NICK));
366
367   /**
368    * GDBusObjectManagerClient:flags:
369    *
370    * Flags from the #GDBusObjectManagerClientFlags enumeration.
371    *
372    * Since: 2.30
373    */
374   g_object_class_install_property (gobject_class,
375                                    PROP_FLAGS,
376                                    g_param_spec_flags ("flags",
377                                                        "Flags",
378                                                        "Flags for the proxy manager",
379                                                        G_TYPE_DBUS_OBJECT_MANAGER_CLIENT_FLAGS,
380                                                        G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
381                                                        G_PARAM_READABLE |
382                                                        G_PARAM_WRITABLE |
383                                                        G_PARAM_CONSTRUCT_ONLY |
384                                                        G_PARAM_STATIC_NAME |
385                                                        G_PARAM_STATIC_BLURB |
386                                                        G_PARAM_STATIC_NICK));
387
388   /**
389    * GDBusObjectManagerClient:object-path:
390    *
391    * The object path the manager is for.
392    *
393    * Since: 2.30
394    */
395   g_object_class_install_property (gobject_class,
396                                    PROP_OBJECT_PATH,
397                                    g_param_spec_string ("object-path",
398                                                         "Object Path",
399                                                         "The object path of the control object",
400                                                         NULL,
401                                                         G_PARAM_READABLE |
402                                                         G_PARAM_WRITABLE |
403                                                         G_PARAM_CONSTRUCT_ONLY |
404                                                         G_PARAM_STATIC_STRINGS));
405
406   /**
407    * GDBusObjectManagerClient:name:
408    *
409    * The well-known name or unique name that the manager is for.
410    *
411    * Since: 2.30
412    */
413   g_object_class_install_property (gobject_class,
414                                    PROP_NAME,
415                                    g_param_spec_string ("name",
416                                                         "Name",
417                                                         "Name that the manager is for",
418                                                         NULL,
419                                                         G_PARAM_READABLE |
420                                                         G_PARAM_WRITABLE |
421                                                         G_PARAM_CONSTRUCT_ONLY |
422                                                         G_PARAM_STATIC_STRINGS));
423
424   /**
425    * GDBusObjectManagerClient:name-owner:
426    *
427    * The unique name that owns #GDBusObjectManagerClient:name or %NULL if
428    * no-one is currently owning the name. Connect to the
429    * #GObject::notify signal to track changes to this property.
430    *
431    * Since: 2.30
432    */
433   g_object_class_install_property (gobject_class,
434                                    PROP_NAME_OWNER,
435                                    g_param_spec_string ("name-owner",
436                                                         "Name Owner",
437                                                         "The owner of the name we are watching",
438                                                         NULL,
439                                                         G_PARAM_READABLE |
440                                                         G_PARAM_STATIC_STRINGS));
441
442   /**
443    * GDBusObjectManagerClient:get-proxy-type-func:
444    *
445    * The #GDBusProxyTypeFunc to use when determining what #GType to
446    * use for interface proxies or %NULL.
447    *
448    * Since: 2.30
449    */
450   g_object_class_install_property (gobject_class,
451                                    PROP_GET_PROXY_TYPE_FUNC,
452                                    g_param_spec_pointer ("get-proxy-type-func",
453                                                          "GDBusProxyTypeFunc Function Pointer",
454                                                          "The GDBusProxyTypeFunc pointer to use",
455                                                          G_PARAM_READABLE |
456                                                          G_PARAM_WRITABLE |
457                                                          G_PARAM_CONSTRUCT_ONLY |
458                                                          G_PARAM_STATIC_STRINGS));
459
460   /**
461    * GDBusObjectManagerClient:get-proxy-type-user-data:
462    *
463    * The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
464    *
465    * Since: 2.30
466    */
467   g_object_class_install_property (gobject_class,
468                                    PROP_GET_PROXY_TYPE_USER_DATA,
469                                    g_param_spec_pointer ("get-proxy-type-user-data",
470                                                          "GDBusProxyTypeFunc User Data",
471                                                          "The GDBusProxyTypeFunc user_data",
472                                                          G_PARAM_READABLE |
473                                                          G_PARAM_WRITABLE |
474                                                          G_PARAM_CONSTRUCT_ONLY |
475                                                          G_PARAM_STATIC_STRINGS));
476
477   /**
478    * GDBusObjectManagerClient:get-proxy-type-destroy-notify:
479    *
480    * A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
481    *
482    * Since: 2.30
483    */
484   g_object_class_install_property (gobject_class,
485                                    PROP_GET_PROXY_TYPE_DESTROY_NOTIFY,
486                                    g_param_spec_pointer ("get-proxy-type-destroy-notify",
487                                                          "GDBusProxyTypeFunc user data free function",
488                                                          "The GDBusProxyTypeFunc user data free function",
489                                                          G_PARAM_READABLE |
490                                                          G_PARAM_WRITABLE |
491                                                          G_PARAM_CONSTRUCT_ONLY |
492                                                          G_PARAM_STATIC_STRINGS));
493
494   /**
495    * GDBusObjectManagerClient::interface-proxy-signal:
496    * @manager: The #GDBusObjectManagerClient emitting the signal.
497    * @object_proxy: The #GDBusObjectProxy on which an interface is emitting a D-Bus signal.
498    * @interface_proxy: The #GDBusProxy that is emitting a D-Bus signal.
499    * @sender_name: The sender of the signal or NULL if the connection is not a bus connection.
500    * @signal_name: The signal name.
501    * @parameters: A #GVariant tuple with parameters for the signal.
502    *
503    * Emitted when a D-Bus signal is received on @interface_proxy.
504    *
505    * This signal exists purely as a convenience to avoid having to
506    * connect signals to all interface proxies managed by @manager.
507    *
508    * This signal is emitted in the
509    * [thread-default main context][g-main-context-push-thread-default]
510    * that @manager was constructed in.
511    *
512    * Since: 2.30
513    */
514   signals[INTERFACE_PROXY_SIGNAL_SIGNAL] =
515     g_signal_new ("interface-proxy-signal",
516                   G_TYPE_DBUS_OBJECT_MANAGER_CLIENT,
517                   G_SIGNAL_RUN_LAST,
518                   G_STRUCT_OFFSET (GDBusObjectManagerClientClass, interface_proxy_signal),
519                   NULL,
520                   NULL,
521                   NULL,
522                   G_TYPE_NONE,
523                   5,
524                   G_TYPE_DBUS_OBJECT_PROXY,
525                   G_TYPE_DBUS_PROXY,
526                   G_TYPE_STRING,
527                   G_TYPE_STRING,
528                   G_TYPE_VARIANT);
529
530   /**
531    * GDBusObjectManagerClient::interface-proxy-properties-changed:
532    * @manager: The #GDBusObjectManagerClient emitting the signal.
533    * @object_proxy: The #GDBusObjectProxy on which an interface has properties that are changing.
534    * @interface_proxy: The #GDBusProxy that has properties that are changing.
535    * @changed_properties: A #GVariant containing the properties that changed.
536    * @invalidated_properties: A %NULL terminated array of properties that was invalidated.
537    *
538    * Emitted when one or more D-Bus properties on proxy changes. The
539    * local cache has already been updated when this signal fires. Note
540    * that both @changed_properties and @invalidated_properties are
541    * guaranteed to never be %NULL (either may be empty though).
542    *
543    * This signal exists purely as a convenience to avoid having to
544    * connect signals to all interface proxies managed by @manager.
545    *
546    * This signal is emitted in the
547    * [thread-default main context][g-main-context-push-thread-default]
548    * that @manager was constructed in.
549    *
550    * Since: 2.30
551    */
552   signals[INTERFACE_PROXY_PROPERTIES_CHANGED_SIGNAL] =
553     g_signal_new ("interface-proxy-properties-changed",
554                   G_TYPE_DBUS_OBJECT_MANAGER_CLIENT,
555                   G_SIGNAL_RUN_LAST,
556                   G_STRUCT_OFFSET (GDBusObjectManagerClientClass, interface_proxy_properties_changed),
557                   NULL,
558                   NULL,
559                   NULL,
560                   G_TYPE_NONE,
561                   4,
562                   G_TYPE_DBUS_OBJECT_PROXY,
563                   G_TYPE_DBUS_PROXY,
564                   G_TYPE_VARIANT,
565                   G_TYPE_STRV);
566 }
567
568 static void
569 g_dbus_object_manager_client_init (GDBusObjectManagerClient *manager)
570 {
571   manager->priv = g_dbus_object_manager_client_get_instance_private (manager);
572   g_mutex_init (&manager->priv->lock);
573   manager->priv->map_object_path_to_object_proxy = g_hash_table_new_full (g_str_hash,
574                                                                           g_str_equal,
575                                                                           g_free,
576                                                                           (GDestroyNotify) g_object_unref);
577 }
578
579 /* ---------------------------------------------------------------------------------------------------- */
580
581 /**
582  * g_dbus_object_manager_client_new_sync:
583  * @connection: A #GDBusConnection.
584  * @flags: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
585  * @name: (allow-none): The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
586  * @object_path: The object path of the control object.
587  * @get_proxy_type_func: (allow-none): A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
588  * @get_proxy_type_user_data: User data to pass to @get_proxy_type_func.
589  * @get_proxy_type_destroy_notify: (allow-none): Free function for @get_proxy_type_user_data or %NULL.
590  * @cancellable: (allow-none): A #GCancellable or %NULL
591  * @error: Return location for error or %NULL.
592  *
593  * Creates a new #GDBusObjectManagerClient object.
594  *
595  * This is a synchronous failable constructor - the calling thread is
596  * blocked until a reply is received. See g_dbus_object_manager_client_new()
597  * for the asynchronous version.
598  *
599  * Returns: (transfer full) (type GDBusObjectManagerClient): A
600  *   #GDBusObjectManagerClient object or %NULL if @error is set. Free
601  *   with g_object_unref().
602  *
603  * Since: 2.30
604  */
605 GDBusObjectManager *
606 g_dbus_object_manager_client_new_sync (GDBusConnection               *connection,
607                                        GDBusObjectManagerClientFlags  flags,
608                                        const gchar                   *name,
609                                        const gchar                   *object_path,
610                                        GDBusProxyTypeFunc             get_proxy_type_func,
611                                        gpointer                       get_proxy_type_user_data,
612                                        GDestroyNotify                 get_proxy_type_destroy_notify,
613                                        GCancellable                  *cancellable,
614                                        GError                       **error)
615 {
616   GInitable *initable;
617
618   g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
619   g_return_val_if_fail ((name == NULL && g_dbus_connection_get_unique_name (connection) == NULL) ||
620                         g_dbus_is_name (name), NULL);
621   g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
622   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
623
624   initable = g_initable_new (G_TYPE_DBUS_OBJECT_MANAGER_CLIENT,
625                              cancellable,
626                              error,
627                              "connection", connection,
628                              "flags", flags,
629                              "name", name,
630                              "object-path", object_path,
631                              "get-proxy-type-func", get_proxy_type_func,
632                              "get-proxy-type-user-data", get_proxy_type_user_data,
633                              "get-proxy-type-destroy-notify", get_proxy_type_destroy_notify,
634                              NULL);
635   if (initable != NULL)
636     return G_DBUS_OBJECT_MANAGER (initable);
637   else
638     return NULL;
639 }
640
641 /**
642  * g_dbus_object_manager_client_new:
643  * @connection: A #GDBusConnection.
644  * @flags: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
645  * @name: The owner of the control object (unique or well-known name).
646  * @object_path: The object path of the control object.
647  * @get_proxy_type_func: (allow-none): A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
648  * @get_proxy_type_user_data: User data to pass to @get_proxy_type_func.
649  * @get_proxy_type_destroy_notify: (allow-none): Free function for @get_proxy_type_user_data or %NULL.
650  * @cancellable: (allow-none): A #GCancellable or %NULL
651  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
652  * @user_data: The data to pass to @callback.
653  *
654  * Asynchronously creates a new #GDBusObjectManagerClient object.
655  *
656  * This is an asynchronous failable constructor. When the result is
657  * ready, @callback will be invoked in the
658  * [thread-default main context][g-main-context-push-thread-default]
659  * of the thread you are calling this method from. You can
660  * then call g_dbus_object_manager_client_new_finish() to get the result. See
661  * g_dbus_object_manager_client_new_sync() for the synchronous version.
662  *
663  * Since: 2.30
664  */
665 void
666 g_dbus_object_manager_client_new (GDBusConnection               *connection,
667                                   GDBusObjectManagerClientFlags  flags,
668                                   const gchar                   *name,
669                                   const gchar                   *object_path,
670                                   GDBusProxyTypeFunc             get_proxy_type_func,
671                                   gpointer                       get_proxy_type_user_data,
672                                   GDestroyNotify                 get_proxy_type_destroy_notify,
673                                   GCancellable                  *cancellable,
674                                   GAsyncReadyCallback            callback,
675                                   gpointer                       user_data)
676 {
677   g_return_if_fail (G_IS_DBUS_CONNECTION (connection));
678   g_return_if_fail ((name == NULL && g_dbus_connection_get_unique_name (connection) == NULL) ||
679                         g_dbus_is_name (name));
680   g_return_if_fail (g_variant_is_object_path (object_path));
681
682   g_async_initable_new_async (G_TYPE_DBUS_OBJECT_MANAGER_CLIENT,
683                               G_PRIORITY_DEFAULT,
684                               cancellable,
685                               callback,
686                               user_data,
687                               "connection", connection,
688                               "flags", flags,
689                               "name", name,
690                               "object-path", object_path,
691                               "get-proxy-type-func", get_proxy_type_func,
692                               "get-proxy-type-user-data", get_proxy_type_user_data,
693                               "get-proxy-type-destroy-notify", get_proxy_type_destroy_notify,
694                               NULL);
695 }
696
697 /**
698  * g_dbus_object_manager_client_new_finish:
699  * @res: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new().
700  * @error: Return location for error or %NULL.
701  *
702  * Finishes an operation started with g_dbus_object_manager_client_new().
703  *
704  * Returns: (transfer full) (type GDBusObjectManagerClient): A
705  *   #GDBusObjectManagerClient object or %NULL if @error is set. Free
706  *   with g_object_unref().
707  *
708  * Since: 2.30
709  */
710 GDBusObjectManager *
711 g_dbus_object_manager_client_new_finish (GAsyncResult   *res,
712                                          GError        **error)
713 {
714   GObject *object;
715   GObject *source_object;
716
717   source_object = g_async_result_get_source_object (res);
718   g_assert (source_object != NULL);
719
720   object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
721                                         res,
722                                         error);
723   g_object_unref (source_object);
724
725   if (object != NULL)
726     return G_DBUS_OBJECT_MANAGER (object);
727   else
728     return NULL;
729 }
730
731 /* ---------------------------------------------------------------------------------------------------- */
732
733 /**
734  * g_dbus_object_manager_client_new_for_bus_sync:
735  * @bus_type: A #GBusType.
736  * @flags: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
737  * @name: The owner of the control object (unique or well-known name).
738  * @object_path: The object path of the control object.
739  * @get_proxy_type_func: (allow-none): A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
740  * @get_proxy_type_user_data: User data to pass to @get_proxy_type_func.
741  * @get_proxy_type_destroy_notify: (allow-none): Free function for @get_proxy_type_user_data or %NULL.
742  * @cancellable: (allow-none): A #GCancellable or %NULL
743  * @error: Return location for error or %NULL.
744  *
745  * Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
746  * of a #GDBusConnection.
747  *
748  * This is a synchronous failable constructor - the calling thread is
749  * blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
750  * for the asynchronous version.
751  *
752  * Returns: (transfer full) (type GDBusObjectManagerClient): A
753  *   #GDBusObjectManagerClient object or %NULL if @error is set. Free
754  *   with g_object_unref().
755  *
756  * Since: 2.30
757  */
758 GDBusObjectManager *
759 g_dbus_object_manager_client_new_for_bus_sync (GBusType                       bus_type,
760                                                GDBusObjectManagerClientFlags  flags,
761                                                const gchar                   *name,
762                                                const gchar                   *object_path,
763                                                GDBusProxyTypeFunc             get_proxy_type_func,
764                                                gpointer                       get_proxy_type_user_data,
765                                                GDestroyNotify                 get_proxy_type_destroy_notify,
766                                                GCancellable                  *cancellable,
767                                                GError                       **error)
768 {
769   GInitable *initable;
770
771   g_return_val_if_fail (bus_type != G_BUS_TYPE_NONE, NULL);
772   g_return_val_if_fail (g_dbus_is_name (name), NULL);
773   g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
774   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
775
776   initable = g_initable_new (G_TYPE_DBUS_OBJECT_MANAGER_CLIENT,
777                              cancellable,
778                              error,
779                              "bus-type", bus_type,
780                              "flags", flags,
781                              "name", name,
782                              "object-path", object_path,
783                              "get-proxy-type-func", get_proxy_type_func,
784                              "get-proxy-type-user-data", get_proxy_type_user_data,
785                              "get-proxy-type-destroy-notify", get_proxy_type_destroy_notify,
786                              NULL);
787   if (initable != NULL)
788     return G_DBUS_OBJECT_MANAGER (initable);
789   else
790     return NULL;
791 }
792
793 /**
794  * g_dbus_object_manager_client_new_for_bus:
795  * @bus_type: A #GBusType.
796  * @flags: Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
797  * @name: The owner of the control object (unique or well-known name).
798  * @object_path: The object path of the control object.
799  * @get_proxy_type_func: (allow-none): A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
800  * @get_proxy_type_user_data: User data to pass to @get_proxy_type_func.
801  * @get_proxy_type_destroy_notify: (allow-none): Free function for @get_proxy_type_user_data or %NULL.
802  * @cancellable: (allow-none): A #GCancellable or %NULL
803  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
804  * @user_data: The data to pass to @callback.
805  *
806  * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
807  * #GDBusConnection.
808  *
809  * This is an asynchronous failable constructor. When the result is
810  * ready, @callback will be invoked in the
811  * [thread-default main loop][g-main-context-push-thread-default]
812  * of the thread you are calling this method from. You can
813  * then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
814  * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
815  *
816  * Since: 2.30
817  */
818 void
819 g_dbus_object_manager_client_new_for_bus (GBusType                       bus_type,
820                                           GDBusObjectManagerClientFlags  flags,
821                                           const gchar                   *name,
822                                           const gchar                   *object_path,
823                                           GDBusProxyTypeFunc             get_proxy_type_func,
824                                           gpointer                       get_proxy_type_user_data,
825                                           GDestroyNotify                 get_proxy_type_destroy_notify,
826                                           GCancellable                  *cancellable,
827                                           GAsyncReadyCallback            callback,
828                                           gpointer                       user_data)
829 {
830   g_return_if_fail (bus_type != G_BUS_TYPE_NONE);
831   g_return_if_fail (g_dbus_is_name (name));
832   g_return_if_fail (g_variant_is_object_path (object_path));
833
834   g_async_initable_new_async (G_TYPE_DBUS_OBJECT_MANAGER_CLIENT,
835                               G_PRIORITY_DEFAULT,
836                               cancellable,
837                               callback,
838                               user_data,
839                               "bus-type", bus_type,
840                               "flags", flags,
841                               "name", name,
842                               "object-path", object_path,
843                               "get-proxy-type-func", get_proxy_type_func,
844                               "get-proxy-type-user-data", get_proxy_type_user_data,
845                               "get-proxy-type-destroy-notify", get_proxy_type_destroy_notify,
846                               NULL);
847 }
848
849 /**
850  * g_dbus_object_manager_client_new_for_bus_finish:
851  * @res: A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new_for_bus().
852  * @error: Return location for error or %NULL.
853  *
854  * Finishes an operation started with g_dbus_object_manager_client_new_for_bus().
855  *
856  * Returns: (transfer full) (type GDBusObjectManagerClient): A
857  *   #GDBusObjectManagerClient object or %NULL if @error is set. Free
858  *   with g_object_unref().
859  *
860  * Since: 2.30
861  */
862 GDBusObjectManager *
863 g_dbus_object_manager_client_new_for_bus_finish (GAsyncResult   *res,
864                                                  GError        **error)
865 {
866   GObject *object;
867   GObject *source_object;
868
869   source_object = g_async_result_get_source_object (res);
870   g_assert (source_object != NULL);
871
872   object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
873                                         res,
874                                         error);
875   g_object_unref (source_object);
876
877   if (object != NULL)
878     return G_DBUS_OBJECT_MANAGER (object);
879   else
880     return NULL;
881 }
882
883 /* ---------------------------------------------------------------------------------------------------- */
884
885 /**
886  * g_dbus_object_manager_client_get_connection:
887  * @manager: A #GDBusObjectManagerClient
888  *
889  * Gets the #GDBusConnection used by @manager.
890  *
891  * Returns: (transfer none): A #GDBusConnection object. Do not free,
892  *   the object belongs to @manager.
893  *
894  * Since: 2.30
895  */
896 GDBusConnection *
897 g_dbus_object_manager_client_get_connection (GDBusObjectManagerClient *manager)
898 {
899   GDBusConnection *ret;
900   g_return_val_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager), NULL);
901   g_mutex_lock (&manager->priv->lock);
902   ret = manager->priv->connection;
903   g_mutex_unlock (&manager->priv->lock);
904   return ret;
905 }
906
907 /**
908  * g_dbus_object_manager_client_get_name:
909  * @manager: A #GDBusObjectManagerClient
910  *
911  * Gets the name that @manager is for, or %NULL if not a message bus
912  * connection.
913  *
914  * Returns: A unique or well-known name. Do not free, the string
915  * belongs to @manager.
916  *
917  * Since: 2.30
918  */
919 const gchar *
920 g_dbus_object_manager_client_get_name (GDBusObjectManagerClient *manager)
921 {
922   const gchar *ret;
923   g_return_val_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager), NULL);
924   g_mutex_lock (&manager->priv->lock);
925   ret = manager->priv->name;
926   g_mutex_unlock (&manager->priv->lock);
927   return ret;
928 }
929
930 /**
931  * g_dbus_object_manager_client_get_flags:
932  * @manager: A #GDBusObjectManagerClient
933  *
934  * Gets the flags that @manager was constructed with.
935  *
936  * Returns: Zero of more flags from the #GDBusObjectManagerClientFlags
937  * enumeration.
938  *
939  * Since: 2.30
940  */
941 GDBusObjectManagerClientFlags
942 g_dbus_object_manager_client_get_flags (GDBusObjectManagerClient *manager)
943 {
944   GDBusObjectManagerClientFlags ret;
945   g_return_val_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager), G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE);
946   g_mutex_lock (&manager->priv->lock);
947   ret = manager->priv->flags;
948   g_mutex_unlock (&manager->priv->lock);
949   return ret;
950 }
951
952 /**
953  * g_dbus_object_manager_client_get_name_owner:
954  * @manager: A #GDBusObjectManagerClient.
955  *
956  * The unique name that owns the name that @manager is for or %NULL if
957  * no-one currently owns that name. You can connect to the
958  * #GObject::notify signal to track changes to the
959  * #GDBusObjectManagerClient:name-owner property.
960  *
961  * Returns: (nullable): The name owner or %NULL if no name owner
962  * exists. Free with g_free().
963  *
964  * Since: 2.30
965  */
966 gchar *
967 g_dbus_object_manager_client_get_name_owner (GDBusObjectManagerClient *manager)
968 {
969   gchar *ret;
970   g_return_val_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager), NULL);
971   g_mutex_lock (&manager->priv->lock);
972   ret = g_strdup (manager->priv->name_owner);
973   g_mutex_unlock (&manager->priv->lock);
974   return ret;
975 }
976
977 /* ---------------------------------------------------------------------------------------------------- */
978
979 /* signal handler for all objects we manage - we dispatch signals
980  * from here to the objects
981  */
982 static void
983 signal_cb (GDBusConnection *connection,
984            const gchar     *sender_name,
985            const gchar     *object_path,
986            const gchar     *interface_name,
987            const gchar     *signal_name,
988            GVariant        *parameters,
989            gpointer         user_data)
990 {
991   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (user_data);
992   GDBusObjectProxy *object_proxy;
993   GDBusInterface *interface;
994
995   g_mutex_lock (&manager->priv->lock);
996   object_proxy = g_hash_table_lookup (manager->priv->map_object_path_to_object_proxy, object_path);
997   if (object_proxy == NULL)
998     {
999       g_mutex_unlock (&manager->priv->lock);
1000       goto out;
1001     }
1002   g_object_ref (object_proxy);
1003   g_mutex_unlock (&manager->priv->lock);
1004
1005   //g_debug ("yay, signal_cb %s %s: %s\n", signal_name, object_path, g_variant_print (parameters, TRUE));
1006
1007   g_object_ref (manager);
1008   if (g_strcmp0 (interface_name, "org.freedesktop.DBus.Properties") == 0)
1009     {
1010       if (g_strcmp0 (signal_name, "PropertiesChanged") == 0)
1011         {
1012           const gchar *interface_name;
1013           GVariant *changed_properties;
1014           const gchar **invalidated_properties;
1015
1016           g_variant_get (parameters,
1017                          "(&s@a{sv}^a&s)",
1018                          &interface_name,
1019                          &changed_properties,
1020                          &invalidated_properties);
1021
1022           interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object_proxy), interface_name);
1023           if (interface != NULL)
1024             {
1025               GVariantIter property_iter;
1026               const gchar *property_name;
1027               GVariant *property_value;
1028               guint n;
1029
1030               /* update caches... */
1031               g_variant_iter_init (&property_iter, changed_properties);
1032               while (g_variant_iter_next (&property_iter,
1033                                           "{&sv}",
1034                                           &property_name,
1035                                           &property_value))
1036                 {
1037                   g_dbus_proxy_set_cached_property (G_DBUS_PROXY (interface),
1038                                                     property_name,
1039                                                     property_value);
1040                   g_variant_unref (property_value);
1041                 }
1042
1043               for (n = 0; invalidated_properties[n] != NULL; n++)
1044                 {
1045                   g_dbus_proxy_set_cached_property (G_DBUS_PROXY (interface),
1046                                                     invalidated_properties[n],
1047                                                     NULL);
1048                 }
1049               /* ... and then synthesize the signal */
1050               g_signal_emit_by_name (interface,
1051                                      "g-properties-changed",
1052                                      changed_properties,
1053                                      invalidated_properties);
1054               g_signal_emit (manager,
1055                              signals[INTERFACE_PROXY_PROPERTIES_CHANGED_SIGNAL],
1056                              0,
1057                              object_proxy,
1058                              interface,
1059                              changed_properties,
1060                              invalidated_properties);
1061               g_object_unref (interface);
1062             }
1063           g_variant_unref (changed_properties);
1064           g_free (invalidated_properties);
1065         }
1066     }
1067   else
1068     {
1069       /* regular signal - just dispatch it */
1070       interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object_proxy), interface_name);
1071       if (interface != NULL)
1072         {
1073           g_signal_emit_by_name (interface,
1074                                  "g-signal",
1075                                  sender_name,
1076                                  signal_name,
1077                                  parameters);
1078           g_signal_emit (manager,
1079                          signals[INTERFACE_PROXY_SIGNAL_SIGNAL],
1080                          0,
1081                          object_proxy,
1082                          interface,
1083                          sender_name,
1084                          signal_name,
1085                          parameters);
1086           g_object_unref (interface);
1087         }
1088     }
1089   g_object_unref (manager);
1090
1091  out:
1092   g_clear_object (&object_proxy);
1093 }
1094
1095 static void
1096 subscribe_signals (GDBusObjectManagerClient *manager,
1097                    const gchar *name_owner)
1098 {
1099   GError *error = NULL;
1100   GVariant *ret;
1101
1102   g_return_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager));
1103   g_return_if_fail (manager->priv->signal_subscription_id == 0);
1104   g_return_if_fail (name_owner == NULL || g_dbus_is_unique_name (name_owner));
1105
1106   if (name_owner != NULL)
1107     {
1108       /* Only add path_namespace if it's non-'/'. This removes a no-op key from
1109        * the match rule, and also works around a D-Bus bug where
1110        * path_namespace='/' matches nothing in D-Bus versions < 1.6.18.
1111        *
1112        * See: https://bugs.freedesktop.org/show_bug.cgi?id=70799 */
1113       if (g_str_equal (manager->priv->object_path, "/"))
1114         {
1115           manager->priv->match_rule = g_strdup_printf ("type='signal',sender='%s'",
1116                                                        name_owner);
1117         }
1118       else
1119         {
1120           manager->priv->match_rule = g_strdup_printf ("type='signal',sender='%s',path_namespace='%s'",
1121                                                        name_owner, manager->priv->object_path);
1122         }
1123
1124       /* The bus daemon may not implement path_namespace so gracefully
1125        * handle this by using a fallback triggered if @error is set. */
1126       ret = g_dbus_connection_call_sync (manager->priv->connection,
1127                                          "org.freedesktop.DBus",
1128                                          "/org/freedesktop/DBus",
1129                                          "org.freedesktop.DBus",
1130                                          "AddMatch",
1131                                          g_variant_new ("(s)",
1132                                                         manager->priv->match_rule),
1133                                          NULL, /* reply_type */
1134                                          G_DBUS_CALL_FLAGS_NONE,
1135                                          -1, /* default timeout */
1136                                          NULL, /* TODO: Cancellable */
1137                                          &error);
1138
1139       /* yay, bus daemon supports path_namespace */
1140       if (ret != NULL)
1141         g_variant_unref (ret);
1142     }
1143
1144   if (error == NULL)
1145     {
1146       /* still need to ask GDBusConnection for the callbacks */
1147       manager->priv->signal_subscription_id =
1148         g_dbus_connection_signal_subscribe (manager->priv->connection,
1149                                             name_owner,
1150                                             NULL, /* interface */
1151                                             NULL, /* member */
1152                                             NULL, /* path - TODO: really want wilcard support here */
1153                                             NULL, /* arg0 */
1154                                             G_DBUS_SIGNAL_FLAGS_NONE |
1155                                             G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE,
1156                                             signal_cb,
1157                                             manager,
1158                                             NULL); /* user_data_free_func */
1159
1160     }
1161   else
1162     {
1163       /* TODO: we could report this to the user
1164       g_warning ("Message bus daemon does not support path_namespace: %s (%s %d)",
1165                  error->message,
1166                  g_quark_to_string (error->domain),
1167                  error->code);
1168       */
1169
1170       g_error_free (error);
1171
1172       /* no need to call RemoveMatch when done since it didn't work */
1173       g_free (manager->priv->match_rule);
1174       manager->priv->match_rule = NULL;
1175
1176       /* Fallback is to subscribe to *all* signals from the name owner which
1177        * is rather wasteful. It's probably not a big practical problem because
1178        * users typically want all objects that the name owner supplies.
1179        */
1180       manager->priv->signal_subscription_id =
1181         g_dbus_connection_signal_subscribe (manager->priv->connection,
1182                                             name_owner,
1183                                             NULL, /* interface */
1184                                             NULL, /* member */
1185                                             NULL, /* path - TODO: really want wilcard support here */
1186                                             NULL, /* arg0 */
1187                                             G_DBUS_SIGNAL_FLAGS_NONE,
1188                                             signal_cb,
1189                                             manager,
1190                                             NULL); /* user_data_free_func */
1191     }
1192 }
1193
1194 static void
1195 maybe_unsubscribe_signals (GDBusObjectManagerClient *manager)
1196 {
1197   g_return_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager));
1198
1199   if (manager->priv->signal_subscription_id > 0)
1200     {
1201       g_dbus_connection_signal_unsubscribe (manager->priv->connection,
1202                                             manager->priv->signal_subscription_id);
1203       manager->priv->signal_subscription_id = 0;
1204     }
1205
1206   if (manager->priv->match_rule != NULL)
1207     {
1208       /* Since the AddMatch call succeeded this is guaranteed to not
1209        * fail - therefore, don't bother checking the return value
1210        */
1211       g_dbus_connection_call (manager->priv->connection,
1212                               "org.freedesktop.DBus",
1213                               "/org/freedesktop/DBus",
1214                               "org.freedesktop.DBus",
1215                               "RemoveMatch",
1216                               g_variant_new ("(s)",
1217                                              manager->priv->match_rule),
1218                               NULL, /* reply_type */
1219                               G_DBUS_CALL_FLAGS_NONE,
1220                               -1, /* default timeout */
1221                               NULL, /* GCancellable */
1222                               NULL, /* GAsyncReadyCallback */
1223                               NULL); /* user data */
1224       g_free (manager->priv->match_rule);
1225       manager->priv->match_rule = NULL;
1226     }
1227
1228 }
1229
1230 /* ---------------------------------------------------------------------------------------------------- */
1231
1232 static void
1233 on_notify_g_name_owner (GObject    *object,
1234                         GParamSpec *pspec,
1235                         gpointer    user_data)
1236 {
1237   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (user_data);
1238   gchar *old_name_owner;
1239   gchar *new_name_owner;
1240
1241   g_mutex_lock (&manager->priv->lock);
1242   old_name_owner = manager->priv->name_owner;
1243   new_name_owner = g_dbus_proxy_get_name_owner (manager->priv->control_proxy);
1244   manager->priv->name_owner = NULL;
1245
1246   g_object_ref (manager);
1247   if (g_strcmp0 (old_name_owner, new_name_owner) != 0)
1248     {
1249       GList *l;
1250       GList *proxies;
1251
1252       /* remote manager changed; nuke all local proxies  */
1253       proxies = g_hash_table_get_values (manager->priv->map_object_path_to_object_proxy);
1254       g_list_foreach (proxies, (GFunc) g_object_ref, NULL);
1255       g_hash_table_remove_all (manager->priv->map_object_path_to_object_proxy);
1256
1257       g_mutex_unlock (&manager->priv->lock);
1258
1259       /* do the :name-owner notify with a NULL name - this way the user knows
1260        * the ::object-proxy-removed following is because the name owner went
1261        * away
1262        */
1263       g_object_notify (G_OBJECT (manager), "name-owner");
1264
1265       for (l = proxies; l != NULL; l = l->next)
1266         {
1267           GDBusObjectProxy *object_proxy = G_DBUS_OBJECT_PROXY (l->data);
1268           g_signal_emit_by_name (manager, "object-removed", object_proxy);
1269         }
1270       g_list_free_full (proxies, g_object_unref);
1271
1272       /* nuke local filter */
1273       maybe_unsubscribe_signals (manager);
1274     }
1275   else
1276     {
1277       g_mutex_unlock (&manager->priv->lock);
1278     }
1279
1280   if (new_name_owner != NULL)
1281     {
1282       GError *error;
1283       GVariant *value;
1284
1285       //g_debug ("repopulating for %s", new_name_owner);
1286
1287       /* TODO: do this async! */
1288       subscribe_signals (manager,
1289                          new_name_owner);
1290       error = NULL;
1291       value = g_dbus_proxy_call_sync (manager->priv->control_proxy,
1292                                       "GetManagedObjects",
1293                                       NULL, /* parameters */
1294                                       G_DBUS_CALL_FLAGS_NONE,
1295                                       -1,
1296                                       NULL,
1297                                       &error);
1298       if (value == NULL)
1299         {
1300           maybe_unsubscribe_signals (manager);
1301           g_warning ("Error calling GetManagedObjects() when name owner %s for name %s came back: %s",
1302                      new_name_owner,
1303                      manager->priv->name,
1304                      error->message);
1305           g_error_free (error);
1306         }
1307       else
1308         {
1309           process_get_all_result (manager, value, new_name_owner);
1310           g_variant_unref (value);
1311         }
1312
1313       /* do the :name-owner notify *AFTER* emitting ::object-proxy-added signals - this
1314        * way the user knows that the signals were emitted because the name owner came back
1315        */
1316       g_mutex_lock (&manager->priv->lock);
1317       manager->priv->name_owner = new_name_owner;
1318       g_mutex_unlock (&manager->priv->lock);
1319       g_object_notify (G_OBJECT (manager), "name-owner");
1320
1321     }
1322   g_free (old_name_owner);
1323   g_object_unref (manager);
1324 }
1325
1326 static gboolean
1327 initable_init (GInitable     *initable,
1328                GCancellable  *cancellable,
1329                GError       **error)
1330 {
1331   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (initable);
1332   gboolean ret;
1333   GVariant *value;
1334   GDBusProxyFlags proxy_flags;
1335
1336   ret = FALSE;
1337
1338   if (manager->priv->bus_type != G_BUS_TYPE_NONE)
1339     {
1340       g_assert (manager->priv->connection == NULL);
1341       manager->priv->connection = g_bus_get_sync (manager->priv->bus_type, cancellable, error);
1342       if (manager->priv->connection == NULL)
1343         goto out;
1344     }
1345
1346   proxy_flags = G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES;
1347   if (manager->priv->flags & G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START)
1348     proxy_flags |= G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START;
1349
1350   manager->priv->control_proxy = g_dbus_proxy_new_sync (manager->priv->connection,
1351                                                         proxy_flags,
1352                                                         NULL, /* GDBusInterfaceInfo* */
1353                                                         manager->priv->name,
1354                                                         manager->priv->object_path,
1355                                                         "org.freedesktop.DBus.ObjectManager",
1356                                                         cancellable,
1357                                                         error);
1358   if (manager->priv->control_proxy == NULL)
1359     goto out;
1360
1361   g_signal_connect (G_OBJECT (manager->priv->control_proxy),
1362                     "notify::g-name-owner",
1363                     G_CALLBACK (on_notify_g_name_owner),
1364                     manager);
1365
1366   g_signal_connect (manager->priv->control_proxy,
1367                     "g-signal",
1368                     G_CALLBACK (on_control_proxy_g_signal),
1369                     manager);
1370
1371   manager->priv->name_owner = g_dbus_proxy_get_name_owner (manager->priv->control_proxy);
1372   if (manager->priv->name_owner == NULL && manager->priv->name != NULL)
1373     {
1374       /* it's perfectly fine if there's no name owner.. we're just going to
1375        * wait until one is ready
1376        */
1377     }
1378   else
1379     {
1380       /* yay, we can get the objects */
1381       subscribe_signals (manager,
1382                          manager->priv->name_owner);
1383       value = g_dbus_proxy_call_sync (manager->priv->control_proxy,
1384                                       "GetManagedObjects",
1385                                       NULL, /* parameters */
1386                                       G_DBUS_CALL_FLAGS_NONE,
1387                                       -1,
1388                                       cancellable,
1389                                       error);
1390       if (value == NULL)
1391         {
1392           maybe_unsubscribe_signals (manager);
1393           g_warn_if_fail (g_signal_handlers_disconnect_by_func (manager->priv->control_proxy,
1394                                                                 on_control_proxy_g_signal,
1395                                                                 manager) == 1);
1396           g_object_unref (manager->priv->control_proxy);
1397           manager->priv->control_proxy = NULL;
1398           goto out;
1399         }
1400
1401       process_get_all_result (manager, value, manager->priv->name_owner);
1402       g_variant_unref (value);
1403     }
1404
1405   ret = TRUE;
1406
1407  out:
1408   return ret;
1409 }
1410
1411 static void
1412 initable_iface_init (GInitableIface *initable_iface)
1413 {
1414   initable_iface->init = initable_init;
1415 }
1416
1417 static void
1418 async_initable_iface_init (GAsyncInitableIface *async_initable_iface)
1419 {
1420   /* for now, just use default: run GInitable code in thread */
1421 }
1422
1423 /* ---------------------------------------------------------------------------------------------------- */
1424
1425 static void
1426 add_interfaces (GDBusObjectManagerClient *manager,
1427                 const gchar       *object_path,
1428                 GVariant          *ifaces_and_properties,
1429                 const gchar       *name_owner)
1430 {
1431   GDBusObjectProxy *op;
1432   gboolean added;
1433   GVariantIter iter;
1434   const gchar *interface_name;
1435   GVariant *properties;
1436   GList *interface_added_signals, *l;
1437   GDBusProxy *interface_proxy;
1438
1439   g_return_if_fail (name_owner == NULL || g_dbus_is_unique_name (name_owner));
1440
1441   g_mutex_lock (&manager->priv->lock);
1442
1443   interface_added_signals = NULL;
1444   added = FALSE;
1445
1446   op = g_hash_table_lookup (manager->priv->map_object_path_to_object_proxy, object_path);
1447   if (op == NULL)
1448     {
1449       GType object_proxy_type;
1450       if (manager->priv->get_proxy_type_func != NULL)
1451         {
1452           object_proxy_type = manager->priv->get_proxy_type_func (manager,
1453                                                                   object_path,
1454                                                                   NULL,
1455                                                                   manager->priv->get_proxy_type_user_data);
1456           g_warn_if_fail (g_type_is_a (object_proxy_type, G_TYPE_DBUS_OBJECT_PROXY));
1457         }
1458       else
1459         {
1460           object_proxy_type = G_TYPE_DBUS_OBJECT_PROXY;
1461         }
1462       op = g_object_new (object_proxy_type,
1463                          "g-connection", manager->priv->connection,
1464                          "g-object-path", object_path,
1465                          NULL);
1466       added = TRUE;
1467     }
1468   g_object_ref (op);
1469
1470   g_variant_iter_init (&iter, ifaces_and_properties);
1471   while (g_variant_iter_next (&iter,
1472                               "{&s@a{sv}}",
1473                               &interface_name,
1474                               &properties))
1475     {
1476       GError *error;
1477       GType interface_proxy_type;
1478
1479       if (manager->priv->get_proxy_type_func != NULL)
1480         {
1481           interface_proxy_type = manager->priv->get_proxy_type_func (manager,
1482                                                                      object_path,
1483                                                                      interface_name,
1484                                                                      manager->priv->get_proxy_type_user_data);
1485           g_warn_if_fail (g_type_is_a (interface_proxy_type, G_TYPE_DBUS_PROXY));
1486         }
1487       else
1488         {
1489           interface_proxy_type = G_TYPE_DBUS_PROXY;
1490         }
1491
1492       /* this is fine - there is no blocking IO because we pass DO_NOT_LOAD_PROPERTIES and
1493        * DO_NOT_CONNECT_SIGNALS and use a unique name
1494        */
1495       error = NULL;
1496       interface_proxy = g_initable_new (interface_proxy_type,
1497                                         NULL, /* GCancellable */
1498                                         &error,
1499                                         "g-connection", manager->priv->connection,
1500                                         "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
1501                                                    G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
1502                                         "g-name", name_owner,
1503                                         "g-object-path", object_path,
1504                                         "g-interface-name", interface_name,
1505                                         NULL);
1506       if (interface_proxy == NULL)
1507         {
1508           g_warning ("%s: Error constructing proxy for path %s and interface %s: %s",
1509                      G_STRLOC,
1510                      object_path,
1511                      interface_name,
1512                      error->message);
1513           g_error_free (error);
1514         }
1515       else
1516         {
1517           GVariantIter property_iter;
1518           const gchar *property_name;
1519           GVariant *property_value;
1520
1521           /* associate the interface proxy with the object */
1522           g_dbus_interface_set_object (G_DBUS_INTERFACE (interface_proxy),
1523                                        G_DBUS_OBJECT (op));
1524
1525           g_variant_iter_init (&property_iter, properties);
1526           while (g_variant_iter_next (&property_iter,
1527                                       "{&sv}",
1528                                       &property_name,
1529                                       &property_value))
1530             {
1531               g_dbus_proxy_set_cached_property (interface_proxy,
1532                                                 property_name,
1533                                                 property_value);
1534               g_variant_unref (property_value);
1535             }
1536
1537           _g_dbus_object_proxy_add_interface (op, interface_proxy);
1538           if (!added)
1539             interface_added_signals = g_list_append (interface_added_signals, g_object_ref (interface_proxy));
1540           g_object_unref (interface_proxy);
1541         }
1542       g_variant_unref (properties);
1543     }
1544
1545   g_mutex_unlock (&manager->priv->lock);
1546
1547   /* now that we don't hold the lock any more, emit signals */
1548   g_object_ref (manager);
1549   for (l = interface_added_signals; l != NULL; l = l->next)
1550     {
1551       interface_proxy = G_DBUS_PROXY (l->data);
1552       g_signal_emit_by_name (manager, "interface-added", op, interface_proxy);
1553       g_object_unref (interface_proxy);
1554     }
1555   g_list_free (interface_added_signals);
1556
1557   if (added)
1558     {
1559       g_hash_table_insert (manager->priv->map_object_path_to_object_proxy,
1560                            g_strdup (object_path),
1561                            op);
1562       g_signal_emit_by_name (manager, "object-added", op);
1563     }
1564   g_object_unref (manager);
1565   g_object_unref (op);
1566 }
1567
1568 static void
1569 remove_interfaces (GDBusObjectManagerClient   *manager,
1570                    const gchar         *object_path,
1571                    const gchar *const  *interface_names)
1572 {
1573   GDBusObjectProxy *op;
1574   GList *interfaces;
1575   guint n;
1576   guint num_interfaces;
1577   guint num_interfaces_to_remove;
1578
1579   g_mutex_lock (&manager->priv->lock);
1580
1581   op = g_hash_table_lookup (manager->priv->map_object_path_to_object_proxy, object_path);
1582   if (op == NULL)
1583     {
1584       g_warning ("%s: Processing InterfaceRemoved signal for path %s but no object proxy exists",
1585                  G_STRLOC,
1586                  object_path);
1587       g_mutex_unlock (&manager->priv->lock);
1588       goto out;
1589     }
1590
1591   interfaces = g_dbus_object_get_interfaces (G_DBUS_OBJECT (op));
1592   num_interfaces = g_list_length (interfaces);
1593   g_list_free_full (interfaces, g_object_unref);
1594
1595   num_interfaces_to_remove = g_strv_length ((gchar **) interface_names);
1596
1597   /* see if we are going to completety remove the object */
1598   g_object_ref (manager);
1599   if (num_interfaces_to_remove == num_interfaces)
1600     {
1601       g_object_ref (op);
1602       g_warn_if_fail (g_hash_table_remove (manager->priv->map_object_path_to_object_proxy, object_path));
1603       g_mutex_unlock (&manager->priv->lock);
1604       g_signal_emit_by_name (manager, "object-removed", op);
1605       g_object_unref (op);
1606     }
1607   else
1608     {
1609       g_object_ref (op);
1610       g_mutex_unlock (&manager->priv->lock);
1611       for (n = 0; interface_names != NULL && interface_names[n] != NULL; n++)
1612         {
1613           GDBusInterface *interface;
1614           interface = g_dbus_object_get_interface (G_DBUS_OBJECT (op), interface_names[n]);
1615           _g_dbus_object_proxy_remove_interface (op, interface_names[n]);
1616           if (interface != NULL)
1617             {
1618               g_signal_emit_by_name (manager, "interface-removed", op, interface);
1619               g_object_unref (interface);
1620             }
1621         }
1622       g_object_unref (op);
1623     }
1624   g_object_unref (manager);
1625  out:
1626   ;
1627 }
1628
1629 static void
1630 process_get_all_result (GDBusObjectManagerClient *manager,
1631                         GVariant          *value,
1632                         const gchar       *name_owner)
1633 {
1634   GVariant *arg0;
1635   const gchar *object_path;
1636   GVariant *ifaces_and_properties;
1637   GVariantIter iter;
1638
1639   g_return_if_fail (name_owner == NULL || g_dbus_is_unique_name (name_owner));
1640
1641   arg0 = g_variant_get_child_value (value, 0);
1642   g_variant_iter_init (&iter, arg0);
1643   while (g_variant_iter_next (&iter,
1644                               "{&o@a{sa{sv}}}",
1645                               &object_path,
1646                               &ifaces_and_properties))
1647     {
1648       add_interfaces (manager, object_path, ifaces_and_properties, name_owner);
1649       g_variant_unref (ifaces_and_properties);
1650     }
1651   g_variant_unref (arg0);
1652 }
1653
1654 static void
1655 on_control_proxy_g_signal (GDBusProxy   *proxy,
1656                            const gchar  *sender_name,
1657                            const gchar  *signal_name,
1658                            GVariant     *parameters,
1659                            gpointer      user_data)
1660 {
1661   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (user_data);
1662   const gchar *object_path;
1663
1664   //g_debug ("yay, g_signal %s: %s\n", signal_name, g_variant_print (parameters, TRUE));
1665
1666   if (g_strcmp0 (signal_name, "InterfacesAdded") == 0)
1667     {
1668       GVariant *ifaces_and_properties;
1669       g_variant_get (parameters,
1670                      "(&o@a{sa{sv}})",
1671                      &object_path,
1672                      &ifaces_and_properties);
1673       add_interfaces (manager, object_path, ifaces_and_properties, manager->priv->name_owner);
1674       g_variant_unref (ifaces_and_properties);
1675     }
1676   else if (g_strcmp0 (signal_name, "InterfacesRemoved") == 0)
1677     {
1678       const gchar **ifaces;
1679       g_variant_get (parameters,
1680                      "(&o^a&s)",
1681                      &object_path,
1682                      &ifaces);
1683       remove_interfaces (manager, object_path, ifaces);
1684       g_free (ifaces);
1685     }
1686 }
1687
1688 /* ---------------------------------------------------------------------------------------------------- */
1689
1690 static const gchar *
1691 g_dbus_object_manager_client_get_object_path (GDBusObjectManager *_manager)
1692 {
1693   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (_manager);
1694   return manager->priv->object_path;
1695 }
1696
1697 static GDBusObject *
1698 g_dbus_object_manager_client_get_object (GDBusObjectManager *_manager,
1699                                          const gchar        *object_path)
1700 {
1701   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (_manager);
1702   GDBusObject *ret;
1703
1704   g_mutex_lock (&manager->priv->lock);
1705   ret = g_hash_table_lookup (manager->priv->map_object_path_to_object_proxy, object_path);
1706   if (ret != NULL)
1707     g_object_ref (ret);
1708   g_mutex_unlock (&manager->priv->lock);
1709   return ret;
1710 }
1711
1712 static GDBusInterface *
1713 g_dbus_object_manager_client_get_interface  (GDBusObjectManager  *_manager,
1714                                              const gchar         *object_path,
1715                                              const gchar         *interface_name)
1716 {
1717   GDBusInterface *ret;
1718   GDBusObject *object;
1719
1720   ret = NULL;
1721
1722   object = g_dbus_object_manager_get_object (_manager, object_path);
1723   if (object == NULL)
1724     goto out;
1725
1726   ret = g_dbus_object_get_interface (object, interface_name);
1727   g_object_unref (object);
1728
1729  out:
1730   return ret;
1731 }
1732
1733 static GList *
1734 g_dbus_object_manager_client_get_objects (GDBusObjectManager *_manager)
1735 {
1736   GDBusObjectManagerClient *manager = G_DBUS_OBJECT_MANAGER_CLIENT (_manager);
1737   GList *ret;
1738
1739   g_return_val_if_fail (G_IS_DBUS_OBJECT_MANAGER_CLIENT (manager), NULL);
1740
1741   g_mutex_lock (&manager->priv->lock);
1742   ret = g_hash_table_get_values (manager->priv->map_object_path_to_object_proxy);
1743   g_list_foreach (ret, (GFunc) g_object_ref, NULL);
1744   g_mutex_unlock (&manager->priv->lock);
1745
1746   return ret;
1747 }
1748
1749
1750 static void
1751 dbus_object_manager_interface_init (GDBusObjectManagerIface *iface)
1752 {
1753   iface->get_object_path = g_dbus_object_manager_client_get_object_path;
1754   iface->get_objects     = g_dbus_object_manager_client_get_objects;
1755   iface->get_object      = g_dbus_object_manager_client_get_object;
1756   iface->get_interface   = g_dbus_object_manager_client_get_interface;
1757 }
1758
1759 /* ---------------------------------------------------------------------------------------------------- */