mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-29 08:56:15 +01:00
8c3fda5c8d
Parts of the `dbus-appinfo` test need support for converting an FD to a path, and Hurd doesn’t currently allow that (see https://gitlab.gnome.org/GNOME/glib/-/merge_requests/4396#note_2279923). Since there’s no fix for that visible in the medium term (new kernel APIs will need to be added), skip parts of the `dbus-appinfo` test which require that functionality for now. This prevents the whole test from failing, and means we can usefully get results from the parts of it which don’t depend on converting FDs to paths. Signed-off-by: Philip Withnall <pwithnall@gnome.org> Helps: #3538
509 lines
16 KiB
C
509 lines
16 KiB
C
/*
|
||
* Copyright © 2024 GNOME Foundation Inc.
|
||
*
|
||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||
*
|
||
* 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/>.
|
||
*
|
||
* Authors: Julian Sparber <jsparber@gnome.org>
|
||
* Philip Withnall <philip@tecnocode.co.uk>
|
||
*/
|
||
|
||
/* A stub implementation of xdg-desktop-portal */
|
||
|
||
#ifdef __FreeBSD__
|
||
#include <fcntl.h>
|
||
#include <sys/types.h>
|
||
#include <sys/user.h>
|
||
#endif /* __FreeBSD__ */
|
||
|
||
#include <glib.h>
|
||
#include <gio/gio.h>
|
||
#include <gio/gunixfdlist.h>
|
||
|
||
|
||
#include "fake-desktop-portal.h"
|
||
#include "fake-openuri-portal-generated.h"
|
||
#include "fake-request-portal-generated.h"
|
||
|
||
struct _GFakeDesktopPortalThread
|
||
{
|
||
GObject parent_instance;
|
||
|
||
char *address; /* (not nullable) */
|
||
GCancellable *cancellable; /* (not nullable) (owned) */
|
||
GThread *thread; /* (not nullable) (owned) */
|
||
GCond cond; /* (mutex mutex) */
|
||
GMutex mutex;
|
||
gboolean ready; /* (mutex mutex) */
|
||
|
||
char *request_activation_token; /* (mutex mutex) */
|
||
char *request_uri; /* (mutex mutex) */
|
||
} FakeDesktopPortalThread;
|
||
|
||
G_DEFINE_FINAL_TYPE (GFakeDesktopPortalThread, g_fake_desktop_portal_thread, G_TYPE_OBJECT)
|
||
|
||
static void g_fake_desktop_portal_thread_finalize (GObject *object);
|
||
|
||
static void
|
||
g_fake_desktop_portal_thread_class_init (GFakeDesktopPortalThreadClass *klass)
|
||
{
|
||
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
||
|
||
gobject_class->finalize = g_fake_desktop_portal_thread_finalize;
|
||
}
|
||
|
||
static void
|
||
g_fake_desktop_portal_thread_init (GFakeDesktopPortalThread *self)
|
||
{
|
||
self->cancellable = g_cancellable_new ();
|
||
g_cond_init (&self->cond);
|
||
g_mutex_init (&self->mutex);
|
||
}
|
||
|
||
static void
|
||
g_fake_desktop_portal_thread_finalize (GObject *object)
|
||
{
|
||
GFakeDesktopPortalThread *self = G_FAKE_DESKTOP_PORTAL_THREAD (object);
|
||
|
||
g_assert (self->thread == NULL); /* should already have been joined */
|
||
|
||
g_mutex_clear (&self->mutex);
|
||
g_cond_clear (&self->cond);
|
||
g_clear_object (&self->cancellable);
|
||
g_clear_pointer (&self->address, g_free);
|
||
|
||
g_clear_pointer (&self->request_activation_token, g_free);
|
||
g_clear_pointer (&self->request_uri, g_free);
|
||
|
||
G_OBJECT_CLASS (g_fake_desktop_portal_thread_parent_class)->finalize (object);
|
||
}
|
||
|
||
static gboolean
|
||
on_handle_close (FakeRequest *object,
|
||
GDBusMethodInvocation *invocation,
|
||
gpointer user_data)
|
||
{
|
||
g_test_message ("Got close request");
|
||
fake_request_complete_close (object, invocation);
|
||
|
||
return G_DBUS_METHOD_INVOCATION_HANDLED;
|
||
}
|
||
|
||
static char*
|
||
get_request_path (GDBusMethodInvocation *invocation,
|
||
const char *token)
|
||
{
|
||
char *request_obj_path;
|
||
char *sender;
|
||
|
||
sender = g_strdup (g_dbus_method_invocation_get_sender (invocation) + 1);
|
||
|
||
/* The object path needs to be the specific format.
|
||
* See: https://flatpak.github.io/xdg-desktop-portal/docs/doc-org.freedesktop.portal.Request.html#org-freedesktop-portal-request */
|
||
for (size_t i = 0; sender[i]; i++)
|
||
if (sender[i] == '.')
|
||
sender[i] = '_';
|
||
|
||
request_obj_path = g_strdup_printf ("/org/freedesktop/portal/desktop/request/%s/%s", sender, token);
|
||
g_free (sender);
|
||
|
||
return request_obj_path;
|
||
}
|
||
|
||
static gboolean
|
||
handle_request (GFakeDesktopPortalThread *self,
|
||
FakeOpenURI *object,
|
||
GDBusMethodInvocation *invocation,
|
||
const gchar *arg_parent_window,
|
||
const gchar *arg_uri,
|
||
gboolean open_file,
|
||
GVariant *arg_options)
|
||
{
|
||
const char *activation_token = NULL;
|
||
GError *error = NULL;
|
||
FakeRequest *interface_request;
|
||
GVariantBuilder opt_builder;
|
||
char *request_obj_path;
|
||
const char *token = NULL;
|
||
|
||
if (arg_options)
|
||
{
|
||
g_variant_lookup (arg_options, "activation_token", "&s", &activation_token);
|
||
g_variant_lookup (arg_options, "handle_token", "&s", &token);
|
||
}
|
||
|
||
g_set_str (&self->request_activation_token, activation_token);
|
||
g_set_str (&self->request_uri, arg_uri);
|
||
|
||
request_obj_path = get_request_path (invocation, token ? token : "t");
|
||
|
||
if (open_file)
|
||
{
|
||
g_test_message ("Got open file request for %s", arg_uri);
|
||
|
||
fake_open_uri_complete_open_file (object,
|
||
invocation,
|
||
NULL,
|
||
request_obj_path);
|
||
|
||
}
|
||
else
|
||
{
|
||
g_test_message ("Got open URI request for %s", arg_uri);
|
||
|
||
fake_open_uri_complete_open_uri (object,
|
||
invocation,
|
||
request_obj_path);
|
||
|
||
}
|
||
|
||
interface_request = fake_request_skeleton_new ();
|
||
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
|
||
|
||
g_signal_connect (interface_request,
|
||
"handle-close",
|
||
G_CALLBACK (on_handle_close),
|
||
NULL);
|
||
|
||
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (interface_request),
|
||
g_dbus_method_invocation_get_connection (invocation),
|
||
request_obj_path,
|
||
&error);
|
||
g_assert_no_error (error);
|
||
g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (interface_request),
|
||
G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
|
||
g_test_message ("Request skeleton exported at %s", request_obj_path);
|
||
|
||
/* We can't use `fake_request_emit_response()` because it doesn't set the sender */
|
||
g_dbus_connection_emit_signal (g_dbus_method_invocation_get_connection (invocation),
|
||
g_dbus_method_invocation_get_sender (invocation),
|
||
request_obj_path,
|
||
"org.freedesktop.portal.Request",
|
||
"Response",
|
||
g_variant_new ("(u@a{sv})",
|
||
0, /* Success */
|
||
g_variant_builder_end (&opt_builder)),
|
||
NULL);
|
||
|
||
g_test_message ("Response emitted");
|
||
|
||
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (interface_request));
|
||
g_free (request_obj_path);
|
||
g_object_unref (interface_request);
|
||
|
||
return G_DBUS_METHOD_INVOCATION_HANDLED;
|
||
}
|
||
|
||
/* This is currently private as there’s only one user of it, but it could become
|
||
* a public API in future. */
|
||
static char *
|
||
_g_fd_query_path (int fd,
|
||
GError **error)
|
||
{
|
||
#if defined(__FreeBSD__)
|
||
struct kinfo_file kf;
|
||
kf.kf_structsize = sizeof (kf);
|
||
if (fcntl (fd, F_KINFO, &kf) < 0)
|
||
{
|
||
int saved_errno = errno;
|
||
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
||
"Error querying file information for FD %d: %s",
|
||
fd, g_strerror (saved_errno));
|
||
return NULL;
|
||
}
|
||
|
||
return g_strdup (kf.kf_path);
|
||
#elif defined(G_OS_UNIX)
|
||
char *path = NULL;
|
||
char *proc_path = g_strdup_printf ("/proc/self/fd/%d", fd);
|
||
path = g_file_read_link (proc_path, error);
|
||
g_free (proc_path);
|
||
return g_steal_pointer (&path);
|
||
#else
|
||
/* - A NetBSD implementation would probably use `fcntl()` with `F_GETPATH`:
|
||
* https://man.netbsd.org/fcntl.2
|
||
* - A Windows implementation would probably use `GetFinalPathNameByHandleW()`:
|
||
* https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlea
|
||
* - A Hurd implementation could open("/dev/fd/%u"):
|
||
* https://gitlab.gnome.org/GNOME/glib/-/merge_requests/4396#note_2279923
|
||
*/
|
||
#error "_g_fd_query_path() not supported on this platform"
|
||
#endif
|
||
}
|
||
|
||
static char *
|
||
handle_to_uri (GVariant *handle,
|
||
GUnixFDList *fd_list)
|
||
{
|
||
int fd = -1;
|
||
int fd_id;
|
||
char *path;
|
||
char *uri;
|
||
GError *local_error = NULL;
|
||
|
||
fd_id = g_variant_get_handle (handle);
|
||
fd = g_unix_fd_list_get (fd_list, fd_id, NULL);
|
||
|
||
if (fd == -1)
|
||
return NULL;
|
||
|
||
path = _g_fd_query_path (fd, &local_error);
|
||
g_assert_no_error (local_error);
|
||
|
||
uri = g_filename_to_uri (path, NULL, NULL);
|
||
g_free (path);
|
||
close (fd);
|
||
|
||
return uri;
|
||
}
|
||
|
||
static gboolean
|
||
on_handle_open_file (FakeOpenURI *object,
|
||
GDBusMethodInvocation *invocation,
|
||
GUnixFDList *fd_list,
|
||
const gchar *arg_parent_window,
|
||
GVariant *arg_fd,
|
||
GVariant *arg_options,
|
||
gpointer user_data)
|
||
{
|
||
GFakeDesktopPortalThread *self = G_FAKE_DESKTOP_PORTAL_THREAD (user_data);
|
||
char *uri = NULL;
|
||
|
||
uri = handle_to_uri (arg_fd, fd_list);
|
||
handle_request (self,
|
||
object,
|
||
invocation,
|
||
arg_parent_window,
|
||
uri,
|
||
TRUE,
|
||
arg_options);
|
||
g_free (uri);
|
||
|
||
return G_DBUS_METHOD_INVOCATION_HANDLED;
|
||
}
|
||
|
||
static gboolean
|
||
on_handle_open_uri (FakeOpenURI *object,
|
||
GDBusMethodInvocation *invocation,
|
||
const gchar *arg_parent_window,
|
||
const gchar *arg_uri,
|
||
GVariant *arg_options,
|
||
gpointer user_data)
|
||
{
|
||
GFakeDesktopPortalThread *self = G_FAKE_DESKTOP_PORTAL_THREAD (user_data);
|
||
|
||
handle_request (self,
|
||
object,
|
||
invocation,
|
||
arg_parent_window,
|
||
arg_uri,
|
||
TRUE,
|
||
arg_options);
|
||
|
||
return G_DBUS_METHOD_INVOCATION_HANDLED;
|
||
}
|
||
|
||
static void
|
||
on_name_acquired (GDBusConnection *connection,
|
||
const gchar *name,
|
||
gpointer user_data)
|
||
{
|
||
GFakeDesktopPortalThread *self = G_FAKE_DESKTOP_PORTAL_THREAD (user_data);
|
||
|
||
g_test_message ("Acquired the name %s", name);
|
||
|
||
g_mutex_lock (&self->mutex);
|
||
self->ready = TRUE;
|
||
g_cond_signal (&self->cond);
|
||
g_mutex_unlock (&self->mutex);
|
||
}
|
||
|
||
static void
|
||
on_name_lost (GDBusConnection *connection,
|
||
const gchar *name,
|
||
gpointer user_data)
|
||
{
|
||
g_test_message ("Lost the name %s", name);
|
||
}
|
||
|
||
static gboolean
|
||
cancelled_cb (GCancellable *cancellable,
|
||
gpointer user_data)
|
||
{
|
||
g_test_message ("fake-desktop-portal cancelled");
|
||
return G_SOURCE_CONTINUE;
|
||
}
|
||
|
||
static gpointer
|
||
fake_desktop_portal_thread_cb (gpointer user_data)
|
||
{
|
||
GFakeDesktopPortalThread *self = G_FAKE_DESKTOP_PORTAL_THREAD (user_data);
|
||
GMainContext *context = NULL;
|
||
GDBusConnection *connection = NULL;
|
||
GSource *source = NULL;
|
||
guint id;
|
||
FakeOpenURI *interface_open_uri;
|
||
GError *local_error = NULL;
|
||
|
||
context = g_main_context_new ();
|
||
g_main_context_push_thread_default (context);
|
||
|
||
connection = g_dbus_connection_new_for_address_sync (self->address,
|
||
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
|
||
G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
|
||
NULL,
|
||
self->cancellable,
|
||
&local_error);
|
||
g_assert_no_error (local_error);
|
||
|
||
/* Listen for cancellation. The source will wake up the context iteration
|
||
* which can then re-check its exit condition below. */
|
||
source = g_cancellable_source_new (self->cancellable);
|
||
g_source_set_callback (source, G_SOURCE_FUNC (cancelled_cb), NULL, NULL);
|
||
g_source_attach (source, context);
|
||
g_source_unref (source);
|
||
|
||
/* Set up the interface */
|
||
g_test_message ("Acquired a message bus connection");
|
||
|
||
interface_open_uri = fake_open_uri_skeleton_new ();
|
||
|
||
g_signal_connect (interface_open_uri,
|
||
"handle-open-file",
|
||
G_CALLBACK (on_handle_open_file),
|
||
self);
|
||
g_signal_connect (interface_open_uri,
|
||
"handle-open-uri",
|
||
G_CALLBACK (on_handle_open_uri),
|
||
self);
|
||
|
||
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (interface_open_uri),
|
||
connection,
|
||
"/org/freedesktop/portal/desktop",
|
||
&local_error);
|
||
g_assert_no_error (local_error);
|
||
|
||
/* Own the portal name */
|
||
id = g_bus_own_name_on_connection (connection,
|
||
"org.freedesktop.portal.Desktop",
|
||
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
|
||
G_BUS_NAME_OWNER_FLAGS_REPLACE,
|
||
on_name_acquired,
|
||
on_name_lost,
|
||
self,
|
||
NULL);
|
||
|
||
while (!g_cancellable_is_cancelled (self->cancellable))
|
||
g_main_context_iteration (context, TRUE);
|
||
|
||
g_bus_unown_name (id);
|
||
g_clear_object (&connection);
|
||
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (interface_open_uri));
|
||
g_object_unref (interface_open_uri);
|
||
g_main_context_pop_thread_default (context);
|
||
g_clear_pointer (&context, g_main_context_unref);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
/* Get the activation token given to the most recent OpenURI request
|
||
*
|
||
* Returns: (transfer none) (nullable: an activation token
|
||
*/
|
||
const gchar *
|
||
g_fake_desktop_portal_thread_get_last_request_activation_token (GFakeDesktopPortalThread *self)
|
||
{
|
||
g_return_val_if_fail (G_IS_FAKE_DESKTOP_PORTAL_THREAD (self), NULL);
|
||
|
||
return self->request_activation_token;
|
||
}
|
||
|
||
/* Get the file or URI given to the most recent OpenURI request
|
||
*
|
||
* Returns: (transfer none) (nullable): an URI
|
||
*/
|
||
const gchar *
|
||
g_fake_desktop_portal_thread_get_last_request_uri (GFakeDesktopPortalThread *self)
|
||
{
|
||
g_return_val_if_fail (G_IS_FAKE_DESKTOP_PORTAL_THREAD (self), NULL);
|
||
|
||
return self->request_uri;
|
||
}
|
||
|
||
/*
|
||
* Create a new #GFakeDesktopPortalThread. The thread isn’t started until
|
||
* g_fake_desktop_portal_thread_run() is called on it.
|
||
*
|
||
* Returns: (transfer full): the new fake desktop portal wrapper
|
||
*/
|
||
GFakeDesktopPortalThread *
|
||
g_fake_desktop_portal_thread_new (const char *address)
|
||
{
|
||
GFakeDesktopPortalThread *self = g_object_new (G_TYPE_FAKE_DESKTOP_PORTAL_THREAD, NULL);
|
||
self->address = g_strdup (address);
|
||
return g_steal_pointer (&self);
|
||
}
|
||
|
||
/*
|
||
* Start a worker thread which will run a fake
|
||
* `org.freedesktop.portal.Desktops` portal on the bus at @address. This is
|
||
* intended to be used with #GTestDBus to mock up a portal from within a unit
|
||
* test process, rather than relying on D-Bus activation of a mock portal
|
||
* subprocess.
|
||
*
|
||
* It blocks until the thread has owned its D-Bus name and is ready to handle
|
||
* requests.
|
||
*/
|
||
void
|
||
g_fake_desktop_portal_thread_run (GFakeDesktopPortalThread *self)
|
||
{
|
||
g_return_if_fail (G_IS_FAKE_DESKTOP_PORTAL_THREAD (self));
|
||
g_return_if_fail (self->thread == NULL);
|
||
|
||
self->thread = g_thread_new ("fake-desktop-portal", fake_desktop_portal_thread_cb, self);
|
||
|
||
/* Block until the thread is ready. */
|
||
g_mutex_lock (&self->mutex);
|
||
while (!self->ready)
|
||
g_cond_wait (&self->cond, &self->mutex);
|
||
g_mutex_unlock (&self->mutex);
|
||
}
|
||
|
||
/* Stop and join a worker thread started with fake_desktop_portal_thread_run().
|
||
* Blocks until the thread has stopped and joined.
|
||
*
|
||
* Once this has been called, it’s safe to drop the final reference on @self. */
|
||
void
|
||
g_fake_desktop_portal_thread_stop (GFakeDesktopPortalThread *self)
|
||
{
|
||
g_return_if_fail (G_IS_FAKE_DESKTOP_PORTAL_THREAD (self));
|
||
g_return_if_fail (self->thread != NULL);
|
||
|
||
g_cancellable_cancel (self->cancellable);
|
||
g_thread_join (g_steal_pointer (&self->thread));
|
||
}
|
||
|
||
/* Whether fake-desktop-portal is supported on this platform. This basically
|
||
* means whether _g_fd_query_path() will work at runtime. */
|
||
gboolean
|
||
g_fake_desktop_portal_is_supported (void)
|
||
{
|
||
#ifdef __GNU__
|
||
return FALSE;
|
||
#else
|
||
return TRUE;
|
||
#endif
|
||
}
|