git: 9940dac255fc - main - x11/gnome-session: update to 47.0.1
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Wed, 11 Jun 2025 10:08:20 UTC
The branch main has been updated by bapt: URL: https://cgit.FreeBSD.org/ports/commit/?id=9940dac255fcdcebf00dddd67db1ca04300a70a0 commit 9940dac255fcdcebf00dddd67db1ca04300a70a0 Author: Olivier Duchateau <duchateau.olivier@gmail.com> AuthorDate: 2025-06-11 09:42:23 +0000 Commit: Baptiste Daroussin <bapt@FreeBSD.org> CommitDate: 2025-06-11 10:07:10 +0000 x11/gnome-session: update to 47.0.1 PR: 286697 --- x11/gnome-session/Makefile | 28 +- x11/gnome-session/distinfo | 6 +- x11/gnome-session/files/patch-data_meson.build | 18 + .../files/patch-doc_man_gnome-session.1 | 37 + .../files/patch-gnome-session_gsm-autostart-app.c | 44 + .../files/patch-gnome-session_gsm-consolekit.c | 975 +++++++++++++++++++++ .../files/patch-gnome-session_gsm-consolekit.h | 62 ++ .../files/patch-gnome-session_gsm-manager.c | 86 ++ .../files/patch-gnome-session_gsm-system.c | 28 + .../files/patch-gnome-session_gsm-systemd.c | 25 + .../files/patch-gnome-session_gsm-util.c | 46 + .../files/patch-gnome-session_gsm-util.h | 18 + x11/gnome-session/files/patch-gnome-session_main.c | 96 ++ .../files/patch-gnome-session_meson.build | 13 + x11/gnome-session/files/patch-meson.build | 73 ++ x11/gnome-session/files/patch-meson__options.txt | 12 + x11/gnome-session/files/patch-tools_meson.build | 18 + x11/gnome-session/pkg-plist | 234 ++--- 18 files changed, 1690 insertions(+), 129 deletions(-) diff --git a/x11/gnome-session/Makefile b/x11/gnome-session/Makefile index ffa5ef43eeff..5abe46cb7361 100644 --- a/x11/gnome-session/Makefile +++ b/x11/gnome-session/Makefile @@ -1,37 +1,47 @@ PORTNAME= gnome-session -PORTVERSION= 42.0 -PORTREVISION= 4 +PORTVERSION= 47.0.1 CATEGORIES= x11 gnome MASTER_SITES= GNOME DIST_SUBDIR= gnome MAINTAINER= gnome@FreeBSD.org COMMENT= Session component for the GNOME desktop -WWW= https://www.gnome.org/ +WWW= https://gitlab.gnome.org/GNOME/gnome-session LICENSE= GPLv2+ LICENSE_FILE= ${WRKSRC}/COPYING +PORTSCOUT= limit:^47\. + BUILD_DEPENDS= xmlto:textproc/xmlto LIB_DEPENDS= libjson-glib-1.0.so:devel/json-glib \ libdbus-glib-1.so:devel/dbus-glib \ libepoxy.so:graphics/libepoxy -RUN_DEPENDS= ${LOCALBASE}/sbin/console-kit-daemon:sysutils/consolekit2 \ - dbus-daemon:devel/dbus - -PORTSCOUT= limitw:1,even +RUN_DEPENDS= consolekit2>0:sysutils/consolekit2 \ + dbus-daemon:devel/dbus \ + zenity:x11/zenity USES= compiler:c11 gettext gl gnome localbase:ldflags meson \ pkgconfig python:build tar:xz xorg -USE_GNOME= gnomedesktop3 gtk30 +USE_GNOME= glib20 gnomedesktop3 gtk30 libxslt:build USE_XORG= ice sm x11 xcomposite xtrans USE_GL= egl gl glesv2 -MESON_ARGS= -Dsystemd=false \ +MESON_ARGS= -Ddocbook=false \ + -Dsystemd=false \ -Dsystemd_session=disable \ -Dsystemd_journal=false \ -Dconsolekit=true BINARY_ALIAS= python3=${PYTHON_VERSION} +PLIST_SUB= VERSION=${PORTVERSION:C/^([0-9]+)\..*/\1/} + GLIB_SCHEMAS= org.gnome.SessionManager.gschema.xml +post-patch: +# Avoid lots of warnings in gdm log +.for f in gnome-wayland.desktop.in.in gnome.desktop.in.in + ${REINPLACE_CMD} -e 's|/gnome-session|/gnome-session --disable-acceleration-check|g' \ + ${WRKSRC}/data/${f} +.endfor + .include <bsd.port.mk> diff --git a/x11/gnome-session/distinfo b/x11/gnome-session/distinfo index 0f12efa56e5a..a6e875cf2f97 100644 --- a/x11/gnome-session/distinfo +++ b/x11/gnome-session/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1648063129 -SHA256 (gnome/gnome-session-42.0.tar.xz) = 3cca06053ab682926920951a7da95f8cc6d72da74c682c46d0a0653332969caa -SIZE (gnome/gnome-session-42.0.tar.xz) = 485616 +TIMESTAMP = 1743437836 +SHA256 (gnome/gnome-session-47.0.1.tar.xz) = 56ae9c68e49995793eb2096bcdc4533b111669e1e54c8b6e0b1d952f6a5e8a70 +SIZE (gnome/gnome-session-47.0.1.tar.xz) = 486996 diff --git a/x11/gnome-session/files/patch-data_meson.build b/x11/gnome-session/files/patch-data_meson.build new file mode 100644 index 000000000000..0d22a37a99dd --- /dev/null +++ b/x11/gnome-session/files/patch-data_meson.build @@ -0,0 +1,18 @@ +--- data/meson.build.orig 2024-03-18 19:30:06 UTC ++++ data/meson.build +@@ -108,6 +108,7 @@ install_data( + install_dir: join_paths(session_datadir, 'glib-2.0', 'schemas'), + ) + ++if enable_systemd_session + unit_conf = configuration_data() + unit_conf.set('libexecdir', session_libexecdir) + +@@ -170,6 +171,7 @@ endforeach + session), + ) + endforeach ++endif + + data = files('hardware-compatibility') + diff --git a/x11/gnome-session/files/patch-doc_man_gnome-session.1 b/x11/gnome-session/files/patch-doc_man_gnome-session.1 new file mode 100644 index 000000000000..f3aca3c6f497 --- /dev/null +++ b/x11/gnome-session/files/patch-doc_man_gnome-session.1 @@ -0,0 +1,37 @@ +--- doc/man/gnome-session.1.orig 2024-03-18 19:30:06 UTC ++++ doc/man/gnome-session.1 +@@ -43,6 +43,14 @@ Use the applications defined in \fBSESSION.session\fP. + Use the applications defined in \fBSESSION.session\fP. If not specified, + \fBgnome.session\fP will be used. + .TP ++.I "--builtin" ++Use the legacy non-systemd method of managing the user session. This is the ++opposite of the \fI--systemd\fP option. ++.TP ++.I "--systemd" ++Use the systemd method of managing the user session. This is the opposite of ++the \fI--builtin\fP option. ++.TP + .I "--failsafe" + Run in fail-safe mode. User-specified applications will not be started. + .TP +@@ -82,11 +90,17 @@ The \fB.session\fP files are looked for in + \fB$XDG_CONFIG_DIRS/gnome-session/sessions\fP and + \fB$XDG_DATA_DIRS/gnome-session/sessions\fP. + .SH systemd +-\fIgnome-session\fP can pass much of the session management over to systemd. +-In this case, startup components that have \fBX-GNOME-HiddenUnderSystemd=true\fP ++\fIgnome-session\fP can pass much of the session management over to systemd ++(see the \fI--systemd\fP option which may be the default since 3.34). In this ++case, startup components that have \fBX-GNOME-HiddenUnderSystemd=true\fP + set in their \fB.desktop\fP file will be ignored by \fIgnome-session\fP. It + instead relies on the fact that these components are managed by systemd. + .PP ++As of GNOME 3.34 the systemd support is new and the customizing the ++configuration is not yet easily possible. With GNOME 3.34 it may be best to use ++\fI--builtin\fP if session customizations are required. This is due to the way ++that GNOME currently defines the components that will be started on each session ++type. + .PP + \fBsystemd\fP provides the two special targets \fBgraphical-session.target\fP + and \fBgraphical-session-pre.target\fP which are fully functional and should be diff --git a/x11/gnome-session/files/patch-gnome-session_gsm-autostart-app.c b/x11/gnome-session/files/patch-gnome-session_gsm-autostart-app.c new file mode 100644 index 000000000000..6d3d660bd50b --- /dev/null +++ b/x11/gnome-session/files/patch-gnome-session_gsm-autostart-app.c @@ -0,0 +1,44 @@ +--- gnome-session/gsm-autostart-app.c.orig 2024-03-18 19:30:06 UTC ++++ gnome-session/gsm-autostart-app.c +@@ -31,8 +31,12 @@ + #define GNOME_DESKTOP_USE_UNSTABLE_API + #include <libgnome-desktop/gnome-systemd.h> + ++#ifdef HAVE_SYSTEMD ++#ifdef ENABLE_SYSTEMD_JOURNAL + #include <systemd/sd-journal.h> ++#endif + #include <systemd/sd-daemon.h> ++#endif + + #include "gsm-autostart-app.h" + #include "gsm-util.h" +@@ -957,6 +961,7 @@ app_launched (GAppLaunchContext *ctx, + NULL, NULL, NULL); + } + ++#ifdef ENABLE_SYSTEMD_JOURNAL + static void + on_child_setup (GsmAutostartApp *app) + { +@@ -983,6 +988,7 @@ on_child_setup (GsmAutostartApp *app) + close (standard_error); + } + } ++#endif + + static gboolean + autostart_app_start_spawn (GsmAutostartApp *app, +@@ -1033,10 +1039,12 @@ autostart_app_start_spawn (GsmAutostartApp *app, + g_app_launch_context_setenv (ctx, "DESKTOP_AUTOSTART_ID", startup_id); + } + ++#ifdef ENABLE_SYSTEMD_JOURNAL + if (sd_booted () > 0) { + child_setup_func = (GSpawnChildSetupFunc) on_child_setup; + child_setup_data = app; + } ++#endif + + handler = g_signal_connect (ctx, "launched", G_CALLBACK (app_launched), app); + success = g_desktop_app_info_launch_uris_as_manager (priv->app_info, diff --git a/x11/gnome-session/files/patch-gnome-session_gsm-consolekit.c b/x11/gnome-session/files/patch-gnome-session_gsm-consolekit.c new file mode 100644 index 000000000000..b26616c7ab86 --- /dev/null +++ b/x11/gnome-session/files/patch-gnome-session_gsm-consolekit.c @@ -0,0 +1,975 @@ +--- gnome-session/gsm-consolekit.c.orig 2024-12-30 10:33:10 UTC ++++ gnome-session/gsm-consolekit.c +@@ -0,0 +1,972 @@ ++/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- ++ * ++ * Copyright (C) 2008 Jon McCann <jmccann@redhat.com> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2, or (at your option) ++ * any later version. ++ * ++ * This program 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 General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, see <http://www.gnu.org/licenses/>. ++ */ ++ ++#include "config.h" ++ ++#include <errno.h> ++#include <string.h> ++#include <stdlib.h> ++#include <unistd.h> ++#include <sys/types.h> ++#include <pwd.h> ++ ++#include <glib.h> ++#include <glib-object.h> ++#include <glib/gi18n.h> ++#include <gio/gio.h> ++#include <gio/gunixfdlist.h> ++ ++#include "gsm-system.h" ++#include "gsm-consolekit.h" ++ ++#define CK_NAME "org.freedesktop.ConsoleKit" ++ ++#define CK_MANAGER_PATH "/org/freedesktop/ConsoleKit/Manager" ++#define CK_MANAGER_INTERFACE CK_NAME ".Manager" ++#define CK_SEAT_INTERFACE CK_NAME ".Seat" ++#define CK_SESSION_INTERFACE CK_NAME ".Session" ++ ++ ++struct _GsmConsolekitPrivate ++{ ++ GDBusProxy *ck_proxy; ++ GDBusProxy *ck_session_proxy; ++ ++ char *session_id; ++ gchar *session_path; ++ ++ const gchar *inhibit_locks; ++ gint inhibit_fd; ++ ++ gboolean is_active; ++ ++ gint delay_inhibit_fd; ++ gboolean prepare_for_shutdown_expected; ++}; ++ ++enum { ++ PROP_0, ++ PROP_ACTIVE ++}; ++ ++static void gsm_consolekit_system_init (GsmSystemInterface *iface); ++ ++G_DEFINE_TYPE_WITH_CODE (GsmConsolekit, gsm_consolekit, G_TYPE_OBJECT, ++ G_IMPLEMENT_INTERFACE (GSM_TYPE_SYSTEM, ++ gsm_consolekit_system_init)) ++ ++static void ++drop_system_inhibitor (GsmConsolekit *manager) ++{ ++ if (manager->priv->inhibit_fd != -1) { ++ g_debug ("GsmConsolekit: Dropping system inhibitor fd %d", manager->priv->inhibit_fd); ++ close (manager->priv->inhibit_fd); ++ manager->priv->inhibit_fd = -1; ++ } ++} ++ ++static void ++drop_delay_inhibitor (GsmConsolekit *manager) ++{ ++ if (manager->priv->delay_inhibit_fd != -1) { ++ g_debug ("GsmConsolekit: Dropping delay inhibitor"); ++ close (manager->priv->delay_inhibit_fd); ++ manager->priv->delay_inhibit_fd = -1; ++ } ++} ++ ++static void ++gsm_consolekit_finalize (GObject *object) ++{ ++ GsmConsolekit *consolekit = GSM_CONSOLEKIT (object); ++ ++ g_clear_object (&consolekit->priv->ck_proxy); ++ g_clear_object (&consolekit->priv->ck_session_proxy); ++ free (consolekit->priv->session_id); ++ g_free (consolekit->priv->session_path); ++ ++ drop_system_inhibitor (consolekit); ++ drop_delay_inhibitor (consolekit); ++ ++ G_OBJECT_CLASS (gsm_consolekit_parent_class)->finalize (object); ++} ++ ++static void ++gsm_consolekit_set_property (GObject *object, ++ guint prop_id, ++ const GValue *value, ++ GParamSpec *pspec) ++{ ++ GsmConsolekit *self = GSM_CONSOLEKIT (object); ++ ++ switch (prop_id) { ++ case PROP_ACTIVE: ++ self->priv->is_active = g_value_get_boolean (value); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); ++ } ++} ++ ++static void ++gsm_consolekit_get_property (GObject *object, ++ guint prop_id, ++ GValue *value, ++ GParamSpec *pspec) ++{ ++ GsmConsolekit *self = GSM_CONSOLEKIT (object); ++ ++ switch (prop_id) { ++ case PROP_ACTIVE: ++ g_value_set_boolean (value, self->priv->is_active); ++ break; ++ default: ++ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); ++ break; ++ } ++} ++ ++static void ++gsm_consolekit_class_init (GsmConsolekitClass *manager_class) ++{ ++ GObjectClass *object_class; ++ ++ object_class = G_OBJECT_CLASS (manager_class); ++ ++ object_class->get_property = gsm_consolekit_get_property; ++ object_class->set_property = gsm_consolekit_set_property; ++ object_class->finalize = gsm_consolekit_finalize; ++ ++ g_object_class_override_property (object_class, PROP_ACTIVE, "active"); ++ ++ g_type_class_add_private (manager_class, sizeof (GsmConsolekitPrivate)); ++} ++ ++static void ck_session_proxy_signal_cb (GDBusProxy *proxy, ++ const gchar *sender_name, ++ const gchar *signal_name, ++ GVariant *parameters, ++ gpointer user_data); ++ ++static void ck_proxy_signal_cb (GDBusProxy *proxy, ++ const gchar *sender_name, ++ const gchar *signal_name, ++ GVariant *parameters, ++ gpointer user_data); ++ ++static void ++ck_pid_get_session (GsmConsolekit *manager, ++ pid_t pid, ++ gchar **session_id) ++{ ++ GVariant *res; ++ ++ *session_id = NULL; ++ ++ if (pid < 0) { ++ g_warning ("Calling GetSessionForUnixProcess failed." ++ "Invalid pid."); ++ return; ++ } ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_proxy, ++ "GetSessionForUnixProcess", ++ g_variant_new ("(u)", pid), ++ 0, ++ -1, ++ NULL, ++ NULL); ++ if (!res) { ++ g_warning ("Calling GetSessionForUnixProcess failed." ++ "Check that ConsoleKit is properly installed."); ++ return; ++ } ++ ++ g_variant_get (res, "(o)", session_id); ++ g_variant_unref (res); ++} ++ ++static void ++gsm_consolekit_init (GsmConsolekit *manager) ++{ ++ GError *error = NULL; ++ GDBusConnection *bus; ++ GVariant *res; ++ ++ manager->priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, ++ GSM_TYPE_CONSOLEKIT, ++ GsmConsolekitPrivate); ++ ++ manager->priv->inhibit_fd = -1; ++ manager->priv->delay_inhibit_fd = -1; ++ ++ bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); ++ if (bus == NULL) ++ g_error ("Failed to connect to system bus: %s", ++ error->message); ++ manager->priv->ck_proxy = ++ g_dbus_proxy_new_sync (bus, ++ 0, ++ NULL, ++ CK_NAME, ++ CK_MANAGER_PATH, ++ CK_MANAGER_INTERFACE, ++ NULL, ++ &error); ++ if (manager->priv->ck_proxy == NULL) { ++ g_warning ("Failed to connect to consolekit: %s", ++ error->message); ++ g_clear_error (&error); ++ } ++ ++ g_signal_connect (manager->priv->ck_proxy, "g-signal", ++ G_CALLBACK (ck_proxy_signal_cb), manager); ++ ++ ck_pid_get_session (manager, getpid (), &manager->priv->session_id); ++ ++ if (manager->priv->session_id == NULL) { ++ g_warning ("Could not get session id for session. Check that ConsoleKit is " ++ "properly installed."); ++ return; ++ } ++ ++ /* in ConsoleKit, the session id is the session path */ ++ manager->priv->session_path = g_strdup (manager->priv->session_id); ++ ++ manager->priv->ck_session_proxy = ++ g_dbus_proxy_new_sync (bus, ++ 0, ++ NULL, ++ CK_NAME, ++ manager->priv->session_path, ++ CK_SESSION_INTERFACE, ++ NULL, ++ &error); ++ if (manager->priv->ck_proxy == NULL) { ++ g_warning ("Failed to connect to consolekit session: %s", ++ error->message); ++ g_clear_error (&error); ++ } ++ ++ g_signal_connect (manager->priv->ck_session_proxy, "g-signal", ++ G_CALLBACK (ck_session_proxy_signal_cb), manager); ++ ++ g_object_unref (bus); ++} ++ ++static void ++emit_restart_complete (GsmConsolekit *manager, ++ GError *error) ++{ ++ GError *call_error; ++ ++ call_error = NULL; ++ ++ if (error != NULL) { ++ call_error = g_error_new_literal (GSM_SYSTEM_ERROR, ++ GSM_SYSTEM_ERROR_RESTARTING, ++ error->message); ++ } ++ ++ g_signal_emit_by_name (G_OBJECT (manager), ++ "request_completed", call_error); ++ ++ if (call_error != NULL) { ++ g_error_free (call_error); ++ } ++} ++ ++static void ++emit_stop_complete (GsmConsolekit *manager, ++ GError *error) ++{ ++ GError *call_error; ++ ++ call_error = NULL; ++ ++ if (error != NULL) { ++ call_error = g_error_new_literal (GSM_SYSTEM_ERROR, ++ GSM_SYSTEM_ERROR_STOPPING, ++ error->message); ++ } ++ ++ g_signal_emit_by_name (G_OBJECT (manager), ++ "request_completed", call_error); ++ ++ if (call_error != NULL) { ++ g_error_free (call_error); ++ } ++} ++ ++static void ++restart_done (GObject *source, ++ GAsyncResult *result, ++ gpointer user_data) ++{ ++ GDBusProxy *proxy = G_DBUS_PROXY (source); ++ GsmConsolekit *manager = user_data; ++ GError *error = NULL; ++ GVariant *res; ++ ++ res = g_dbus_proxy_call_finish (proxy, result, &error); ++ ++ if (!res) { ++ g_warning ("Unable to restart system: %s", error->message); ++ emit_restart_complete (manager, error); ++ g_error_free (error); ++ } else { ++ emit_restart_complete (manager, NULL); ++ g_variant_unref (res); ++ } ++} ++ ++static void ++gsm_consolekit_attempt_restart (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ ++ /* Use Restart instead of Reboot because it will work on ++ * both CK and CK2 */ ++ g_dbus_proxy_call (manager->priv->ck_proxy, ++ "Restart", ++ g_variant_new ("()"), ++ 0, ++ G_MAXINT, ++ NULL, ++ restart_done, ++ manager); ++} ++ ++static void ++stop_done (GObject *source, ++ GAsyncResult *result, ++ gpointer user_data) ++{ ++ GDBusProxy *proxy = G_DBUS_PROXY (source); ++ GsmConsolekit *manager = user_data; ++ GError *error = NULL; ++ GVariant *res; ++ ++ res = g_dbus_proxy_call_finish (proxy, result, &error); ++ ++ if (!res) { ++ g_warning ("Unable to stop system: %s", error->message); ++ emit_stop_complete (manager, error); ++ g_error_free (error); ++ } else { ++ emit_stop_complete (manager, NULL); ++ g_variant_unref (res); ++ } ++} ++ ++static void ++gsm_consolekit_attempt_stop (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ ++ /* Use Stop insetad of PowerOff because it will work with ++ * Ck and CK2. */ ++ g_dbus_proxy_call (manager->priv->ck_proxy, ++ "Stop", ++ g_variant_new ("()"), ++ 0, ++ G_MAXINT, ++ NULL, ++ stop_done, ++ manager); ++} ++ ++static void ++gsm_consolekit_set_session_idle (GsmSystem *system, ++ gboolean is_idle) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ ++ g_debug ("Updating consolekit idle status: %d", is_idle); ++ g_dbus_proxy_call_sync (manager->priv->ck_session_proxy, ++ "SetIdleHint", ++ g_variant_new ("(b)", is_idle), ++ 0, ++ G_MAXINT, ++ NULL, NULL); ++} ++ ++static void ++ck_session_get_seat (GsmConsolekit *manager, ++ gchar **seat) ++{ ++ GVariant *res; ++ ++ *seat = NULL; ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_session_proxy, ++ "GetSeatId", ++ g_variant_new ("()"), ++ 0, ++ -1, ++ NULL, NULL); ++ if (!res) { ++ g_warning ("GsmConsoleKit: Calling GetSeatId failed."); ++ return; ++ } ++ ++ g_variant_get (res, "(o)", seat); ++ g_variant_unref (res); ++} ++ ++/* returns -1 on failure ++ * 0 seat is multi-session ++ * 1 seat is not multi-session ++ */ ++static gint ++ck_seat_can_multi_session (GsmConsolekit *manager, ++ const gchar *seat) ++{ ++ GDBusConnection *bus; ++ GVariant *res; ++ gboolean can_activate; ++ ++ ++ bus = g_dbus_proxy_get_connection (manager->priv->ck_proxy); ++ res = g_dbus_connection_call_sync (bus, ++ CK_NAME, ++ seat, ++ CK_SEAT_INTERFACE, ++ "CanActivateSessions", ++ g_variant_new ("()"), ++ G_VARIANT_TYPE_BOOLEAN, ++ 0, ++ -1, ++ NULL, NULL); ++ if (!res) { ++ g_warning ("GsmConsoleKit: Calling GetSeatId failed."); ++ return -1; ++ } ++ ++ g_variant_get (res, "(b)", &can_activate); ++ g_variant_unref (res); ++ ++ return can_activate == TRUE ? 1 : 0; ++} ++ ++static gboolean ++gsm_consolekit_can_switch_user (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ gchar *seat; ++ gint ret; ++ ++ ck_session_get_seat (manager, &seat); ++ ret = ck_seat_can_multi_session (manager, seat); ++ free (seat); ++ ++ return ret > 0; ++} ++ ++static gboolean ++gsm_consolekit_can_restart (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ GVariant *res; ++ gboolean can_restart; ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_proxy, ++ "CanRestart", ++ g_variant_new ("()"), ++ 0, ++ G_MAXINT, ++ NULL, ++ NULL); ++ if (!res) { ++ g_warning ("Calling CanRestart failed. Check that ConsoleKit is " ++ "properly installed."); ++ return FALSE; ++ } ++ ++ g_variant_get (res, "(b)", &can_restart); ++ g_variant_unref (res); ++ ++ return can_restart; ++} ++ ++static gboolean ++gsm_consolekit_can_stop (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ GVariant *res; ++ gboolean can_stop; ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_proxy, ++ "CanStop", ++ g_variant_new ("()"), ++ 0, ++ G_MAXINT, ++ NULL, ++ NULL); ++ if (!res) { ++ g_warning ("Calling CanStop failed. Check that ConsoleKit is " ++ "properly installed."); ++ return FALSE; ++ } ++ ++ g_variant_get (res, "(b)", &can_stop); ++ g_variant_unref (res); ++ ++ return can_stop; ++} ++ ++/* returns -1 on failure, 0 on success */ ++static gint ++ck_session_get_class (GsmConsolekit *manager, ++ gchar **session_class) ++{ ++ GVariant *res; ++ ++ *session_class = NULL; ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_session_proxy, ++ "GetSessionClass", ++ g_variant_new ("()"), ++ 0, ++ -1, ++ NULL, NULL); ++ if (!res) { ++ g_warning ("GsmConsoleKit: Calling GetSessionClass failed."); ++ return -1; ++ } ++ ++ g_variant_get (res, "(s)", session_class); ++ g_variant_unref (res); ++ ++ return 0; ++} ++ ++static gboolean ++gsm_consolekit_is_login_session (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ int res; ++ gboolean ret; ++ gchar *session_class = NULL; ++ ++ ret = FALSE; ++ ++ if (manager->priv->session_id == NULL) { ++ return ret; ++ } ++ ++ res = ck_session_get_class (manager, &session_class); ++ if (res < 0) { ++ g_warning ("Could not get session class: %s", strerror (-res)); ++ return FALSE; ++ } ++ ret = (g_strcmp0 (session_class, "greeter") == 0); ++ g_free (session_class); ++ ++ return ret; ++} ++ ++static gboolean ++gsm_consolekit_can_suspend (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ gchar *rv; ++ GVariant *res; ++ gboolean can_suspend; ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_proxy, ++ "CanSuspend", ++ NULL, ++ 0, ++ G_MAXINT, ++ NULL, ++ NULL); ++ if (!res) { ++ g_warning ("Calling CanSuspend failed. Check that ConsoleKit is " ++ "properly installed."); ++ return FALSE; ++ } ++ ++ g_variant_get (res, "(s)", &rv); ++ g_variant_unref (res); ++ ++ can_suspend = g_strcmp0 (rv, "yes") == 0 || ++ g_strcmp0 (rv, "challenge") == 0; ++ ++ g_free (rv); ++ ++ return can_suspend; ++} ++ ++static gboolean ++gsm_consolekit_can_hibernate (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ gchar *rv; ++ GVariant *res; ++ gboolean can_hibernate; ++ ++ res = g_dbus_proxy_call_sync (manager->priv->ck_proxy, ++ "CanHibernate", ++ NULL, ++ 0, ++ G_MAXINT, ++ NULL, ++ NULL); ++ if (!res) { ++ g_warning ("Calling CanHibernate failed. Check that ConsoleKit is " ++ "properly installed."); ++ return FALSE; ++ } ++ ++ g_variant_get (res, "(s)", &rv); ++ g_variant_unref (res); ++ ++ can_hibernate = g_strcmp0 (rv, "yes") == 0 || ++ g_strcmp0 (rv, "challenge") == 0; ++ ++ g_free (rv); ++ ++ return can_hibernate; ++} ++ ++static void ++suspend_done (GObject *source, ++ GAsyncResult *result, ++ gpointer user_data) ++{ ++ GDBusProxy *proxy = G_DBUS_PROXY (source); ++ GError *error = NULL; ++ GVariant *res; ++ ++ res = g_dbus_proxy_call_finish (proxy, result, &error); ++ ++ if (!res) { ++ g_warning ("Unable to suspend system: %s", error->message); ++ g_error_free (error); ++ } else { ++ g_variant_unref (res); ++ } ++} ++ ++static void ++hibernate_done (GObject *source, ++ GAsyncResult *result, ++ gpointer user_data) ++{ ++ GDBusProxy *proxy = G_DBUS_PROXY (source); ++ GError *error = NULL; ++ GVariant *res; ++ ++ res = g_dbus_proxy_call_finish (proxy, result, &error); ++ ++ if (!res) { ++ g_warning ("Unable to hibernate system: %s", error->message); ++ g_error_free (error); ++ } else { ++ g_variant_unref (res); ++ } ++} ++ ++static void ++gsm_consolekit_suspend (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ ++ g_dbus_proxy_call (manager->priv->ck_proxy, ++ "Suspend", ++ g_variant_new ("(b)", TRUE), ++ 0, ++ G_MAXINT, ++ NULL, ++ suspend_done, ++ manager); ++} ++ ++static void ++gsm_consolekit_hibernate (GsmSystem *system) ++{ ++ GsmConsolekit *manager = GSM_CONSOLEKIT (system); ++ ++ g_dbus_proxy_call (manager->priv->ck_proxy, ++ "Hibernate", ++ g_variant_new ("(b)", TRUE), ++ 0, ++ G_MAXINT, ++ NULL, ++ hibernate_done, ++ manager); ++} ++ ++static void ++inhibit_done (GObject *source, ++ GAsyncResult *result, ++ gpointer user_data) ++{ ++ GDBusProxy *proxy = G_DBUS_PROXY (source); ++ GsmConsolekit *manager = GSM_CONSOLEKIT (user_data); ++ GError *error = NULL; ++ GVariant *res; ++ GUnixFDList *fd_list = NULL; ++ gint idx; ++ ++ /* Drop any previous inhibit before recording the new one */ ++ drop_system_inhibitor (manager); ++ ++ res = g_dbus_proxy_call_with_unix_fd_list_finish (proxy, &fd_list, result, &error); ++ ++ if (!res) { ++ g_warning ("Unable to inhibit system: %s", error->message); ++ g_error_free (error); ++ } else { ++ g_variant_get (res, "(h)", &idx); ++ manager->priv->inhibit_fd = g_unix_fd_list_get (fd_list, idx, &error); ++ if (manager->priv->inhibit_fd == -1) { ++ g_warning ("Failed to receive system inhibitor fd: %s", error->message); ++ g_error_free (error); ++ } ++ g_debug ("System inhibitor fd is %d", manager->priv->inhibit_fd); ++ g_object_unref (fd_list); ++ g_variant_unref (res); ++ } ++ ++ /* Handle a race condition, where locks got unset during dbus call */ ++ if (manager->priv->inhibit_locks == NULL) { ++ drop_system_inhibitor (manager); ++ } ++} ++ ++static void *** 1015 LINES SKIPPED ***