static void
gsm_logout_dialog_init (GsmLogoutDialog *logout_dialog)
{
logout_dialog->priv = GSM_LOGOUT_DIALOG_GET_PRIVATE (logout_dialog);
logout_dialog->priv->timeout_id = 0;
logout_dialog->priv->timeout = 0;
logout_dialog->priv->default_response = GTK_RESPONSE_CANCEL;
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (logout_dialog), TRUE);
gtk_window_set_keep_above (GTK_WINDOW (logout_dialog), TRUE);
gtk_window_stick (GTK_WINDOW (logout_dialog));
#ifdef HAVE_UPOWER
logout_dialog->priv->up_client = up_client_new ();
#endif
#ifdef HAVE_SYSTEMD
if (LOGIND_RUNNING())
logout_dialog->priv->systemd = gsm_get_systemd ();
else
#endif
logout_dialog->priv->consolekit = gsm_get_consolekit ();
g_signal_connect (logout_dialog,
"destroy",
G_CALLBACK (gsm_logout_dialog_destroy),
NULL);
g_signal_connect (logout_dialog,
"show",
G_CALLBACK (gsm_logout_dialog_show),
NULL);
}
/*
Example:
dbus-send --system --dest=org.gnome.DisplayManager \
--type=method_call --print-reply --reply-timeout=2000 \
/org/gnome/DisplayManager/Manager \
org.gnome.DisplayManager.Manager.GetDisplays
*/
gboolean
gdm_local_display_factory_create_transient_display (GdmLocalDisplayFactory *factory,
char **id,
GError **error)
{
gboolean ret;
GdmDisplay *display = NULL;
const char *seat_id;
g_return_val_if_fail (GDM_IS_LOCAL_DISPLAY_FACTORY (factory), FALSE);
ret = FALSE;
g_debug ("GdmLocalDisplayFactory: Creating transient display");
#ifdef WITH_SYSTEMD
if (LOGIND_RUNNING() > 0) {
display = gdm_local_display_new ();
}
#endif
if (display == NULL) {
guint32 num;
num = take_next_display_number (factory);
display = gdm_legacy_display_new (num);
}
seat_id = get_seat_of_transient_display (factory);
g_object_set (display,
"seat-id", seat_id,
"allow-timed-login", FALSE,
NULL);
store_display (factory, display);
if (! gdm_display_manage (display)) {
display = NULL;
goto out;
}
if (! gdm_display_get_id (display, id, NULL)) {
display = NULL;
goto out;
}
ret = TRUE;
out:
/* ref either held by store or not at all */
g_object_unref (display);
return ret;
}
/**
* gpm_control_shutdown:
* @control: This class instance
*
* Shuts down the computer
**/
gboolean
gpm_control_shutdown (GpmControl *control, GError **error)
{
gboolean ret;
EggConsoleKit *console;
if (LOGIND_RUNNING()) {
ret = gpm_control_systemd_shutdown ();
} else {
console = egg_console_kit_new ();
ret = egg_console_kit_stop (console, error);
g_object_unref (console);
}
return ret;
}
static gboolean
gsm_logout_supports_reboot (GsmLogoutDialog *logout_dialog)
{
gboolean ret;
#ifdef HAVE_SYSTEMD
if (LOGIND_RUNNING())
ret = gsm_systemd_can_restart (logout_dialog->priv->systemd);
else
#endif
ret = gsm_consolekit_can_restart (logout_dialog->priv->consolekit);
if (!ret) {
ret = mdm_supports_logout_action (MDM_LOGOUT_ACTION_REBOOT);
}
return ret;
}
static gboolean
gsm_logout_supports_system_hibernate (GsmLogoutDialog *logout_dialog)
{
gboolean ret;
ret = FALSE;
#ifdef HAVE_SYSTEMD
if (LOGIND_RUNNING())
ret = gsm_systemd_can_hibernate (logout_dialog->priv->systemd);
#endif
#if defined(HAVE_SYSTEMD) && defined(HAVE_UPOWER)
else
#endif
#ifdef HAVE_UPOWER
ret = up_client_get_can_hibernate (logout_dialog->priv->up_client);
#endif
return ret;
}
static void maybe_load_saved_session_apps(GsmManager* manager)
{
GsmConsolekit* consolekit = NULL;
#ifdef HAVE_SYSTEMD
GsmSystemd* systemd = NULL;
#endif
char* session_type;
gboolean is_login;
#ifdef HAVE_SYSTEMD
if (LOGIND_RUNNING()) {
systemd = gsm_get_systemd();
session_type = gsm_systemd_get_current_session_type(systemd);
is_login = g_strcmp0 (session_type, GSM_SYSTEMD_SESSION_TYPE_LOGIN_WINDOW) == 0;
}
else {
#endif
consolekit = gsm_get_consolekit();
session_type = gsm_consolekit_get_current_session_type(consolekit);
is_login = g_strcmp0 (session_type, GSM_CONSOLEKIT_SESSION_TYPE_LOGIN_WINDOW) == 0;
#ifdef HAVE_SYSTEMD
}
#endif
if (!is_login)
{
GSettings* settings;
gboolean autostart;
settings = g_settings_new (GSM_SCHEMA);
autostart = g_settings_get_boolean (settings, KEY_AUTOSAVE);
g_object_unref (settings);
if (autostart == TRUE)
gsm_manager_add_autostart_apps_from_dir(manager, gsm_util_get_saved_session_dir());
}
if (consolekit != NULL)
g_object_unref(consolekit);
#ifdef HAVE_SYSTEMD
if (systemd != NULL)
g_object_unref(systemd);
#endif
g_free(session_type);
}
static const char *
get_seat_of_transient_display (GdmLocalDisplayFactory *factory)
{
const char *seat_id = NULL;
/* FIXME: don't hardcode seat */
#ifdef WITH_SYSTEMD
if (LOGIND_RUNNING() > 0) {
seat_id = SYSTEMD_SEAT0_PATH;
}
#endif
if (seat_id == NULL) {
seat_id = CK_SEAT1_PATH;
}
return seat_id;
}
static gboolean
gdm_local_display_factory_start (GdmDisplayFactory *base_factory)
{
GdmLocalDisplayFactory *factory = GDM_LOCAL_DISPLAY_FACTORY (base_factory);
GdmDisplay *display;
g_return_val_if_fail (GDM_IS_LOCAL_DISPLAY_FACTORY (factory), FALSE);
#ifdef WITH_SYSTEMD
if (LOGIND_RUNNING()) {
gdm_local_display_factory_start_monitor (factory);
return gdm_local_display_factory_sync_seats (factory);
}
#endif
/* On ConsoleKit just create Seat1, and that's it. */
display = create_display (factory, CK_SEAT1_PATH, NULL, TRUE);
return display != NULL;
}
static gboolean
gsm_logout_supports_switch_user (GsmLogoutDialog *logout_dialog)
{
GSettings *settings;
gboolean ret = FALSE;
gboolean locked;
settings = g_settings_new (LOCKDOWN_SCHEMA);
locked = g_settings_get_boolean (settings, KEY_USER_SWITCHING_DISABLE);
g_object_unref (settings);
if (!locked) {
#ifdef HAVE_SYSTEMD
if (LOGIND_RUNNING())
ret = gsm_systemd_can_switch_user (logout_dialog->priv->systemd);
else
#endif
ret = gsm_consolekit_can_switch_user (logout_dialog->priv->consolekit);
}
return ret;
}
static void
gdm_display_real_get_timed_login_details (GdmDisplay *display,
gboolean *enabledp,
char **usernamep,
int *delayp)
{
gboolean res;
gboolean enabled;
int delay;
char *username;
enabled = FALSE;
username = NULL;
delay = 0;
#ifdef WITH_SYSTEMD
/* FIXME: More careful thought needs to happen before we
* can support auto/timed login on auxilliary seats in the
* systemd path.
*/
if (LOGIND_RUNNING()) {
if (g_strcmp0 (display->priv->seat_id, "seat0") != 0) {
goto out;
}
}
#endif
res = gdm_settings_direct_get_boolean (GDM_KEY_AUTO_LOGIN_ENABLE, &enabled);
if (res && enabled) {
res = gdm_settings_direct_get_string (GDM_KEY_AUTO_LOGIN_USER, &username);
}
if (enabled && res && username != NULL && username[0] != '\0') {
goto out;
}
g_free (username);
username = NULL;
enabled = FALSE;
res = gdm_settings_direct_get_boolean (GDM_KEY_TIMED_LOGIN_ENABLE, &enabled);
if (res && ! enabled) {
goto out;
}
res = gdm_settings_direct_get_string (GDM_KEY_TIMED_LOGIN_USER, &username);
if (res && (username == NULL || username[0] == '\0')) {
enabled = FALSE;
g_free (username);
username = NULL;
goto out;
}
delay = 0;
res = gdm_settings_direct_get_int (GDM_KEY_TIMED_LOGIN_DELAY, &delay);
if (res && delay <= 0) {
/* we don't allow the timed login to have a zero delay */
delay = 10;
}
out:
if (enabledp != NULL) {
*enabledp = enabled;
}
if (usernamep != NULL) {
*usernamep = username;
} else {
g_free (username);
}
if (delayp != NULL) {
*delayp = delay;
}
}
/**
* gpm_control_hibernate:
**/
gboolean
gpm_control_hibernate (GpmControl *control, GError **error)
{
gboolean allowed;
gboolean ret = FALSE;
gboolean do_lock;
gboolean nm_sleep;
GpmScreensaver *screensaver;
guint32 throttle_cookie = 0;
#ifdef WITH_KEYRING
gboolean lock_gnome_keyring;
GnomeKeyringResult keyres;
#endif /* WITH_KEYRING */
GError *dbus_error = NULL;
GDBusProxy *proxy;
screensaver = gpm_screensaver_new ();
if (!LOGIND_RUNNING()) {
g_object_get (control->priv->client,
"can-hibernate", &allowed,
NULL);
if (!allowed) {
egg_debug ("cannot hibernate as not allowed from policy");
g_set_error_literal (error, GPM_CONTROL_ERROR, GPM_CONTROL_ERROR_GENERAL, "Cannot hibernate");
goto out;
}
}
#ifdef WITH_KEYRING
/* we should perhaps lock keyrings when sleeping #375681 */
lock_gnome_keyring = g_settings_get_boolean (control->priv->settings, GPM_SETTINGS_LOCK_KEYRING_HIBERNATE);
if (lock_gnome_keyring) {
keyres = gnome_keyring_lock_all_sync ();
if (keyres != GNOME_KEYRING_RESULT_OK) {
egg_warning ("could not lock keyring");
}
}
#endif /* WITH_KEYRING */
do_lock = gpm_control_get_lock_policy (control, GPM_SETTINGS_LOCK_ON_HIBERNATE);
if (do_lock) {
throttle_cookie = gpm_screensaver_add_throttle (screensaver, "hibernate");
gpm_screensaver_lock (screensaver);
}
nm_sleep = g_settings_get_boolean (control->priv->settings, GPM_SETTINGS_NETWORKMANAGER_SLEEP);
if (nm_sleep)
gpm_networkmanager_sleep ();
egg_debug ("emitting sleep");
g_signal_emit (control, signals [SLEEP], 0, GPM_CONTROL_ACTION_HIBERNATE);
if (LOGIND_RUNNING()) {
/* sleep via logind */
proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
NULL,
"org.freedesktop.login1",
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
NULL,
&dbus_error );
if (proxy == NULL) {
egg_error("Error connecting to dbus - %s", dbus_error->message);
g_error_free (dbus_error);
return -1;
}
g_dbus_proxy_call_sync (proxy, "Hibernate",
g_variant_new( "(b)",FALSE),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&dbus_error
);
if (dbus_error != NULL ) {
egg_debug ("Error in dbus - %s", dbus_error->message);
g_error_free (dbus_error);
ret = TRUE;
}
else {
ret = TRUE;
}
}
else {
ret = up_client_hibernate_sync (control->priv->client, NULL, error);
}
egg_debug ("emitting resume");
g_signal_emit (control, signals [RESUME], 0, GPM_CONTROL_ACTION_HIBERNATE);
if (do_lock) {
gpm_screensaver_poke (screensaver);
if (throttle_cookie)
gpm_screensaver_remove_throttle (screensaver, throttle_cookie);
}
nm_sleep = g_settings_get_boolean (control->priv->settings, GPM_SETTINGS_NETWORKMANAGER_SLEEP);
if (nm_sleep)
gpm_networkmanager_wake ();
out:
g_object_unref (screensaver);
return ret;
}
static gboolean
gsm_logout_dialog_timeout (gpointer data)
{
GsmLogoutDialog *logout_dialog;
char *seconds_warning;
char *secondary_text;
static char *session_type = NULL;
static gboolean is_not_login;
logout_dialog = (GsmLogoutDialog *) data;
if (!logout_dialog->priv->timeout) {
gtk_dialog_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
return FALSE;
}
switch (logout_dialog->priv->type) {
case GSM_DIALOG_LOGOUT_TYPE_LOGOUT:
seconds_warning = ngettext ("You will be automatically logged "
"out in %d second",
"You will be automatically logged "
"out in %d seconds",
logout_dialog->priv->timeout);
break;
case GSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
seconds_warning = ngettext ("This system will be automatically "
"shut down in %d second",
"This system will be automatically "
"shut down in %d seconds",
logout_dialog->priv->timeout);
break;
default:
g_assert_not_reached ();
}
seconds_warning = g_strdup_printf (seconds_warning, logout_dialog->priv->timeout);
if (session_type == NULL) {
#ifdef HAVE_SYSTEMD
if (LOGIND_RUNNING()) {
GsmSystemd *systemd;
systemd = gsm_get_systemd ();
session_type = gsm_systemd_get_current_session_type (systemd);
g_object_unref (systemd);
is_not_login = (g_strcmp0 (session_type, GSM_SYSTEMD_SESSION_TYPE_LOGIN_WINDOW) != 0);
}
else {
#endif
GsmConsolekit *consolekit;
consolekit = gsm_get_consolekit ();
session_type = gsm_consolekit_get_current_session_type (consolekit);
g_object_unref (consolekit);
is_not_login = (g_strcmp0 (session_type, GSM_CONSOLEKIT_SESSION_TYPE_LOGIN_WINDOW) != 0);
#ifdef HAVE_SYSTEMD
}
#endif
}
if (is_not_login) {
char *name;
name = g_locale_to_utf8 (g_get_real_name (), -1, NULL, NULL, NULL);
if (!name || name[0] == '\0' || strcmp (name, "Unknown") == 0) {
name = g_locale_to_utf8 (g_get_user_name (), -1 , NULL, NULL, NULL);
}
if (!name) {
name = g_strdup (g_get_user_name ());
}
secondary_text = g_strdup_printf (_("You are currently logged in as \"%s\"."), name);
g_free (name);
} else {
secondary_text = g_strdup (seconds_warning);
}
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar),
logout_dialog->priv->timeout / 60.0);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar),
seconds_warning);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (logout_dialog),
secondary_text,
NULL);
logout_dialog->priv->timeout--;
g_free (secondary_text);
g_free (seconds_warning);
return TRUE;
}
static GtkWidget *
create_field_page(GtkWidget *tree, const gchar *child_schema, const gchar *text)
{
GtkWidget *vbox;
GtkWidget *scrolled;
GtkWidget *label;
GtkWidget *treeview;
GList *it, *columns;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
label = gtk_label_new_with_mnemonic (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
g_object_unref (G_OBJECT (model));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"active", 0,
NULL);
if (g_strcmp0 (child_schema, "proctree") == 0)
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (proc_field_toggled), model);
else if (g_strcmp0 (child_schema, "disktreenew") == 0)
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (disk_field_toggled), model);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"text", 1,
NULL);
gtk_tree_view_column_set_title (column, "Not Shown");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
for(it = columns; it; it = it->next)
{
GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
GtkTreeIter iter;
const gchar *title;
gboolean visible;
gint column_id;
title = gtk_tree_view_column_get_title (column);
if (!title)
title = _("Icon");
column_id = gtk_tree_view_column_get_sort_column_id(column);
if ((column_id == COL_CGROUP) && (!cgroups_enabled()))
continue;
if ((column_id == COL_UNIT ||
column_id == COL_SESSION ||
column_id == COL_SEAT ||
column_id == COL_OWNER)
#ifdef HAVE_SYSTEMD
&& !LOGIND_RUNNING()
#endif
)
continue;
visible = gtk_tree_view_column_get_visible (column);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
}
g_list_free(columns);
return vbox;
}
/**
* idle_changed_cb:
* @idle: The idle class instance
* @mode: The idle mode, e.g. GPM_IDLE_MODE_BLANK
* @manager: This class instance
*
* This callback is called when mate-screensaver detects that the idle state
* has changed. GPM_IDLE_MODE_BLANK is when the session has become inactive,
* and GPM_IDLE_MODE_SLEEP is where the session has become inactive, AND the
* session timeout has elapsed for the idle action.
**/
static void
idle_changed_cb (GpmIdle *idle, GpmIdleMode mode, GpmBacklight *backlight)
{
gboolean ret;
GError *error = NULL;
gboolean on_battery;
GpmDpmsMode dpms_mode;
/* don't dim or undim the screen when the lid is closed */
if (gpm_button_is_lid_closed (backlight->priv->button))
return;
/* don't dim or undim the screen unless ConsoleKit/systemd say we are on the active console */
if (!LOGIND_RUNNING() && !egg_console_kit_is_active (backlight->priv->console)) {
egg_debug ("ignoring as not on active console");
return;
}
if (mode == GPM_IDLE_MODE_NORMAL) {
/* sync lcd brightness */
gpm_backlight_notify_system_idle_changed (backlight, FALSE);
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, FALSE);
/* ensure backlight is on */
ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
if (!ret) {
egg_warning ("failed to turn on DPMS: %s", error->message);
g_error_free (error);
}
} else if (mode == GPM_IDLE_MODE_DIM) {
/* sync lcd brightness */
gpm_backlight_notify_system_idle_changed (backlight, TRUE);
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, FALSE);
/* ensure backlight is on */
ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
if (!ret) {
egg_warning ("failed to turn on DPMS: %s", error->message);
g_error_free (error);
}
} else if (mode == GPM_IDLE_MODE_BLANK) {
/* sync lcd brightness */
gpm_backlight_notify_system_idle_changed (backlight, TRUE);
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, FALSE);
/* get the DPMS state we're supposed to use on the power state */
g_object_get (backlight->priv->client,
"on-battery", &on_battery,
NULL);
if (!on_battery)
dpms_mode = g_settings_get_enum (backlight->priv->settings, GPM_SETTINGS_DPMS_METHOD_AC);
else
dpms_mode = g_settings_get_enum (backlight->priv->settings, GPM_SETTINGS_DPMS_METHOD_BATT);
/* check if method is valid */
if (dpms_mode == GPM_DPMS_MODE_UNKNOWN || dpms_mode == GPM_DPMS_MODE_ON) {
egg_warning ("BACKLIGHT method %i unknown. Using OFF.", dpms_mode);
dpms_mode = GPM_DPMS_MODE_OFF;
}
/* turn backlight off */
ret = gpm_dpms_set_mode (backlight->priv->dpms, dpms_mode, &error);
if (!ret) {
egg_warning ("failed to change DPMS: %s", error->message);
g_error_free (error);
}
}
}