/* GDBus - GLib D-Bus Library

 *

 * Copyright (C) 2008-2010 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author: David Zeuthen <davidz@redhat.com>

 */

#include "config.h"

#include <stdlib.h>

#include <string.h>

#include "gdbusutils.h"

#include "gdbusproxy.h"

#include "gioenumtypes.h"

#include "gdbusconnection.h"

#include "gdbuserror.h"

#include "gdbusprivate.h"

#include "ginitable.h"

#include "gasyncinitable.h"

#include "gioerror.h"

#include "gtask.h"

#include "gcancellable.h"

#include "gdbusinterface.h"

#include "gasyncresult.h"

#ifdef G_OS_UNIX

#include "gunixfdlist.h"

#endif

#include "glibintl.h"

/**

 * SECTION:gdbusproxy

 * @short_description: Client-side D-Bus interface proxy

 * @include: gio/gio.h

 *

 * #GDBusProxy is a base class used for proxies to access a D-Bus

 * interface on a remote object. A #GDBusProxy can be constructed for

 * both well-known and unique names.

 *

 * By default, #GDBusProxy will cache all properties (and listen to

 * changes) of the remote object, and proxy all signals that get

 * emitted. This behaviour can be changed by passing suitable

 * #GDBusProxyFlags when the proxy is created. If the proxy is for a

 * well-known name, the property cache is flushed when the name owner

 * vanishes and reloaded when a name owner appears.

 *

 * If a #GDBusProxy is used for a well-known name, the owner of the

 * name is tracked and can be read from

 * #GDBusProxy:g-name-owner. Connect to the #GObject::notify signal to

 * get notified of changes. Additionally, only signals and property

 * changes emitted from the current name owner are considered and

 * calls are always sent to the current name owner. This avoids a

 * number of race conditions when the name is lost by one owner and

 * claimed by another. However, if no name owner currently exists,

 * then calls will be sent to the well-known name which may result in

 * the message bus launching an owner (unless

 * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is set).

 *

 * The generic #GDBusProxy::g-properties-changed and

 * #GDBusProxy::g-signal signals are not very convenient to work with.

 * Therefore, the recommended way of working with proxies is to subclass

 * #GDBusProxy, and have more natural properties and signals in your derived

 * class. This [example][gdbus-example-gdbus-codegen] shows how this can

 * easily be done using the [gdbus-codegen][gdbus-codegen] tool.

 *

 * A #GDBusProxy instance can be used from multiple threads but note

 * that all signals (e.g. #GDBusProxy::g-signal, #GDBusProxy::g-properties-changed

 * and #GObject::notify) are emitted in the

 * [thread-default main context][g-main-context-push-thread-default]

 * of the thread where the instance was constructed.

 *

 * An example using a proxy for a well-known name can be found in

 * [gdbus-example-watch-proxy.c](https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-watch-proxy.c)

 */

/* lock protecting the mutable properties: name_owner, timeout_msec,

 * expected_interface, and the properties hash table

 */

G_LOCK_DEFINE_STATIC (properties_lock);

/* ---------------------------------------------------------------------------------------------------- */

G_LOCK_DEFINE_STATIC (signal_subscription_lock);

typedef struct

{

  volatile gint ref_count;

  GDBusProxy *proxy;

} SignalSubscriptionData;

static SignalSubscriptionData *

signal_subscription_ref (SignalSubscriptionData *data)

{

  g_atomic_int_inc (&data->ref_count);

  return data;

}

static void

signal_subscription_unref (SignalSubscriptionData *data)

{

  if (g_atomic_int_dec_and_test (&data->ref_count))

    {

      g_slice_free (SignalSubscriptionData, data);

    }

}

/* ---------------------------------------------------------------------------------------------------- */

struct _GDBusProxyPrivate

{

  GBusType bus_type;

  GDBusProxyFlags flags;

  GDBusConnection *connection;

  gchar *name;

  /* mutable, protected by properties_lock */

  gchar *name_owner;

  gchar *object_path;

  gchar *interface_name;

  /* mutable, protected by properties_lock */

  gint timeout_msec;

  guint name_owner_changed_subscription_id;

  GCancellable *get_all_cancellable;

  /* gchar* -> GVariant*, protected by properties_lock */

  GHashTable *properties;

  /* mutable, protected by properties_lock */

  GDBusInterfaceInfo *expected_interface;

  guint properties_changed_subscription_id;

  guint signals_subscription_id;

  gboolean initialized;

  /* mutable, protected by properties_lock */

  GDBusObject *object;

  SignalSubscriptionData *signal_subscription_data;

};

enum

{

  PROP_0,

  PROP_G_CONNECTION,

  PROP_G_BUS_TYPE,

  PROP_G_NAME,

  PROP_G_NAME_OWNER,

  PROP_G_FLAGS,

  PROP_G_OBJECT_PATH,

  PROP_G_INTERFACE_NAME,

  PROP_G_DEFAULT_TIMEOUT,

  PROP_G_INTERFACE_INFO

};

enum

{

  PROPERTIES_CHANGED_SIGNAL,

  SIGNAL_SIGNAL,

  LAST_SIGNAL,

};

static guint signals[LAST_SIGNAL] = {0};

static void dbus_interface_iface_init (GDBusInterfaceIface *dbus_interface_iface);

static void initable_iface_init       (GInitableIface *initable_iface);

static void async_initable_iface_init (GAsyncInitableIface *async_initable_iface);

G_DEFINE_TYPE_WITH_CODE (GDBusProxy, g_dbus_proxy, G_TYPE_OBJECT,

                         G_ADD_PRIVATE (GDBusProxy)

                         G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_INTERFACE, dbus_interface_iface_init)

                         G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init)

                         G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, async_initable_iface_init))

static void

g_dbus_proxy_dispose (GObject *object)

{

  GDBusProxy *proxy = G_DBUS_PROXY (object);

  G_LOCK (signal_subscription_lock);

  if (proxy->priv->signal_subscription_data != NULL)

    {

      proxy->priv->signal_subscription_data->proxy = NULL;

      signal_subscription_unref (proxy->priv->signal_subscription_data);

      proxy->priv->signal_subscription_data = NULL;

    }

  G_UNLOCK (signal_subscription_lock);

  G_OBJECT_CLASS (g_dbus_proxy_parent_class)->dispose (object);

}

static void

g_dbus_proxy_finalize (GObject *object)

{

  GDBusProxy *proxy = G_DBUS_PROXY (object);

  g_warn_if_fail (proxy->priv->get_all_cancellable == NULL);

  if (proxy->priv->name_owner_changed_subscription_id > 0)

    g_dbus_connection_signal_unsubscribe (proxy->priv->connection,

                                          proxy->priv->name_owner_changed_subscription_id);

  if (proxy->priv->properties_changed_subscription_id > 0)

    g_dbus_connection_signal_unsubscribe (proxy->priv->connection,

                                          proxy->priv->properties_changed_subscription_id);

  if (proxy->priv->signals_subscription_id > 0)

    g_dbus_connection_signal_unsubscribe (proxy->priv->connection,

                                          proxy->priv->signals_subscription_id);

  if (proxy->priv->connection != NULL)

    g_object_unref (proxy->priv->connection);

  g_free (proxy->priv->name);

  g_free (proxy->priv->name_owner);

  g_free (proxy->priv->object_path);

  g_free (proxy->priv->interface_name);

  if (proxy->priv->properties != NULL)

    g_hash_table_unref (proxy->priv->properties);

  if (proxy->priv->expected_interface != NULL)

    {

      g_dbus_interface_info_cache_release (proxy->priv->expected_interface);

      g_dbus_interface_info_unref (proxy->priv->expected_interface);

    }

  if (proxy->priv->object != NULL)

    g_object_remove_weak_pointer (G_OBJECT (proxy->priv->object), (gpointer *) &proxy->priv->object);

  G_OBJECT_CLASS (g_dbus_proxy_parent_class)->finalize (object);

}

static void

g_dbus_proxy_get_property (GObject    *object,

                           guint       prop_id,

                           GValue     *value,

                           GParamSpec *pspec)

{

  GDBusProxy *proxy = G_DBUS_PROXY (object);

  switch (prop_id)

    {

    case PROP_G_CONNECTION:

      g_value_set_object (value, proxy->priv->connection);

      break;

    case PROP_G_FLAGS:

      g_value_set_flags (value, proxy->priv->flags);

      break;

    case PROP_G_NAME:

      g_value_set_string (value, proxy->priv->name);

      break;

    case PROP_G_NAME_OWNER:

      g_value_take_string (value, g_dbus_proxy_get_name_owner (proxy));

      break;

    case PROP_G_OBJECT_PATH:

      g_value_set_string (value, proxy->priv->object_path);

      break;

    case PROP_G_INTERFACE_NAME:

      g_value_set_string (value, proxy->priv->interface_name);

      break;

    case PROP_G_DEFAULT_TIMEOUT:

      g_value_set_int (value, g_dbus_proxy_get_default_timeout (proxy));

      break;

    case PROP_G_INTERFACE_INFO:

      g_value_set_boxed (value, g_dbus_proxy_get_interface_info (proxy));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

g_dbus_proxy_set_property (GObject      *object,

                           guint         prop_id,

                           const GValue *value,

                           GParamSpec   *pspec)

{

  GDBusProxy *proxy = G_DBUS_PROXY (object);

  switch (prop_id)

    {

    case PROP_G_CONNECTION:

      proxy->priv->connection = g_value_dup_object (value);

      break;

    case PROP_G_FLAGS:

      proxy->priv->flags = g_value_get_flags (value);

      break;

    case PROP_G_NAME:

      proxy->priv->name = g_value_dup_string (value);

      break;

    case PROP_G_OBJECT_PATH:

      proxy->priv->object_path = g_value_dup_string (value);

      break;

    case PROP_G_INTERFACE_NAME:

      proxy->priv->interface_name = g_value_dup_string (value);

      break;

    case PROP_G_DEFAULT_TIMEOUT:

      g_dbus_proxy_set_default_timeout (proxy, g_value_get_int (value));

      break;

    case PROP_G_INTERFACE_INFO:

      g_dbus_proxy_set_interface_info (proxy, g_value_get_boxed (value));

      break;

    case PROP_G_BUS_TYPE:

      proxy->priv->bus_type = g_value_get_enum (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

g_dbus_proxy_class_init (GDBusProxyClass *klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->dispose      = g_dbus_proxy_dispose;

  gobject_class->finalize     = g_dbus_proxy_finalize;

  gobject_class->set_property = g_dbus_proxy_set_property;

  gobject_class->get_property = g_dbus_proxy_get_property;

  /* Note that all property names are prefixed to avoid collisions with D-Bus property names

   * in derived classes */

  /**

   * GDBusProxy:g-interface-info:

   *

   * Ensure that interactions with this proxy conform to the given

   * interface. This is mainly to ensure that malformed data received

   * from the other peer is ignored. The given #GDBusInterfaceInfo is

   * said to be the "expected interface".

   *

   * The checks performed are:

   * - When completing a method call, if the type signature of

   *   the reply message isn't what's expected, the reply is

   *   discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.

   *

   * - Received signals that have a type signature mismatch are dropped and

   *   a warning is logged via g_warning().

   *

   * - Properties received via the initial `GetAll()` call or via the 

   *   `::PropertiesChanged` signal (on the

   *   [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)

   *   interface) or set using g_dbus_proxy_set_cached_property()

   *   with a type signature mismatch are ignored and a warning is

   *   logged via g_warning().

   *

   * Note that these checks are never done on methods, signals and

   * properties that are not referenced in the given

   * #GDBusInterfaceInfo, since extending a D-Bus interface on the

   * service-side is not considered an ABI break.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_INTERFACE_INFO,

                                   g_param_spec_boxed ("g-interface-info",

                                                       P_("Interface Information"),

                                                       P_("Interface Information"),

                                                       G_TYPE_DBUS_INTERFACE_INFO,

                                                       G_PARAM_READABLE |

                                                       G_PARAM_WRITABLE |

                                                       G_PARAM_STATIC_NAME |

                                                       G_PARAM_STATIC_BLURB |

                                                       G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-connection:

   *

   * The #GDBusConnection the proxy is for.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_CONNECTION,

                                   g_param_spec_object ("g-connection",

                                                        P_("g-connection"),

                                                        P_("The connection the proxy is for"),

                                                        G_TYPE_DBUS_CONNECTION,

                                                        G_PARAM_READABLE |

                                                        G_PARAM_WRITABLE |

                                                        G_PARAM_CONSTRUCT_ONLY |

                                                        G_PARAM_STATIC_NAME |

                                                        G_PARAM_STATIC_BLURB |

                                                        G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-bus-type:

   *

   * If this property is not %G_BUS_TYPE_NONE, then

   * #GDBusProxy:g-connection must be %NULL and will be set to the

   * #GDBusConnection obtained by calling g_bus_get() with the value

   * of this property.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_BUS_TYPE,

                                   g_param_spec_enum ("g-bus-type",

                                                      P_("Bus Type"),

                                                      P_("The bus to connect to, if any"),

                                                      G_TYPE_BUS_TYPE,

                                                      G_BUS_TYPE_NONE,

                                                      G_PARAM_WRITABLE |

                                                      G_PARAM_CONSTRUCT_ONLY |

                                                      G_PARAM_STATIC_NAME |

                                                      G_PARAM_STATIC_BLURB |

                                                      G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-flags:

   *

   * Flags from the #GDBusProxyFlags enumeration.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_FLAGS,

                                   g_param_spec_flags ("g-flags",

                                                       P_("g-flags"),

                                                       P_("Flags for the proxy"),

                                                       G_TYPE_DBUS_PROXY_FLAGS,

                                                       G_DBUS_PROXY_FLAGS_NONE,

                                                       G_PARAM_READABLE |

                                                       G_PARAM_WRITABLE |

                                                       G_PARAM_CONSTRUCT_ONLY |

                                                       G_PARAM_STATIC_NAME |

                                                       G_PARAM_STATIC_BLURB |

                                                       G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-name:

   *

   * The well-known or unique name that the proxy is for.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_NAME,

                                   g_param_spec_string ("g-name",

                                                        P_("g-name"),

                                                        P_("The well-known or unique name that the proxy is for"),

                                                        NULL,

                                                        G_PARAM_READABLE |

                                                        G_PARAM_WRITABLE |

                                                        G_PARAM_CONSTRUCT_ONLY |

                                                        G_PARAM_STATIC_NAME |

                                                        G_PARAM_STATIC_BLURB |

                                                        G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-name-owner:

   *

   * The unique name that owns #GDBusProxy:g-name or %NULL if no-one

   * currently owns that name. You may connect to #GObject::notify signal to

   * track changes to this property.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_NAME_OWNER,

                                   g_param_spec_string ("g-name-owner",

                                                        P_("g-name-owner"),

                                                        P_("The unique name for the owner"),

                                                        NULL,

                                                        G_PARAM_READABLE |

                                                        G_PARAM_STATIC_NAME |

                                                        G_PARAM_STATIC_BLURB |

                                                        G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-object-path:

   *

   * The object path the proxy is for.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_OBJECT_PATH,

                                   g_param_spec_string ("g-object-path",

                                                        P_("g-object-path"),

                                                        P_("The object path the proxy is for"),

                                                        NULL,

                                                        G_PARAM_READABLE |

                                                        G_PARAM_WRITABLE |

                                                        G_PARAM_CONSTRUCT_ONLY |

                                                        G_PARAM_STATIC_NAME |

                                                        G_PARAM_STATIC_BLURB |

                                                        G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-interface-name:

   *

   * The D-Bus interface name the proxy is for.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_INTERFACE_NAME,

                                   g_param_spec_string ("g-interface-name",

                                                        P_("g-interface-name"),

                                                        P_("The D-Bus interface name the proxy is for"),

                                                        NULL,

                                                        G_PARAM_READABLE |

                                                        G_PARAM_WRITABLE |

                                                        G_PARAM_CONSTRUCT_ONLY |

                                                        G_PARAM_STATIC_NAME |

                                                        G_PARAM_STATIC_BLURB |

                                                        G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy:g-default-timeout:

   *

   * The timeout to use if -1 (specifying default timeout) is passed

   * as @timeout_msec in the g_dbus_proxy_call() and

   * g_dbus_proxy_call_sync() functions.

   *

   * This allows applications to set a proxy-wide timeout for all

   * remote method invocations on the proxy. If this property is -1,

   * the default timeout (typically 25 seconds) is used. If set to

   * %G_MAXINT, then no timeout is used.

   *

   * Since: 2.26

   */

  g_object_class_install_property (gobject_class,

                                   PROP_G_DEFAULT_TIMEOUT,

                                   g_param_spec_int ("g-default-timeout",

                                                     P_("Default Timeout"),

                                                     P_("Timeout for remote method invocation"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     G_PARAM_READABLE |

                                                     G_PARAM_WRITABLE |

                                                     G_PARAM_CONSTRUCT |

                                                     G_PARAM_STATIC_NAME |

                                                     G_PARAM_STATIC_BLURB |

                                                     G_PARAM_STATIC_NICK));

  /**

   * GDBusProxy::g-properties-changed:

   * @proxy: The #GDBusProxy emitting the signal.

   * @changed_properties: A #GVariant containing the properties that changed

   * @invalidated_properties: A %NULL terminated array of properties that was invalidated

   *

   * Emitted when one or more D-Bus properties on @proxy changes. The

   * local cache has already been updated when this signal fires. Note

   * that both @changed_properties and @invalidated_properties are

   * guaranteed to never be %NULL (either may be empty though).

   *

   * If the proxy has the flag

   * %G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES set, then

   * @invalidated_properties will always be empty.

   *

   * This signal corresponds to the

   * `PropertiesChanged` D-Bus signal on the

   * `org.freedesktop.DBus.Properties` interface.

   *

   * Since: 2.26

   */

  signals[PROPERTIES_CHANGED_SIGNAL] = g_signal_new (I_("g-properties-changed"),

                                                     G_TYPE_DBUS_PROXY,

                                                     G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,

                                                     G_STRUCT_OFFSET (GDBusProxyClass, g_properties_changed),

                                                     NULL,

                                                     NULL,

                                                     NULL,

                                                     G_TYPE_NONE,

                                                     2,

                                                     G_TYPE_VARIANT,

                                                     G_TYPE_STRV | G_SIGNAL_TYPE_STATIC_SCOPE);

  /**

   * GDBusProxy::g-signal:

   * @proxy: The #GDBusProxy emitting the signal.

   * @sender_name: (nullable): The sender of the signal or %NULL if the connection is not a bus connection.

   * @signal_name: The name of the signal.

   * @parameters: A #GVariant tuple with parameters for the signal.

   *

   * Emitted when a signal from the remote object and interface that @proxy is for, has been received.

   *

   * Since: 2.26

   */

  signals[SIGNAL_SIGNAL] = g_signal_new (I_("g-signal"),

                                         G_TYPE_DBUS_PROXY,

                                         G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,

                                         G_STRUCT_OFFSET (GDBusProxyClass, g_signal),

                                         NULL,

                                         NULL,

                                         NULL,

                                         G_TYPE_NONE,

                                         3,

                                         G_TYPE_STRING,

                                         G_TYPE_STRING,

                                         G_TYPE_VARIANT);

}

static void

g_dbus_proxy_init (GDBusProxy *proxy)

{

  proxy->priv = g_dbus_proxy_get_instance_private (proxy);

  proxy->priv->signal_subscription_data = g_slice_new0 (SignalSubscriptionData);

  proxy->priv->signal_subscription_data->ref_count = 1;

  proxy->priv->signal_subscription_data->proxy = proxy;

  proxy->priv->properties = g_hash_table_new_full (g_str_hash,

                                                   g_str_equal,

                                                   g_free,

                                                   (GDestroyNotify) g_variant_unref);

}

/* ---------------------------------------------------------------------------------------------------- */

static gint

property_name_sort_func (const gchar **a,

                         const gchar **b)

{

  return g_strcmp0 (*a, *b);

}

/**

 * g_dbus_proxy_get_cached_property_names:

 * @proxy: A #GDBusProxy.

 *

 * Gets the names of all cached properties on @proxy.

 *

 * Returns: (transfer full) (nullable) (array zero-terminated=1): A

 *          %NULL-terminated array of strings or %NULL if

 *          @proxy has no cached properties. Free the returned array with

 *          g_strfreev().

 *

 * Since: 2.26

 */

gchar **

g_dbus_proxy_get_cached_property_names (GDBusProxy  *proxy)

{

  gchar **names;

  GPtrArray *p;

  GHashTableIter iter;

  const gchar *key;

  g_return_val_if_fail (G_IS_DBUS_PROXY (proxy), NULL);

  G_LOCK (properties_lock);

  names = NULL;

  if (g_hash_table_size (proxy->priv->properties) == 0)

    goto out;

  p = g_ptr_array_new ();

  g_hash_table_iter_init (&iter, proxy->priv->properties);

  while (g_hash_table_iter_next (&iter, (gpointer) &key, NULL))

    g_ptr_array_add (p, g_strdup (key));

  g_ptr_array_sort (p, (GCompareFunc) property_name_sort_func);

  g_ptr_array_add (p, NULL);

  names = (gchar **) g_ptr_array_free (p, FALSE);

 out:

  G_UNLOCK (properties_lock);

  return names;

}

/* properties_lock must be held for as long as you will keep the

 * returned value

 */

static const GDBusPropertyInfo *

lookup_property_info (GDBusProxy  *proxy,

                      const gchar *property_name)

{

  const GDBusPropertyInfo *info = NULL;

  if (proxy->priv->expected_interface == NULL)

    goto out;

  info = g_dbus_interface_info_lookup_property (proxy->priv->expected_interface, property_name);

 out:

  return info;

}

/**

 * g_dbus_proxy_get_cached_property:

 * @proxy: A #GDBusProxy.

 * @property_name: Property name.

 *

 * Looks up the value for a property from the cache. This call does no

 * blocking IO.

 *

 * If @proxy has an expected interface (see

 * #GDBusProxy:g-interface-info) and @property_name is referenced by

 * it, then @value is checked against the type of the property.

 *

 * Returns: (transfer full) (nullable): A reference to the #GVariant instance

 *    that holds the value for @property_name or %NULL if the value is not in

 *    the cache. The returned reference must be freed with g_variant_unref().

 *

 * Since: 2.26

 */

GVariant *

g_dbus_proxy_get_cached_property (GDBusProxy   *proxy,

                                  const gchar  *property_name)

{

  const GDBusPropertyInfo *info;

  GVariant *value;

  g_return_val_if_fail (G_IS_DBUS_PROXY (proxy), NULL);

  g_return_val_if_fail (property_name != NULL, NULL);

  G_LOCK (properties_lock);

  value = g_hash_table_lookup (proxy->priv->properties, property_name);

  if (value == NULL)

    goto out;

  info = lookup_property_info (proxy, property_name);

  if (info != NULL)

    {

      const gchar *type_string = g_variant_get_type_string (value);

      if (g_strcmp0 (type_string, info->signature) != 0)

        {

          g_warning ("Trying to get property %s with type %s but according to the expected "

                     "interface the type is %s",

                     property_name,

                     type_string,

                     info->signature);

          value = NULL;

          goto out;

        }

    }

  g_variant_ref (value);

 out:

  G_UNLOCK (properties_lock);

  return value;

}

/**

 * g_dbus_proxy_set_cached_property:

 * @proxy: A #GDBusProxy

 * @property_name: Property name.

 * @value: (nullable): Value for the property or %NULL to remove it from the cache.

 *

 * If @value is not %NULL, sets the cached value for the property with

 * name @property_name to the value in @value.

 *

 * If @value is %NULL, then the cached value is removed from the

 * property cache.

 *

 * If @proxy has an expected interface (see

 * #GDBusProxy:g-interface-info) and @property_name is referenced by

 * it, then @value is checked against the type of the property.

 *

 * If the @value #GVariant is floating, it is consumed. This allows

 * convenient 'inline' use of g_variant_new(), e.g.

 * |[

 *  g_dbus_proxy_set_cached_property (proxy,

 *                                    "SomeProperty",

 *                                    g_variant_new ("(si)",

 *                                                  "A String",

 *                                                  42));

 * ]|

 *

 * Normally you will not need to use this method since @proxy

 * is tracking changes using the

 * `org.freedesktop.DBus.Properties.PropertiesChanged`

 * D-Bus signal. However, for performance reasons an object may

 * decide to not use this signal for some properties and instead

 * use a proprietary out-of-band mechanism to transmit changes.

 *

 * As a concrete example, consider an object with a property

 * `ChatroomParticipants` which is an array of strings. Instead of

 * transmitting the same (long) array every time the property changes,

 * it is more efficient to only transmit the delta using e.g. signals

 * `ChatroomParticipantJoined(String name)` and

 * `ChatroomParticipantParted(String name)`.

 *

 * Since: 2.26

 */

void

g_dbus_proxy_set_cached_property (GDBusProxy   *proxy,

                                  const gchar  *property_name,

                                  GVariant     *value)

{

  const GDBusPropertyInfo *info;

  g_return_if_fail (G_IS_DBUS_PROXY (proxy));

  g_return_if_fail (property_name != NULL);

  G_LOCK (properties_lock);

  if (value != NULL)

    {

      info = lookup_property_info (proxy, property_name);

      if (info != NULL)

        {

          if (g_strcmp0 (info->signature, g_variant_get_type_string (value)) != 0)

            {

              g_warning ("Trying to set property %s of type %s but according to the expected "

			 "interface the type is %s",

                         property_name,

                         g_variant_get_type_string (value),

                         info->signature);

              goto out;

            }

        }

      g_hash_table_insert (proxy->priv->properties,

                           g_strdup (property_name),

                           g_variant_ref_sink (value));

    }

  else

    {

      g_hash_table_remove (proxy->priv->properties, property_name);

    }

 out:

  G_UNLOCK (properties_lock);

}

/* ---------------------------------------------------------------------------------------------------- */

static void

on_signal_received (GDBusConnection *connection,

                    const gchar     *sender_name,

                    const gchar     *object_path,

                    const gchar     *interface_name,

                    const gchar     *signal_name,

                    GVariant        *parameters,

                    gpointer         user_data)

{

  SignalSubscriptionData *data = user_data;

  GDBusProxy *proxy;

  G_LOCK (signal_subscription_lock);

  proxy = data->proxy;

  if (proxy == NULL)

    {

      G_UNLOCK (signal_subscription_lock);

      return;

    }

  else

    {

      g_object_ref (proxy);

      G_UNLOCK (signal_subscription_lock);

    }