/**
* This file is a part of the Cairo-Dock project
*
* Copyright : (C) see the 'copyright' file.
* E-mail : see the 'copyright' file.
*
* 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 3
* 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 General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include
#include
#ifdef CD_UPOWER_AVAILABLE
/* to access suspend/resume functionality on Upower 0.9
* even if we use first logind, we only use logind via DBus
*/
#define UPOWER_ENABLE_DEPRECATED
#include
#endif
#include "applet-struct.h"
#include "applet-reboot-required.h"
#include "applet-timer.h"
#include "applet-logout.h"
typedef struct {
gchar *cUserName;
gchar *cIconFile;
gchar *cRealName;
} CDUser;
static void cd_logout_shut_down (void);
static void cd_logout_restart (void);
static void cd_logout_suspend (void);
static void cd_logout_hibernate (void);
static void cd_logout_hybridSleep (void);
static void cd_logout_close_session (void);
static void cd_logout_switch_to_user (const gchar *cUser);
static void cd_logout_switch_to_guest (void);
//static gboolean cd_logout_switch_to_greeter (void);
static void _free_user (CDUser *pUser);
static GList *cd_logout_get_users_list (void);
static void _display_menu (void);
////////////////////
/// CAPABILITIES ///
////////////////////
/*
* Check if the method (cMethod) exists and returns 'yes' or 'challenge':
* http://www.freedesktop.org/wiki/Software/systemd/logind/
* If "yes" is returned the operation is supported and the user may execute the
* operation without further authentication.
* If "challenge" is returned the operation is available, but only after
* authorization.
* If it exists, *bIsAble is modified and TRUE is returned.
*/
static gboolean _cd_logout_check_capabilities_logind (DBusGProxy *pProxy, const gchar *cMethod, gboolean *bIsAble)
{
GError *error = NULL;
gchar *cResult = NULL;
dbus_g_proxy_call (pProxy, cMethod, &error,
G_TYPE_INVALID,
G_TYPE_STRING, &cResult,
G_TYPE_INVALID);
if (!error)
{
*bIsAble = (cResult && (strcmp (cResult, "yes") == 0
|| strcmp (cResult, "challenge") == 0));
g_free (cResult);
}
else
{
cd_debug ("Logind error: %s", error->message);
g_error_free (error);
return FALSE;
}
return TRUE;
}
static void _cd_logout_check_capabilities_async (CDSharedMemory *pSharedMemory)
{
// test first with LoginD
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.login1",
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager");
const gchar *cLogindMethods[] = {"CanPowerOff", "CanReboot", "CanSuspend", "CanHibernate", "CanHybridSleep", NULL};
gboolean *bCapabilities[] = {&pSharedMemory->bCanStop,
&pSharedMemory->bCanRestart, &pSharedMemory->bCanSuspend,
&pSharedMemory->bCanHibernate, &pSharedMemory->bCanHybridSleep};
if (pProxy && _cd_logout_check_capabilities_logind (pProxy, cLogindMethods[0], bCapabilities[0]))
{
pSharedMemory->iLoginManager = CD_LOGIND;
for (int i = 1; cLogindMethods[i] != NULL; i++)
_cd_logout_check_capabilities_logind (pProxy, cLogindMethods[i], bCapabilities[i]);
g_object_unref (pProxy);
}
else // then check with ConsoleKit and UPower
{
GError *error = NULL;
// get capabilities from UPower: hibernate and suspend
#ifdef CD_UPOWER_AVAILABLE
UpClient *pUPowerClient = up_client_new ();
if (pUPowerClient)
{
up_client_get_properties_sync (pUPowerClient, NULL, &error); // this function always returns false ... and it crashes the dock (Debian 6) ! :-O
if (error)
{
cd_warning ("UPower error: %s", error->message);
g_error_free (error);
error = NULL;
}
else
{
pSharedMemory->bCanHibernate = up_client_get_can_hibernate (pUPowerClient);
pSharedMemory->bCanSuspend = up_client_get_can_suspend (pUPowerClient);
g_object_unref (pUPowerClient); // not do that if there is an error to avoid: double free or corruption
}
}
#endif
// get capabilities from ConsoleKit.: reboot and poweroff
pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.ConsoleKit",
"/org/freedesktop/ConsoleKit/Manager",
"org.freedesktop.ConsoleKit.Manager");
dbus_g_proxy_call (pProxy, "CanRestart", &error,
G_TYPE_INVALID,
G_TYPE_BOOLEAN, &pSharedMemory->bCanRestart,
G_TYPE_INVALID);
if (!error)
{
pSharedMemory->iLoginManager = CD_CONSOLE_KIT;
dbus_g_proxy_call (pProxy, "CanStop", &error,
G_TYPE_INVALID,
G_TYPE_BOOLEAN, &pSharedMemory->bCanStop,
G_TYPE_INVALID);
if (error)
{
cd_warning ("ConsoleKit error: %s", error->message);
g_error_free (error);
/*g_object_unref (pProxy); // should not happen but lets check guest account
return;*/
}
}
else
{
cd_debug ("ConsoleKit error: %s", error->message);
g_error_free (error);
}
g_object_unref (pProxy);
}
// get capabilities from DisplayManager
const gchar *seat = g_getenv ("XDG_SEAT_PATH");
if (seat) // else, we could possibly get it by: ck -> GetCurrentSession -> session -> GetSeatId
{
pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.DisplayManager",
seat,
DBUS_INTERFACE_PROPERTIES);
pSharedMemory->bHasGuestAccount = cairo_dock_dbus_get_property_as_boolean (pProxy, "org.freedesktop.DisplayManager.Seat", "HasGuestAccount");
g_object_unref (pProxy);
}
else
{
pSharedMemory->bHasGuestAccount = cairo_dock_dbus_detect_system_application ("org.gnome.DisplayManager");
}
}
static gboolean _cd_logout_got_capabilities (CDSharedMemory *pSharedMemory)
{
CD_APPLET_ENTER;
// fetch the capabilities.
myData.bCapabilitiesChecked = TRUE;
myData.bCanHibernate = pSharedMemory->bCanHibernate;
myData.bCanHybridSleep = pSharedMemory->bCanHybridSleep;
myData.bCanSuspend = pSharedMemory->bCanSuspend;
myData.bCanRestart = pSharedMemory->bCanRestart;
myData.bCanStop = pSharedMemory->bCanStop;
myData.bHasGuestAccount = pSharedMemory->bHasGuestAccount;
myData.iLoginManager = pSharedMemory->iLoginManager;
cd_debug ("capabilities: %d; %d; %d; %d; %d; %d", myData.bCanHibernate,
myData.bCanHybridSleep, myData.bCanSuspend, myData.bCanRestart,
myData.bCanStop, myData.bHasGuestAccount);
// display the menu that has been asked beforehand.
_display_menu ();
// sayonara task-san ^^
gldi_task_discard (myData.pTask);
myData.pTask = NULL;
CD_APPLET_LEAVE (FALSE);
}
void cd_logout_display_actions (void)
{
if (myData.pTask != NULL)
return;
if (! myData.bCapabilitiesChecked)
{
CDSharedMemory *pSharedMemory = g_new0 (CDSharedMemory, 1);
myData.pTask = gldi_task_new_full (0,
(GldiGetDataAsyncFunc) _cd_logout_check_capabilities_async,
(GldiUpdateSyncFunc) _cd_logout_got_capabilities,
(GFreeFunc) g_free,
pSharedMemory);
gldi_task_launch (myData.pTask);
}
else
{
_display_menu ();
}
}
////////////
/// MENU ///
////////////
gchar *cd_logout_check_icon (const gchar *cIconStock, gint iIconSize)
{
gchar *cImagePath = cairo_dock_search_icon_s_path (cIconStock, iIconSize);
if (cImagePath != NULL && g_file_test (cImagePath, G_FILE_TEST_EXISTS))
return cImagePath;
else
return NULL;
}
static void _switch_to_user (GtkMenuItem *menu_item, gchar *cUserName)
{
if (cUserName != NULL)
{
cd_logout_switch_to_user (cUserName);
}
else // guest
{
cd_logout_switch_to_guest ();
}
}
static GtkWidget *_build_menu (GtkWidget **pShutdownMenuItem)
{
GtkWidget *pMenu = gldi_menu_new (myIcon);
GtkWidget *pMenuItem;
gchar *cImagePath;
cImagePath = cd_logout_check_icon ("system-shutdown", myData.iDesiredIconSize);
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Shut down"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/system-shutdown.svg", cd_logout_shut_down, pMenu);
g_free (cImagePath);
if (!myData.bCanStop && ! myConfig.cUserActionShutdown)
gtk_widget_set_sensitive (pMenuItem, FALSE);
*pShutdownMenuItem = pMenuItem;
cImagePath = cd_logout_check_icon (GLDI_ICON_NAME_REFRESH, myData.iDesiredIconSize);
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Restart"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/system-restart.svg", cd_logout_restart, pMenu);
g_free (cImagePath);
if (!myData.bCanRestart)
gtk_widget_set_sensitive (pMenuItem, FALSE);
cImagePath = cd_logout_check_icon ("sleep", myData.iDesiredIconSize);
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Hibernate"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/system-hibernate.svg", cd_logout_hibernate, pMenu);
gtk_widget_set_tooltip_text (pMenuItem, D_("Your computer will not consume any energy."));
if (!myData.bCanHibernate)
gtk_widget_set_sensitive (pMenuItem, FALSE);
if (myData.bCanHybridSleep)
{
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Hybrid Sleep"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/system-hibernate.svg", cd_logout_hybridSleep, pMenu);
gtk_widget_set_tooltip_text (pMenuItem, D_("Your computer will still consume a small amount of energy but after some time, the computer will suspend to disk and not consume any energy."));
}
g_free (cImagePath);
cImagePath = cd_logout_check_icon ("clock", myData.iDesiredIconSize);
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Suspend"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/system-suspend.svg", cd_logout_suspend, pMenu);
g_free (cImagePath);
gtk_widget_set_tooltip_text (pMenuItem, D_("Your computer will still consume a small amount of energy."));
if (!myData.bCanSuspend)
gtk_widget_set_sensitive (pMenuItem, FALSE);
if (g_getenv ("SESSION_MANAGER") != NULL) // needs a session manager for this.
{
cImagePath = cd_logout_check_icon ("system-log-out", myData.iDesiredIconSize);
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Log out"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/system-log-out.svg", cd_logout_close_session, pMenu);
g_free (cImagePath);
gtk_widget_set_tooltip_text (pMenuItem, D_("Close your session and allow to open a new one."));
}
if (myData.pUserList != NULL) // refresh the users list (we could listen for the UserAdded,UserDeleted, UserChanged signals too).
{
g_list_foreach (myData.pUserList, (GFunc)_free_user, NULL);
g_list_free (myData.pUserList);
}
myData.pUserList = cd_logout_get_users_list ();
if (myData.pUserList != NULL && (myData.bHasGuestAccount || myData.pUserList->next != NULL)) // at least 2 users
{
GtkWidget *pUsersSubMenu = CD_APPLET_ADD_SUB_MENU_WITH_IMAGE (D_("Switch user"), pMenu, GLDI_ICON_NAME_JUMP_TO);
gboolean bFoundUser = FALSE;
const gchar *cCurrentUser = g_getenv ("USER");
CDUser *pUser;
GList *u;
for (u = myData.pUserList; u != NULL; u = u->next)
{
pUser = u->data;
pMenuItem = CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (
(pUser->cRealName && *(pUser->cRealName) != '\0') ? pUser->cRealName : pUser->cUserName,
pUser->cIconFile, _switch_to_user, pUsersSubMenu, pUser->cUserName);
if (! bFoundUser && cCurrentUser && strcmp (cCurrentUser, pUser->cUserName) == 0)
{
bFoundUser = TRUE;
gtk_widget_set_sensitive (pMenuItem, FALSE);
}
}
if (myData.bHasGuestAccount && bFoundUser) // if we didn't find the user yet, it means we are the guest, so don't show this entry.
{
CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Guest session"), NULL, _switch_to_user, pUsersSubMenu, NULL); // NULL will mean "guest"
}
}
CD_APPLET_ADD_SEPARATOR_IN_MENU (pMenu);
cImagePath = cd_logout_check_icon ("system-lock-screen", myData.iDesiredIconSize);
CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Lock screen"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/locked.svg", cairo_dock_fm_lock_screen, pMenu); /// TODO: same question...
g_free (cImagePath);
if (myData.bCanStop)
{
cImagePath = cd_logout_check_icon ("document-open-recent", myData.iDesiredIconSize);
CD_APPLET_ADD_IN_MENU_WITH_STOCK (D_("Program an automatic shut-down"), cImagePath ? cImagePath : MY_APPLET_SHARE_DATA_DIR"/icon-scheduling.svg", cd_logout_program_shutdown, pMenu);
g_free (cImagePath);
}
if ((myDock && myDock->container.bIsHorizontal && ! myDock->container.bDirectionUp) // on the top, we inverse the menu (mainly to be close to what others do).
|| (myDesklet && myDesklet->container.iWindowPositionY < (g_desktopGeometry.Xscreen.height / 2)))
{
GList *children = gtk_container_get_children (GTK_CONTAINER (pMenu));
GList *pMenuList;
for (pMenuList = children; pMenuList != NULL; pMenuList = pMenuList->next)
{
pMenuItem = pMenuList->data;
gtk_menu_reorder_child (GTK_MENU (pMenu), pMenuItem, 0);
}
g_list_free (children);
}
return pMenu;
}
static void _display_menu (void)
{
// build and show the menu
GtkWidget *pShutdownMenuItem = NULL;
GtkWidget *pMenu = _build_menu (&pShutdownMenuItem);
CD_APPLET_POPUP_MENU_ON_MY_ICON (pMenu);
// select the first (or last) item, which corresponds to the 'shutdown' action.
gtk_menu_shell_select_item (GTK_MENU_SHELL (pMenu), pShutdownMenuItem); // must be done here, after the menu has been realized.
}
///////////////
/// ACTIONS ///
///////////////
static void _console_kit_action (const gchar *cAction)
{
GError *error = NULL;
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.ConsoleKit",
"/org/freedesktop/ConsoleKit/Manager",
"org.freedesktop.ConsoleKit.Manager");
dbus_g_proxy_call (pProxy, cAction, &error,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error)
{
cd_warning ("ConsoleKit error: %s", error->message);
g_error_free (error);
}
g_object_unref (pProxy);
}
static void _logind_action (const gchar *cAction)
{
GError *error = NULL;
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.login1",
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager");
dbus_g_proxy_call (pProxy, cAction, &error,
G_TYPE_BOOLEAN, FALSE, // non-interactive
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error)
{
cd_warning ("Logind error: %s", error->message);
gchar *cMessage = g_strdup_printf ("%s %s\n%s",
D_("Logind has returned this error:"),
error->message,
D_("Please check that you can do this action\n"
"(e.g. you can't power the computer off if another session is active)"));
gldi_dialog_show_temporary_with_icon (cMessage, myIcon, myContainer,
15e3, "same icon");
g_free (cMessage);
g_error_free (error);
}
g_object_unref (pProxy);
}
static void _upower_action (gboolean bSuspend)
{
#ifdef CD_UPOWER_AVAILABLE
UpClient *pUPowerClient = up_client_new ();
if (bSuspend)
up_client_suspend_sync (pUPowerClient, NULL, NULL);
else
up_client_hibernate_sync (pUPowerClient, NULL, NULL);
g_object_unref (pUPowerClient);
#endif
}
static void _exec_action (int iClickedButton, GtkWidget *pInteractiveWidget, void (*callback) (void), CairoDialog *pDialog)
{
if (iClickedButton == 0 || iClickedButton == -1) // 'OK' button or 'Enter', execute the action.
callback ();
else if (myData.iSidShutDown != 0) // 'Cancel' or 'Escap', if a countdown was scheduled, remove it.
{
g_source_remove (myData.iSidShutDown);
myData.iSidShutDown = 0;
}
myData.pConfirmationDialog = NULL;
}
static void _demand_confirmation (const gchar *cMessage, const gchar *cIconStock, const gchar *cIconImage, void (*callback) (void))
{
gchar *cImagePath = cd_logout_check_icon (cIconStock, 32); // dialog
myData.pConfirmationDialog = gldi_dialog_show (cMessage, myIcon, myContainer, 0, cImagePath ? cImagePath : cIconImage, NULL, (CairoDockActionOnAnswerFunc) _exec_action, callback, NULL);
g_free (cImagePath);
}
static void _shut_down (void)
{
gldi_object_notify (&myModuleObjectMgr, NOTIFICATION_LOGOUT);
if (myData.bCanStop)
{
switch (myData.iLoginManager)
{
case CD_CONSOLE_KIT:
_console_kit_action ("Stop"); // could use org.gnome.SessionManager.RequestShutdown, but it's not standard.
break;
case CD_LOGIND:
_logind_action ("PowerOff");
break;
default:
break;
}
}
else if (myConfig.cUserActionShutdown)
{
cairo_dock_launch_command (myConfig.cUserActionShutdown);
}
}
static inline gchar *_info_msg (void)
{
gchar *cInfo = g_strdup_printf (D_("It will automatically shut-down in %ds"), myData.iCountDown);
gchar *cMessage = g_strdup_printf ("%s\n\n (%s)", D_("Shut down the computer?"), cInfo);
g_free (cInfo);
if (! cd_logout_can_safety_shutdown ())
{
cInfo = g_strdup_printf ("%s\n\n%s", cMessage,
D_("It seems your system is being updated!\n"
"Please be sure that you can shut down your computer right now."));
g_free (cMessage);
return cInfo;
}
return cMessage;
}
static gboolean _auto_shot_down (gpointer data)
{
myData.iCountDown --;
if (myData.iCountDown <= 0)
{
myData.iSidShutDown = 0;
gldi_object_unref (GLDI_OBJECT(myData.pConfirmationDialog));
myData.pConfirmationDialog = NULL;
_shut_down ();
return FALSE;
}
else
{
if (myData.pConfirmationDialog) // paranoia
{
gchar *cMessage = _info_msg ();
gldi_dialog_set_message (myData.pConfirmationDialog, cMessage);
g_free (cMessage);
}
return TRUE;
}
}
void cd_logout_shut_down (void)
{
if (myConfig.bConfirmAction)
{
myData.iCountDown = 60;
gchar *cMessage = _info_msg ();
_demand_confirmation (cMessage, "system-shutdown", MY_APPLET_SHARE_DATA_DIR"/system-shutdown.svg", _shut_down);
g_free (cMessage);
if (myData.iSidShutDown == 0)
{
myData.iSidShutDown = g_timeout_add_seconds (1, _auto_shot_down, NULL);
}
}
else
{
_shut_down ();
}
}
static void _restart (void)
{
gldi_object_notify (&myModuleObjectMgr, NOTIFICATION_LOGOUT);
if (myData.bCanRestart)
{
switch (myData.iLoginManager)
{
case CD_CONSOLE_KIT:
_console_kit_action ("Restart"); // could use org.gnome.SessionManager.RequestShutdown, but it's not standard.
break;
case CD_LOGIND:
_logind_action ("Reboot");
break;
default:
break;
}
}
else if (myConfig.cUserActionShutdown)
{
cairo_dock_launch_command (myConfig.cUserActionShutdown);
}
}
static void cd_logout_restart (void)
{
if (myConfig.bConfirmAction)
{
_demand_confirmation (D_("Restart the computer?"), GLDI_ICON_NAME_REFRESH, MY_APPLET_SHARE_DATA_DIR"/system-restart.svg", _restart);
}
else
{
_restart ();
}
}
static void cd_logout_suspend (void)
{
if (myData.iLoginManager == CD_LOGIND)
_logind_action ("Suspend");
else
_upower_action (TRUE);
}
static void cd_logout_hibernate (void)
{
if (myData.iLoginManager == CD_LOGIND)
_logind_action ("Hibernate");
else
_upower_action (FALSE);
}
static void cd_logout_hybridSleep (void)
{
if (myData.iLoginManager == CD_LOGIND)
_logind_action ("HybridSleep");
else
_upower_action (FALSE);
}
static void _logout (void)
{
gldi_object_notify (&myModuleObjectMgr, NOTIFICATION_LOGOUT);
if (myConfig.cUserAction != NULL)
cairo_dock_launch_command (myConfig.cUserAction);
else // SwitchToGreeter will only show the greeter, we want to close the session
cairo_dock_launch_command (MY_APPLET_SHARE_DATA_DIR"/logout.sh");
}
static void cd_logout_close_session (void) // could use org.gnome.SessionManager.Logout
{
/* Currently, cairo_dock_fm_logout displays to us a window from the DE
* to confirm if we want to close the session or not. So there is a
* confirmation box if cairo_dock_fm_logout returns TRUE.
* Now, if it returns FALSE, we will use logout.sh script and display
* a confirmation box if the user wants to have this dialogue.
*/
if (! cairo_dock_fm_logout ()) // it seems it's better to use tools from the DE for the logout action
{
if (myConfig.bConfirmAction)
{
_demand_confirmation (D_("Close the current session?"), "system-log-out", MY_APPLET_SHARE_DATA_DIR"/system-log-out.svg", _logout); /// same question, see above...
}
else
{
_logout ();
}
}
else
gldi_object_notify (&myModuleObjectMgr, NOTIFICATION_LOGOUT);
}
static void cd_logout_switch_to_user (const gchar *cUser)
{
const gchar *seat = g_getenv ("XDG_SEAT_PATH");
GError *error = NULL;
if (seat) // else, we could possibly get it by: ck -> GetCurrentSession -> session -> GetSeatId
{
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.DisplayManager",
seat,
"org.freedesktop.DisplayManager.Seat");
dbus_g_proxy_call (pProxy, "SwitchToUser", &error,
G_TYPE_STRING, cUser,
G_TYPE_STRING, "", // session, but actually it can be NULL so why bother?
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error)
{
cd_warning ("DisplayManager (LocalDisplay) error: %s", error->message);
g_error_free (error);
if (myConfig.cUserActionSwitchUser != NULL)
cairo_dock_launch_command_printf ("%s %s", NULL,
myConfig.cUserActionSwitchUser, cUser);
}
g_object_unref (pProxy);
}
else // try with gdm
{
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.gnome.DisplayManager",
"/org/gnome/DisplayManager/LocalDisplayFactory",
"org.gnome.DisplayManager.LocalDisplayFactory");
dbus_g_proxy_call (pProxy, "SwitchToUser", &error,
G_TYPE_STRING, cUser,
G_TYPE_INVALID,
G_TYPE_INVALID); // we don't care the 'id' object path returned
if (error)
{
cd_warning ("DisplayManager error: %s", error->message);
g_error_free (error);
if (myConfig.cUserActionSwitchUser != NULL)
cairo_dock_launch_command_printf ("%s %s", NULL,
myConfig.cUserActionSwitchUser, cUser);
}
g_object_unref (pProxy);
}
}
static void cd_logout_switch_to_guest (void)
{
const gchar *seat = g_getenv ("XDG_SEAT_PATH");
GError *error = NULL;
if (seat) // else, we could possibly get it by: ck -> GetCurrentSession -> session -> GetSeatId
{
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.DisplayManager",
seat,
"org.freedesktop.DisplayManager.Seat");
dbus_g_proxy_call (pProxy, "SwitchToGuest", &error,
G_TYPE_STRING, "", // session, but actually it can be NULL so why bother?
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error)
{
cd_warning ("DisplayManager error: %s", error->message);
g_error_free (error);
if (myConfig.cUserActionSwitchUser != NULL)
cairo_dock_launch_command (myConfig.cUserActionSwitchUser);
}
g_object_unref (pProxy);
}
else // try with gdm
{
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.gnome.DisplayManager",
"/org/gnome/DisplayManager/LocalDisplayFactory",
"org.gnome.DisplayManager.LocalDisplayFactory");
dbus_g_proxy_call (pProxy, "StartGuestSession", &error,
G_TYPE_STRING, "", // current user session, but actually it can be NULL so why bother?
G_TYPE_INVALID,
G_TYPE_INVALID); // we don't care the 'id' object path returned
if (error)
{
cd_warning ("DisplayManager (LocalDisplay) error: %s", error->message);
g_error_free (error);
if (myConfig.cUserActionSwitchUser != NULL)
cairo_dock_launch_command (myConfig.cUserActionSwitchUser);
}
g_object_unref (pProxy);
}
}
/*
static gboolean cd_logout_switch_to_greeter (void) // not really sure how to use it.
{
const gchar *seat = g_getenv ("XDG_SEAT_PATH");
if (!seat)
return FALSE;
GError *error = NULL;
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy (
"org.freedesktop.DisplayManager",
seat,
"org.freedesktop.DisplayManager.Seat");
dbus_g_proxy_call (pProxy, "SwitchToGreeter", &error,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error)
{
cd_warning ("DisplayManager error: %s", error->message);
g_error_free (error);
g_object_unref (pProxy);
return FALSE;
}
g_object_unref (pProxy);
return TRUE;
}
*/
//////////////////
/// USERS LIST ///
//////////////////
static void _free_user (CDUser *pUser)
{
g_free (pUser->cUserName);
g_free (pUser->cIconFile);
g_free (pUser->cRealName);
g_free (pUser);
}
static int _compare_user_name (CDUser *pUser1, CDUser *pUser2)
{
return strcmp (pUser1->cUserName, pUser2->cUserName);
}
static GList* _get_users_list_fallback (void)
{
// read from /etc/passwd
gchar *cContent=NULL;
gsize length = 0;
g_file_get_contents ("/etc/passwd",
&cContent,
&length,
NULL);
g_return_val_if_fail (cContent != NULL, NULL);
// parse eash user
gchar **cUsers = g_strsplit (cContent, "\n", 0);
GList *pUserList = NULL;
gchar **cUserProps;
CDUser *pUser;
char *str;
int i;
for (i = 0; cUsers[i] != NULL; i ++)
{
cUserProps = g_strsplit (cUsers[i], ":", 0);
// add the user if it fits
if (cUserProps && cUserProps[0] && cUserProps[1] && cUserProps[2]
&& atoi (cUserProps[2]) >= 1000 && atoi (cUserProps[2]) < 65530) // heuristic: first user has an udi of 1000, and other users an uid >= 1000; remove the 'nobody' user (uid=65534)
{
pUser = g_new0 (CDUser, 1);
pUser->cUserName = g_strdup (cUserProps[0]);
pUser->cIconFile = NULL;
pUser->cRealName = g_strdup (cUserProps[4]);
if (pUser->cRealName)
{
str = strchr (pUser->cRealName, ',');
if (str) // remove the comments, separated by ','
*str = '\0';
}
pUserList = g_list_insert_sorted (pUserList, pUser, (GCompareFunc)_compare_user_name);
}
}
free (cContent);
g_strfreev (cUsers);
return pUserList;
}
static GList* _get_users_list_gdm (void)
{
GError *error = NULL;
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy ("org.gnome.DisplayManager",
"/org/gnome/DisplayManager/UserManager",
"org.gnome.DisplayManager.UserManager");
GArray *users = NULL;
dbus_g_proxy_call (pProxy, "GetUserList", &error,
G_TYPE_INVALID,
dbus_g_type_get_collection ("GArray", G_TYPE_INT64), &users,
G_TYPE_INVALID);
if (error)
{
cd_warning ("Couldn't get users on the bus from org.gnome.DisplayManager (%s)\n-> Using a fallback method.", error->message);
g_error_free (error);
users = NULL;
}
if (users == NULL)
return _get_users_list_fallback ();
GType g_type_ptrarray = dbus_g_type_get_collection ("GPtrArray",
dbus_g_type_get_struct("GValueArray",
G_TYPE_INT64, // uid
G_TYPE_STRING, // user name
G_TYPE_STRING, // real name
G_TYPE_STRING, // shell
G_TYPE_INT, // login frequency
G_TYPE_STRING, // icon URL
G_TYPE_INVALID));
GPtrArray *info = NULL;
dbus_g_proxy_call (pProxy, "GetUsersInfo", &error,
dbus_g_type_get_collection ("GArray", G_TYPE_INT64), users,
G_TYPE_INVALID,
g_type_ptrarray, &info,
G_TYPE_INVALID);
if (error)
{
cd_warning ("Couldn't get info on the bus from org.gnome.DisplayManager (%s)\n-> Using a fallback method.", error->message);
g_error_free (error);
info = NULL;
}
if (info == NULL)
return _get_users_list_fallback ();
CDUser *pUser;
GList *pUserList = NULL;
GValueArray *va;
GValue *v;
guint i;
for (i = 0; i < info->len; i ++)
{
va = info->pdata[i];
if (! va)
continue;
pUser = g_new0 (CDUser, 1);
v = g_value_array_get_nth (va, 1); // GValueArray is deprecated from 2.32, yet it's so convenient to map the g_type_ptrarray type ...
if (v && G_VALUE_HOLDS_STRING (v))
pUser->cUserName = g_strdup (g_value_get_string (v));
if (pUser->cUserName == NULL) // shouldn't happen
continue;
v = g_value_array_get_nth (va, 2);
if (v && G_VALUE_HOLDS_STRING (v))
pUser->cRealName = g_strdup (g_value_get_string (v));
v = g_value_array_get_nth (va, 5);
if (v && G_VALUE_HOLDS_STRING (v))
pUser->cIconFile = g_strdup (g_value_get_string (v));
pUserList = g_list_insert_sorted (pUserList, pUser, (GCompareFunc)_compare_user_name);
}
g_ptr_array_free (info, TRUE);
g_array_free (users, TRUE);
g_object_unref (pProxy);
return pUserList;
}
static GList *cd_logout_get_users_list (void)
{
// get the list of users
GError *error = NULL;
DBusGProxy *pProxy = cairo_dock_create_new_system_proxy ("org.freedesktop.Accounts",
"/org/freedesktop/Accounts",
"org.freedesktop.Accounts");
GPtrArray *users = NULL;
dbus_g_proxy_call (pProxy, "ListCachedUsers", &error,
G_TYPE_INVALID,
dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &users,
G_TYPE_INVALID);
g_object_unref (pProxy);
if (error)
{
cd_warning ("Couldn't get info on the bus from org.freedesktop.Accounts (%s)\n-> Trying from GnomeDisplayManager.", error->message);
g_error_free (error);
users = NULL;
}
if (users == NULL)
return _get_users_list_gdm ();
// foreach user, get its properties (name & icon).
CDUser *pUser;
GList *pUserList = NULL;
gchar *cUserObjectPath;
guint i;
for (i = 0; i < users->len; i++)
{
cUserObjectPath = g_ptr_array_index (users, i);
pProxy = cairo_dock_create_new_system_proxy ("org.freedesktop.Accounts",
cUserObjectPath,
DBUS_INTERFACE_PROPERTIES);
pUser = g_new0 (CDUser, 1);
pUser->cUserName = cairo_dock_dbus_get_property_as_string (pProxy, "org.freedesktop.Accounts.User", "UserName"); // used to identify the user in SwitchToUser()
if (pUser->cUserName == NULL) // shouldn't happen
continue;
pUser->cIconFile = cairo_dock_dbus_get_property_as_string (pProxy, "org.freedesktop.Accounts.User", "IconFile");
pUser->cRealName = cairo_dock_dbus_get_property_as_string (pProxy, "org.freedesktop.Accounts.User", "RealName");
pUserList = g_list_insert_sorted (pUserList, pUser, (GCompareFunc)_compare_user_name);
g_object_unref (pProxy);
}
return pUserList;
}