From 5c7761f15cae8e28dcca38087e4ae88489db79bc Mon Sep 17 00:00:00 2001 From: Max Krummenacher Date: Wed, 8 Jan 2014 20:41:38 +0100 Subject: lxsession: backport of lxsession-logout 0.4.9.2 segfaults when systemd's logind is installed. --- ...-62bfec81f6c50083423b8501a94be80125396966.patch | 1455 ++++++++++++++++++++ recipes-lxde/lxsession/lxsession_0.4.9.2.bb | 3 +- 2 files changed, 1457 insertions(+), 1 deletion(-) create mode 100644 recipes-lxde/lxsession/lxsession-0.4.9.2/lxsession-logout-git-62bfec81f6c50083423b8501a94be80125396966.patch diff --git a/recipes-lxde/lxsession/lxsession-0.4.9.2/lxsession-logout-git-62bfec81f6c50083423b8501a94be80125396966.patch b/recipes-lxde/lxsession/lxsession-0.4.9.2/lxsession-logout-git-62bfec81f6c50083423b8501a94be80125396966.patch new file mode 100644 index 0000000..464de95 --- /dev/null +++ b/recipes-lxde/lxsession/lxsession-0.4.9.2/lxsession-logout-git-62bfec81f6c50083423b8501a94be80125396966.patch @@ -0,0 +1,1455 @@ +Update lxsession-logout to newer git revision. +This ensures that shutdown, reboot etc. can be done with the help of logind. +Without this we get a segfault when using the nonconsistent implementation for logind. +i.e. function prototypes and implementation do not much. +diff -Naur lxsession-0.4.9.2/lxsession-logout.orig/dbus-interface.c lxsession-0.4.9.2/lxsession-logout/dbus-interface.c +--- lxsession-0.4.9.2/lxsession-logout.orig/dbus-interface.c 2013-04-12 23:02:19.000000000 +0200 ++++ lxsession-0.4.9.2/lxsession-logout/dbus-interface.c 1970-01-01 01:00:00.000000000 +0100 +@@ -1,641 +0,0 @@ +-/** +- * Copyright (c) 2010 LxDE Developers, see the file AUTHORS for details. +- * +- * 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 General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +- */ +- +-#include +-#include +-#include +-#include +-#include +- +-/*** Mechanism independent ***/ +- +-/* D-Bus context. */ +-static struct { +- int connection_tried : 1; /* True if connection has been tried */ +- DBusConnection * connection; /* Handle for connection */ +-} dbus_context; +- +-static GDBusProxy *logind_proxy = NULL; +- +-enum { DBUS_TIMEOUT = 60000 }; /* Reply timeout */ +- +-/* FORWARDS */ +-gboolean dbus_ConsoleKit_CanStop(void); +-gboolean dbus_ConsoleKit_CanRestart(void); +-char * dbus_ConsoleKit_Stop(void); +-char * dbus_ConsoleKit_Restart(void); +-gboolean dbus_UPower_CanSuspend(void); +-gboolean dbus_UPower_CanHibernate(void); +-char * dbus_UPower_Suspend(void); +-char * dbus_UPower_Hibernate(void); +-gboolean dbus_HAL_CanShutdown(void); +-gboolean dbus_HAL_CanReboot(void); +-gboolean dbus_HAL_CanSuspend(void); +-gboolean dbus_HAL_CanHibernate(void); +-char * dbus_HAL_Shutdown(void); +-char * dbus_HAL_Reboot(void); +-char * dbus_HAL_Suspend(void); +-char * dbus_HAL_Hibernate(void); +-char * dbus_LXDE_Logout(void); +-/* End FORWARDS */ +- +-/* Connect to the system bus. Once a connection is made, it is saved for reuse. */ +-static DBusConnection * dbus_connect_system(void) +-{ +- DBusError error; +- dbus_error_init(&error); +- dbus_context.connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error); +- if (dbus_context.connection == NULL) +- { +- g_warning(G_STRLOC ": Failed to connect to the system message bus: %s", error.message); +- dbus_error_free(&error); +- } +- dbus_context.connection_tried = TRUE; +- +- return dbus_context.connection; +-} +- +-static DBusConnection * dbus_connect_session(void) +-{ +- DBusError error; +- dbus_error_init(&error); +- dbus_context.connection = dbus_bus_get(DBUS_BUS_SESSION, &error); +- if (dbus_context.connection == NULL) +- { +- g_warning(G_STRLOC ": Failed to connect to the session message bus: %s", error.message); +- dbus_error_free(&error); +- } +- dbus_context.connection_tried = TRUE; +- +- return dbus_context.connection; +-} +- +- +-/* Send a message. */ +-static DBusMessage * dbus_send_message_system(DBusMessage * message, char * * error_text) +-{ +- /* Get a connection handle. */ +- DBusConnection * connection = dbus_connect_system(); +- if (connection == NULL) +- return FALSE; +- +- /* Send the message. */ +- DBusError error; +- dbus_error_init(&error); +- DBusMessage * reply = dbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT, &error); +- dbus_message_unref(message); +- if (reply == NULL) +- { +- if ((error.name == NULL) || (strcmp(error.name, DBUS_ERROR_NO_REPLY) != 0)) +- { +- if (error_text != NULL) +- *error_text = g_strdup(error.message); +- g_warning(G_STRLOC ": DBUS: %s", error.message); +- } +- dbus_error_free(&error); +- } +- return reply; +-} +- +-/* Send a message. */ +-static DBusMessage * dbus_send_message_session(DBusMessage * message, char * * error_text) +-{ +- /* Get a connection handle. */ +- DBusConnection * connection = dbus_connect_session(); +- if (connection == NULL) +- return FALSE; +- +- /* Send the message. */ +- DBusError error; +- dbus_error_init(&error); +- DBusMessage * reply = dbus_connection_send_with_reply_and_block(connection, message, DBUS_TIMEOUT, &error); +- dbus_message_unref(message); +- if (reply == NULL) +- { +- if ((error.name == NULL) || (strcmp(error.name, DBUS_ERROR_NO_REPLY) != 0)) +- { +- if (error_text != NULL) +- *error_text = g_strdup(error.message); +- g_warning(G_STRLOC ": DBUS: %s", error.message); +- } +- dbus_error_free(&error); +- } +- return reply; +-} +- +-/* Read a result for a method that returns void. */ +-static char * dbus_read_result_void(DBusMessage * reply) +-{ +- if (reply != NULL) +- dbus_message_unref(reply); +- +- /* No result. Assume success. */ +- return NULL; +-} +- +-/* Read a result for a method that returns boolean. */ +-static gboolean dbus_read_result_boolean(DBusMessage * reply) +-{ +- gboolean result = FALSE; +- if (reply != NULL) +- { +- /* Get the boolean result. */ +- DBusError error; +- dbus_error_init(&error); +- dbus_bool_t status = dbus_message_get_args( +- reply, +- &error, +- DBUS_TYPE_BOOLEAN, &result, +- DBUS_TYPE_INVALID); +- dbus_message_unref(reply); +- if ( ! status) +- { +- g_warning(G_STRLOC ": DBUS: %s", error.message); +- dbus_error_free(&error); +- return FALSE; +- } +- } +- return result; +-} +- +-/* Read a result for a method that returns string. */ +-static char * dbus_read_result_string(DBusMessage * reply) +-{ +- char * result = FALSE; +- if (reply != NULL) +- { +- /* Get the boolean result. */ +- DBusError error; +- dbus_error_init(&error); +- dbus_bool_t status = dbus_message_get_args( +- reply, +- &error, +- DBUS_TYPE_STRING, &result, +- DBUS_TYPE_INVALID); +- dbus_message_unref(reply); +- if ( ! status) +- { +- g_warning(G_STRLOC ": DBUS: %s", error.message); +- dbus_error_free(&error); +- return NULL; +- } +- } +- return result; +-} +- +-/*** logind mechanism ***/ +- +-static gboolean +-logind_query (const gchar *function, gboolean default_result, GError **error) +-{ +- GVariant *result; +- gboolean function_result = FALSE; +- const gchar *str; +- +- if (!logind_proxy) +- { +- logind_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, +- G_DBUS_PROXY_FLAGS_NONE, +- NULL, +- "org.freedesktop.login1", +- "/org/freedesktop/login1", +- "org.freedesktop.login1.Manager", +- NULL, +- error); +- if (!logind_proxy) +- return FALSE; +- } +- +- result = g_dbus_proxy_call_sync (logind_proxy, +- function, +- NULL, +- G_DBUS_CALL_FLAGS_NONE, +- -1, +- NULL, +- error); +- if (!result) +- return default_result; +- +- if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(s)"))) +- { +- g_variant_get (result, "(s)", &str); +- if (g_strcmp0 (str, "yes") || g_strcmp0 (str, "challenge")) +- function_result = TRUE; +- else +- function_result = default_result; +- } +- +- g_variant_unref (result); +- return function_result; +-} +- +-static void +-logind_call_function (const gchar *function, gboolean value, GError **error) +-{ +- GVariant *result; +- +- if (!logind_proxy) +- { +- logind_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, +- G_DBUS_PROXY_FLAGS_NONE, +- NULL, +- "org.freedesktop.login1", +- "/org/freedesktop/login1", +- "org.freedesktop.login1.Manager", +- NULL, +- error); +- if (!logind_proxy) +- return; +- } +- +- result = g_dbus_proxy_call_sync (logind_proxy, +- function, +- g_variant_new ("(b)", value), +- G_DBUS_CALL_FLAGS_NONE, +- -1, +- NULL, +- error); +- g_variant_unref (result); +- return; +-} +- +-gboolean +-dbus_logind_CanPowerOff (void) +-{ +- return logind_query ("CanPowerOff", FALSE, NULL); +-} +- +-void +-dbus_logind_PowerOff (GError **error) +-{ +- logind_call_function ("PowerOff", TRUE, error); +-} +- +-gboolean +-dbus_logind_CanReboot (void) +-{ +- return logind_query ("CanReboot", FALSE, NULL); +-} +- +-void +-dbus_logind_Reboot (GError **error) +-{ +- logind_call_function ("Reboot", TRUE, error); +-} +- +-gboolean +-dbus_logind_CanSuspend (void) +-{ +- return logind_query ("CanSuspend", FALSE, NULL); +-} +- +-void +-dbus_logind_Suspend (GError **error) +-{ +- logind_call_function ("Suspend", TRUE, error); +-} +- +-gboolean +-dbus_logind_CanHibernate (void) +-{ +- return logind_query ("CanHibernate", FALSE, NULL); +-} +- +-void +-dbus_logind_Hibernate (GError **error) +-{ +- logind_call_function ("Hibernate", TRUE, error); +-} +- +-/*** ConsoleKit mechanism ***/ +- +-/* Formulate a message to the ConsoleKit Manager interface. */ +-static DBusMessage * dbus_ConsoleKit_formulate_message(const char * const query) +-{ +- return dbus_message_new_method_call( +- "org.freedesktop.ConsoleKit", +- "/org/freedesktop/ConsoleKit/Manager", +- "org.freedesktop.ConsoleKit.Manager", +- query); +-} +- +-/* Send a specified message to the ConsoleKit interface and process a boolean result. */ +-static gboolean dbus_ConsoleKit_query(const char * const query) +-{ +- return dbus_read_result_boolean(dbus_send_message_system(dbus_ConsoleKit_formulate_message(query), NULL)); +-} +- +-/* Send a specified message to the ConsoleKit interface and process a void result. */ +-static char * dbus_ConsoleKit_command(const char * const command) +-{ +- char * error = NULL; +- dbus_read_result_void(dbus_send_message_system(dbus_ConsoleKit_formulate_message(command), &error)); +- return error; +-} +- +-/* Invoke the CanStop method on ConsoleKit. */ +-gboolean dbus_ConsoleKit_CanStop(void) +-{ +- return dbus_ConsoleKit_query("CanStop"); +-} +- +-/* Invoke the CanRestart method on ConsoleKit. */ +-gboolean dbus_ConsoleKit_CanRestart(void) +-{ +- return dbus_ConsoleKit_query("CanRestart"); +-} +- +-/* Invoke the Stop method on ConsoleKit. */ +-char * dbus_ConsoleKit_Stop(void) +-{ +- return dbus_ConsoleKit_command("Stop"); +-} +- +-/* Invoke the Restart method on ConsoleKit. */ +-char * dbus_ConsoleKit_Restart(void) +-{ +- return dbus_ConsoleKit_command("Restart"); +-} +- +-/*** UPower mechanism ***/ +- +-/* Formulate a message to the UPower interface. */ +-static DBusMessage * dbus_UPower_formulate_command(const char * const command) +-{ +- return dbus_message_new_method_call( +- "org.freedesktop.UPower", +- "/org/freedesktop/UPower", +- "org.freedesktop.UPower", +- command); +-} +- +-/* Send a specified message to the UPower interface and process a boolean result. */ +-static gboolean dbus_UPower_query(const char * const query) +-{ +- /* Formulate a message to the Properties interface. */ +- DBusMessage * message = dbus_message_new_method_call( +- "org.freedesktop.UPower", +- "/org/freedesktop/UPower", +- "org.freedesktop.DBus.Properties", +- "Get"); +- const char * const interface_name = "org.freedesktop.UPower"; +- dbus_message_append_args(message, +- DBUS_TYPE_STRING, &interface_name, +- DBUS_TYPE_STRING, &query, +- DBUS_TYPE_INVALID); +- +- /* Send the message. */ +- DBusMessage * reply = dbus_send_message_system(message, NULL); +- if (reply == NULL) +- return FALSE; +- +- /* The return type is VARIANT expected to contain BOOLEAN. */ +- gboolean result = FALSE; +- DBusMessageIter iter; +- DBusMessageIter inner; +- dbus_message_iter_init(reply, &iter); +- if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_VARIANT) +- { +- dbus_message_iter_recurse(&iter, &inner); +- if (dbus_message_iter_get_arg_type(&inner) == DBUS_TYPE_BOOLEAN) +- dbus_message_iter_get_basic(&inner, &result); +- } +- dbus_message_unref(reply); +- return result; +-} +- +-/* Send a specified message to the UPower interface and process a void result. */ +-static char * dbus_UPower_command(const char * const command) +-{ +- char * error = NULL; +- dbus_read_result_void(dbus_send_message_system(dbus_UPower_formulate_command(command), &error)); +- return error; +-} +- +-/* Read the can-suspend property of UPower. */ +-gboolean dbus_UPower_CanSuspend(void) +-{ +- return dbus_UPower_query("CanSuspend"); +-} +- +-/* Read the can-hibernate property of UPower. */ +-gboolean dbus_UPower_CanHibernate(void) +-{ +- return dbus_UPower_query("CanHibernate"); +-} +- +-/* Invoke the Suspend method on UPower. */ +-char * dbus_UPower_Suspend(void) +-{ +- return dbus_UPower_command("Suspend"); +-} +- +-/* Invoke the Hibernate method on UPower. */ +-char * dbus_UPower_Hibernate(void) +-{ +- return dbus_UPower_command("Hibernate"); +-} +- +-/*** HAL mechanism ***/ +- +-/* Formulate a message to the HAL SystemPowerManagement interface. */ +-static DBusMessage * dbus_HAL_formulate_message(const char * const query) +-{ +- return dbus_message_new_method_call( +- "org.freedesktop.Hal", +- "/org/freedesktop/Hal/devices/computer", +- "org.freedesktop.Hal.Device.SystemPowerManagement", +- query); +-} +- +-/* Formulate a message to the HAL SystemPowerManagement interface to query a property. */ +-static DBusMessage * dbus_HAL_formulate_property_query(const char * const method, const char * const property) +-{ +- DBusMessage * message = dbus_message_new_method_call( +- "org.freedesktop.Hal", +- "/org/freedesktop/Hal/devices/computer", +- "org.freedesktop.Hal.Device", +- method); +- if (message != NULL) +- dbus_message_append_args(message, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID); +- return message; +-} +- +-/* Formulate a message to the HAL SystemPowerManagement interface to query a boolean property. */ +-static DBusMessage * dbus_HAL_formulate_boolean_property_query(const char * const property) +-{ +- return dbus_HAL_formulate_property_query("GetPropertyBoolean", property); +-} +- +-/* Formulate a message to the HAL SystemPowerManagement interface to query a string property. */ +-static DBusMessage * dbus_HAL_formulate_string_property_query(const char * const property) +-{ +- return dbus_HAL_formulate_property_query("GetPropertyString", property); +-} +- +-/* Send a specified property query to the HAL interface and process whether the result exists. */ +-static gboolean dbus_HAL_string_exists_query(const char * const property) +-{ +- DBusMessage * message = dbus_HAL_formulate_string_property_query(property); +- if (message == NULL) +- return FALSE; +- DBusMessage * reply = dbus_send_message_system(message, NULL); +- if (reply == NULL) +- return FALSE; +- dbus_message_unref(reply); +- return TRUE; +-} +- +-/* Send a specified property query to the HAL interface and process a boolean result. */ +-static gboolean dbus_HAL_boolean_query(const char * const property) +-{ +- return dbus_read_result_boolean(dbus_send_message_system(dbus_HAL_formulate_boolean_property_query(property), NULL)); +-} +- +-/* Send a specified message to the HAL interface and process a void result. */ +-static char * dbus_HAL_command(const char * const command) +-{ +- /* Formulate the message. */ +- DBusMessage * message = dbus_HAL_formulate_message(command); +- if (message == NULL) +- return NULL; +- +- /* Suspend has an argument. */ +- if (strcmp(command, "Suspend") == 0) +- { +- dbus_int32_t suspend_arg = 0; +- dbus_message_append_args(message, DBUS_TYPE_INT32, &suspend_arg, DBUS_TYPE_INVALID); +- } +- +- /* Send the message and wait for a reply. */ +- char * error = NULL; +- dbus_read_result_void(dbus_send_message_system(message, &error)); +- return error; +-} +- +-/* Read the can-shutdown property of HAL. */ +-gboolean dbus_HAL_CanShutdown(void) +-{ +- return dbus_HAL_string_exists_query("power_management.type"); +-} +- +-/* Read the can-reboot property of HAL. */ +-gboolean dbus_HAL_CanReboot(void) +-{ +- return dbus_HAL_string_exists_query("power_management.type"); +-} +- +-/* Read the can-suspend property of HAL. */ +-gboolean dbus_HAL_CanSuspend(void) +-{ +- return dbus_HAL_boolean_query("power_management.can_suspend"); +-} +- +-/* Read the can-hibernate property of HAL. */ +-gboolean dbus_HAL_CanHibernate(void) +-{ +- return dbus_HAL_boolean_query("power_management.can_hibernate"); +-} +- +-/* Invoke the Shutdown method on HAL. */ +-char * dbus_HAL_Shutdown(void) +-{ +- return dbus_HAL_command("Shutdown"); +-} +- +-/* Invoke the Reboot method on HAL. */ +-char * dbus_HAL_Reboot(void) +-{ +- return dbus_HAL_command("Reboot"); +-} +- +-/* Invoke the Suspend method on HAL. */ +-char * dbus_HAL_Suspend(void) +-{ +- return dbus_HAL_command("Suspend"); +-} +- +-/* Invoke the Hibernate method on HAL. */ +-char * dbus_HAL_Hibernate(void) +-{ +- return dbus_HAL_command("Hibernate"); +-} +- +-/*** LXDE mechanism ***/ +- +-/* Formulate a message to the LXDE Session Manager interface. */ +-static DBusMessage * dbus_LXDE_formulate_message(const char * const query) +-{ +- return dbus_message_new_method_call( +- "org.lxde.SessionManager", +- "/org/lxde/SessionManager", +- "org.lxde.SessionManager", +- query); +-} +- +-/* Send a specified message to the LXDE interface and process a boolean result. */ +-static gboolean dbus_LXDE_query(const char * const query) +-{ +- return dbus_read_result_boolean(dbus_send_message_session(dbus_LXDE_formulate_message(query), NULL)); +-} +- +-/* Send a specified message to the LXDE interface and process a void result. */ +-static char * dbus_LXDE_command(const char * const command) +-{ +- char * error = NULL; +- dbus_read_result_void(dbus_send_message_session(dbus_LXDE_formulate_message(command), &error)); +- return error; +-} +- +-/* Invoke the Logout method on LXDE. */ +-char * dbus_LXDE_Logout(void) +-{ +- return dbus_LXDE_command("Logout"); +-} +- +-/*** Lightdm mechanism ***/ +- +-/* Formulate a message to the Lightdm interface. */ +-static DBusMessage * dbus_Lightdm_formulate_message(const char * const query) +-{ +- return dbus_message_new_method_call( +- "org.freedesktop.DisplayManager", +- g_getenv ("XDG_SEAT_PATH"), +- "org.freedesktop.DisplayManager.Seat", +- query); +-} +- +-/* Send a specified message to the Lightdm interface and process a boolean result. */ +-static gboolean dbus_Lightdm_query(const char * const query) +-{ +- return dbus_read_result_boolean(dbus_send_message_session(dbus_Lightdm_formulate_message(query), NULL)); +-} +- +-/* Send a specified message to the Lightdm interface and process a void result. */ +-static char * dbus_Lightdm_command(const char * const command) +-{ +- char * error = NULL; +- dbus_read_result_void(dbus_send_message_session(dbus_Lightdm_formulate_message(command), &error)); +- return error; +-} +- +-/* Invoke the Logout method on LXDE. */ +-char * dbus_Lightdm_SwitchToGreeter(void) +-{ +- return dbus_Lightdm_command("SwitchToGreeter"); +-} +diff -Naur lxsession-0.4.9.2/lxsession-logout.orig/dbus-interface.h lxsession-0.4.9.2/lxsession-logout/dbus-interface.h +--- lxsession-0.4.9.2/lxsession-logout.orig/dbus-interface.h 2013-03-10 12:48:25.000000000 +0100 ++++ lxsession-0.4.9.2/lxsession-logout/dbus-interface.h 1970-01-01 01:00:00.000000000 +0100 +@@ -1,61 +0,0 @@ +-/** +- * Copyright (c) 2010 LxDE Developers, see the file AUTHORS for details. +- * +- * 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 General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software Foundation, +- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +- */ +- +-#ifndef _DBUS_INTERFACE_H +-#define _DBUS_INTERFACE_H +- +-#include +- +-/* Interface to logind for shutdown, reboot, suspend and hibernate. */ +-extern gboolean dbus_logind_CanPowerOff(void); +-extern gboolean dbus_logind_CanReboot(void); +-extern gboolean dbus_logind_CanSuspend(void); +-extern gboolean dbus_logind_CanHibernate(void); +-extern char * dbus_logind_PowerOff(void); +-extern char * dbus_logind_Reboot(void); +-extern char * dbus_logind_Suspend(void); +-extern char * dbus_logind_Hibernate(void); +- +-/* Interface to ConsoleKit for shutdown and reboot. */ +-extern gboolean dbus_ConsoleKit_CanStop(void); +-extern gboolean dbus_ConsoleKit_CanRestart(void); +-extern char * dbus_ConsoleKit_Stop(void); +-extern char * dbus_ConsoleKit_Restart(void); +- +-/* Interface to UPower for suspend and hibernate. */ +-extern gboolean dbus_UPower_CanSuspend(void); +-extern gboolean dbus_UPower_CanHibernate(void); +-extern char * dbus_UPower_Suspend(void); +-extern char * dbus_UPower_Hibernate(void); +- +-/* Interface to HAL for shutdown, reboot, suspend, and hibernate. +- * HAL is being replaced by the above two mechanisms; this support is legacy. */ +-extern gboolean dbus_HAL_CanShutdown(void); +-extern gboolean dbus_HAL_CanReboot(void); +-extern gboolean dbus_HAL_CanSuspend(void); +-extern gboolean dbus_HAL_CanHibernate(void); +-extern char * dbus_HAL_Shutdown(void); +-extern char * dbus_HAL_Reboot(void); +-extern char * dbus_HAL_Suspend(void); +-extern char * dbus_HAL_Hibernate(void); +- +-extern char * dbus_LXDE_Logout(void); +- +-extern char * dbus_Lightdm_SwitchToGreeter(); +- +-#endif +diff -Naur lxsession-0.4.9.2/lxsession-logout.orig/lxsession-logout.c lxsession-0.4.9.2/lxsession-logout/lxsession-logout.c +--- lxsession-0.4.9.2/lxsession-logout.orig/lxsession-logout.c 2013-05-31 21:38:58.000000000 +0200 ++++ lxsession-0.4.9.2/lxsession-logout/lxsession-logout.c 2014-01-03 15:42:59.596454865 +0100 +@@ -36,7 +36,7 @@ + #include + #include + +-#include "dbus-interface.h" ++#include "lxsession-logout-dbus-interface.h" + + /* Command parameters. */ + static char * prompt = NULL; +@@ -61,18 +61,14 @@ + int hibernate_available : 1; /* Hibernate is available */ + int switch_user_available : 1; /* Switch User is available */ + +- int shutdown_logind : 1; /* Shutdown is available via logind */ +- int reboot_logind : 1; /* Reboot is available via logind */ +- int suspend_logind : 1; /* Suspend is available via logind */ +- int hibernate_logind : 1; /* Hibernate is available via logind */ ++ int shutdown_systemd : 1; /* Shutdown is available via systemd */ ++ int reboot_systemd : 1; /* Reboot is available via systemd */ ++ int suspend_systemd : 1; /* Suspend is available via systemd */ ++ int hibernate_systemd : 1; /* Hibernate is available via systemd */ + int shutdown_ConsoleKit : 1; /* Shutdown is available via ConsoleKit */ + int reboot_ConsoleKit : 1; /* Reboot is available via ConsoleKit */ + int suspend_UPower : 1; /* Suspend is available via UPower */ + int hibernate_UPower : 1; /* Hibernate is available via UPower */ +- int shutdown_HAL : 1; /* Shutdown is available via HAL */ +- int reboot_HAL : 1; /* Reboot is available via HAL */ +- int suspend_HAL : 1; /* Suspend is available via HAL */ +- int hibernate_HAL : 1; /* Hibernate is available via HAL */ + int switch_user_GDM : 1; /* Switch User is available via GDM */ + int switch_user_LIGHTDM : 1; /* Switch User is available via GDM */ + int switch_user_KDM : 1; /* Switch User is available via LIGHTDM */ +@@ -212,7 +208,7 @@ + /* Handler for "clicked" signal on Shutdown button. */ + static void shutdown_clicked(GtkButton * button, HandlerContext * handler_context) + { +- char * error_result = NULL; ++ GError *err = NULL; + gtk_label_set_text(GTK_LABEL(handler_context->error_label), NULL); + + if (handler_context->ltsp) +@@ -224,21 +220,25 @@ + } + } + else if (handler_context->shutdown_ConsoleKit) +- error_result = dbus_ConsoleKit_Stop(); +- else if (handler_context->shutdown_logind) +- error_result = dbus_logind_PowerOff(); +- else if (handler_context->shutdown_HAL) +- error_result = dbus_HAL_Shutdown(); +- +- if (error_result != NULL) +- gtk_label_set_text(GTK_LABEL(handler_context->error_label), error_result); +- else gtk_main_quit(); ++ dbus_ConsoleKit_Stop(&err); ++ else if (handler_context->shutdown_systemd) ++ dbus_systemd_PowerOff(&err); ++ ++ if (err) ++ { ++ gtk_label_set_text(GTK_LABEL(handler_context->error_label), err->message); ++ g_error_free (err); ++ } ++ else ++ { ++ gtk_main_quit(); ++ } + } + + /* Handler for "clicked" signal on Reboot button. */ + static void reboot_clicked(GtkButton * button, HandlerContext * handler_context) + { +- char * error_result = NULL; ++ GError *err = NULL; + gtk_label_set_text(GTK_LABEL(handler_context->error_label), NULL); + + if (handler_context->ltsp) +@@ -250,58 +250,71 @@ + } + } + else if (handler_context->reboot_ConsoleKit) +- error_result = dbus_ConsoleKit_Restart(); +- else if (handler_context->reboot_logind) +- error_result = dbus_logind_Reboot(); +- else if (handler_context->reboot_HAL) +- error_result = dbus_HAL_Reboot(); +- +- if (error_result != NULL) +- gtk_label_set_text(GTK_LABEL(handler_context->error_label), error_result); +- else gtk_main_quit(); ++ dbus_ConsoleKit_Restart(&err); ++ else if (handler_context->reboot_systemd) ++ dbus_systemd_Reboot(&err); ++ ++ if (err) ++ { ++ gtk_label_set_text(GTK_LABEL(handler_context->error_label), err->message); ++ g_error_free (err); ++ } ++ else ++ { ++ gtk_main_quit(); ++ } + } + + /* Handler for "clicked" signal on Suspend button. */ + static void suspend_clicked(GtkButton * button, HandlerContext * handler_context) + { +- char * error_result = NULL; ++ GError *err = NULL; + gtk_label_set_text(GTK_LABEL(handler_context->error_label), NULL); + + lock_screen(); + if (handler_context->suspend_UPower) +- error_result = dbus_UPower_Suspend(); +- else if (handler_context->suspend_logind) +- error_result = dbus_logind_Suspend(); +- else if (handler_context->suspend_HAL) +- error_result = dbus_HAL_Suspend(); +- +- if (error_result != NULL) +- gtk_label_set_text(GTK_LABEL(handler_context->error_label), error_result); +- else gtk_main_quit(); ++ dbus_UPower_Suspend(&err); ++ else if (handler_context->suspend_systemd) ++ dbus_systemd_Suspend(&err); ++ ++ if (err) ++ { ++ gtk_label_set_text(GTK_LABEL(handler_context->error_label), err->message); ++ g_error_free (err); ++ } ++ else ++ { ++ gtk_main_quit(); ++ } + } + + /* Handler for "clicked" signal on Hibernate button. */ + static void hibernate_clicked(GtkButton * button, HandlerContext * handler_context) + { +- char * error_result = NULL; ++ GError *err = NULL; + gtk_label_set_text(GTK_LABEL(handler_context->error_label), NULL); + + lock_screen(); + if (handler_context->hibernate_UPower) +- error_result = dbus_UPower_Hibernate(); +- else if (handler_context->hibernate_logind) +- error_result = dbus_logind_Hibernate(); +- else if (handler_context->hibernate_HAL) +- error_result = dbus_HAL_Hibernate(); +- +- if (error_result != NULL) +- gtk_label_set_text(GTK_LABEL(handler_context->error_label), error_result); +- else gtk_main_quit(); ++ dbus_UPower_Hibernate(&err); ++ else if (handler_context->hibernate_systemd) ++ dbus_systemd_Hibernate(&err); ++ ++ if (err) ++ { ++ gtk_label_set_text(GTK_LABEL(handler_context->error_label), err->message); ++ g_error_free (err); ++ } ++ else ++ { ++ gtk_main_quit(); ++ } + } + + /* Handler for "clicked" signal on Switch User button. */ + static void switch_user_clicked(GtkButton * button, HandlerContext * handler_context) + { ++ GError *err = NULL; + gtk_label_set_text(GTK_LABEL(handler_context->error_label), NULL); + + lock_screen(); +@@ -310,11 +323,19 @@ + else if (handler_context->switch_user_KDM) + g_spawn_command_line_sync("kdmctl reserve", NULL, NULL, NULL, NULL); + else if (handler_context->switch_user_LIGHTDM) +- dbus_Lightdm_SwitchToGreeter(); ++ dbus_Lightdm_SwitchToGreeter(&err); + else if(handler_context->switch_user_LXDM) + g_spawn_command_line_sync("lxdm-binary -c USER_SWITCH", NULL, NULL, NULL, NULL); + +- gtk_main_quit(); ++ if (err) ++ { ++ gtk_label_set_text(GTK_LABEL(handler_context->error_label), err->message); ++ g_error_free (err); ++ } ++ else ++ { ++ gtk_main_quit(); ++ } + } + + /* Handler for "clicked" signal on Lock button. */ +@@ -449,26 +470,26 @@ + const char * p = g_getenv("_LXSESSION_PID"); + if (p != NULL) handler_context.lxsession_pid = atoi(p); + +- /* Initialize capabilities of the logind mechanism. */ +- if (dbus_logind_CanPowerOff()) ++ /* Initialize capabilities of the systemd mechanism. */ ++ if (dbus_systemd_CanPowerOff()) + { + handler_context.shutdown_available = TRUE; +- handler_context.shutdown_logind = TRUE; ++ handler_context.shutdown_systemd = TRUE; + } +- if (dbus_logind_CanReboot()) ++ if (dbus_systemd_CanReboot()) + { + handler_context.reboot_available = TRUE; +- handler_context.reboot_logind = TRUE; ++ handler_context.reboot_systemd = TRUE; + } +- if (dbus_logind_CanSuspend()) ++ if (dbus_systemd_CanSuspend()) + { + handler_context.suspend_available = TRUE; +- handler_context.suspend_logind = TRUE; ++ handler_context.suspend_systemd = TRUE; + } +- if (dbus_logind_CanHibernate()) ++ if (dbus_systemd_CanHibernate()) + { + handler_context.hibernate_available = TRUE; +- handler_context.hibernate_logind = TRUE; ++ handler_context.hibernate_systemd = TRUE; + } + + /* Initialize capabilities of the ConsoleKit mechanism. */ +@@ -495,28 +516,6 @@ + handler_context.hibernate_UPower = TRUE; + } + +- /* Initialize capabilities of the HAL mechanism. */ +- if (!handler_context.shutdown_available && dbus_HAL_CanShutdown()) +- { +- handler_context.shutdown_available = TRUE; +- handler_context.shutdown_HAL = TRUE; +- } +- if (!handler_context.reboot_available && dbus_HAL_CanReboot()) +- { +- handler_context.reboot_available = TRUE; +- handler_context.reboot_HAL = TRUE; +- } +- if (!handler_context.suspend_available && dbus_HAL_CanSuspend()) +- { +- handler_context.suspend_available = TRUE; +- handler_context.suspend_HAL = TRUE; +- } +- if (!handler_context.hibernate_available && dbus_HAL_CanHibernate()) +- { +- handler_context.hibernate_available = TRUE; +- handler_context.hibernate_HAL = TRUE; +- } +- + /* If we are under GDM, its "Switch User" is available. */ + if (verify_running("gdm", "gdmflexiserver")) + { +@@ -664,20 +663,23 @@ + if (session_name == NULL) + session_name = "LXDE"; + +- const gchar *command_line = "lsb_release -r -s"; + gchar *output = NULL; +- GError *error; + +- if (!g_spawn_command_line_sync( command_line, +- &output, +- NULL, +- NULL, +- &error)) ++ if (g_find_program_in_path("lsb_release")) + { ++ const gchar *command_line = "lsb_release -r -s"; ++ GError *error; ++ if (!g_spawn_command_line_sync( command_line, ++ &output, ++ NULL, ++ NULL, ++ &error)) ++ { + +- fprintf (stderr, "Error: %s\n", error->message); +- g_error_free (error); ++ fprintf (stderr, "Error: %s\n", error->message); ++ g_error_free (error); + ++ } + } + + if (output == NULL) +diff -Naur lxsession-0.4.9.2/lxsession-logout.orig/lxsession-logout-dbus-interface.c lxsession-0.4.9.2/lxsession-logout/lxsession-logout-dbus-interface.c +--- lxsession-0.4.9.2/lxsession-logout.orig/lxsession-logout-dbus-interface.c 1970-01-01 01:00:00.000000000 +0100 ++++ lxsession-0.4.9.2/lxsession-logout/lxsession-logout-dbus-interface.c 2014-01-03 15:42:59.596454865 +0100 +@@ -0,0 +1,368 @@ ++/* Taken from LightDM and modified. ++ * Copyright (C) 2012 Fabrice THIROUX . ++ * ++ **** License from former file (power.c) **** ++ * ++ * Copyright (C) 2010-2011 Robert Ancell. ++ * Author: Robert Ancell ++ * ++ * This library is free software; you can redistribute it and/or modify it under ++ * the terms of the GNU Lesser General Public License as published by the Free ++ * Software Foundation; either version 3 of the License, or (at your option) any ++ * later version. See http://www.gnu.org/copyleft/lgpl.html the full text of the ++ * license. ++ */ ++#include ++#include ++#include ++#include ++#include ++ ++/*** Mechanism independent ***/ ++ ++static GDBusProxy *upower_proxy = NULL; ++static GDBusProxy *ck_proxy = NULL; ++static GDBusProxy *systemd_proxy = NULL; ++static GDBusProxy *lightdm_proxy = NULL; ++static GDBusProxy *lxde_proxy = NULL; ++ ++ ++/*** UPower mechanism ***/ ++ ++static gboolean ++upower_call_function (const gchar *function, gboolean default_result, GError **error) ++{ ++ GVariant *result; ++ gboolean function_result = FALSE; ++ ++ if (!upower_proxy) ++ { ++ upower_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, ++ G_DBUS_PROXY_FLAGS_NONE, ++ NULL, ++ "org.freedesktop.UPower", ++ "/org/freedesktop/UPower", ++ "org.freedesktop.UPower", ++ NULL, ++ error); ++ if (!upower_proxy) ++ return FALSE; ++ } ++ ++ result = g_dbus_proxy_call_sync (upower_proxy, ++ function, ++ NULL, ++ G_DBUS_CALL_FLAGS_NONE, ++ -1, ++ NULL, ++ error); ++ if (!result) ++ return default_result; ++ ++ if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(b)"))) ++ g_variant_get (result, "(b)", &function_result); ++ ++ g_variant_unref (result); ++ return function_result; ++} ++ ++gboolean ++dbus_UPower_CanSuspend (void) ++{ ++ return upower_call_function ("SuspendAllowed", FALSE, NULL); ++} ++ ++gboolean ++dbus_UPower_Suspend (GError **error) ++{ ++ return upower_call_function ("Suspend", TRUE, error); ++} ++ ++gboolean ++dbus_UPower_CanHibernate (void) ++{ ++ return upower_call_function ("HibernateAllowed", FALSE, NULL); ++} ++ ++gboolean ++dbus_UPower_Hibernate (GError **error) ++{ ++ return upower_call_function ("Hibernate", TRUE, error); ++} ++ ++/*** ConsoleKit mechanism ***/ ++ ++static gboolean ++ck_call_function (const gchar *function, gboolean default_result, GError **error) ++{ ++ GVariant *result; ++ gboolean function_result = FALSE; ++ ++ if (!ck_proxy) ++ { ++ ck_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, ++ G_DBUS_PROXY_FLAGS_NONE, ++ NULL, ++ "org.freedesktop.ConsoleKit", ++ "/org/freedesktop/ConsoleKit/Manager", ++ "org.freedesktop.ConsoleKit.Manager", ++ NULL, ++ error); ++ if (!ck_proxy) ++ return FALSE; ++ } ++ ++ result = g_dbus_proxy_call_sync (ck_proxy, ++ function, ++ NULL, ++ G_DBUS_CALL_FLAGS_NONE, ++ -1, ++ NULL, ++ error); ++ if (!result) ++ return default_result; ++ ++ if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(b)"))) ++ g_variant_get (result, "(b)", &function_result); ++ ++ g_variant_unref (result); ++ return function_result; ++} ++ ++gboolean ++dbus_ConsoleKit_CanRestart (void) ++{ ++ return ck_call_function ("CanRestart", FALSE, NULL); ++} ++ ++gboolean ++dbus_ConsoleKit_Restart (GError **error) ++{ ++ return ck_call_function ("Restart", TRUE, error); ++} ++ ++gboolean ++dbus_ConsoleKit_CanStop (void) ++{ ++ return ck_call_function ("CanStop", FALSE, NULL); ++} ++ ++gboolean ++dbus_ConsoleKit_Stop (GError **error) ++{ ++ return ck_call_function ("Stop", TRUE, error); ++} ++ ++/*** Systemd mechanism ***/ ++ ++static gboolean ++systemd_query (const gchar *function, gboolean default_result, GError **error) ++{ ++ GVariant *result; ++ gboolean function_result = FALSE; ++ const gchar *str; ++ ++ if (!systemd_proxy) ++ { ++ systemd_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, ++ G_DBUS_PROXY_FLAGS_NONE, ++ NULL, ++ "org.freedesktop.login1", ++ "/org/freedesktop/login1", ++ "org.freedesktop.login1.Manager", ++ NULL, ++ error); ++ if (!systemd_proxy) ++ return FALSE; ++ } ++ ++ result = g_dbus_proxy_call_sync (systemd_proxy, ++ function, ++ NULL, ++ G_DBUS_CALL_FLAGS_NONE, ++ -1, ++ NULL, ++ error); ++ if (!result) ++ return default_result; ++ ++ if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(s)"))) ++ { ++ g_variant_get (result, "(s)", &str); ++ if (g_strcmp0 (str, "yes") || g_strcmp0 (str, "challenge")) ++ function_result = TRUE; ++ else ++ function_result = default_result; ++ } ++ ++ g_variant_unref (result); ++ return function_result; ++} ++ ++static void ++systemd_call_function (const gchar *function, gboolean value, GError **error) ++{ ++ GVariant *result; ++ ++ if (!systemd_proxy) ++ { ++ systemd_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, ++ G_DBUS_PROXY_FLAGS_NONE, ++ NULL, ++ "org.freedesktop.login1", ++ "/org/freedesktop/login1", ++ "org.freedesktop.login1.Manager", ++ NULL, ++ error); ++ if (!systemd_proxy) ++ return; ++ } ++ ++ result = g_dbus_proxy_call_sync (systemd_proxy, ++ function, ++ g_variant_new ("(b)", value), ++ G_DBUS_CALL_FLAGS_NONE, ++ -1, ++ NULL, ++ error); ++ g_variant_unref (result); ++ return; ++} ++ ++gboolean ++dbus_systemd_CanPowerOff (void) ++{ ++ return systemd_query ("CanPowerOff", FALSE, NULL); ++} ++ ++void ++dbus_systemd_PowerOff (GError **error) ++{ ++ systemd_call_function ("PowerOff", TRUE, error); ++} ++ ++gboolean ++dbus_systemd_CanReboot (void) ++{ ++ return systemd_query ("CanReboot", FALSE, NULL); ++} ++ ++void ++dbus_systemd_Reboot (GError **error) ++{ ++ systemd_call_function ("Reboot", TRUE, error); ++} ++ ++gboolean ++dbus_systemd_CanSuspend (void) ++{ ++ return systemd_query ("CanSuspend", FALSE, NULL); ++} ++ ++void ++dbus_systemd_Suspend (GError **error) ++{ ++ systemd_call_function ("Suspend", TRUE, error); ++} ++ ++gboolean ++dbus_systemd_CanHibernate (void) ++{ ++ return systemd_query ("CanHibernate", FALSE, NULL); ++} ++ ++void ++dbus_systemd_Hibernate (GError **error) ++{ ++ systemd_call_function ("Hibernate", TRUE, error); ++} ++ ++/*** Lightdm mechanism ***/ ++ ++static gboolean ++lightdm_call_function (const gchar *function, gboolean default_result, GError **error) ++{ ++ GVariant *result; ++ gboolean function_result = FALSE; ++ ++ if (!lightdm_proxy) ++ { ++ lightdm_proxy = g_dbus_proxy_new_for_bus_sync ( G_BUS_TYPE_SYSTEM, ++ G_DBUS_PROXY_FLAGS_NONE, ++ NULL, ++ "org.freedesktop.DisplayManager", ++ g_getenv ("XDG_SEAT_PATH"), ++ "org.freedesktop.DisplayManager.Seat", ++ NULL, ++ error); ++ if (!lightdm_proxy) ++ return FALSE; ++ } ++ ++ result = g_dbus_proxy_call_sync (lightdm_proxy, ++ function, ++ NULL, ++ G_DBUS_CALL_FLAGS_NONE, ++ -1, ++ NULL, ++ error); ++ if (!result) ++ return default_result; ++ ++ if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(b)"))) ++ g_variant_get (result, "(b)", &function_result); ++ ++ g_variant_unref (result); ++ return function_result; ++} ++ ++gboolean ++dbus_Lightdm_SwitchToGreeter (GError **error) ++{ ++ return lightdm_call_function ("SwitchToGreeter", TRUE, error); ++} ++ ++/*** LXDE mechanism ***/ ++ ++static gboolean ++lxde_call_function (const gchar *function, gboolean default_result, GError **error) ++{ ++ GVariant *result; ++ gboolean function_result = FALSE; ++ ++ if (!lxde_proxy) ++ { ++ lxde_proxy = g_dbus_proxy_new_for_bus_sync ( G_BUS_TYPE_SYSTEM, ++ G_DBUS_PROXY_FLAGS_NONE, ++ NULL, ++ "org.lxde.SessionManager", ++ "/org/lxde/SessionManager", ++ "org.lxde.SessionManager", ++ NULL, ++ error); ++ if (!lxde_proxy) ++ return FALSE; ++ } ++ ++ result = g_dbus_proxy_call_sync (lxde_proxy, ++ function, ++ NULL, ++ G_DBUS_CALL_FLAGS_NONE, ++ -1, ++ NULL, ++ error); ++ if (!result) ++ return default_result; ++ ++ if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(b)"))) ++ g_variant_get (result, "(b)", &function_result); ++ ++ g_variant_unref (result); ++ return function_result; ++} ++ ++gboolean ++dbus_LXDE_Logout (GError **error) ++{ ++ return lxde_call_function ("Restart", TRUE, error); ++} +diff -Naur lxsession-0.4.9.2/lxsession-logout.orig/lxsession-logout-dbus-interface.h lxsession-0.4.9.2/lxsession-logout/lxsession-logout-dbus-interface.h +--- lxsession-0.4.9.2/lxsession-logout.orig/lxsession-logout-dbus-interface.h 1970-01-01 01:00:00.000000000 +0100 ++++ lxsession-0.4.9.2/lxsession-logout/lxsession-logout-dbus-interface.h 2014-01-03 15:42:59.596454865 +0100 +@@ -0,0 +1,52 @@ ++/** ++ * Copyright (c) 2010 LxDE Developers, see the file AUTHORS for details. ++ * ++ * 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 General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. ++ */ ++ ++#ifndef _DBUS_INTERFACE_H ++#define _DBUS_INTERFACE_H ++ ++#include ++ ++/* Interface to ConsoleKit for shutdown and reboot. */ ++extern gboolean dbus_ConsoleKit_CanStop(void); ++extern gboolean dbus_ConsoleKit_CanRestart(void); ++extern gboolean dbus_ConsoleKit_Stop(GError **); ++extern gboolean dbus_ConsoleKit_Restart(GError **); ++ ++/* Interface to UPower for suspend and hibernate. */ ++extern gboolean dbus_UPower_CanSuspend(void); ++extern gboolean dbus_UPower_CanHibernate(void); ++extern gboolean dbus_UPower_Suspend(GError **); ++extern gboolean dbus_UPower_Hibernate(GError **); ++ ++/* Interface to systemd for suspend, hibernate, shutdown and reboot. */ ++extern gboolean dbus_systemd_CanPowerOff(void); ++extern gboolean dbus_systemd_CanReboot(void); ++extern gboolean dbus_systemd_CanSuspend(void); ++extern gboolean dbus_systemd_CanHibernate(void); ++extern void dbus_systemd_PowerOff(GError **); ++extern void dbus_systemd_Reboot(GError **); ++extern void dbus_systemd_Suspend(GError **); ++extern void dbus_systemd_Hibernate(GError **); ++ ++/* Interface to lightdm for switch user. */ ++extern gboolean dbus_Lightdm_SwitchToGreeter (GError **error); ++ ++/* Interface to lxde for logout. */ ++extern gboolean dbus_LXDE_Logout (GError **error); ++ ++#endif +diff -Naur lxsession-0.4.9.2/lxsession-logout.orig/Makefile.am lxsession-0.4.9.2/lxsession-logout/Makefile.am +--- lxsession-0.4.9.2/lxsession-logout.orig/Makefile.am 2012-10-25 20:20:04.000000000 +0200 ++++ lxsession-0.4.9.2/lxsession-logout/Makefile.am 2014-01-03 15:42:59.596454865 +0100 +@@ -8,6 +8,6 @@ + lxsession_logout_LDADD = $(GTK_LIBS) $(SM_LIBS) $(DBUS_LIBS) $(X11_LIBS) + + lxsession_logout_SOURCES= \ +- dbus-interface.c \ +- dbus-interface.h \ ++ lxsession-logout-dbus-interface.c \ ++ lxsession-logout-dbus-interface.h \ + lxsession-logout.c diff --git a/recipes-lxde/lxsession/lxsession_0.4.9.2.bb b/recipes-lxde/lxsession/lxsession_0.4.9.2.bb index 08723e2..d3002ce 100644 --- a/recipes-lxde/lxsession/lxsession_0.4.9.2.bb +++ b/recipes-lxde/lxsession/lxsession_0.4.9.2.bb @@ -2,7 +2,7 @@ DESCRIPTION = "LXDE session manager" HOMEPAGE = "http://lxde.sf.net/" SECTION = "x11" -PR = "r1" +PR = "r2" LICENSE = "GPLv2" LIC_FILES_CHKSUM = "file://COPYING;md5=a76102f7f48780284bee49e6edaeb5a9" @@ -12,6 +12,7 @@ DEPENDS = "${COMMON_DEPENDS} xproto virtual/libx11" RDEPENDS_{PN} = "${COMMON_DEPENDS} upower dbus-x11" SRC_URI = "${SOURCEFORGE_MIRROR}/lxde/${PN}-${PV}.tar.gz" +SRC_URI += "file://lxsession-logout-git-62bfec81f6c50083423b8501a94be80125396966.patch" SRC_URI[md5sum] = "bc3eb71936dbdf813e9ac2f00ab948f0" SRC_URI[sha256sum] = "eff03e573b561cabe81c5d015d825e3d998e98d6621040113d7df471c8b9cfb4" -- cgit v1.2.3