Index: daemon/gdmconsolekit.c

===================================================================

--- daemon/gdmconsolekit.c	(revision 4556)

+++ daemon/gdmconsolekit.c	(working copy)

@@ -1,6 +1,6 @@

 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-

  *

- * Copyright (C) 2006 William Jon McCann <mccann@jhu.edu>

+ * Copyright (C) 2006-2007 William Jon McCann <mccann@jhu.edu>

  *

  * 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

@@ -20,11 +20,11 @@

 #include "config.h"

+#include <stdlib.h>

 #include <pwd.h>

 #define DBUS_API_SUBJECT_TO_CHANGE

 #include <dbus/dbus.h>

-#include <dbus/dbus-glib.h>

 #include <dbus/dbus-glib-lowlevel.h>

 #include "misc.h" /* for gdm_debug */

@@ -38,182 +38,360 @@

 #define CK_MANAGER_INTERFACE "org.freedesktop.ConsoleKit.Manager"

 #define CK_SESSION_INTERFACE "org.freedesktop.ConsoleKit.Session"

-#define CK_TYPE_PARAMETER_STRUCT (dbus_g_type_get_struct ("GValueArray", \

-							  G_TYPE_STRING, \

-							  G_TYPE_VALUE, \

-							  G_TYPE_INVALID))

-#define CK_TYPE_PARAMETER_LIST (dbus_g_type_get_collection ("GPtrArray", \

-							    CK_TYPE_PARAMETER_STRUCT))

+static DBusConnection *private_connection = NULL;

+

 static void

-add_param_int (GPtrArray       *parameters,

+add_param_int (DBusMessageIter *iter_struct,

 	       const char      *key,

 	       int              value)

 {

-	GValue val = { 0, };

-	GValue param_val = { 0, };

+	DBusMessageIter iter_struct_entry;

+	DBusMessageIter iter_var;

+

+	dbus_message_iter_open_container (iter_struct,

+					  DBUS_TYPE_STRUCT,

+					  NULL,

+					  &iter_struct_entry);

+

+	dbus_message_iter_append_basic (&iter_struct_entry,

+					DBUS_TYPE_STRING,

+					&key);

+

+	dbus_message_iter_open_container (&iter_struct_entry,

+					  DBUS_TYPE_VARIANT,

+					  DBUS_TYPE_INT32_AS_STRING,

+					  &iter_var);

+

+	dbus_message_iter_append_basic (&iter_var,

+					DBUS_TYPE_INT32,

+					&value);

+

+	dbus_message_iter_close_container (&iter_struct_entry,

+					   &iter_var);

-	g_value_init (&val, G_TYPE_INT);

-	g_value_set_int (&val, value);

-	g_value_init (&param_val, CK_TYPE_PARAMETER_STRUCT);

-	g_value_take_boxed (&param_val,

-			    dbus_g_type_specialized_construct (CK_TYPE_PARAMETER_STRUCT));

-	dbus_g_type_struct_set (&param_val,

-				0, key,

-				1, &val,

-				G_MAXUINT);

-	g_ptr_array_add (parameters, g_value_get_boxed (&param_val));

+	dbus_message_iter_close_container (iter_struct, &iter_struct_entry);

 }

 static void

-add_param_boolean (GPtrArray       *parameters,

+add_param_boolean (DBusMessageIter *iter_struct,

 		   const char      *key,

 		   gboolean         value)

 {

-	GValue val = { 0, };

-	GValue param_val = { 0, };

+	DBusMessageIter iter_struct_entry;

+	DBusMessageIter iter_var;

-	g_value_init (&val, G_TYPE_BOOLEAN);

-	g_value_set_boolean (&val, value);

-	g_value_init (&param_val, CK_TYPE_PARAMETER_STRUCT);

-	g_value_take_boxed (&param_val,

-			    dbus_g_type_specialized_construct (CK_TYPE_PARAMETER_STRUCT));

-	dbus_g_type_struct_set (&param_val,

-				0, key,

-				1, &val,

-				G_MAXUINT);

-	g_ptr_array_add (parameters, g_value_get_boxed (&param_val));

+	dbus_message_iter_open_container (iter_struct,

+					  DBUS_TYPE_STRUCT,

+					  NULL,

+					  &iter_struct_entry);

+

+	dbus_message_iter_append_basic (&iter_struct_entry,

+					DBUS_TYPE_STRING,

+					&key);

+

+	dbus_message_iter_open_container (&iter_struct_entry,

+					  DBUS_TYPE_VARIANT,

+					  DBUS_TYPE_BOOLEAN_AS_STRING,

+					  &iter_var);

+

+	dbus_message_iter_append_basic (&iter_var,

+					DBUS_TYPE_BOOLEAN,

+					&value);

+

+	dbus_message_iter_close_container (&iter_struct_entry,

+					   &iter_var);

+

+	dbus_message_iter_close_container (iter_struct, &iter_struct_entry);

 }

 static void

-add_param_string (GPtrArray       *parameters,

+add_param_string (DBusMessageIter *iter_struct,

 		  const char      *key,

 		  const char      *value)

 {

-	GValue val = { 0, };

-	GValue param_val = { 0, };

+	DBusMessageIter iter_struct_entry;

+	DBusMessageIter iter_var;

+

+	dbus_message_iter_open_container (iter_struct,

+					  DBUS_TYPE_STRUCT,

+					  NULL,

+					  &iter_struct_entry);

+

+	dbus_message_iter_append_basic (&iter_struct_entry,

+					DBUS_TYPE_STRING,

+					&key);

+

+	dbus_message_iter_open_container (&iter_struct_entry,

+					  DBUS_TYPE_VARIANT,

+					  DBUS_TYPE_STRING_AS_STRING,

+					  &iter_var);

+

+	dbus_message_iter_append_basic (&iter_var,

+					DBUS_TYPE_STRING,

+					&value);

+

+	dbus_message_iter_close_container (&iter_struct_entry,

+					   &iter_var);

+

+	dbus_message_iter_close_container (iter_struct, &iter_struct_entry);

+}

+

+static gboolean

+session_get_x11_display (DBusConnection *connection,

+			 const char     *ssid,

+			 char          **str)

+{

+	DBusError       error;

+	DBusMessage    *message;

+	DBusMessage    *reply;

+	DBusMessageIter iter;

+	const char     *value;

+

+	if (str != NULL) {

+		*str = NULL;

+	}

+

+	message = dbus_message_new_method_call (CK_NAME,

+						ssid,

+						CK_SESSION_INTERFACE,

+						"GetX11Display");

+	if (message == NULL) {

+		gdm_debug ("ConsoleKit: Couldn't allocate the D-Bus message");

+		return FALSE;

+	}

+

+	dbus_error_init (&error);

+	reply = dbus_connection_send_with_reply_and_block (connection,

+							   message,

+							   -1, &error);

+	if (dbus_error_is_set (&error)) {

+		gdm_debug ("ConsoleKit: %s raised:\n %s\n\n", error.name, error.message);

+		reply = NULL;

+	}

+

+        dbus_connection_flush (connection);

+        dbus_message_unref (message);

+

+	if (reply == NULL) {

+		return FALSE;

+	}

-	g_value_init (&val, G_TYPE_STRING);

-	g_value_set_string (&val, value);

+	dbus_message_iter_init (reply, &iter);

+	dbus_message_iter_get_basic (&iter, &value);

+	if (str != NULL) {

+		*str = g_strdup (value);

+	}

+	dbus_message_unref (reply);

-	g_value_init (&param_val, CK_TYPE_PARAMETER_STRUCT);

-	g_value_take_boxed (&param_val,

-			    dbus_g_type_specialized_construct (CK_TYPE_PARAMETER_STRUCT));

-

-	dbus_g_type_struct_set (&param_val,

-				0, key,

-				1, &val,

-				G_MAXUINT);

-	g_ptr_array_add (parameters, g_value_get_boxed (&param_val));

+	return TRUE;

 }

 static gboolean

-get_string (DBusGProxy *proxy,

-	    const char *method,

-	    char      **str)

+session_unlock (DBusConnection *connection,

+		const char     *ssid)

+{

+	DBusError       error;

+	DBusMessage    *message;

+	DBusMessage    *reply;

+

+	gdm_debug ("ConsoleKit: Unlocking session %s", ssid);

+	message = dbus_message_new_method_call (CK_NAME,

+						ssid,

+						CK_SESSION_INTERFACE,

+						"Unlock");

+	if (message == NULL) {

+		gdm_debug ("ConsoleKit: Couldn't allocate the D-Bus message");

+		return FALSE;

+	}

+

+	dbus_error_init (&error);

+	reply = dbus_connection_send_with_reply_and_block (connection,

+							   message,

+							   -1, &error);

+        dbus_message_unref (message);

+        dbus_message_unref (reply);

+        dbus_connection_flush (connection);

+

+	if (dbus_error_is_set (&error)) {

+		gdm_debug ("ConsoleKit: %s raised:\n %s\n\n", error.name, error.message);

+		return FALSE;

+	}

+

+	return TRUE;

+}

+

+/* from libhal */

+static char **

+get_path_array_from_iter (DBusMessageIter *iter,

+			  int             *num_elements)

+{

+	int count;

+	char **buffer;

+

+	count = 0;

+	buffer = (char **)malloc (sizeof (char *) * 8);

+

+	if (buffer == NULL)

+		goto oom;

+

+	buffer[0] = NULL;

+	while (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_OBJECT_PATH) {

+		const char *value;

+		char *str;

+

+		if ((count % 8) == 0 && count != 0) {

+			buffer = realloc (buffer, sizeof (char *) * (count + 8));

+			if (buffer == NULL)

+				goto oom;

+		}

+

+		dbus_message_iter_get_basic (iter, &value);

+		str = strdup (value);

+		if (str == NULL)

+			goto oom;

+

+		buffer[count] = str;

+

+		dbus_message_iter_next (iter);

+		count++;

+	}

+

+	if ((count % 8) == 0) {

+		buffer = realloc (buffer, sizeof (char *) * (count + 1));

+		if (buffer == NULL)

+			goto oom;

+	}

+

+	buffer[count] = NULL;

+	if (num_elements != NULL)

+		*num_elements = count;

+	return buffer;

+

+oom:

+	fprintf (stderr, "%s %d : error allocating memory\n", __FILE__, __LINE__);

+	return NULL;

+

+}

+

+static char **

+get_sessions_for_user (DBusConnection *connection,

+		       const char     *user,

+		       const char     *x11_display)

 {

-	GError	*error;

-	gboolean res;

+	DBusError       error;

+	DBusMessage    *message;

+	DBusMessage    *reply;

+	DBusMessageIter iter;

+	DBusMessageIter iter_reply;

+	DBusMessageIter iter_array;

+	struct passwd	*pwent;

+	char           **sessions;

+

+	sessions = NULL;

+	message = NULL;

+	reply = NULL;

-	error = NULL;

-	res = dbus_g_proxy_call (proxy,

-				 method,

-				 &error,

-				 G_TYPE_INVALID,

-				 G_TYPE_STRING, str,

-				 G_TYPE_INVALID);

-	if (! res) {

-		g_warning ("%s failed: %s", method, error->message);

-		g_error_free (error);

+	pwent = getpwnam (user);

+

+	dbus_error_init (&error);

+	message = dbus_message_new_method_call (CK_NAME,

+						CK_MANAGER_PATH,

+						CK_MANAGER_INTERFACE,

+						"GetSessionsForUser");

+	if (message == NULL) {

+		gdm_debug ("ConsoleKit: Couldn't allocate the D-Bus message");

+		goto out;

+	}

+

+	dbus_message_iter_init_append (message, &iter);

+	dbus_message_iter_append_basic (&iter,

+					DBUS_TYPE_UINT32,

+					&pwent->pw_uid);

+

+	dbus_error_init (&error);

+	reply = dbus_connection_send_with_reply_and_block (connection,

+							   message,

+							   -1, &error);

+        dbus_connection_flush (connection);

+

+	if (dbus_error_is_set (&error)) {

+		gdm_debug ("ConsoleKit: %s raised:\n %s\n\n", error.name, error.message);

+		goto out;

+	}

+

+	if (reply == NULL) {

+		gdm_debug ("ConsoleKit: No reply for GetSessionsForUser");

+		goto out;

+	}

+

+	dbus_message_iter_init (reply, &iter_reply);

+	if (dbus_message_iter_get_arg_type (&iter_reply) != DBUS_TYPE_ARRAY) {

+		gdm_debug ("ConsoleKit: Wrong reply for GetSessionsForUser - expecting an array.");

+		goto out;

+	}

+

+	dbus_message_iter_recurse (&iter_reply, &iter_array);

+	sessions = get_path_array_from_iter (&iter_array, NULL);

+

+ out:

+	if (message != NULL) {

+		dbus_message_unref (message);

+	}

+	if (reply != NULL) {

+		dbus_message_unref (reply);

 	}

-	return res;

+	return sessions;

 }

 void

 unlock_ck_session (const char *user,

 		   const char *x11_display)

 {

-	DBusGConnection *connection;

-	DBusGProxy	*proxy;

-	GError		*error;

-	gboolean	 res;

-	struct passwd	*pwent;

-	GPtrArray	*sessions;

-	int		 i;

+	DBusError       error;

+	DBusConnection *connection;

+	char           **sessions;

+	int              i;

-	gdm_debug ("Unlocking ConsoleKit session for %s on %s", user, x11_display);

+	gdm_debug ("ConsoleKit: Unlocking session for %s on %s", user, x11_display);

-	error = NULL;

-	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);

+	dbus_error_init (&error);

+	connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);

 	if (connection == NULL) {

-		gdm_debug ("Failed to connect to the D-Bus daemon: %s", error->message);

-		g_error_free (error);

+		gdm_debug ("ConsoleKit: Failed to connect to the D-Bus daemon: %s", error.message);

+		dbus_error_free (&error);

 		return;

 	}

-	proxy = dbus_g_proxy_new_for_name (connection,

-					   CK_NAME,

-					   CK_MANAGER_PATH,

-					   CK_MANAGER_INTERFACE);

-	if (proxy == NULL) {

+	sessions = get_sessions_for_user (connection, user, x11_display);

+	if (sessions == NULL || sessions[0] == NULL) {

+		gdm_debug ("ConsoleKit: no sessions found");

 		return;

 	}

-	pwent = getpwnam (user);

-

-	error = NULL;

-	res = dbus_g_proxy_call (proxy,

-				 "GetSessionsForUser",

-				 &error,

-				 G_TYPE_UINT,

-				 pwent->pw_uid,

-				 G_TYPE_INVALID,

-				 dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH),

-				 &sessions,

-				 G_TYPE_INVALID);

-	if (! res) {

-		g_warning ("Failed to get list of sessions: %s", error->message);

-		g_error_free (error);

-		goto out;

-	}

-

-	for (i = 0; i < sessions->len; i++) {

-		char	   *ssid;

-		DBusGProxy *session_proxy;

-

-		ssid = g_ptr_array_index (sessions, i);

-

-		session_proxy = dbus_g_proxy_new_for_name (connection,

-							   CK_NAME,

-							   ssid,

-							   CK_SESSION_INTERFACE);

-		if (session_proxy != NULL) {

-			char *xdisplay;

-

-			get_string (session_proxy, "GetX11Display", &xdisplay);

-			if (xdisplay != NULL

-			    && x11_display != NULL

-			    && strcmp (xdisplay, x11_display) == 0) {

-				res = dbus_g_proxy_call (session_proxy,

-							 "Unlock",

-							 &error,

-							 G_TYPE_INVALID,

-							 G_TYPE_INVALID);

-				if (! res) {

-					g_warning ("Unable to unlock %s: %s", ssid, error->message);

-					g_error_free (error);

-				}

+	for (i = 0; sessions[i] != NULL; i++) {

+		char *ssid;

+		char *xdisplay;

+

+		ssid = sessions[i];

+		session_get_x11_display (connection, ssid, &xdisplay);

+		gdm_debug ("ConsoleKit: session %s has DISPLAY %s", ssid, xdisplay);

+

+		if (xdisplay != NULL

+		    && x11_display != NULL

+		    && strcmp (xdisplay, x11_display) == 0) {

+			gboolean res;

+

+			res = session_unlock (connection, ssid);

+			if (! res) {

+				gdm_error ("ConsoleKit: Unable to unlock %s", ssid);

 			}

 		}

-		g_object_unref (session_proxy);

-		g_free (ssid);

+		g_free (xdisplay);

 	}

-	g_ptr_array_free (sessions, TRUE);

-

- out:

-	g_object_unref (proxy);

+	g_strfreev (sessions);

 }

 char *

@@ -221,70 +399,89 @@ open_ck_session (struct passwd *pwent,

 		 GdmDisplay    *d,

 		 const char    *session)

 {

-	DBusGConnection *connection;

-	DBusGProxy	*proxy;

-	GError		*error;

-	gboolean	 res;

-	char		*cookie;

-	GPtrArray	*parameters;

+	DBusConnection *connection;

+	DBusError       error;

+	DBusMessage    *message;

+	DBusMessage    *reply;

+	DBusMessageIter iter;

+	DBusMessageIter iter_struct;

+	char	       *cookie;

 	cookie = NULL;

-	gdm_debug ("Opening ConsoleKit session for %s", pwent->pw_name);

+	gdm_debug ("ConsoleKit: Opening session for %s", pwent->pw_name);

+

+	dbus_error_init (&error);

+	connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &error);

+	private_connection = connection;

-	error = NULL;

-	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);

 	if (connection == NULL) {

-		gdm_debug ("Failed to connect to the D-Bus daemon: %s", error->message);

-		g_error_free (error);

+		gdm_debug ("ConsoleKit: Failed to connect to the D-Bus daemon: %s", error.message);

+		dbus_error_free (&error);

 		return NULL;

 	}

-	proxy = dbus_g_proxy_new_for_name (connection,

-					   CK_NAME,

-					   CK_MANAGER_PATH,

-					   CK_MANAGER_INTERFACE);

-	if (proxy == NULL) {

+	dbus_connection_set_exit_on_disconnect (connection, FALSE);

+	dbus_connection_setup_with_g_main (connection, NULL);

+

+	dbus_error_init (&error);

+	message = dbus_message_new_method_call (CK_NAME,

+						CK_MANAGER_PATH,

+						CK_MANAGER_INTERFACE,

+						"OpenSessionWithParameters");

+	if (message == NULL) {

+		gdm_debug ("ConsoleKit: Couldn't allocate the D-Bus message");

 		return NULL;

 	}

-	parameters = g_ptr_array_sized_new (10);

-

-	add_param_int (parameters, "user", pwent->pw_uid);

-	add_param_string (parameters, "x11-display", d->name);

-	add_param_string (parameters, "host-name", d->hostname);

-	add_param_boolean (parameters, "is-local", d->attached);

-

+	dbus_message_iter_init_append (message, &iter);

+	dbus_message_iter_open_container (&iter,

+					  DBUS_TYPE_ARRAY,

+					  DBUS_STRUCT_BEGIN_CHAR_AS_STRING

+					  DBUS_TYPE_STRING_AS_STRING

+					  DBUS_TYPE_VARIANT_AS_STRING

+					  DBUS_STRUCT_END_CHAR_AS_STRING,

+					  &iter_struct);

+

+	add_param_int (&iter_struct, "user", pwent->pw_uid);

+	add_param_string (&iter_struct, "x11-display", d->name);

+	add_param_string (&iter_struct, "host-name", d->hostname);

+	add_param_boolean (&iter_struct, "is-local", d->attached);

 	/* FIXME: this isn't really a reliable value to use */

-	add_param_string (parameters, "session-type", session);

+	add_param_string (&iter_struct, "session-type", session);

 	if (d->vt > 0) {

 		char *device;

 		/* FIXME: how does xorg construct this */

 		device = g_strdup_printf ("/dev/tty%d", d->vt);

-		add_param_string (parameters, "display-device", device);

+		add_param_string (&iter_struct, "display-device", device);

 		g_free (device);

 	}

-	error = NULL;

-	res = dbus_g_proxy_call (proxy,

-				 "OpenSessionWithParameters",

-				 &error,

-				 CK_TYPE_PARAMETER_LIST,

-				 parameters,

-				 G_TYPE_INVALID,

-				 G_TYPE_STRING,

-				 &cookie,

-				 G_TYPE_INVALID);

-	if (! res) {

-		g_warning ("OpenSession failed: %s", error->message);

-		g_error_free (error);

+	dbus_message_iter_close_container (&iter, &iter_struct);

+

+	reply = dbus_connection_send_with_reply_and_block (connection,

+							   message,

+							   -1, &error);

+	if (dbus_error_is_set (&error)) {

+		gdm_debug ("ConsoleKit: %s raised:\n %s\n\n", error.name, error.message);

+		reply = NULL;

 	}

-	g_object_unref (proxy);

+        dbus_connection_flush (connection);

+

+        dbus_message_unref (message);

+        dbus_error_free (&error);

-	g_ptr_array_free (parameters, TRUE);

+	if (reply != NULL) {

+		const char *value;

+

+		dbus_message_iter_init (reply, &iter);

+		dbus_message_iter_get_basic (&iter, &value);

+		cookie = g_strdup (value);

+		dbus_message_unref (reply);

+	}

 	return cookie;

 }

@@ -292,41 +489,47 @@ open_ck_session (struct passwd *pwent,

 void

 close_ck_session (const char *cookie)

 {

-	DBusGConnection *connection;

-	DBusGProxy	*proxy;

-	GError		*error;

-	gboolean	 res;

+	DBusError       error;

+	DBusMessage    *message;

+	DBusMessage    *reply;

+	DBusMessageIter iter;

-	g_return_if_fail (cookie != NULL);

+	if (cookie == NULL) {

+		return;

+	}

-	error = NULL;

-	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);

-	if (connection == NULL) {

-		gdm_debug ("Failed to connect to the D-Bus daemon: %s", error->message);

-		g_error_free (error);

+	if (private_connection == NULL) {

 		return;

 	}

-	proxy = dbus_g_proxy_new_for_name (connection,

-					   CK_NAME,

-					   CK_MANAGER_PATH,

-					   CK_MANAGER_INTERFACE);

-	if (proxy == NULL) {

+	dbus_error_init (&error);

+	message = dbus_message_new_method_call (CK_NAME,

+						CK_MANAGER_PATH,

+						CK_MANAGER_INTERFACE,

+						"CloseSession");

+	if (message == NULL) {

+		gdm_debug ("ConsoleKit: Couldn't allocate the D-Bus message");

 		return;

 	}

-	error = NULL;

-	res = dbus_g_proxy_call (proxy,

-				 "CloseSession",

-				 &error,

-				 G_TYPE_STRING,

-				 &cookie,

-				 G_TYPE_INVALID,

-				 G_TYPE_INVALID);

-	if (! res) {

-		g_warning ("CloseSession failed: %s", error->message);

-		g_error_free (error);

+	dbus_message_iter_init_append (message, &iter);

+	dbus_message_iter_append_basic (&iter,

+					DBUS_TYPE_STRING,

+					&cookie);

+

+	reply = dbus_connection_send_with_reply_and_block (private_connection,

+							   message,

+							   -1, &error);

+	if (dbus_error_is_set (&error)) {

+		gdm_debug ("ConsoleKit: %s raised:\n %s\n\n", error.name, error.message);

+		reply = NULL;

 	}

-	g_object_unref (proxy);

+        dbus_connection_flush (private_connection);

+

+        dbus_message_unref (message);

+        dbus_error_free (&error);

+