From 8c3a382416729296e1d9ba24af6832c354bd6fc4 Mon Sep 17 00:00:00 2001

From: Ray Strode <rstrode@redhat.com>

Date: Fri, 16 Jul 2021 12:34:57 -0400

Subject: [PATCH 1/2] local-display-factory: Provide more flexibility for

 configuring display server

There's currently a way to disable wayland, but no way to disable Xorg.

We currently prefer wayland if it's not disabled, but have no way to

prefer Xorg without disabling wayland entirely.

There's currently no way use legacy Xorg support at all if user display

server support is enabled at a build time.

This commit adds more flexibility to display server selection. It adds

two new keys: XorgEnable and and PreferredDisplayServer.

XorgEnable=false disables Xorg support entirely on seat 0.

PreferredDisplayServer can be set to "wayland", "xorg", "legacy-xorg" or

"none" to select which display server is used by default. If it's set to

"wayland", it will fall back to "xorg". If it's set to "xorg" it will

fall back to "wayland".

---

 common/gdm-settings-keys.h         |   2 +

 daemon/gdm-display.c               |  36 +++++

 daemon/gdm-launch-environment.c    |   9 ++

 daemon/gdm-local-display-factory.c | 220 ++++++++++++++++++++++++-----

 daemon/gdm-manager.c               |  20 +--

 daemon/gdm-session.c               | 143 +++++++++++--------

 data/gdm.schemas.in                |  10 ++

 libgdm/gdm-sessions.c              |  72 +++++++---

 8 files changed, 378 insertions(+), 134 deletions(-)

diff --git a/common/gdm-settings-keys.h b/common/gdm-settings-keys.h

index f0059b5cf..87685d3cd 100644

--- a/common/gdm-settings-keys.h

+++ b/common/gdm-settings-keys.h

@@ -6,59 +6,61 @@

  * modify it under the terms of the GNU Library General Public

  * License as published by the Free Software Foundation; either

  * version 2 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

  * Library General Public License for more details.

  *

  * You should have received a copy of the GNU Library General Public

  * License along with this library; if not, write to the

  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

  * Boston, MA 02110-1301, USA.

  */

 #ifndef _GDM_SETTINGS_KEYS_H

 #define _GDM_SETTINGS_KEYS_H

 #include <glib.h>

 G_BEGIN_DECLS

 #define GDM_KEY_USER "daemon/User"

 #define GDM_KEY_GROUP "daemon/Group"

 #define GDM_KEY_AUTO_LOGIN_ENABLE "daemon/AutomaticLoginEnable"

 #define GDM_KEY_AUTO_LOGIN_USER "daemon/AutomaticLogin"

 #define GDM_KEY_TIMED_LOGIN_ENABLE "daemon/TimedLoginEnable"

 #define GDM_KEY_TIMED_LOGIN_USER "daemon/TimedLogin"

 #define GDM_KEY_TIMED_LOGIN_DELAY "daemon/TimedLoginDelay"

 #define GDM_KEY_INITIAL_SETUP_ENABLE "daemon/InitialSetupEnable"

+#define GDM_KEY_PREFERRED_DISPLAY_SERVER "daemon/PreferredDisplayServer"

 #define GDM_KEY_WAYLAND_ENABLE "daemon/WaylandEnable"

+#define GDM_KEY_XORG_ENABLE "daemon/XorgEnable"

 #define GDM_KEY_DEBUG "debug/Enable"

 #define GDM_KEY_INCLUDE "greeter/Include"

 #define GDM_KEY_EXCLUDE "greeter/Exclude"

 #define GDM_KEY_INCLUDE_ALL "greeter/IncludeAll"

 #define GDM_KEY_DISALLOW_TCP "security/DisallowTCP"

 #define GDM_KEY_ALLOW_REMOTE_AUTOLOGIN "security/AllowRemoteAutoLogin"

 #define GDM_KEY_XDMCP_ENABLE "xdmcp/Enable"

 #define GDM_KEY_SHOW_LOCAL_GREETER "xdmcp/ShowLocalGreeter"

 #define GDM_KEY_MAX_PENDING "xdmcp/MaxPending"

 #define GDM_KEY_MAX_SESSIONS "xdmcp/MaxSessions"

 #define GDM_KEY_MAX_WAIT "xdmcp/MaxWait"

 #define GDM_KEY_DISPLAYS_PER_HOST "xdmcp/DisplaysPerHost"

 #define GDM_KEY_UDP_PORT "xdmcp/Port"

 #define GDM_KEY_INDIRECT "xdmcp/HonorIndirect"

 #define GDM_KEY_MAX_WAIT_INDIRECT "xdmcp/MaxWaitIndirect"

 #define GDM_KEY_PING_INTERVAL "xdmcp/PingIntervalSeconds"

 #define GDM_KEY_WILLING "xdmcp/Willing"

 #define GDM_KEY_MULTICAST "chooser/Multicast"

 #define GDM_KEY_MULTICAST_ADDR "chooser/MulticastAddr"

 G_END_DECLS

 #endif /* _GDM_SETTINGS_KEYS_H */

diff --git a/daemon/gdm-display.c b/daemon/gdm-display.c

index 7c954ad24..874f9e6ba 100644

--- a/daemon/gdm-display.c

+++ b/daemon/gdm-display.c

@@ -66,83 +66,86 @@ typedef struct _GdmDisplayPrivate

         char                 *x11_display_name;

         int                   status;

         time_t                creation_time;

         char                 *x11_cookie;

         gsize                 x11_cookie_size;

         GdmDisplayAccessFile *access_file;

         guint                 finish_idle_id;

         xcb_connection_t     *xcb_connection;

         int                   xcb_screen_number;

         GDBusConnection      *connection;

         GdmDisplayAccessFile *user_access_file;

         GdmDBusDisplay       *display_skeleton;

         GDBusObjectSkeleton  *object_skeleton;

         GDBusProxy           *accountsservice_proxy;

         /* this spawns and controls the greeter session */

         GdmLaunchEnvironment *launch_environment;

         guint                 is_local : 1;

         guint                 is_initial : 1;

         guint                 allow_timed_login : 1;

         guint                 have_existing_user_accounts : 1;

         guint                 doing_initial_setup : 1;

         guint                 session_registered : 1;

+

+        GStrv                 supported_session_types;

 } GdmDisplayPrivate;

 enum {

         PROP_0,

         PROP_ID,

         PROP_STATUS,

         PROP_SEAT_ID,

         PROP_SESSION_ID,

         PROP_SESSION_CLASS,

         PROP_SESSION_TYPE,

         PROP_REMOTE_HOSTNAME,

         PROP_X11_DISPLAY_NUMBER,

         PROP_X11_DISPLAY_NAME,

         PROP_X11_COOKIE,

         PROP_X11_AUTHORITY_FILE,

         PROP_IS_CONNECTED,

         PROP_IS_LOCAL,

         PROP_LAUNCH_ENVIRONMENT,

         PROP_IS_INITIAL,

         PROP_ALLOW_TIMED_LOGIN,

         PROP_HAVE_EXISTING_USER_ACCOUNTS,

         PROP_DOING_INITIAL_SETUP,

         PROP_SESSION_REGISTERED,

+        PROP_SUPPORTED_SESSION_TYPES,

 };

 static void     gdm_display_class_init  (GdmDisplayClass *klass);

 static void     gdm_display_init        (GdmDisplay      *self);

 static void     gdm_display_finalize    (GObject         *object);

 static void     queue_finish            (GdmDisplay      *self);

 static void     _gdm_display_set_status (GdmDisplay *self,

                                          int         status);

 static gboolean wants_initial_setup (GdmDisplay *self);

 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdmDisplay, gdm_display, G_TYPE_OBJECT)

 GQuark

 gdm_display_error_quark (void)

 {

         static GQuark ret = 0;

         if (ret == 0) {

                 ret = g_quark_from_static_string ("gdm_display_error");

         }

         return ret;

 }

 time_t

 gdm_display_get_creation_time (GdmDisplay *self)

 {

         GdmDisplayPrivate *priv;

         g_return_val_if_fail (GDM_IS_DISPLAY (self), 0);

         priv = gdm_display_get_instance_private (self);

@@ -885,116 +888,136 @@ _gdm_display_set_launch_environment (GdmDisplay           *self,

         priv = gdm_display_get_instance_private (self);

         g_clear_object (&priv->launch_environment);

         priv->launch_environment = g_object_ref (launch_environment);

 }

 static void

 _gdm_display_set_is_initial (GdmDisplay     *self,

                              gboolean        initial)

 {

         GdmDisplayPrivate *priv;

         priv = gdm_display_get_instance_private (self);

         g_debug ("GdmDisplay: initial: %s", initial? "yes" : "no");

         priv->is_initial = initial;

 }

 static void

 _gdm_display_set_allow_timed_login (GdmDisplay     *self,

                                     gboolean        allow_timed_login)

 {

         GdmDisplayPrivate *priv;

         priv = gdm_display_get_instance_private (self);

         g_debug ("GdmDisplay: allow timed login: %s", allow_timed_login? "yes" : "no");

         priv->allow_timed_login = allow_timed_login;

 }

+static void

+_gdm_display_set_supported_session_types (GdmDisplay         *self,

+                                          const char * const *supported_session_types)

+

+{

+        GdmDisplayPrivate *priv;

+        g_autofree char *supported_session_types_string = NULL;

+

+        if (supported_session_types != NULL)

+                supported_session_types_string = g_strjoinv (":", (GStrv) supported_session_types);

+

+        priv = gdm_display_get_instance_private (self);

+        g_debug ("GdmDisplay: supported session types: %s", supported_session_types_string);

+        g_strfreev (priv->supported_session_types);

+        priv->supported_session_types = g_strdupv ((GStrv) supported_session_types);

+}

+

 static void

 gdm_display_set_property (GObject        *object,

                           guint           prop_id,

                           const GValue   *value,

                           GParamSpec     *pspec)

 {

         GdmDisplay *self;

         self = GDM_DISPLAY (object);

         switch (prop_id) {

         case PROP_ID:

                 _gdm_display_set_id (self, g_value_get_string (value));

                 break;

         case PROP_STATUS:

                 _gdm_display_set_status (self, g_value_get_int (value));

                 break;

         case PROP_SEAT_ID:

                 _gdm_display_set_seat_id (self, g_value_get_string (value));

                 break;

         case PROP_SESSION_ID:

                 _gdm_display_set_session_id (self, g_value_get_string (value));

                 break;

         case PROP_SESSION_CLASS:

                 _gdm_display_set_session_class (self, g_value_get_string (value));

                 break;

         case PROP_SESSION_TYPE:

                 _gdm_display_set_session_type (self, g_value_get_string (value));

                 break;

         case PROP_REMOTE_HOSTNAME:

                 _gdm_display_set_remote_hostname (self, g_value_get_string (value));

                 break;

         case PROP_X11_DISPLAY_NUMBER:

                 _gdm_display_set_x11_display_number (self, g_value_get_int (value));

                 break;

         case PROP_X11_DISPLAY_NAME:

                 _gdm_display_set_x11_display_name (self, g_value_get_string (value));

                 break;

         case PROP_X11_COOKIE:

                 _gdm_display_set_x11_cookie (self, g_value_get_string (value));

                 break;

         case PROP_IS_LOCAL:

                 _gdm_display_set_is_local (self, g_value_get_boolean (value));

                 break;

         case PROP_ALLOW_TIMED_LOGIN:

                 _gdm_display_set_allow_timed_login (self, g_value_get_boolean (value));

                 break;

         case PROP_LAUNCH_ENVIRONMENT:

                 _gdm_display_set_launch_environment (self, g_value_get_object (value));

                 break;

         case PROP_IS_INITIAL:

                 _gdm_display_set_is_initial (self, g_value_get_boolean (value));

                 break;

         case PROP_SESSION_REGISTERED:

                 _gdm_display_set_session_registered (self, g_value_get_boolean (value));

                 break;

+        case PROP_SUPPORTED_SESSION_TYPES:

+                _gdm_display_set_supported_session_types (self, g_value_get_boxed (value));

+                break;

         default:

                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

                 break;

         }

 }

 static void

 gdm_display_get_property (GObject        *object,

                           guint           prop_id,

                           GValue         *value,

                           GParamSpec     *pspec)

 {

         GdmDisplay *self;

         GdmDisplayPrivate *priv;

         self = GDM_DISPLAY (object);

         priv = gdm_display_get_instance_private (self);

         switch (prop_id) {

         case PROP_ID:

                 g_value_set_string (value, priv->id);

                 break;

         case PROP_STATUS:

                 g_value_set_int (value, priv->status);

                 break;

         case PROP_SEAT_ID:

                 g_value_set_string (value, priv->seat_id);

                 break;

         case PROP_SESSION_ID:

                 g_value_set_string (value, priv->session_id);

@@ -1019,60 +1042,63 @@ gdm_display_get_property (GObject        *object,

                 break;

         case PROP_X11_AUTHORITY_FILE:

                 g_value_take_string (value,

                                      priv->access_file?

                                      gdm_display_access_file_get_path (priv->access_file) : NULL);

                 break;

         case PROP_IS_LOCAL:

                 g_value_set_boolean (value, priv->is_local);

                 break;

         case PROP_IS_CONNECTED:

                 g_value_set_boolean (value, priv->xcb_connection != NULL);

                 break;

         case PROP_LAUNCH_ENVIRONMENT:

                 g_value_set_object (value, priv->launch_environment);

                 break;

         case PROP_IS_INITIAL:

                 g_value_set_boolean (value, priv->is_initial);

                 break;

         case PROP_HAVE_EXISTING_USER_ACCOUNTS:

                 g_value_set_boolean (value, priv->have_existing_user_accounts);

                 break;

         case PROP_DOING_INITIAL_SETUP:

                 g_value_set_boolean (value, priv->doing_initial_setup);

                 break;

         case PROP_SESSION_REGISTERED:

                 g_value_set_boolean (value, priv->session_registered);

                 break;

         case PROP_ALLOW_TIMED_LOGIN:

                 g_value_set_boolean (value, priv->allow_timed_login);

                 break;

+        case PROP_SUPPORTED_SESSION_TYPES:

+                g_value_set_boxed (value, priv->supported_session_types);

+                break;

         default:

                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

                 break;

         }

 }

 static gboolean

 handle_get_id (GdmDBusDisplay        *skeleton,

                GDBusMethodInvocation *invocation,

                GdmDisplay            *self)

 {

         char *id;

         gdm_display_get_id (self, &id, NULL);

         gdm_dbus_display_complete_get_id (skeleton, invocation, id);

         g_free (id);

         return TRUE;

 }

 static gboolean

 handle_get_remote_hostname (GdmDBusDisplay        *skeleton,

                             GDBusMethodInvocation *invocation,

                             GdmDisplay            *self)

 {

         char *hostname;

         gdm_display_get_remote_hostname (self, &hostname, NULL);

@@ -1204,60 +1230,61 @@ gdm_display_constructor (GType                  type,

         priv = gdm_display_get_instance_private (self);

         g_free (priv->id);

         priv->id = g_strdup_printf ("/org/gnome/DisplayManager/Displays/%lu",

                                           (gulong) self);

         res = register_display (self);

         if (! res) {

                 g_warning ("Unable to register display with system bus");

         }

         return G_OBJECT (self);

 }

 static void

 gdm_display_dispose (GObject *object)

 {

         GdmDisplay *self;

         GdmDisplayPrivate *priv;

         self = GDM_DISPLAY (object);

         priv = gdm_display_get_instance_private (self);

         g_debug ("GdmDisplay: Disposing display");

         if (priv->finish_idle_id != 0) {

                 g_source_remove (priv->finish_idle_id);

                 priv->finish_idle_id = 0;

         }

         g_clear_object (&priv->launch_environment);

+        g_clear_pointer (&priv->supported_session_types, g_strfreev);

         g_warn_if_fail (priv->status != GDM_DISPLAY_MANAGED);

         g_warn_if_fail (priv->user_access_file == NULL);

         g_warn_if_fail (priv->access_file == NULL);

         G_OBJECT_CLASS (gdm_display_parent_class)->dispose (object);

 }

 static void

 gdm_display_class_init (GdmDisplayClass *klass)

 {

         GObjectClass   *object_class = G_OBJECT_CLASS (klass);

         object_class->get_property = gdm_display_get_property;

         object_class->set_property = gdm_display_set_property;

         object_class->constructor = gdm_display_constructor;

         object_class->dispose = gdm_display_dispose;

         object_class->finalize = gdm_display_finalize;

         klass->prepare = gdm_display_real_prepare;

         g_object_class_install_property (object_class,

                                          PROP_ID,

                                          g_param_spec_string ("id",

                                                               "id",

                                                               "id",

                                                               NULL,

                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

         g_object_class_install_property (object_class,

                                          PROP_REMOTE_HOSTNAME,

@@ -1364,60 +1391,68 @@ gdm_display_class_init (GdmDisplayClass *klass)

                                          PROP_DOING_INITIAL_SETUP,

                                          g_param_spec_boolean ("doing-initial-setup",

                                                                NULL,

                                                                NULL,

                                                                FALSE,

                                                                G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

         g_object_class_install_property (object_class,

                                          PROP_SESSION_REGISTERED,

                                          g_param_spec_boolean ("session-registered",

                                                                NULL,

                                                                NULL,

                                                                FALSE,

                                                                G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

         g_object_class_install_property (object_class,

                                          PROP_LAUNCH_ENVIRONMENT,

                                          g_param_spec_object ("launch-environment",

                                                               NULL,

                                                               NULL,

                                                               GDM_TYPE_LAUNCH_ENVIRONMENT,

                                                               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

         g_object_class_install_property (object_class,

                                          PROP_STATUS,

                                          g_param_spec_int ("status",

                                                            "status",

                                                            "status",

                                                            -1,

                                                            G_MAXINT,

                                                            GDM_DISPLAY_UNMANAGED,

                                                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

+

+        g_object_class_install_property (object_class,

+                                         PROP_SUPPORTED_SESSION_TYPES,

+                                         g_param_spec_boxed ("supported-session-types",

+                                                             "supported session types",

+                                                             "supported session types",

+                                                             G_TYPE_STRV,

+                                                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

 }

 static void

 gdm_display_init (GdmDisplay *self)

 {

         GdmDisplayPrivate *priv;

         priv = gdm_display_get_instance_private (self);

         priv->creation_time = time (NULL);

 }

 static void

 gdm_display_finalize (GObject *object)

 {

         GdmDisplay *self;

         GdmDisplayPrivate *priv;

         g_return_if_fail (object != NULL);

         g_return_if_fail (GDM_IS_DISPLAY (object));

         self = GDM_DISPLAY (object);

         priv = gdm_display_get_instance_private (self);

         g_return_if_fail (priv != NULL);

         g_debug ("GdmDisplay: Finalizing display: %s", priv->id);

         g_free (priv->id);

         g_free (priv->seat_id);

         g_free (priv->session_class);

@@ -1696,60 +1731,61 @@ gdm_display_start_greeter_session (GdmDisplay *self)

                                  G_CALLBACK (on_launch_environment_session_opened),

                                  self, 0);

         g_signal_connect_object (priv->launch_environment,

                                  "started",

                                  G_CALLBACK (on_launch_environment_session_started),

                                  self, 0);

         g_signal_connect_object (priv->launch_environment,

                                  "stopped",

                                  G_CALLBACK (on_launch_environment_session_stopped),

                                  self, 0);

         g_signal_connect_object (priv->launch_environment,

                                  "exited",

                                  G_CALLBACK (on_launch_environment_session_exited),

                                  self, 0);

         g_signal_connect_object (priv->launch_environment,

                                  "died",

                                  G_CALLBACK (on_launch_environment_session_died),

                                  self, 0);

         if (auth_file != NULL) {

                 g_object_set (priv->launch_environment,

                               "x11-authority-file", auth_file,

                               NULL);

         }

         gdm_launch_environment_start (priv->launch_environment);

         session = gdm_launch_environment_get_session (priv->launch_environment);

         g_object_set (G_OBJECT (session),

                       "display-is-initial", priv->is_initial,

+                      "supported-session-types", priv->supported_session_types,

                       NULL);

         g_free (display_name);

         g_free (seat_id);

         g_free (hostname);

         g_free (auth_file);

 }

 void

 gdm_display_stop_greeter_session (GdmDisplay *self)

 {

         GdmDisplayPrivate *priv;

         priv = gdm_display_get_instance_private (self);

         if (priv->launch_environment != NULL) {

                 g_signal_handlers_disconnect_by_func (priv->launch_environment,

                                                       G_CALLBACK (on_launch_environment_session_opened),

                                                       self);

                 g_signal_handlers_disconnect_by_func (priv->launch_environment,

                                                       G_CALLBACK (on_launch_environment_session_started),

                                                       self);

                 g_signal_handlers_disconnect_by_func (priv->launch_environment,

                                                       G_CALLBACK (on_launch_environment_session_stopped),

                                                       self);

                 g_signal_handlers_disconnect_by_func (priv->launch_environment,

                                                       G_CALLBACK (on_launch_environment_session_exited),

                                                       self);

                 g_signal_handlers_disconnect_by_func (priv->launch_environment,

diff --git a/daemon/gdm-launch-environment.c b/daemon/gdm-launch-environment.c

index feccf057f..5044290cd 100644

--- a/daemon/gdm-launch-environment.c

+++ b/daemon/gdm-launch-environment.c

@@ -117,60 +117,61 @@ static GHashTable *

 build_launch_environment (GdmLaunchEnvironment *launch_environment,

                           gboolean              start_session)

 {

         GHashTable    *hash;

         struct passwd *pwent;

         static const char *const optional_environment[] = {

                 "GI_TYPELIB_PATH",

                 "LANG",

                 "LANGUAGE",

                 "LC_ADDRESS",

                 "LC_ALL",

                 "LC_COLLATE",

                 "LC_CTYPE",

                 "LC_IDENTIFICATION",

                 "LC_MEASUREMENT",

                 "LC_MESSAGES",

                 "LC_MONETARY",

                 "LC_NAME",

                 "LC_NUMERIC",

                 "LC_PAPER",

                 "LC_TELEPHONE",

                 "LC_TIME",

                 "LD_LIBRARY_PATH",

                 "PATH",

                 "WINDOWPATH",

                 "XCURSOR_PATH",

                 "XDG_CONFIG_DIRS",

                 NULL

         };

         char *system_data_dirs;

+        g_auto (GStrv) supported_session_types = NULL;

         int i;

         /* create a hash table of current environment, then update keys has necessary */

         hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);

         for (i = 0; optional_environment[i] != NULL; i++) {

                 if (g_getenv (optional_environment[i]) == NULL) {

                         continue;

                 }

                 g_hash_table_insert (hash,

                                      g_strdup (optional_environment[i]),

                                      g_strdup (g_getenv (optional_environment[i])));

         }

         system_data_dirs = g_strjoinv (":", (char **) g_get_system_data_dirs ());

         g_hash_table_insert (hash,

                              g_strdup ("XDG_DATA_DIRS"),

                              g_strdup_printf ("%s:%s",

                                               DATADIR "/gdm/greeter",

                                               system_data_dirs));

         g_free (system_data_dirs);

         if (launch_environment->priv->x11_authority_file != NULL)

                 g_hash_table_insert (hash, g_strdup ("XAUTHORITY"), g_strdup (launch_environment->priv->x11_authority_file));

         if (launch_environment->priv->session_mode != NULL) {

                 g_hash_table_insert (hash, g_strdup ("GNOME_SHELL_SESSION_MODE"), g_strdup (launch_environment->priv->session_mode));

@@ -191,60 +192,68 @@ build_launch_environment (GdmLaunchEnvironment *launch_environment,

         g_hash_table_insert (hash, g_strdup ("USER"), g_strdup (launch_environment->priv->user_name));

         g_hash_table_insert (hash, g_strdup ("USERNAME"), g_strdup (launch_environment->priv->user_name));

         g_hash_table_insert (hash, g_strdup ("GDM_VERSION"), g_strdup (VERSION));

         g_hash_table_remove (hash, "MAIL");

         g_hash_table_insert (hash, g_strdup ("HOME"), g_strdup ("/"));

         g_hash_table_insert (hash, g_strdup ("PWD"), g_strdup ("/"));

         g_hash_table_insert (hash, g_strdup ("SHELL"), g_strdup ("/bin/sh"));

         gdm_get_pwent_for_name (launch_environment->priv->user_name, &pwent);

         if (pwent != NULL) {

                 if (pwent->pw_dir != NULL && pwent->pw_dir[0] != '\0') {

                         g_hash_table_insert (hash, g_strdup ("HOME"), g_strdup (pwent->pw_dir));

                         g_hash_table_insert (hash, g_strdup ("PWD"), g_strdup (pwent->pw_dir));

                 }

                 g_hash_table_insert (hash, g_strdup ("SHELL"), g_strdup (pwent->pw_shell));

         }

         if (start_session && launch_environment->priv->x11_display_seat_id != NULL) {

                 char *seat_id;

                 seat_id = launch_environment->priv->x11_display_seat_id;

                 g_hash_table_insert (hash, g_strdup ("GDM_SEAT_ID"), g_strdup (seat_id));

         }

         g_hash_table_insert (hash, g_strdup ("RUNNING_UNDER_GDM"), g_strdup ("true"));

+        g_object_get (launch_environment->priv->session,

+                      "supported-session-types",

+                      &supported_session_types,

+                      NULL);

+        g_hash_table_insert (hash,

+                             g_strdup ("GDM_SUPPORTED_SESSION_TYPES"),

+                             g_strjoinv (":", supported_session_types));

+

         return hash;

 }

 static void

 on_session_setup_complete (GdmSession        *session,

                            const char        *service_name,

                            GdmLaunchEnvironment *launch_environment)

 {

         GHashTable       *hash;

         GHashTableIter    iter;

         gpointer          key, value;

         hash = build_launch_environment (launch_environment, TRUE);

         g_hash_table_iter_init (&iter, hash);

         while (g_hash_table_iter_next (&iter, &key, &value)) {

                 gdm_session_set_environment_variable (launch_environment->priv->session, key, value);

         }

         g_hash_table_destroy (hash);

 }

 static void

 on_session_opened (GdmSession           *session,

                    const char           *service_name,

                    const char           *session_id,

                    GdmLaunchEnvironment *launch_environment)

 {

         launch_environment->priv->session_id = g_strdup (session_id);

         g_signal_emit (G_OBJECT (launch_environment), signals [OPENED], 0);