/*
* Copyright © 2018 Igalia S.L.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* This program 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 .
*
* Authors:
* Patrick Griffis
*/
#include "config.h"
#include
#include
#include
#include
#include "settings.h"
#include "xdp-dbus.h"
#include "xdp-impl-dbus.h"
#include "xdp-portal-impl.h"
#include "xdp-utils.h"
typedef struct _Settings Settings;
typedef struct _SettingsClass SettingsClass;
struct _Settings
{
XdpDbusSettingsSkeleton parent_instance;
};
struct _SettingsClass
{
XdpDbusSettingsSkeletonClass parent_class;
};
static XdpDbusImplSettings **impls;
static int n_impls = 0;
GType settings_get_type (void) G_GNUC_CONST;
static void settings_iface_init (XdpDbusSettingsIface *iface);
G_DEFINE_TYPE_WITH_CODE (Settings, settings, XDP_DBUS_TYPE_SETTINGS_SKELETON,
G_IMPLEMENT_INTERFACE (XDP_DBUS_TYPE_SETTINGS,
settings_iface_init));
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Settings, g_object_unref)
static void
merge_impl_settings (GHashTable *merged,
GVariant *settings)
{
GVariantIter iter;
const char *namespace;
GVariant *nsvalue;
g_variant_iter_init (&iter, settings);
while (g_variant_iter_next (&iter, "{&s@a{sv}}", &namespace, &nsvalue))
{
g_autoptr (GVariant) owned_nsvalue = NULL;
g_autofree char *owned_namespace = NULL;
g_autoptr (GVariantDict) dict = NULL;
GVariantIter iter2;
const char *key;
GVariant *value;
owned_nsvalue = nsvalue;
if (!g_hash_table_steal_extended (merged, namespace,
(gpointer *)&owned_namespace,
(gpointer *)&dict))
{
dict = g_variant_dict_new (NULL);
owned_namespace = g_strdup (namespace);
}
g_variant_iter_init (&iter2, nsvalue);
while (g_variant_iter_loop (&iter2, "{sv}", &key, &value))
g_variant_dict_insert_value (dict, key, value);
g_hash_table_insert (merged,
g_steal_pointer (&owned_namespace),
g_steal_pointer (&dict));
}
}
static GVariant *
merged_to_variant (GHashTable *merged)
{
g_auto(GVariantBuilder) builder =
G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("(a{sa{sv}})"));
const char *namespace;
GVariantDict *dict;
GHashTableIter iter;
g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sa{sv}}"));
g_hash_table_iter_init (&iter, merged);
while (g_hash_table_iter_next (&iter,
(gpointer *)&namespace,
(gpointer *)&dict))
{
g_variant_builder_add (&builder, "{s@a{sv}}",
namespace,
g_variant_dict_end (dict));
}
g_variant_builder_close (&builder);
return g_variant_ref_sink (g_variant_builder_end (&builder));
}
static gboolean
settings_handle_read_all (XdpDbusSettings *object,
GDBusMethodInvocation *invocation,
const char * const *arg_namespaces)
{
g_autoptr(GHashTable) merged = NULL;
g_autoptr(GVariant) settings = NULL;
int j;
merged = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify) g_variant_dict_unref);
for (j = n_impls - 1; j >= 0; j--)
{
g_autoptr(GError) error = NULL;
g_autoptr(GVariant) impl_value = NULL;
if (!xdp_dbus_impl_settings_call_read_all_sync (impls[j], arg_namespaces,
&impl_value, NULL, &error))
g_warning ("Failed to ReadAll() from Settings implementation: %s", error->message);
else
merge_impl_settings (merged, impl_value);
}
settings = merged_to_variant (merged);
g_dbus_method_invocation_return_value (invocation, settings);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
settings_handle_read (XdpDbusSettings *object,
GDBusMethodInvocation *invocation,
const char *arg_namespace,
const char *arg_key)
{
int i;
g_debug ("Read %s %s", arg_namespace, arg_key);
for (i = 0; i < n_impls; i++)
{
g_autoptr(GError) error = NULL;
g_autoptr(GVariant) impl_value = NULL;
if (!xdp_dbus_impl_settings_call_read_sync (impls[i], arg_namespace,
arg_key, &impl_value, NULL, &error))
{
/* A key not being found is expected, continue to our implementation */
g_debug ("Failed to Read() from Settings implementation: %s", error->message);
}
else
{
g_dbus_method_invocation_return_value (invocation, g_variant_new ("(v)", impl_value));
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
}
g_debug ("Attempted to read unknown namespace/key pair: %s %s", arg_namespace, arg_key);
g_dbus_method_invocation_return_error_literal (invocation, XDG_DESKTOP_PORTAL_ERROR,
XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
_("Requested setting not found"));
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
settings_handle_read_one (XdpDbusSettings *object,
GDBusMethodInvocation *invocation,
const char *arg_namespace,
const char *arg_key)
{
int i;
g_debug ("ReadOne %s %s", arg_namespace, arg_key);
for (i = 0; i < n_impls; i++)
{
g_autoptr(GError) error = NULL;
g_autoptr(GVariant) impl_value = NULL;
if (!xdp_dbus_impl_settings_call_read_sync (impls[i], arg_namespace,
arg_key, &impl_value, NULL, &error))
{
/* A key not being found is expected, continue to our implementation */
g_debug ("Failed to Read() from Settings implementation: %s", error->message);
}
else
{
g_dbus_method_invocation_return_value (invocation, g_variant_new_tuple (&impl_value, 1));
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
}
g_debug ("Attempted to read unknown namespace/key pair: %s %s", arg_namespace, arg_key);
g_dbus_method_invocation_return_error_literal (invocation, XDG_DESKTOP_PORTAL_ERROR,
XDG_DESKTOP_PORTAL_ERROR_NOT_FOUND,
_("Requested setting not found"));
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static void
on_impl_settings_changed (XdpDbusImplSettings *impl,
const char *arg_namespace,
const char *arg_key,
GVariant *arg_value,
XdpDbusSettings *settings)
{
g_debug ("Emitting changed for %s %s", arg_namespace, arg_key);
xdp_dbus_settings_emit_setting_changed (settings, arg_namespace,
arg_key, arg_value);
}
static void
settings_iface_init (XdpDbusSettingsIface *iface)
{
iface->handle_read = settings_handle_read;
iface->handle_read_one = settings_handle_read_one;
iface->handle_read_all = settings_handle_read_all;
}
static void
settings_init (Settings *settings)
{
xdp_dbus_settings_set_version (XDP_DBUS_SETTINGS (settings), 2);
}
static void
settings_finalize (GObject *object)
{
Settings *self = (Settings*)object;
int i;
for (i = 0; i < n_impls; i++)
g_signal_handlers_disconnect_by_data (impls[i], self);
G_OBJECT_CLASS (settings_parent_class)->finalize (object);
}
static void
settings_class_init (SettingsClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = settings_finalize;
}
GDBusInterfaceSkeleton *
settings_create (GDBusConnection *connection,
GPtrArray *implementations)
{
g_autoptr(Settings) settings = NULL;
g_autoptr(GError) error = NULL;
int i;
int n_impls_tmp;
n_impls_tmp = implementations->len;
impls = g_new (XdpDbusImplSettings *, n_impls_tmp);
settings = g_object_new (settings_get_type (), NULL);
for (i = 0; i < n_impls_tmp; i++)
{
XdpPortalImplementation *impl = g_ptr_array_index (implementations, i);
const char *dbus_name = impl->dbus_name;
XdpDbusImplSettings *impl_proxy =
xdp_dbus_impl_settings_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
dbus_name,
DESKTOP_PORTAL_OBJECT_PATH,
NULL,
&error);
if (impl_proxy == NULL)
{
g_warning ("Failed to create settings proxy: %s", error->message);
}
else
{
impls[n_impls++] = impl_proxy;
g_signal_connect (impl_proxy, "setting-changed", G_CALLBACK (on_impl_settings_changed), settings);
}
}
if (!n_impls)
{
return NULL;
}
return G_DBUS_INTERFACE_SKELETON (g_steal_pointer (&settings));
}