/*
* Copyright © 2019 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:
* Christian J. Kellner
*/
#include "config.h"
#include "gamemode.h"
#define _GNU_SOURCE 1
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "xdp-app-info.h"
#include "xdp-context.h"
#include "xdp-dbus.h"
#include "xdp-impl-dbus.h"
#include "xdp-permissions.h"
#include "xdp-utils.h"
/* well known names*/
#define GAMEMODE_BACKEND_DBUS_NAME "com.feralinteractive.GameMode"
#define GAMEMODE_BACKEND_DBUS_IFACE "com.feralinteractive.GameMode"
#define GAMEMODE_BACKEND_DBUS_PATH "/com/feralinteractive/GameMode"
/* */
typedef struct _GameMode GameMode;
typedef struct _GameModeClass GameModeClass;
static gboolean handle_query_status (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint pid);
static gboolean handle_register_game (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint pid);
static gboolean handle_unregister_game (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint pid);
static gboolean handle_query_status_by_pid (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint target,
gint requester);
static gboolean handle_register_game_by_pid (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint target,
gint requester);
static gboolean handle_unregister_game_by_pid (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint target,
gint requester);
static gboolean handle_query_status_by_pidfd (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
GVariant *arg_target,
GVariant *arg_requester);
static gboolean handle_register_game_by_pidfd (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
GVariant *arg_target,
GVariant *arg_requester);
static gboolean handle_unregister_game_by_pidfd (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
GVariant *arg_target,
GVariant *arg_requester);
/* gobject */
struct _GameMode
{
XdpDbusGameModeSkeleton parent_instance;
/* */
GDBusProxy *client;
};
struct _GameModeClass
{
XdpDbusGameModeSkeletonClass parent_class;
};
GType game_mode_get_type (void) G_GNUC_CONST;
static void game_mode_iface_init (XdpDbusGameModeIface *iface);
G_DEFINE_TYPE_WITH_CODE (GameMode, game_mode, XDP_DBUS_TYPE_GAME_MODE_SKELETON,
G_IMPLEMENT_INTERFACE (XDP_DBUS_TYPE_GAME_MODE,
game_mode_iface_init));
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GameMode, g_object_unref)
static void
game_mode_iface_init (XdpDbusGameModeIface *iface)
{
iface->handle_query_status = handle_query_status;
iface->handle_register_game = handle_register_game;
iface->handle_unregister_game = handle_unregister_game;
iface->handle_query_status_by_pid = handle_query_status_by_pid;
iface->handle_register_game_by_pid = handle_register_game_by_pid;
iface->handle_unregister_game_by_pid = handle_unregister_game_by_pid;
iface->handle_query_status_by_pidfd = handle_query_status_by_pidfd;
iface->handle_register_game_by_pidfd = handle_register_game_by_pidfd;
iface->handle_unregister_game_by_pidfd = handle_unregister_game_by_pidfd;
}
static void
game_mode_dispose (GObject *object)
{
GameMode *gamemode = (GameMode *) object;
g_clear_object (&gamemode->client);
G_OBJECT_CLASS (game_mode_parent_class)->dispose (object);
}
static void
game_mode_init (GameMode *gamemode)
{
}
static void
game_mode_class_init (GameModeClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = game_mode_dispose;
}
/* internal helpers */
static gboolean
game_mode_is_allowed_for_app (const char *app_id, GError **error)
{
g_autoptr(GVariant) perms = NULL;
g_autoptr(GVariant) data = NULL;
g_autoptr(GError) err = NULL;
const char **stored;
gboolean ok;
ok = xdp_dbus_impl_permission_store_call_lookup_sync (xdp_get_permission_store (),
GAMEMODE_PERMISSION_TABLE,
GAMEMODE_PERMISSION_ID,
&perms,
&data,
NULL,
&err);
if (!ok)
{
g_dbus_error_strip_remote_error (err);
g_debug ("No gamemode permissions found: %s", err->message);
g_clear_error (&err);
}
else if (perms != NULL && g_variant_lookup (perms, app_id, "^a&s", &stored))
{
g_autofree char *as_str = NULL;
gboolean allowed;
as_str = g_strjoinv (" ", (char **)stored);
g_debug ("GameMode permissions for %s: %s", app_id, as_str);
allowed = !g_strv_contains (stored, "no");
if (!allowed)
g_set_error (error, XDG_DESKTOP_PORTAL_ERROR, XDG_DESKTOP_PORTAL_ERROR_NOT_ALLOWED,
"GameMode is not allowed for %s", app_id);
return allowed;
}
g_debug ("No gamemode permissions stored for %s: allowing", app_id);
return TRUE;
}
static gboolean
check_pids(const pid_t *pids, gint count, GError **error)
{
for (gint i = 0; i < count; i++) {
if (pids[i] == 0) {
g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
"pid %d is invalid (0)", i);
return FALSE;
}
}
return TRUE;
}
/* generic dbus call handling */
typedef struct CallData_ {
GDBusMethodInvocation *inv;
XdpAppInfo *app_info;
GDBusProxy *client;
char *method;
int ids[2];
guint n_ids;
GUnixFDList *fdlist;
} CallData;
static CallData *
call_data_new (GDBusMethodInvocation *inv,
XdpAppInfo *app_info,
const char *method,
GDBusProxy *client)
{
CallData *call;
call = g_slice_new0 (CallData);
call->inv = g_object_ref (inv);
call->app_info = g_object_ref (app_info);
call->method = g_strdup (method);
call->client = g_object_ref (client);
return call;
}
static void
call_data_free (gpointer data)
{
CallData *call = data;
if (call == NULL)
return;
g_clear_object (&call->inv);
g_clear_object (&call->app_info);
g_clear_pointer (&call->method, g_free);
g_clear_object (&call->fdlist);
g_clear_object (&call->client);
g_slice_free (CallData, call);
}
static void
handle_call_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
g_autoptr(GError) error = NULL;
g_autoptr(GVariant) res = NULL;
GUnixFDList *fdlist = NULL;
GVariant *params;
const char *app_id;
CallData *call;
gboolean ok;
gint r;
call = (CallData *) task_data;
app_id = xdp_app_info_get_id (call->app_info);
if (!game_mode_is_allowed_for_app (app_id, &error))
{
g_dbus_method_invocation_return_gerror (call->inv, error);
return;
}
/* if we don't have a list of fds, we got pids and need to map them */
if (call->fdlist == NULL)
{
pid_t pids[2] = {0, };
guint n_pids;
ino_t pidns_id;
n_pids = call->n_ids;
for (guint i = 0; i < n_pids; i++)
pids[0] = (pid_t) call->ids[i];
if (!xdp_app_info_get_pidns (call->app_info, &pidns_id, &error))
{
g_prefix_error (&error, "Could not get pidns: ");
g_warning ("GameMode error: %s", error->message);
g_dbus_method_invocation_return_gerror (call->inv, error);
return;
}
if (pidns_id != 0 && !xdp_map_pids (pidns_id, pids, n_pids, &error))
{
g_prefix_error (&error, "Could not map pids: ");
g_warning ("GameMode error: %s", error->message);
g_dbus_method_invocation_return_gerror (call->inv, error);
return;
}
if (n_pids == 1)
params = g_variant_new ("(i)", (gint32) pids[0]);
else
params = g_variant_new ("(ii)", (gint32) pids[0], (gint32) pids[1]);
}
else
{
pid_t pids[2] = {0, };
const int *fds;
gint n_pids;
fdlist = call->fdlist;
/* verify fds are actually pidfds */
fds = g_unix_fd_list_peek_fds (fdlist, &n_pids);
ok = xdp_pidfds_to_pids (fds, pids, n_pids, &error);
if (!ok || !check_pids (pids, n_pids, &error))
{
g_warning ("Pidfd verification error: %s", error->message);
g_dbus_method_invocation_return_error (call->inv,
G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"failed to verify fds as pidfds: %s",
error->message);
return;
}
params = g_variant_new ("(hh)", 0, 1);
}
res = g_dbus_proxy_call_with_unix_fd_list_sync (G_DBUS_PROXY (call->client),
call->method,
params,
G_DBUS_CALL_FLAGS_NONE,
-1,
fdlist,
NULL,
NULL, /* cancel */
&error);
r = -2; /* default to "call got rejected" */
if (res != NULL)
g_variant_get (res, "(i)", &r);
else
g_debug ("Call to GameMode failed: %s", error->message);
g_dbus_method_invocation_return_value (call->inv, g_variant_new ("(i)", r));
}
static void
handle_call_in_thread_fds (XdpDbusGameMode *object,
const char *method,
GDBusMethodInvocation *invocation,
GUnixFDList *fdlist)
{
GameMode *gamemode = (GameMode *)object;
XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation);
g_autoptr(GTask) task = NULL;
CallData *call_data;
if (fdlist == NULL || g_unix_fd_list_get_length (fdlist) != 2)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
"File descriptor number is incorrect");
return;
}
call_data = call_data_new (invocation, app_info, method, gamemode->client);
call_data->fdlist = g_object_ref (fdlist);
task = g_task_new (object, NULL, NULL, NULL);
g_task_set_source_tag (task, handle_call_in_thread_fds);
g_task_set_task_data (task, call_data, call_data_free);
g_task_run_in_thread (task, handle_call_thread);
}
static void
handle_call_in_thread (XdpDbusGameMode *object,
const char *method,
GDBusMethodInvocation *invocation,
gint target,
gint requester)
{
GameMode *gamemode = (GameMode *)object;
XdpAppInfo *app_info = xdp_invocation_get_app_info (invocation);
g_autoptr(GTask) task = NULL;
CallData *call_data;
call_data = call_data_new (invocation, app_info, method, gamemode->client);
call_data->ids[0] = target;
call_data->n_ids = 1;
if (requester != 0)
{
call_data->ids[1] = requester;
call_data->n_ids += 1;
}
task = g_task_new (object, NULL, NULL, NULL);
g_task_set_source_tag (task, handle_call_in_thread);
g_task_set_task_data (task, call_data, call_data_free);
g_task_run_in_thread (task, handle_call_thread);
}
/* dbus */
static gboolean
handle_query_status (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint pid)
{
handle_call_in_thread (object, "QueryStatus", invocation, pid, 0);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_register_game (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint pid)
{
handle_call_in_thread (object, "RegisterGame", invocation, pid, 0);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_unregister_game (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint pid)
{
handle_call_in_thread (object, "UnregisterGame", invocation, pid, 0);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_query_status_by_pid (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint target,
gint requester)
{
handle_call_in_thread (object,
"QueryStatusByPID",
invocation,
target,
requester);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_register_game_by_pid (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint target,
gint requester)
{
handle_call_in_thread (object,
"RegisterGameByPID",
invocation,
target,
requester);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_unregister_game_by_pid (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
gint target,
gint requester)
{
handle_call_in_thread (object,
"UnregisterGameByPID",
invocation,
target,
requester);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
/* pidfd based APIs */
static gboolean
handle_query_status_by_pidfd (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
GVariant *arg_target,
GVariant *arg_requester)
{
handle_call_in_thread_fds (object,
"QueryStatusByPIDFd",
invocation,
fd_list);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_register_game_by_pidfd (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
GVariant *arg_target,
GVariant *arg_requester)
{
handle_call_in_thread_fds (object,
"RegisterGameByPIDFd",
invocation,
fd_list);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
static gboolean
handle_unregister_game_by_pidfd (XdpDbusGameMode *object,
GDBusMethodInvocation *invocation,
GUnixFDList *fd_list,
GVariant *arg_target,
GVariant *arg_requester)
{
handle_call_in_thread_fds (object,
"UnregisterGameByPIDFd",
invocation,
fd_list);
return G_DBUS_METHOD_INVOCATION_HANDLED;
}
/* properties */
static void
update_active_state (GameMode *gamemode,
GVariant *client_count)
{
gboolean enabled = g_variant_get_int32 (client_count) > 0;
xdp_dbus_game_mode_set_active (XDP_DBUS_GAME_MODE (gamemode), enabled);
}
static void
update_active_state_from_cache (GameMode *gamemode,
GDBusProxy *proxy)
{
g_autoptr(GVariant) client_count = NULL;
client_count = g_dbus_proxy_get_cached_property (proxy, "ClientCount");
if (client_count != NULL)
update_active_state (gamemode, client_count);
}
static void
on_client_properties_changed (GDBusProxy *proxy,
GVariant *changed_properties,
char **invalidated_properties,
gpointer user_data)
{
GameMode *gamemode = user_data;
update_active_state_from_cache (gamemode, proxy);
}
static GameMode *
game_mode_new (GDBusProxy *client)
{
GameMode *gamemode;
gamemode = g_object_new (game_mode_get_type (), NULL);
gamemode->client = g_object_ref (client);
xdp_dbus_game_mode_set_version (XDP_DBUS_GAME_MODE (gamemode), 4);
g_signal_connect_object (gamemode->client, "g-properties-changed",
G_CALLBACK (on_client_properties_changed),
gamemode, G_CONNECT_DEFAULT);
update_active_state_from_cache (gamemode, gamemode->client);
return gamemode;
}
/* public API */
void
init_game_mode (XdpContext *context)
{
g_autoptr(GameMode) gamemode = NULL;
g_autoptr(GDBusProxy) client = NULL;
GDBusProxyFlags flags;
g_autoptr(GError) error = NULL;
flags = G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION |
G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES;
client = g_dbus_proxy_new_sync (xdp_context_get_connection (context),
flags,
NULL,
GAMEMODE_BACKEND_DBUS_NAME,
GAMEMODE_BACKEND_DBUS_PATH,
GAMEMODE_BACKEND_DBUS_IFACE,
NULL,
&error);
if (client == NULL)
{
g_warning ("Failed to create GameMode proxy: %s", error->message);
return;
}
gamemode = game_mode_new (client);
xdp_context_take_and_export_portal (context,
G_DBUS_INTERFACE_SKELETON (g_steal_pointer (&gamemode)),
XDP_CONTEXT_EXPORT_FLAGS_NONE);
}