main.c 21.7 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
247
248
249
                           &status, error)) {
                return FALSE;
        }

        return g_spawn_check_exit_status (status, error);
}

250
251
252
253
254
255
256
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
257
        use_vfs = g_strdup (g_getenv ("GIO_USE_VFS"));
258
259
260
261
262
263
264
265
266
267
268
269
270

        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) {
271
                g_setenv ("GVFS_DISABLE_FUSE", disable_fuse, TRUE);
272
273
274
275
276
277
                g_free (disable_fuse);
        } else {
                g_unsetenv ("GVFS_DISABLE_FUSE");
        }
}

278
279
280
281
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
#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);
352
        if (res < 0 && errno != EEXIST)
353
354
355
356
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
                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 */

384
int
385
main (int argc, char **argv)
386
{
387
        GError           *error = NULL;
388
        static char     **override_autostart_dirs = NULL;
Colin Walters's avatar
Colin Walters committed
389
        static char      *opt_session_name = NULL;
390
        const char       *debug_string = NULL;
391
392
        const char       *env_override_autostart_dirs = NULL;
        g_auto(GStrv)     env_override_autostart_dirs_v = NULL;
393
        gboolean          gl_failed = FALSE;
Cosimo Cecchi's avatar
Cosimo Cecchi committed
394
        guint             name_owner_id;
395
        GOptionContext   *options;
396
        static GOptionEntry entries[] = {
Benjamin Berg's avatar
Benjamin Berg committed
397
398
399
400
401
#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 },
402
                { "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
403
                { "session", 0, 0, G_OPTION_ARG_STRING, &opt_session_name, N_("Session to use"), N_("SESSION_NAME") },
404
405
406
                { "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
407
                /* Translators: the 'fail whale' is the black dialog we show when something goes seriously wrong */
408
                { "whale", 0, 0, G_OPTION_ARG_NONE, &please_fail, N_("Show the fail whale dialog for testing"), NULL },
409
                { "disable-acceleration-check", 0, 0, G_OPTION_ARG_NONE, &disable_acceleration_check, N_("Disable hardware acceleration check"), NULL },
410
411
                { NULL, 0, 0, 0, NULL, NULL, NULL }
        };
412

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

418
419
420
421
422
423
424
425
426
        /* 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");
        }

427
428
429
        /* Make sure we initialize gio in a way that does not autostart any daemon */
        initialize_gio ();

430
        setlocale (LC_ALL, "");
431
432
433
434
        bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
        bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
        textdomain (GETTEXT_PACKAGE);

435
436
        debug_string = g_getenv ("GNOME_SESSION_DEBUG");
        if (debug_string != NULL) {
Antoine Jacoutot's avatar
Antoine Jacoutot committed
437
                debug = atoi (debug_string) == 1;
438
439
        }

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

449
450
        g_option_context_free (options);

451
452
453
454
        /* 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.
         */
455
#ifdef ENABLE_SYSTEMD_JOURNAL
456
457
458
459
460
461
462
463
464
465
466
        if (!debug) {
                int journalfd;

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

467
468
469
        gdm_log_init ();
        gdm_log_set_debug (debug);

Benjamin Berg's avatar
Benjamin Berg committed
470
471
472
473
474
475
        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) {
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
                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);
        }

503
504
        if (gl_failed) {
                gsm_fail_whale_dialog_we_failed (FALSE, TRUE, NULL);
505
                gsm_main ();
506
507
508
                exit (1);
        }

509
        if (please_fail) {
510
                gsm_fail_whale_dialog_we_failed (TRUE, TRUE, NULL);
511
                gsm_main ();
512
513
514
                exit (1);
        }

515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
        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);
                }
        }

532
533
534
535
536
        gsm_util_export_activation_environment (&error);
        if (error) {
                g_warning ("Failed to upload environment to DBus: %s", error->message);
                g_clear_error (&error);
        }
537

Benjamin Berg's avatar
Benjamin Berg committed
538
539
        session_name = opt_session_name;

540
#ifdef HAVE_SYSTEMD
541
542
543
544
545
        gsm_util_export_user_environment (&error);
        if (error) {
                g_warning ("Failed to upload environment to systemd: %s", error->message);
                g_clear_error (&error);
        }
546
547
#endif

Benjamin Berg's avatar
Benjamin Berg committed
548
549
550
551
552
553
554
555
556
557
558
559
560
#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);
                }

561
562
563
564
565
566
567
568
569
570
                /* 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);
                if (error) {
                        g_warning ("Failed to reset failed state of units: %s", error->message);
                        g_clear_error (&error);
                }

Benjamin Berg's avatar
Benjamin Berg committed
571
572
573
574
575
576
577
578
579
580
                /* 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. */
                 g_warning ("Falling back to non-systemd startup procedure due to error: %s", error->message);
581
                 g_clear_error (&error);
Benjamin Berg's avatar
Benjamin Berg committed
582
583
584
        }
#endif /* ENABLE_SYSTEMD_SESSION */

585
586
587
588
589
590
        {
                gchar *ibus_path;

                ibus_path = g_find_program_in_path("ibus-daemon");

                if (ibus_path) {
591
592
593
594
595
596
597
598
599
                        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);
600
601
602
603
604
                }

                g_free (ibus_path);
        }

Florian Müllner's avatar
Florian Müllner committed
605
606
607
608
        /* We want to use the GNOME menus which has the designed categories.
         */
        gsm_util_setenv ("XDG_MENU_PREFIX", "gnome-");

609
610
611
612
613
614
615
        /* 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
616
        name_owner_id  = acquire_name ();
617

618
        gsm_main ();
619

620
621
622
623
#ifdef HAVE_SYSTEMD
        gsm_util_export_user_environment (NULL);
#endif

624
        g_clear_object (&manager);
625
        g_free (gl_renderer);
626

Cosimo Cecchi's avatar
Cosimo Cecchi committed
627
        g_bus_unown_name (name_owner_id);
628
629
        gdm_log_shutdown ();

630
        return 0;
631
}