main.c 22.1 KB
Newer Older
1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
2
3
 *
 * Copyright (C) 2006 Novell, Inc.
William Jon McCann's avatar
William Jon McCann committed
4
 * Copyright (C) 2008 Red Hat, Inc.
5
6
7
8
9
10
11
12
13
14
15
16
 *
 * 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 of the
 * License, 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18
 */
19
20
21

#include <config.h>

22
#include <libintl.h>
Tom Tromey's avatar
Tom Tromey committed
23
#include <signal.h>
24
#include <stdlib.h>
25
#include <string.h>
Ray Strode's avatar
Ray Strode committed
26
#include <locale.h>
27
28
#include <unistd.h>
#include <errno.h>
29
#include <sys/stat.h>
30

31
#include <glib/gi18n.h>
32
#include <glib.h>
33
#include <glib/gstdio.h>
34
#include <glib-unix.h>
Cosimo Cecchi's avatar
Cosimo Cecchi committed
35
#include <gio/gio.h>
36

37
#include "gdm-log.h"
38

Matthias Clasen's avatar
Matthias Clasen committed
39
#include "gsm-util.h"
40
#include "gsm-manager.h"
41
#include "gsm-session-fill.h"
42
#include "gsm-store.h"
43
#include "gsm-system.h"
44
#include "gsm-fail-whale.h"
45

46
#ifdef ENABLE_SYSTEMD_JOURNAL
47
48
49
#include <systemd/sd-journal.h>
#endif

50
51
#define GSM_DBUS_NAME "org.gnome.SessionManager"

Benjamin Berg's avatar
Benjamin Berg committed
52
53
static gboolean systemd_service = FALSE;
static gboolean use_systemd = USE_SYSTEMD_SESSION;
54
55
static gboolean failsafe = FALSE;
static gboolean show_version = FALSE;
56
static gboolean debug = FALSE;
57
static gboolean please_fail = FALSE;
58
static gboolean disable_acceleration_check = FALSE;
Cosimo Cecchi's avatar
Cosimo Cecchi committed
59
60
static const char *session_name = NULL;
static GsmManager *manager = NULL;
61
static char *gl_renderer = NULL;
62

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
static GMainLoop *loop;

void
gsm_quit (void)
{
        g_main_loop_quit (loop);
}

static void
gsm_main (void)
{
        if (loop == NULL)
                loop = g_main_loop_new (NULL, TRUE);

        g_main_loop_run (loop);
}

80
static void
Cosimo Cecchi's avatar
Cosimo Cecchi committed
81
82
83
on_name_lost (GDBusConnection *connection,
              const char *name,
              gpointer    data)
84
85
{
        if (connection == NULL) {
Cosimo Cecchi's avatar
Cosimo Cecchi committed
86
87
88
89
                g_warning ("Lost name on bus: %s", name);
                gsm_fail_whale_dialog_we_failed (TRUE, TRUE, NULL);
        } else {
                g_debug ("Calling name lost callback function");
90

Cosimo Cecchi's avatar
Cosimo Cecchi committed
91
92
93
94
95
96
97
                /*
                 * When the signal handler gets a shutdown signal, it calls
                 * this function to inform GsmManager to not restart
                 * applications in the off chance a handler is already queued
                 * to dispatch following the below call to gtk_main_quit.
                 */
                gsm_manager_set_phase (manager, GSM_MANAGER_PHASE_EXIT);
98

Cosimo Cecchi's avatar
Cosimo Cecchi committed
99
                gsm_quit ();
100
        }
101
102
}

103
static gboolean
104
term_or_int_signal_cb (gpointer data)
105
{
106
        g_autoptr(GError) error = NULL;
107
        GsmManager *manager = (GsmManager *)data;
108

109
110
        /* let the fatal signals interrupt us */
        g_debug ("Caught SIGINT/SIGTERM, shutting down normally.");
111

112
113
114
115
116
        if (!gsm_manager_logout (manager, GSM_MANAGER_LOGOUT_MODE_FORCE, &error)) {
                if (g_error_matches (error, GSM_MANAGER_ERROR, GSM_MANAGER_ERROR_NOT_IN_RUNNING)) {
                    gsm_quit ();
                    return FALSE;
                }
117
118
119

                g_critical ("Failed to log out: %s", error->message);
        }
120

121
122
        return FALSE;
}
123

124
125
126
127
128
129
130
static gboolean
sigusr2_cb (gpointer data)
{
        g_debug ("-------- MARK --------");
        return TRUE;
}

131
132
133
134
135
static gboolean
sigusr1_cb (gpointer data)
{
        gdm_log_toggle_debug ();
        return TRUE;
136
137
}

138
139
140
141
142
143
144
145
static void
on_name_acquired (GDBusConnection *connection,
                  const char *name,
                  gpointer data)
{
        gsm_manager_start (manager);
}

146
static void
Cosimo Cecchi's avatar
Cosimo Cecchi committed
147
create_manager (void)
148
{
Cosimo Cecchi's avatar
Cosimo Cecchi committed
149
        GsmStore *client_store;
150

Cosimo Cecchi's avatar
Cosimo Cecchi committed
151
        client_store = gsm_store_new ();
Benjamin Berg's avatar
Benjamin Berg committed
152
        manager = gsm_manager_new (client_store, failsafe, systemd_service);
Cosimo Cecchi's avatar
Cosimo Cecchi committed
153
154
155
156
157
158
159
160
161
162
163
164
165
166
        g_object_unref (client_store);

        g_unix_signal_add (SIGTERM, term_or_int_signal_cb, manager);
        g_unix_signal_add (SIGINT, term_or_int_signal_cb, manager);
        g_unix_signal_add (SIGUSR1, sigusr1_cb, manager);
        g_unix_signal_add (SIGUSR2, sigusr2_cb, manager);

        if (IS_STRING_EMPTY (session_name)) {
                session_name = _gsm_manager_get_default_session (manager);
        }

        if (!gsm_session_fill (manager, session_name)) {
                gsm_fail_whale_dialog_we_failed (FALSE, TRUE, NULL);
        }
167

168
        _gsm_manager_set_renderer (manager, gl_renderer);
Cosimo Cecchi's avatar
Cosimo Cecchi committed
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
}

static void
on_bus_acquired (GDBusConnection *connection,
                 const char *name,
                 gpointer data)
{
        create_manager ();
}

static guint
acquire_name (void)
{
        return g_bus_own_name (G_BUS_TYPE_SESSION,
                               GSM_DBUS_NAME,
                               G_BUS_NAME_OWNER_FLAGS_NONE,
                               on_bus_acquired,
186
                               on_name_acquired,
Cosimo Cecchi's avatar
Cosimo Cecchi committed
187
188
                               on_name_lost,
                               NULL, NULL);
189
190
}

191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
static gboolean
require_dbus_session (int      argc,
                      char   **argv,
                      GError **error)
{
        char **new_argv;
        int    i;

        if (g_getenv ("DBUS_SESSION_BUS_ADDRESS"))
                return TRUE;

        /* Just a sanity check to prevent infinite recursion if
         * dbus-launch fails to set DBUS_SESSION_BUS_ADDRESS 
         */
        g_return_val_if_fail (!g_str_has_prefix (argv[0], "dbus-launch"),
                              TRUE);

        /* +2 for our new arguments, +1 for NULL */
209
        new_argv = g_malloc ((argc + 3) * sizeof (*argv));
210

211
212
        new_argv[0] = "dbus-launch";
        new_argv[1] = "--exit-with-session";
213
        for (i = 0; i < argc; i++) {
214
                new_argv[i + 2] = argv[i];
Ray Strode's avatar
Ray Strode committed
215
        }
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
        new_argv[i + 2] = NULL;
        
        if (!execvp ("dbus-launch", new_argv)) {
                g_set_error (error, 
                             G_SPAWN_ERROR,
                             G_SPAWN_ERROR_FAILED,
                             "No session bus and could not exec dbus-launch: %s",
                             g_strerror (errno));
                return FALSE;
        }

        /* Should not be reached */
        return TRUE;
}

231
232
233
234
235
236
static gboolean
check_gl (GError **error)
{
        int status;
        char *argv[] = { LIBEXECDIR "/gnome-session-check-accelerated", NULL };

237
238
239
240
241
        if (getenv ("DISPLAY") == NULL) {
                /* Not connected to X11, someone else will take care of checking GL */
                return TRUE;
        }

242
        if (!g_spawn_sync (NULL, (char **) argv, NULL, 0, NULL, NULL, &gl_renderer, NULL,
243
244
245
246
                           &status, error)) {
                return FALSE;
        }

247
248
249
#if GLIB_CHECK_VERSION(2, 70, 0)
        return g_spawn_check_wait_status (status, error);
#else
250
        return g_spawn_check_exit_status (status, error);
251
#endif
252
253
}

254
255
256
257
258
259
260
static void
initialize_gio (void)
{
        char *disable_fuse = NULL;
        char *use_vfs = NULL;

        disable_fuse = g_strdup (g_getenv ("GVFS_DISABLE_FUSE"));
Ray Strode's avatar
Ray Strode committed
261
        use_vfs = g_strdup (g_getenv ("GIO_USE_VFS"));
262
263
264
265
266
267
268
269
270
271
272
273
274

        g_setenv ("GVFS_DISABLE_FUSE", "1", TRUE);
        g_setenv ("GIO_USE_VFS", "local", TRUE);
        g_vfs_get_default ();

        if (use_vfs) {
                g_setenv ("GIO_USE_VFS", use_vfs, TRUE);
                g_free (use_vfs);
        } else {
                g_unsetenv ("GIO_USE_VFS");
        }

        if (disable_fuse) {
275
                g_setenv ("GVFS_DISABLE_FUSE", disable_fuse, TRUE);
276
277
278
279
280
281
                g_free (disable_fuse);
        } else {
                g_unsetenv ("GVFS_DISABLE_FUSE");
        }
}

282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
#ifdef ENABLE_SYSTEMD_SESSION
static gboolean
leader_term_or_int_signal_cb (gpointer data)
{
        gint fifo_fd = GPOINTER_TO_INT (data);

        /* Start a shutdown explicitly. */
        gsm_util_start_systemd_unit ("gnome-session-shutdown.target", "replace-irreversibly", NULL);

        if (fifo_fd >= 0) {
                int res;

                /* If we have a fifo, try to signal the other side. */
                res = write (fifo_fd, "S", 1);
                if (res < 0) {
                        g_warning ("Error signaling shutdown to monitoring process: %m");
                        gsm_quit ();
                }
        } else {
                /* Otherwise quit immediately as we cannot wait on systemd */
                gsm_quit ();
        }

        return G_SOURCE_REMOVE;
}

/**
 * systemd_leader_run:
 *
 * This is the session leader when running under systemd, i.e. it is the only
 * process that is *not* managed by the systemd user instance, this process
 * is the one executed by the GDM helpers and is part of the session scope in
 * the system systemd instance.
 *
 * This process works together with a service running in the user systemd
 * instance (currently gnome-session-ctl@monitor.service):
 *
 * - It needs to signal shutdown to the user session when receiving SIGTERM
 *
 * - It needs to quit just after the user session is done
 *
 * - The monitor instance needs to know if this process was killed
 *
 * All this is achieved by opening a named fifo in a well known location.
 * If this process receives SIGTERM or SIGINT then it will write a single byte
 * causing the monitor service to signal STOPPING=1 to systemd, triggering a
 * clean shutdown, solving the first item. The other two items are solved by
 * waiting for EOF/HUP on both sides and quitting immediately when receiving
 * that signal.
 *
 * As an example, a shutdown might look as follows:
 *
 * - session-X.scope for user is stopped
 * - Leader process receive SIGTERM
 * - Leader sends single byte
 * - Monitor process receives byte and signals STOPPING=1
 * - Systemd user instance starts session teardown
 * - Session is torn down, last job run is stopping monitor process (SIGTERM)
 * - Monitor process quits, closing FD in the process
 * - Leader process receives HUP and quits
 * - GDM shuts down its processes in the users scope
 *
 * The result is that the session is stopped cleanly.
 */
static void
systemd_leader_run(void)
{
        g_autofree char *fifo_name = NULL;
        int res;
        int fifo_fd;

        fifo_name = g_strdup_printf ("%s/gnome-session-leader-fifo",
                                     g_get_user_runtime_dir ());
        res = mkfifo (fifo_name, 0666);
356
        if (res < 0 && errno != EEXIST)
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
                g_warning ("Error creating FIFO: %m");

        fifo_fd = g_open (fifo_name, O_WRONLY | O_CLOEXEC, 0666);
        if (fifo_fd >= 0) {
                struct stat buf;

                res = fstat (fifo_fd, &buf);
                if (res < 0) {
                        g_warning ("Unable to watch systemd session: fstat failed with %m");
                        close (fifo_fd);
                        fifo_fd = -1;
                } else if (!(buf.st_mode & S_IFIFO)) {
                        g_warning ("Unable to watch systemd session: FD is not a FIFO");
                        close (fifo_fd);
                        fifo_fd = -1;
                } else {
                        g_unix_fd_add (fifo_fd, G_IO_HUP, (GUnixFDSourceFunc) gsm_quit, NULL);
                }
        } else {
                g_warning ("Unable to watch systemd session: Opening FIFO failed with %m");
        }

        g_unix_signal_add (SIGTERM, leader_term_or_int_signal_cb, GINT_TO_POINTER (fifo_fd));
        g_unix_signal_add (SIGINT, leader_term_or_int_signal_cb, GINT_TO_POINTER (fifo_fd));

        /* Sleep until we receive HUP or are killed. */
        gsm_main ();
        exit(0);
}
#endif /* ENABLE_SYSTEMD_SESSION */

388
int
389
main (int argc, char **argv)
390
{
391
        GError           *error = NULL;
392
        static char     **override_autostart_dirs = NULL;
Colin Walters's avatar
Colin Walters committed
393
        static char      *opt_session_name = NULL;
394
        const char       *debug_string = NULL;
395
396
        const char       *env_override_autostart_dirs = NULL;
        g_auto(GStrv)     env_override_autostart_dirs_v = NULL;
397
        gboolean          gl_failed = FALSE;
Cosimo Cecchi's avatar
Cosimo Cecchi committed
398
        guint             name_owner_id;
399
        GOptionContext   *options;
400
        static GOptionEntry entries[] = {
Benjamin Berg's avatar
Benjamin Berg committed
401
402
403
404
405
#ifdef ENABLE_SYSTEMD_SESSION
                { "systemd-service", 0, 0, G_OPTION_ARG_NONE, &systemd_service, N_("Running as systemd service"), NULL },
                { "systemd", 0, 0, G_OPTION_ARG_NONE, &use_systemd, N_("Use systemd session management"), NULL },
#endif
                { "builtin", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &use_systemd, N_("Use builtin session management (rather than the systemd based one)"), NULL },
406
                { "autostart", 'a', 0, G_OPTION_ARG_STRING_ARRAY, &override_autostart_dirs, N_("Override standard autostart directories"), N_("AUTOSTART_DIR") },
Colin Walters's avatar
Colin Walters committed
407
                { "session", 0, 0, G_OPTION_ARG_STRING, &opt_session_name, N_("Session to use"), N_("SESSION_NAME") },
408
409
410
                { "debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable debugging code"), NULL },
                { "failsafe", 'f', 0, G_OPTION_ARG_NONE, &failsafe, N_("Do not load user-specified applications"), NULL },
                { "version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Version of this application"), NULL },
Matthias Clasen's avatar
Matthias Clasen committed
411
                /* Translators: the 'fail whale' is the black dialog we show when something goes seriously wrong */
412
                { "whale", 0, 0, G_OPTION_ARG_NONE, &please_fail, N_("Show the fail whale dialog for testing"), NULL },
413
                { "disable-acceleration-check", 0, 0, G_OPTION_ARG_NONE, &disable_acceleration_check, N_("Disable hardware acceleration check"), NULL },
414
415
                { NULL, 0, 0, 0, NULL, NULL, NULL }
        };
416

417
418
419
420
421
        /* Make sure that we have a session bus */
        if (!require_dbus_session (argc, argv, &error)) {
                gsm_util_init_error (TRUE, "%s", error->message);
        }

422
423
424
425
426
427
428
429
430
        /* From 3.14 GDM sets XDG_CURRENT_DESKTOP. For compatibility with
         * older versions of GDM,  other display managers, and startx,
         * set a fallback value if we don't find it set.
         */
        if (g_getenv ("XDG_CURRENT_DESKTOP") == NULL) {
            g_setenv("XDG_CURRENT_DESKTOP", "GNOME", TRUE);
            gsm_util_setenv ("XDG_CURRENT_DESKTOP", "GNOME");
        }

431
432
433
        /* Make sure we initialize gio in a way that does not autostart any daemon */
        initialize_gio ();

434
        setlocale (LC_ALL, "");
435
436
437
438
        bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
        bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
        textdomain (GETTEXT_PACKAGE);

439
440
        debug_string = g_getenv ("GNOME_SESSION_DEBUG");
        if (debug_string != NULL) {
Antoine Jacoutot's avatar
Antoine Jacoutot committed
441
                debug = atoi (debug_string) == 1;
442
443
        }

444
        error = NULL;
445
        options = g_option_context_new (_(" — the GNOME session manager"));
446
447
        g_option_context_add_main_entries (options, entries, GETTEXT_PACKAGE);
        g_option_context_parse (options, &argc, &argv, &error);
448
        if (error != NULL) {
449
450
451
452
                g_warning ("%s", error->message);
                exit (1);
        }

453
454
        g_option_context_free (options);

455
456
457
458
        /* Rebind stdout/stderr to the journal explicitly, so that
         * journald picks ups the nicer "gnome-session" as the program
         * name instead of whatever shell script GDM happened to use.
         */
459
#ifdef ENABLE_SYSTEMD_JOURNAL
460
461
462
463
464
465
466
467
468
469
470
        if (!debug) {
                int journalfd;

                journalfd = sd_journal_stream_fd (PACKAGE, LOG_INFO, 0);
                if (journalfd >= 0) {
                        dup2(journalfd, 1);
                        dup2(journalfd, 2);
                }
        }
#endif

471
472
473
        gdm_log_init ();
        gdm_log_set_debug (debug);

Benjamin Berg's avatar
Benjamin Berg committed
474
475
476
477
478
479
        if (systemd_service) {
                /* XXX: This is an optimization, but we actually need to do
                 *      it right now as the DISPLAY environment might leak
                 *      into the new session from an old run. */
                g_debug ("hardware acceleration already done if needed");
        } else if (disable_acceleration_check) {
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
                g_debug ("hardware acceleration check is disabled");
        } else {
                /* Check GL, if it doesn't work out then force software fallback */
                if (!check_gl (&error)) {
                        gl_failed = TRUE;

                        g_debug ("hardware acceleration check failed: %s",
                                 error? error->message : "");
                        g_clear_error (&error);
                        if (g_getenv ("LIBGL_ALWAYS_SOFTWARE") == NULL) {
                                g_setenv ("LIBGL_ALWAYS_SOFTWARE", "1", TRUE);
                                if (!check_gl (&error)) {
                                        g_warning ("software acceleration check failed: %s",
                                                   error? error->message : "");
                                        g_clear_error (&error);
                                } else {
                                        gl_failed = FALSE;
                                }
                        }
                }
        }

        if (show_version) {
                g_print ("%s %s\n", argv [0], VERSION);
                exit (0);
        }

507
508
        if (gl_failed) {
                gsm_fail_whale_dialog_we_failed (FALSE, TRUE, NULL);
509
                gsm_main ();
510
511
512
                exit (1);
        }

513
        if (please_fail) {
514
                gsm_fail_whale_dialog_we_failed (TRUE, TRUE, NULL);
515
                gsm_main ();
516
517
518
                exit (1);
        }

519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
        env_override_autostart_dirs = g_getenv ("GNOME_SESSION_AUTOSTART_DIR");

        if (env_override_autostart_dirs != NULL && env_override_autostart_dirs[0] != '\0') {
                env_override_autostart_dirs_v = g_strsplit (env_override_autostart_dirs, ":", 0);
                gsm_util_set_autostart_dirs (env_override_autostart_dirs_v);
        } else {
                gsm_util_set_autostart_dirs (override_autostart_dirs);

                /* Export the override autostart dirs parameter to the environment
                 * in case we are running on systemd. */
                if (override_autostart_dirs) {
                        g_autofree char *autostart_dirs = NULL;
                        autostart_dirs = g_strjoinv (":", override_autostart_dirs);
                        g_setenv ("GNOME_SESSION_AUTOSTART_DIR", autostart_dirs, TRUE);
                }
        }

536
537
538
539
540
        gsm_util_export_activation_environment (&error);
        if (error) {
                g_warning ("Failed to upload environment to DBus: %s", error->message);
                g_clear_error (&error);
        }
541

Benjamin Berg's avatar
Benjamin Berg committed
542
543
        session_name = opt_session_name;

544
#ifdef HAVE_SYSTEMD
545
        gsm_util_export_user_environment (&error);
546
        if (error && !g_getenv ("RUNNING_UNDER_GDM")) {
547
548
549
                g_warning ("Failed to upload environment to systemd: %s", error->message);
                g_clear_error (&error);
        }
550
551
#endif

Benjamin Berg's avatar
Benjamin Berg committed
552
553
554
555
556
557
558
559
560
561
562
563
564
#ifdef ENABLE_SYSTEMD_SESSION
        if (use_systemd && !systemd_service) {
                g_autofree gchar *gnome_session_target;
                const gchar *session_type;

                session_type = g_getenv ("XDG_SESSION_TYPE");

                /* We really need to resolve the session name at this point,
                 * which requires talking to GSettings internally. */
                if (IS_STRING_EMPTY (session_name)) {
                        session_name = _gsm_manager_get_default_session (NULL);
                }

565
566
567
568
569
                /* Reset all failed units; we are going to start a lof ot things and
                 * really do not want to run into errors because units have failed
                 * in a previous session
                 */
                gsm_util_systemd_reset_failed (&error);
570
                if (error && !g_getenv ("RUNNING_UNDER_GDM")) {
571
572
573
574
                        g_warning ("Failed to reset failed state of units: %s", error->message);
                        g_clear_error (&error);
                }

Benjamin Berg's avatar
Benjamin Berg committed
575
576
577
578
579
580
581
582
583
                /* We don't escape the name (i.e. we leave any '-' intact). */
                gnome_session_target = g_strdup_printf ("gnome-session-%s@%s.target", session_type, session_name);
                if (gsm_util_start_systemd_unit (gnome_session_target, "fail", &error)) {
                        /* We started the unit, open fifo and sleep forever. */
                        systemd_leader_run ();
                        exit(0);
                }

                /* We could not start the unit, fall back. */
584
585
586
587
588
                if (g_getenv ("RUNNING_UNDER_GDM"))
                        g_message ("Falling back to non-systemd startup procedure. This is expected to happen for GDM sessions.");
                else
                        g_warning ("Falling back to non-systemd startup procedure due to error: %s", error->message);
                g_clear_error (&error);
Benjamin Berg's avatar
Benjamin Berg committed
589
590
591
        }
#endif /* ENABLE_SYSTEMD_SESSION */

592
593
594
595
596
597
        {
                gchar *ibus_path;

                ibus_path = g_find_program_in_path("ibus-daemon");

                if (ibus_path) {
598
599
600
601
602
603
604
605
606
                        const gchar *p;
                        p = g_getenv ("QT_IM_MODULE");
                        if (!p || !*p)
                                p = "ibus";
                        gsm_util_setenv ("QT_IM_MODULE", p);
                        p = g_getenv ("XMODIFIERS");
                        if (!p || !*p)
                                p = "@im=ibus";
                        gsm_util_setenv ("XMODIFIERS", p);
607
608
609
610
611
                }

                g_free (ibus_path);
        }

Florian Müllner's avatar
Florian Müllner committed
612
613
614
615
        /* We want to use the GNOME menus which has the designed categories.
         */
        gsm_util_setenv ("XDG_MENU_PREFIX", "gnome-");

616
617
618
619
620
621
622
        /* Talk to logind before acquiring a name, since it does synchronous
         * calls at initialization time that invoke a main loop and if we
         * already owned a name, then we would service too early during
         * that main loop.
         */
        g_object_unref (gsm_get_system ());

Cosimo Cecchi's avatar
Cosimo Cecchi committed
623
        name_owner_id  = acquire_name ();
624

625
        gsm_main ();
626

627
628
629
630
#ifdef HAVE_SYSTEMD
        gsm_util_export_user_environment (NULL);
#endif

631
        g_clear_object (&manager);
632
        g_free (gl_renderer);
633

Cosimo Cecchi's avatar
Cosimo Cecchi committed
634
        g_bus_unown_name (name_owner_id);
635
636
        gdm_log_shutdown ();

637
        return 0;
638
}