/*
* Copyright © 2016 Red Hat, Inc
*
* 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:
* Matthias Clasen
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "screenshot.h"
#include "xdp-permissions.h"
#include "xdp-request.h"
#include "xdp-documents.h"
#include "xdp-dbus.h"
#include "xdp-impl-dbus.h"
#include "xdp-utils.h"
#define PERMISSION_TABLE "screenshot"
#define PERMISSION_ID "screenshot"
typedef struct _Screenshot Screenshot;
typedef struct _ScreenshotClass ScreenshotClass;
struct _Screenshot
{
XdpDbusScreenshotSkeleton parent_instance;
};
struct _ScreenshotClass
{
XdpDbusScreenshotSkeletonClass parent_class;
};
static XdpDbusImplScreenshot *impl;
static XdpDbusImplAccess *access_impl;
static guint32 impl_version;
static Screenshot *screenshot;
GType screenshot_get_type (void) G_GNUC_CONST;
static void screenshot_iface_init (XdpDbusScreenshotIface *iface);
G_DEFINE_TYPE_WITH_CODE (Screenshot, screenshot, XDP_DBUS_TYPE_SCREENSHOT_SKELETON,
G_IMPLEMENT_INTERFACE (XDP_DBUS_TYPE_SCREENSHOT,
screenshot_iface_init));
static void
send_response (XdpRequest *request,
guint response,
GVariant *results)
{
if (request->exported)
{
g_debug ("sending response: %d", response);
xdp_dbus_request_emit_response (XDP_DBUS_REQUEST (request), response, results);
xdp_request_unexport (request);
}
else
{
g_variant_ref_sink (results);
g_variant_unref (results);
}
}
static void
send_response_in_thread_func (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
XdpRequest *request = task_data;
g_auto(GVariantBuilder) results =
G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);
guint response;
GVariant *options;
g_autoptr(GError) error = NULL;
const char *retval;
REQUEST_AUTOLOCK (request);
response = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (request), "response"));
options = (GVariant *)g_object_get_data (G_OBJECT (request), "options");
if (response != 0)
goto out;
retval = g_object_get_data (G_OBJECT (task), "retval");
if (g_strcmp0 (retval, "url") == 0)
{
const char *uri;
g_autofree char *ruri = NULL;
if (!g_variant_lookup (options, "uri", "&s", &uri))
{
g_warning ("No URI was provided");
goto out;
}
if (xdp_app_info_is_host (request->app_info))
ruri = g_strdup (uri);
else
ruri = xdp_register_document (uri, xdp_app_info_get_id (request->app_info), XDP_DOCUMENT_FLAG_DELETABLE, &error);
if (ruri == NULL)
g_warning ("Failed to register %s: %s", uri, error->message);
else
g_variant_builder_add (&results, "{&sv}", "uri", g_variant_new_string (ruri));
}
else if (g_strcmp0 (retval, "color") == 0)
{
double red, green, blue;
if (!g_variant_lookup (options, "color", "(ddd)", &red, &green, &blue))
{
g_warning ("No color was provided");
goto out;
}
g_variant_builder_add (&results, "{&sv}", "color", g_variant_new ("(ddd)", red, green, blue));
}
else
{
g_warning ("Don't know what to return");
}
out:
send_response (request, response, g_variant_builder_end (&results));
}
static void
screenshot_done (GObject *source,
GAsyncResult *result,
gpointer data)
{
g_autoptr(XdpRequest) request = data;
guint response = 2;
g_autoptr(GVariant) options = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GTask) task = NULL;
if (!xdp_dbus_impl_screenshot_call_screenshot_finish (XDP_DBUS_IMPL_SCREENSHOT (source),
&response,
&options,
result,
&error))
{
g_dbus_error_strip_remote_error (error);
g_warning ("A backend call failed: %s", error->message);
}
g_object_set_data (G_OBJECT (request), "response", GINT_TO_POINTER (response));
if (options)
g_object_set_data_full (G_OBJECT (request), "options", g_variant_ref (options), (GDestroyNotify)g_variant_unref);
task = g_task_new (NULL, NULL, NULL, NULL);
g_task_set_task_data (task, g_object_ref (request), g_object_unref);
g_object_set_data (G_OBJECT (task), "retval", "url");
g_task_run_in_thread (task, send_response_in_thread_func);
}
static XdpOptionKey screenshot_options[] = {
{ "modal", G_VARIANT_TYPE_BOOLEAN, NULL },
{ "interactive", G_VARIANT_TYPE_BOOLEAN, NULL }
};
static void
handle_screenshot_in_thread_func (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
XdpRequest *request = XDP_REQUEST (task_data);
g_autoptr(GError) error = NULL;
g_autoptr(XdpDbusImplRequest) impl_request = NULL;
g_auto(GVariantBuilder) opt_builder =
G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);
XdpPermission permission;
GVariant *options;
gboolean permission_store_checked = FALSE;
gboolean interactive;
gboolean modal;
const char *parent_window;
const char *app_id;
REQUEST_AUTOLOCK (request);
app_id = xdp_app_info_get_id (request->app_info);
parent_window = ((const char *)g_object_get_data (G_OBJECT (request), "parent-window"));
options = ((GVariant *)g_object_get_data (G_OBJECT (request), "options"));
if (xdp_dbus_impl_screenshot_get_version (impl) < 2)
goto query_impl;
permission = xdp_get_permission_sync (app_id, PERMISSION_TABLE, PERMISSION_ID);
if (!g_variant_lookup (options, "interactive", "b", &interactive))
interactive = FALSE;
if (!g_variant_lookup (options, "modal", "b", &modal))
modal = TRUE;
if (!interactive && permission != XDP_PERMISSION_YES)
{
g_autoptr(GVariant) access_results = NULL;
g_auto(GVariantBuilder) access_opt_builder =
G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);
g_autofree gchar *subtitle = NULL;
g_autofree gchar *title = NULL;
const gchar *body;
guint access_response = 2;
if (permission == XDP_PERMISSION_NO)
{
send_response (request, 2, g_variant_builder_end (&opt_builder));
return;
}
g_variant_builder_add (&access_opt_builder, "{sv}",
"deny_label", g_variant_new_string (_("Deny")));
g_variant_builder_add (&access_opt_builder, "{sv}",
"grant_label", g_variant_new_string (_("Allow")));
g_variant_builder_add (&access_opt_builder, "{sv}",
"icon", g_variant_new_string ("applets-screenshooter-symbolic"));
g_variant_builder_add (&access_opt_builder, "{sv}",
"modal", g_variant_new_boolean (modal));
if (g_strcmp0 (app_id, "") != 0)
{
g_autoptr(GDesktopAppInfo) info = NULL;
g_autofree gchar *id = NULL;
const gchar *name = NULL;
id = g_strconcat (app_id, ".desktop", NULL);
info = g_desktop_app_info_new (id);
if (info)
name = g_app_info_get_display_name (G_APP_INFO (info));
else
name = app_id;
title = g_strdup_printf (_("Allow %s to Take Screenshots?"), name);
subtitle = g_strdup_printf (_("%s wants to be able to take screenshots at any time."), name);
}
else
{
/* Note: this will set the wallpaper permission for all unsandboxed
* apps for which an app ID can't be determined.
*/
g_assert (xdp_app_info_is_host (request->app_info));
title = g_strdup (_("Allow Applications to Take Screenshots?"));
subtitle = g_strdup (_("An application wants to be able to take screenshots at any time."));
}
body = _("This permission can be changed at any time from the privacy settings.");
if (!xdp_dbus_impl_access_call_access_dialog_sync (access_impl,
request->id,
app_id,
parent_window,
title,
subtitle,
body,
g_variant_builder_end (&access_opt_builder),
&access_response,
&access_results,
NULL,
&error))
{
g_warning ("Failed to show access dialog: %s", error->message);
send_response (request, 2, g_variant_builder_end (&opt_builder));
return;
}
if (permission == XDP_PERMISSION_UNSET)
xdp_set_permission_sync (app_id, PERMISSION_TABLE, PERMISSION_ID, access_response == 0 ? XDP_PERMISSION_YES : XDP_PERMISSION_NO);
if (access_response != 0)
{
send_response (request, 2, g_variant_builder_end (&opt_builder));
return;
}
}
permission_store_checked = TRUE;
query_impl:
impl_request =
xdp_dbus_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),
request->id,
NULL, &error);
if (!impl_request)
{
g_warning ("Failed to to create screenshot implementation proxy: %s", error->message);
send_response (request, 2, g_variant_builder_end (&opt_builder));
return;
}
xdp_request_set_impl_request (request, impl_request);
xdp_filter_options (options, &opt_builder,
screenshot_options, G_N_ELEMENTS (screenshot_options),
NULL);
if (permission_store_checked)
{
g_variant_builder_add (&opt_builder, "{sv}", "permission_store_checked",
g_variant_new_boolean (TRUE));
}
g_debug ("Calling Screenshot with interactive=%d", interactive);
xdp_dbus_impl_screenshot_call_screenshot (impl,
request->id,
app_id,
parent_window,
g_variant_builder_end (&opt_builder),
NULL,
screenshot_done,
g_object_ref (request));
}
static gboolean
handle_screenshot (XdpDbusScreenshot *object,
GDBusMethodInvocation *invocation,
const gchar *arg_parent_window,
GVariant *arg_options)
{
XdpRequest *request = xdp_request_from_invocation (invocation);
g_autoptr(GTask) task = NULL;
g_debug ("Handle Screenshot");
g_object_set_data_full (G_OBJECT (request), "parent-window", g_strdup (arg_parent_window), g_free);
g_object_set_data_full (G_OBJECT (request),
"options",
g_variant_ref (arg_options),
(GDestroyNotify)g_variant_unref);
xdp_request_export (request, g_dbus_method_invocation_get_connection (invocation));
xdp_dbus_screenshot_complete_screenshot (object, invocation, request->id);
task = g_task_new (object, NULL, NULL, NULL);
g_task_set_task_data (task, g_object_ref (request), g_object_unref);
g_task_run_in_thread (task, handle_screenshot_in_thread_func);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static void
pick_color_done (GObject *source,
GAsyncResult *result,
gpointer data)
{
g_autoptr(XdpRequest) request = data;
guint response = 2;
g_autoptr(GVariant) options = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GTask) task = NULL;
if (!xdp_dbus_impl_screenshot_call_pick_color_finish (XDP_DBUS_IMPL_SCREENSHOT (source),
&response,
&options,
result,
&error))
{
g_dbus_error_strip_remote_error (error);
g_warning ("A backend call failed: %s", error->message);
}
g_object_set_data (G_OBJECT (request), "response", GINT_TO_POINTER (response));
if (options)
g_object_set_data_full (G_OBJECT (request), "options", g_variant_ref (options), (GDestroyNotify)g_variant_unref);
task = g_task_new (NULL, NULL, NULL, NULL);
g_task_set_task_data (task, g_object_ref (request), g_object_unref);
g_object_set_data (G_OBJECT (task), "retval", "color");
g_task_run_in_thread (task, send_response_in_thread_func);
}
static XdpOptionKey pick_color_options[] = {
};
static gboolean
handle_pick_color (XdpDbusScreenshot *object,
GDBusMethodInvocation *invocation,
const gchar *arg_parent_window,
GVariant *arg_options)
{
XdpRequest *request = xdp_request_from_invocation (invocation);
g_autoptr(GError) error = NULL;
g_autoptr(XdpDbusImplRequest) impl_request = NULL;
g_auto(GVariantBuilder) opt_builder =
G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);
REQUEST_AUTOLOCK (request);
impl_request =
xdp_dbus_impl_request_proxy_new_sync (g_dbus_proxy_get_connection (G_DBUS_PROXY (impl)),
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
g_dbus_proxy_get_name (G_DBUS_PROXY (impl)),
request->id,
NULL, &error);
if (!impl_request)
{
g_dbus_method_invocation_return_gerror (invocation, error);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
xdp_request_set_impl_request (request, impl_request);
xdp_request_export (request, g_dbus_method_invocation_get_connection (invocation));
xdp_filter_options (arg_options, &opt_builder,
pick_color_options, G_N_ELEMENTS (pick_color_options),
NULL);
xdp_dbus_impl_screenshot_call_pick_color (impl,
request->id,
xdp_app_info_get_id (request->app_info),
arg_parent_window,
g_variant_builder_end (&opt_builder),
NULL,
pick_color_done,
g_object_ref (request));
xdp_dbus_screenshot_complete_pick_color (object, invocation, request->id);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static void
screenshot_iface_init (XdpDbusScreenshotIface *iface)
{
iface->handle_screenshot = handle_screenshot;
iface->handle_pick_color = handle_pick_color;
}
static void
screenshot_init (Screenshot *screenshot)
{
/* Before there was a version property, the version was hardcoded to 2, so
* make sure we retain that behaviour */
impl_version = 2;
xdp_dbus_screenshot_set_version (XDP_DBUS_SCREENSHOT (screenshot),
impl_version);
}
static void
screenshot_class_init (ScreenshotClass *klass)
{
}
GDBusInterfaceSkeleton *
screenshot_create (GDBusConnection *connection,
const char *dbus_name_access,
const char *dbus_name_screenshot)
{
g_autoptr(GError) error = NULL;
g_autoptr(GVariant) version = NULL;
impl = xdp_dbus_impl_screenshot_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
dbus_name_screenshot,
DESKTOP_PORTAL_OBJECT_PATH,
NULL,
&error);
if (impl == NULL)
{
g_warning ("Failed to create screenshot proxy: %s", error->message);
return NULL;
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (impl), G_MAXINT);
/* Set the version if supported; otherwise fallback to hardcoded version 2 */
version = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (impl), "version");
impl_version = (version != NULL) ? g_variant_get_uint32 (version) : 2;
screenshot = g_object_new (screenshot_get_type (), NULL);
access_impl = xdp_dbus_impl_access_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
dbus_name_access,
DESKTOP_PORTAL_OBJECT_PATH,
NULL,
&error);
return G_DBUS_INTERFACE_SKELETON (screenshot);
}