git: 9940dac255fc - main - x11/gnome-session: update to 47.0.1

From: Baptiste Daroussin <bapt_at_FreeBSD.org>
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 ***