← Back to branch summary

~noskcaj/ubuntu/vivid/gdm/3.14.1

« back to all changes in this revision

Viewing changes to daemon/gdm-simple-slave.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha, Tim Lunn, Jeremy Bicha, Robert Ancell
  • Date: 2013-05-31 22:36:08 UTC
  • mfrom: (1.4.55)
  • Revision ID: package-import@ubuntu.com-20130531223608-33uo85niksee5460
Tags: 3.8.1.1-0ubuntu1
[ Tim Lunn ]
* New upstream release
* debian/patches/ubuntu_dont_catch_sigsegv.patch:
  - Dropped, obsolete
* debian/rules:
  - Don't rename gdm binary since that's already been
    done in the new version

[ Jeremy Bicha ]
* debian/control.in: Bump minimum glib
* debian/watch: Watch for unstable releases
* debian/patches/00git_logind_check.patch:
  - Dropped, applied in new release
* debian/patches/08_frequent-users_greeter.patch: Refreshed

[ Robert Ancell ]
* New upstream release
* debian/patches/ubuntu_daemon_autologin_tracking.patch:
* debian/patches/ubuntu_ensure_dirs.patch:
* debian/patches/ubuntu_slave-only-set-up-autologin.patch:
  - Applied upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/gdm-simple-slave.c
65
65
#define DEFAULT_PING_INTERVAL 15
66
66
 
67
67
#define INITIAL_SETUP_USERNAME "gnome-initial-setup"
68
 
#define INITIAL_SETUP_TRIGGER_FILE LOCALSTATEDIR "/lib/gdm/run-initial-setup"
69
68
 
70
69
struct GdmSimpleSlavePrivate
71
70
{
90
89
 
91
90
        GHashTable        *open_reauthentication_requests;
92
91
 
 
92
        GDBusProxy        *accountsservice_proxy;
 
93
        guint              have_existing_user_accounts : 1;
 
94
        guint              accountsservice_ready : 1;
 
95
        guint              waiting_to_connect_to_display : 1;
 
96
 
93
97
        guint              start_session_when_ready : 1;
94
98
        guint              waiting_to_start_session : 1;
95
99
        guint              session_is_running : 1;
117
121
                                                                GCancellable         *cancellable);
118
122
 
119
123
static gboolean wants_initial_setup (GdmSimpleSlave *slave);
120
 
static void destroy_initial_setup_user (GdmSimpleSlave *slave);
121
124
G_DEFINE_TYPE (GdmSimpleSlave, gdm_simple_slave, GDM_TYPE_SLAVE)
122
125
 
123
126
static void create_new_session (GdmSimpleSlave  *slave);
758
761
create_new_session (GdmSimpleSlave  *slave)
759
762
{
760
763
        gboolean       display_is_local;
761
 
        char          *display_id;
762
764
        char          *display_name;
763
765
        char          *display_hostname;
764
766
        char          *display_device;
777
779
        }
778
780
 
779
781
        g_object_get (slave,
780
 
                      "display-id", &display_id,
781
782
                      "display-name", &display_name,
782
783
                      "display-hostname", &display_hostname,
783
784
                      "display-is-local", &display_is_local,
800
801
                                                display_is_local,
801
802
                                                NULL);
802
803
 
803
 
        g_free (display_id);
804
804
        g_free (display_name);
805
805
        g_free (display_device);
806
806
        g_free (display_hostname);
887
887
        if (slave->priv->start_session_service_name == NULL) {
888
888
                gdm_slave_stop (GDM_SLAVE (slave));
889
889
        } else {
890
 
                if (wants_initial_setup (slave)) {
891
 
                        destroy_initial_setup_user (slave);
892
 
                }
893
890
                start_session (slave);
894
891
        }
895
892
 
993
990
        /* Put cursor out of the way on first head */
994
991
        gdm_slave_set_initial_cursor_position (GDM_SLAVE (slave));
995
992
 
996
 
        /* Set the busy cursor */
997
 
        gdm_slave_set_busy_cursor (GDM_SLAVE (slave));
998
 
 
999
 
        /* The root window has a background that may be useful
1000
 
         * to cross fade or transition from when setting the
1001
 
         * login screen background.  We read it here, and stuff
1002
 
         * it into the standard _XROOTPMAP_ID root window property,
1003
 
         * so gnome-settings-daemon can get at it.
1004
 
         */
1005
 
        gdm_slave_save_root_windows (GDM_SLAVE (slave));
1006
 
 
1007
993
#ifdef WITH_PLYMOUTH
1008
994
        /* Plymouth is waiting for the go-ahead to exit */
1009
995
        if (slave->priv->plymouth_is_running) {
1071
1057
                          char           *session_id)
1072
1058
{
1073
1059
        gboolean       display_is_local;
1074
 
        char          *display_id;
1075
1060
        char          *display_name;
1076
1061
        char          *seat_id;
1077
1062
        char          *display_device;
1082
1067
        g_debug ("GdmSimpleSlave: Running greeter");
1083
1068
 
1084
1069
        display_is_local = FALSE;
1085
 
        display_id = NULL;
1086
1070
        display_name = NULL;
1087
1071
        seat_id = NULL;
1088
1072
        auth_file = NULL;
1090
1074
        display_hostname = NULL;
1091
1075
 
1092
1076
        g_object_get (slave,
1093
 
                      "display-id", &display_id,
1094
1077
                      "display-is-local", &display_is_local,
1095
1078
                      "display-name", &display_name,
1096
1079
                      "display-seat-id", &seat_id,
1152
1135
 
1153
1136
        gdm_launch_environment_start (GDM_LAUNCH_ENVIRONMENT (slave->priv->greeter_environment));
1154
1137
 
1155
 
        g_free (display_id);
1156
1138
        g_free (display_name);
1157
1139
        g_free (seat_id);
1158
1140
        g_free (display_device);
1166
1148
        start_launch_environment (slave, GDM_USERNAME, NULL);
1167
1149
}
1168
1150
 
1169
 
#define RULES_DIR DATADIR "/polkit-1/rules.d/"
1170
 
#define RULES_FILE "20-gnome-initial-setup.rules"
1171
 
 
1172
 
static const gboolean
1173
 
create_initial_setup_user (GdmSimpleSlave *slave)
1174
 
{
1175
 
        gboolean ret = TRUE;
1176
 
        ActUserManager *act;
1177
 
        ActUser *user;
1178
 
        GFile *src_file, *dest_file;
1179
 
        GError *error = NULL;
1180
 
        const char *e = NULL;
1181
 
 
1182
 
        /* First, create the user */
1183
 
        act = act_user_manager_get_default ();
1184
 
 
1185
 
        user = act_user_manager_create_user (act, INITIAL_SETUP_USERNAME, "", 0, &error);
1186
 
        if (user == NULL) {
1187
 
                if (g_dbus_error_is_remote_error (error)) {
1188
 
                        e = g_dbus_error_get_remote_error (error);
1189
 
                }
1190
 
 
1191
 
                g_warning ("Creating user '%s' failed: %s / %s",
1192
 
                           INITIAL_SETUP_USERNAME, e, error->message);
1193
 
 
1194
 
                if (g_strcmp0 (e, "org.freedesktop.Accounts.Error.UserExists") != 0) {
1195
 
                        ret = FALSE;
1196
 
                        goto out;
1197
 
                }
1198
 
 
1199
 
                g_clear_error (&error);
1200
 
        } else {
1201
 
                g_object_unref (user);
1202
 
        }
1203
 
 
1204
 
        /* Now, make sure the PolicyKit policy is in place */
1205
 
        src_file = g_file_new_for_path (DATADIR "/gnome-initial-setup/" RULES_FILE);
1206
 
        dest_file = g_file_new_for_path (RULES_DIR RULES_FILE);
1207
 
 
1208
 
        if (!g_file_copy (src_file,
1209
 
                          dest_file,
1210
 
                          G_FILE_COPY_OVERWRITE,
1211
 
                          NULL, NULL, NULL, &error)) {
1212
 
                g_warning ("Failed to copy '%s' to '%s': %s",
1213
 
                           g_file_get_path (src_file),
1214
 
                           g_file_get_path (dest_file),
1215
 
                           error->message);
1216
 
                ret = FALSE;
1217
 
                goto out_clear_files;
1218
 
        }
1219
 
 
1220
 
 out_clear_files:
1221
 
        g_object_unref (src_file);
1222
 
        g_object_unref (dest_file);
1223
 
 
1224
 
 out:
1225
 
        g_clear_pointer (&e, g_free);
1226
 
        g_clear_error (&error);
1227
 
        return ret;
1228
 
}
1229
 
 
1230
 
static void
1231
 
destroy_initial_setup_user (GdmSimpleSlave *slave)
1232
 
{
1233
 
        ActUserManager *act;
1234
 
        ActUser *user;
1235
 
        const char *filename;
1236
 
        GError *error;
1237
 
 
1238
 
        filename = RULES_DIR RULES_FILE;
1239
 
 
1240
 
        if (g_remove (filename) < 0) {
1241
 
                g_warning ("Failed to remove '%s': %s", filename, g_strerror (errno));
1242
 
        }
1243
 
 
1244
 
        act = act_user_manager_get_default ();
1245
 
 
1246
 
        error = NULL;
1247
 
        user = act_user_manager_get_user (act, INITIAL_SETUP_USERNAME);
1248
 
        if (user != NULL) {
1249
 
                if (!act_user_manager_delete_user (act, user, TRUE, &error)) {
1250
 
                        g_warning ("Failed to delete user '%s': %s", INITIAL_SETUP_USERNAME, error->message);
1251
 
                        g_error_free (error);
1252
 
                }
1253
 
                g_object_unref (user);
1254
 
        }
1255
 
 
1256
 
        if (g_remove (INITIAL_SETUP_TRIGGER_FILE) < 0) {
1257
 
                g_warning ("Failed to remove '%s': %s", INITIAL_SETUP_TRIGGER_FILE, g_strerror (errno));
1258
 
        }
1259
 
}
1260
 
 
1261
1151
static void
1262
1152
start_initial_setup (GdmSimpleSlave *slave)
1263
1153
{
1264
 
        create_initial_setup_user (slave);
1265
1154
        start_launch_environment (slave, INITIAL_SETUP_USERNAME, "gnome-initial-setup");
1266
1155
}
1267
1156
 
1283
1172
static gboolean
1284
1173
wants_initial_setup (GdmSimpleSlave *slave)
1285
1174
{
1286
 
        gboolean enabled;
 
1175
        gboolean enabled = FALSE;
1287
1176
 
1288
 
        if (!g_file_test (INITIAL_SETUP_TRIGGER_FILE, G_FILE_TEST_EXISTS)) {
 
1177
        /* don't run if the system has existing users */
 
1178
        if (slave->priv->have_existing_user_accounts) {
1289
1179
                return FALSE;
1290
1180
        }
1291
1181
 
1293
1183
                return FALSE;
1294
1184
        }
1295
1185
 
1296
 
        if (!enabled) {
1297
 
                return FALSE;
 
1186
        return enabled;
 
1187
}
 
1188
 
 
1189
static void
 
1190
setup_session (GdmSimpleSlave *slave)
 
1191
{
 
1192
        if (wants_initial_setup (slave)) {
 
1193
                start_initial_setup (slave);
 
1194
        } else if (wants_autologin (slave)) {
 
1195
                /* Run the init script. gdmslave suspends until script has terminated */
 
1196
                gdm_slave_run_script (GDM_SLAVE (slave), GDMCONFDIR "/Init", GDM_USERNAME);
 
1197
        } else {
 
1198
                start_greeter (slave);
1298
1199
        }
1299
 
 
1300
 
        return TRUE;
 
1200
        create_new_session (slave);
1301
1201
}
1302
1202
 
1303
1203
static gboolean
1310
1210
        res = gdm_slave_connect_to_x11_display (GDM_SLAVE (slave));
1311
1211
        if (res) {
1312
1212
                setup_server (slave);
1313
 
 
1314
 
                if (wants_initial_setup (slave)) {
1315
 
                        start_initial_setup (slave);
1316
 
                } else if (wants_autologin (slave)) {
1317
 
                        /* Run the init script. gdmslave suspends until script has terminated */
1318
 
                        gdm_slave_run_script (GDM_SLAVE (slave), GDMCONFDIR "/Init", GDM_USERNAME);
1319
 
                } else {
1320
 
                        start_greeter (slave);
1321
 
                }
1322
 
                create_new_session (slave);
 
1213
                setup_session (slave);
1323
1214
        } else {
1324
1215
                if (slave->priv->connection_attempts >= MAX_CONNECT_ATTEMPTS) {
1325
1216
                        g_warning ("Unable to connect to display after %d tries - bailing out", slave->priv->connection_attempts);
1332
1223
}
1333
1224
 
1334
1225
static void
 
1226
connect_to_display_when_accountsservice_ready (GdmSimpleSlave *slave)
 
1227
{
 
1228
        if (slave->priv->accountsservice_ready) {
 
1229
                slave->priv->waiting_to_connect_to_display = FALSE;
 
1230
                g_idle_add ((GSourceFunc)idle_connect_to_display, slave);
 
1231
        } else {
 
1232
                slave->priv->waiting_to_connect_to_display = TRUE;
 
1233
        }
 
1234
}
 
1235
 
 
1236
static void
1335
1237
on_server_ready (GdmServer      *server,
1336
1238
                 GdmSimpleSlave *slave)
1337
1239
{
1338
 
        g_idle_add ((GSourceFunc)idle_connect_to_display, slave);
 
1240
        connect_to_display_when_accountsservice_ready (slave);
1339
1241
}
1340
1242
 
1341
1243
static void
1372
1274
#endif
1373
1275
}
1374
1276
 
 
1277
static void
 
1278
on_list_cached_users_complete (GObject       *proxy,
 
1279
                               GAsyncResult  *result,
 
1280
                               gpointer       user_data)
 
1281
{
 
1282
        GdmSimpleSlave *slave = GDM_SIMPLE_SLAVE (user_data);
 
1283
        GVariant *call_result = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, NULL);
 
1284
        GVariant *user_list;
 
1285
 
 
1286
        if (!call_result) {
 
1287
                slave->priv->have_existing_user_accounts = FALSE;
 
1288
        } else {
 
1289
                g_variant_get (call_result, "(@ao)", &user_list);
 
1290
                slave->priv->have_existing_user_accounts = g_variant_n_children (user_list) > 0;
 
1291
                g_variant_unref (user_list);
 
1292
                g_variant_unref (call_result);
 
1293
        }
 
1294
 
 
1295
        slave->priv->accountsservice_ready = TRUE;
 
1296
 
 
1297
        if (slave->priv->waiting_to_connect_to_display) {
 
1298
                connect_to_display_when_accountsservice_ready (slave);
 
1299
        }
 
1300
}
 
1301
 
 
1302
static void
 
1303
on_accountsservice_ready (GObject       *object,
 
1304
                          GAsyncResult  *result,
 
1305
                          gpointer       user_data)
 
1306
{
 
1307
        GdmSimpleSlave *slave = GDM_SIMPLE_SLAVE (user_data);
 
1308
        GError *local_error = NULL;
 
1309
 
 
1310
        slave->priv->accountsservice_proxy = g_dbus_proxy_new_for_bus_finish (result, &local_error);
 
1311
        if (!slave->priv->accountsservice_proxy) {
 
1312
                g_error ("Failed to contact accountsservice: %s", local_error->message);
 
1313
        } 
 
1314
 
 
1315
        g_dbus_proxy_call (slave->priv->accountsservice_proxy, "ListCachedUsers", NULL, 0, -1, NULL,
 
1316
                           on_list_cached_users_complete, slave);
 
1317
}
 
1318
                          
 
1319
 
1375
1320
static gboolean
1376
1321
gdm_simple_slave_run (GdmSimpleSlave *slave)
1377
1322
{
1418
1363
                                  G_CALLBACK (on_server_ready),
1419
1364
                                  slave);
1420
1365
 
 
1366
                g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
 
1367
                                          0, NULL,
 
1368
                                          "org.freedesktop.Accounts",
 
1369
                                          "/org/freedesktop/Accounts",
 
1370
                                          "org.freedesktop.Accounts",
 
1371
                                          NULL,
 
1372
                                          on_accountsservice_ready, slave);
 
1373
                
1421
1374
#ifdef WITH_PLYMOUTH
1422
1375
                slave->priv->plymouth_is_running = plymouth_is_running ();
1423
1376
 
1571
1524
                self->priv->greeter_environment = NULL;
1572
1525
        }
1573
1526
 
 
1527
        if (self->priv->start_session_id > 0) {
 
1528
                g_source_remove (self->priv->start_session_id);
 
1529
                self->priv->start_session_id = 0;
 
1530
        }
 
1531
 
 
1532
        g_clear_pointer (&self->priv->start_session_service_name,
 
1533
                         (GDestroyNotify) g_free);
 
1534
 
1574
1535
        if (self->priv->session_is_running) {
1575
1536
                char *username;
1576
1537
 
1600
1561
                g_clear_object (&self->priv->server);
1601
1562
        }
1602
1563
 
 
1564
        g_clear_object (&self->priv->accountsservice_proxy);
 
1565
 
1603
1566
        return TRUE;
1604
1567
}
1605
1568