#include <stdlib.h>
#include <string.h>
+#include <gio/gio.h>
+#include <gio/gunixsocketaddress.h>
#include <security/pam_appl.h>
#include "lightdm/greeter.h"
+G_DEFINE_QUARK (lightdm_greeter_error, lightdm_greeter_error)
+
enum {
- PROP_0,
- PROP_DEFAULT_SESSION_HINT,
+ PROP_DEFAULT_SESSION_HINT = 1,
PROP_HIDE_USERS_HINT,
PROP_SHOW_MANUAL_LOGIN_HINT,
PROP_SHOW_REMOTE_LOGIN_HINT,
/* TRUE if the daemon can reuse this greeter */
gboolean resettable;
+ /* Socket connection to daemon */
+ GSocket *socket;
+
/* Channel to write to daemon */
GIOChannel *to_server_channel;
/* Channel to read from daemon */
GIOChannel *from_server_channel;
+ guint from_server_watch;
/* Data read from the daemon */
guint8 *read_buffer;
typedef struct
{
GObject parent_instance;
+ LightDMGreeter *greeter;
GCancellable *cancellable;
GAsyncReadyCallback callback;
gpointer user_data;
gboolean complete;
- guint32 return_code;
+ gboolean result;
+ GError *error;
gchar *dir;
} Request;
typedef struct
#define REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), request_get_type (), Request))
G_DEFINE_TYPE_WITH_CODE (Request, request, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_RESULT, request_iface_init));
+static gboolean from_server_cb (GIOChannel *source, GIOCondition condition, gpointer data);
+
+GType
+lightdm_greeter_error_get_type (void)
+{
+ static GType enum_type = 0;
+
+ if (G_UNLIKELY(enum_type == 0)) {
+ static const GEnumValue values[] = {
+ { LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR, "LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR", "communication-error" },
+ { LIGHTDM_GREETER_ERROR_CONNECTION_FAILED, "LIGHTDM_GREETER_ERROR_CONNECTION_FAILED", "connection-failed" },
+ { LIGHTDM_GREETER_ERROR_SESSION_FAILED, "LIGHTDM_GREETER_ERROR_SESSION_FAILED", "session-failed" },
+ { LIGHTDM_GREETER_ERROR_NO_AUTOLOGIN, "LIGHTDM_GREETER_ERROR_NO_AUTOLOGIN", "no-autologin" },
+ { LIGHTDM_GREETER_ERROR_INVALID_USER, "LIGHTDM_GREETER_ERROR_INVALID_USER", "invalid-user" },
+ { 0, NULL, NULL }
+ };
+ enum_type = g_enum_register_static (g_intern_static_string ("LightDMGreeterError"), values);
+ }
+
+ return enum_type;
+}
+
GType
lightdm_prompt_type_get_type (void)
{
}
static Request *
-request_new (GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
+request_new (LightDMGreeter *greeter, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
{
Request *request;
request = g_object_new (request_get_type (), NULL);
+ request->greeter = greeter;
if (cancellable)
request->cancellable = g_object_ref (cancellable);
request->callback = callback;
return request;
}
+static gboolean
+request_callback_cb (gpointer data)
+{
+ Request *request = data;
+ if (request->callback)
+ request->callback (G_OBJECT (request->greeter), G_ASYNC_RESULT (request), request->user_data);
+ g_object_unref (request);
+ return G_SOURCE_REMOVE;
+}
+
static void
-request_complete (Request *request, GObject *object)
+request_complete (Request *request)
{
request->complete = TRUE;
if (request->cancellable && g_cancellable_is_cancelled (request->cancellable))
return;
- request->callback (object, G_ASYNC_RESULT (request), request->user_data);
+ g_idle_add (request_callback_cb, g_object_ref (request));
}
static gboolean
return 4;
}
-static void
-write_int (guint8 *buffer, gint buffer_length, guint32 value, gsize *offset)
+static gboolean
+write_int (guint8 *buffer, gint buffer_length, guint32 value, gsize *offset, GError **error)
{
if (*offset + 4 >= buffer_length)
- return;
+ {
+ g_set_error_literal (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR,
+ "Not enough buffer space to write integer");
+ return FALSE;
+ }
buffer[*offset] = value >> 24;
buffer[*offset+1] = (value >> 16) & 0xFF;
buffer[*offset+2] = (value >> 8) & 0xFF;
buffer[*offset+3] = value & 0xFF;
*offset += 4;
+
+ return TRUE;
}
-static void
-write_string (guint8 *buffer, gint buffer_length, const gchar *value, gsize *offset)
+static gboolean
+write_string (guint8 *buffer, gint buffer_length, const gchar *value, gsize *offset, GError **error)
{
gint length = 0;
if (value)
length = strlen (value);
- write_int (buffer, buffer_length, length, offset);
+ if (!write_int (buffer, buffer_length, length, offset, error))
+ return FALSE;
if (*offset + length >= buffer_length)
- return;
+ {
+ g_set_error (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR,
+ "Not enough buffer space to write string of length %d octets", length);
+ return FALSE;
+ }
if (value)
memcpy (buffer + *offset, value, length);
*offset += length;
+
+ return TRUE;
}
static guint32
return int_length ();
}
-static void
-write_header (guint8 *buffer, gint buffer_length, guint32 id, guint32 length, gsize *offset)
+static gboolean
+write_header (guint8 *buffer, gint buffer_length, guint32 id, guint32 length, gsize *offset, GError **error)
{
- write_int (buffer, buffer_length, id, offset);
- write_int (buffer, buffer_length, length, offset);
+ return write_int (buffer, buffer_length, id, offset, error) &&
+ write_int (buffer, buffer_length, length, offset, error);
}
static guint32
}
static gboolean
-send_message (LightDMGreeter *greeter, guint8 *message, gsize message_length)
+connect_to_daemon (LightDMGreeter *greeter, GError **error)
+{
+ LightDMGreeterPrivate *priv = GET_PRIVATE (greeter);
+ const gchar *to_server_fd, *from_server_fd, *pipe_path;
+
+ if (priv->to_server_channel || priv->from_server_channel)
+ return TRUE;
+
+ /* Use private connection if one exists */
+ to_server_fd = g_getenv ("LIGHTDM_TO_SERVER_FD");
+ from_server_fd = g_getenv ("LIGHTDM_FROM_SERVER_FD");
+ pipe_path = g_getenv ("LIGHTDM_GREETER_PIPE");
+ if (to_server_fd && from_server_fd)
+ {
+ priv->to_server_channel = g_io_channel_unix_new (atoi (to_server_fd));
+ priv->from_server_channel = g_io_channel_unix_new (atoi (from_server_fd));
+ }
+ else if (pipe_path)
+ {
+ GSocketAddress *address;
+ gboolean result;
+
+ priv->socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, error);
+ if (!priv->socket)
+ return FALSE;
+
+ address = g_unix_socket_address_new (pipe_path);
+ result = g_socket_connect (priv->socket, address, NULL, error);
+ g_object_unref (address);
+ if (!result)
+ return FALSE;
+
+ priv->from_server_channel = g_io_channel_unix_new (g_socket_get_fd (priv->socket));
+ priv->to_server_channel = g_io_channel_ref (priv->from_server_channel);
+ }
+ else
+ {
+ g_set_error_literal (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_CONNECTION_FAILED,
+ "Unable to determine socket to daemon");
+ return FALSE;
+ }
+
+ priv->from_server_watch = g_io_add_watch (priv->from_server_channel, G_IO_IN, from_server_cb, greeter);
+
+ if (!g_io_channel_set_encoding (priv->to_server_channel, NULL, error) ||
+ !g_io_channel_set_encoding (priv->from_server_channel, NULL, error))
+ return FALSE;
+
+ return TRUE;
+}
+
+static gboolean
+send_message (LightDMGreeter *greeter, guint8 *message, gsize message_length, GError **error)
{
LightDMGreeterPrivate *priv = GET_PRIVATE (greeter);
gchar *data;
gsize data_length;
- GError *error = NULL;
guint32 stated_length;
+ GError *flush_error = NULL;
- if (!priv->to_server_channel)
+ if (!connect_to_daemon (greeter, error))
return FALSE;
/* Double check that we're sending well-formed messages. If we say we're
stated_length = HEADER_SIZE + get_message_length (message, message_length);
if (stated_length != message_length)
{
- g_warning ("Refusing to write malformed packet to daemon: declared size is %u, but actual size is %zu", stated_length, message_length);
+ g_set_error (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR,
+ "Refusing to write malformed packet to daemon: declared size is %u, but actual size is %zu",
+ stated_length, message_length);
return FALSE;
}
{
GIOStatus status;
gsize n_written;
-
- status = g_io_channel_write_chars (priv->to_server_channel, data, data_length, &n_written, &error);
- if (error)
- g_warning ("Error writing to daemon: %s", error->message);
- g_clear_error (&error);
- if (status != G_IO_STATUS_NORMAL)
+ GError *write_error = NULL;
+
+ status = g_io_channel_write_chars (priv->to_server_channel, data, data_length, &n_written, &write_error);
+ if (write_error)
+ g_set_error (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR,
+ "Failed to write to daemon: %s",
+ write_error->message);
+ g_clear_error (&write_error);
+ if (status == G_IO_STATUS_AGAIN)
+ continue;
+ if (status != G_IO_STATUS_NORMAL)
return FALSE;
data_length -= n_written;
data += n_written;
}
g_debug ("Wrote %zi bytes to daemon", message_length);
- g_io_channel_flush (priv->to_server_channel, &error);
- if (error)
- g_warning ("Failed to flush data to daemon: %s", error->message);
- g_clear_error (&error);
+ if (!g_io_channel_flush (priv->to_server_channel, &flush_error))
+ {
+ g_set_error (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR,
+ "Failed to write to daemon: %s",
+ flush_error->message);
+ g_clear_error (&flush_error);
+ return FALSE;
+ }
return TRUE;
}
request = g_list_nth_data (priv->connect_requests, 0);
if (request)
{
- request_complete (request, G_OBJECT (greeter));
+ request->result = TRUE;
+ request_complete (request);
priv->connect_requests = g_list_remove (priv->connect_requests, request);
g_object_unref (request);
}
request = g_list_nth_data (priv->start_session_requests, 0);
if (request)
{
- request->return_code = read_int (message, message_length, offset);
- request_complete (request, G_OBJECT (greeter));
+ guint32 return_code;
+
+ return_code = read_int (message, message_length, offset);
+ if (return_code == 0)
+ request->result = TRUE;
+ else
+ request->error = g_error_new (LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_SESSION_FAILED,
+ "Session returned error code %d", return_code);
+ request_complete (request);
priv->start_session_requests = g_list_remove (priv->start_session_requests, request);
g_object_unref (request);
}
{
g_free (request->dir);
request->dir = NULL;
+ request->error = g_error_new (LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_INVALID_USER,
+ "No such user");
}
- request_complete (request, G_OBJECT (greeter));
+ request_complete (request);
priv->ensure_shared_data_dir_requests = g_list_remove (priv->ensure_shared_data_dir_requests, request);
g_object_unref (request);
}
}
}
-static guint8 *
-recv_message (LightDMGreeter *greeter, gsize *length, gboolean block)
+static gboolean
+recv_message (LightDMGreeter *greeter, gboolean block, guint8 **message, gsize *length, GError **error)
{
LightDMGreeterPrivate *priv = GET_PRIVATE (greeter);
gsize n_to_read, n_read;
- guint8 *buffer;
- GError *error = NULL;
- if (!priv->from_server_channel)
- return NULL;
+ if (!connect_to_daemon (greeter, error))
+ return FALSE;
/* Read the header, or the whole message if we already have that */
n_to_read = HEADER_SIZE;
do
{
GIOStatus status;
+ GError *read_error = NULL;
+
status = g_io_channel_read_chars (priv->from_server_channel,
(gchar *) priv->read_buffer + priv->n_read,
n_to_read - priv->n_read,
&n_read,
- &error);
- if (error)
- g_warning ("Error reading from server: %s", error->message);
- g_clear_error (&error);
- if (status != G_IO_STATUS_NORMAL)
- break;
+ &read_error);
+ if (status == G_IO_STATUS_AGAIN)
+ {
+ if (block)
+ continue;
+ }
+ else if (status != G_IO_STATUS_NORMAL)
+ {
+ g_set_error (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_COMMUNICATION_ERROR,
+ "Failed to read from daemon: %s",
+ read_error->message);
+ g_clear_error (&read_error);
+ return FALSE;
+ }
g_debug ("Read %zi bytes from daemon", n_read);
/* Stop if haven't got all the data we want */
if (priv->n_read != n_to_read)
- return NULL;
+ {
+ if (message)
+ *message = NULL;
+ if (length)
+ *length = 0;
+ return TRUE;
+ }
/* If have header, rerun for content */
if (priv->n_read == HEADER_SIZE)
if (n_to_read > 0)
{
priv->read_buffer = g_realloc (priv->read_buffer, HEADER_SIZE + n_to_read);
- return recv_message (greeter, length, block);
+ return recv_message (greeter, block, message, length, error);
}
}
- buffer = priv->read_buffer;
- *length = priv->n_read;
+ if (message)
+ *message = priv->read_buffer;
+ else
+ g_free (priv->read_buffer);
+ if (length)
+ *length = priv->n_read;
priv->read_buffer = g_malloc (priv->n_read);
priv->n_read = 0;
- return buffer;
+ return TRUE;
}
static gboolean
LightDMGreeter *greeter = data;
guint8 *message;
gsize message_length;
+ GError *error = NULL;
/* Read one message and process it */
- message = recv_message (greeter, &message_length, FALSE);
+ if (!recv_message (greeter, FALSE, &message, &message_length, &error))
+ {
+ // FIXME: Should push this up to the client somehow
+ g_warning ("Failed to read from daemon: %s\n", error->message);
+ g_clear_error (&error);
+ return G_SOURCE_REMOVE;
+ }
+
if (message)
{
handle_message (greeter, message, message_length);
g_free (message);
}
- return TRUE;
+ return G_SOURCE_CONTINUE;
}
static gboolean
-send_connect (LightDMGreeter *greeter, gboolean resettable)
+send_connect (LightDMGreeter *greeter, gboolean resettable, GError **error)
{
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
g_debug ("Connecting to display manager...");
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_CONNECT, string_length (VERSION) + int_length (), &offset);
- write_string (message, MAX_MESSAGE_LENGTH, VERSION, &offset);
- write_int (message, MAX_MESSAGE_LENGTH, resettable ? 1 : 0, &offset);
-
- return send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_CONNECT, string_length (VERSION) + int_length (), &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, VERSION, &offset, error) &&
+ write_int (message, MAX_MESSAGE_LENGTH, resettable ? 1 : 0, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
static gboolean
-send_start_session (LightDMGreeter *greeter, const gchar *session)
+send_start_session (LightDMGreeter *greeter, const gchar *session, GError **error)
{
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
else
g_debug ("Starting default session");
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_START_SESSION, string_length (session), &offset);
- write_string (message, MAX_MESSAGE_LENGTH, session, &offset);
- return send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_START_SESSION, string_length (session), &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, session, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
static gboolean
-send_ensure_shared_data_dir (LightDMGreeter *greeter, const gchar *username)
+send_ensure_shared_data_dir (LightDMGreeter *greeter, const gchar *username, GError **error)
{
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
g_debug ("Ensuring data directory for user %s", username);
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_ENSURE_SHARED_DIR, string_length (username), &offset);
- write_string (message, MAX_MESSAGE_LENGTH, username, &offset);
- return send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_ENSURE_SHARED_DIR, string_length (username), &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, username, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
/**
{
LightDMGreeterPrivate *priv;
Request *request;
+ GError *error = NULL;
g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
priv = GET_PRIVATE (greeter);
- request = request_new (cancellable, callback, user_data);
- priv->connect_requests = g_list_append (priv->connect_requests, request);
- send_connect (greeter, priv->resettable);
+ request = request_new (greeter, cancellable, callback, user_data);
+ if (send_connect (greeter, priv->resettable, &error))
+ priv->connect_requests = g_list_append (priv->connect_requests, request);
+ else
+ {
+ request->error = error;
+ request_complete (request);
+ g_object_unref (request);
+ }
}
/**
* lightdm_greeter_connect_to_daemon_finish:
+ * @greeter: The greeter the the request was done with
* @result: A #GAsyncResult.
* @error: return location for a #GError, or %NULL
*
gboolean
lightdm_greeter_connect_to_daemon_finish (LightDMGreeter *greeter, GAsyncResult *result, GError **error)
{
+ Request *request = REQUEST (result);
+
g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
- return REQUEST (result)->complete;
+
+ if (request->error)
+ g_propagate_error (error, request->error);
+ return request->result;
}
/**
priv = GET_PRIVATE (greeter);
/* Read until we are connected */
- send_connect (greeter, priv->resettable);
- request = request_new (NULL, NULL, NULL);
+ if (!send_connect (greeter, priv->resettable, error))
+ return FALSE;
+ request = request_new (greeter, NULL, NULL, NULL);
priv->connect_requests = g_list_append (priv->connect_requests, g_object_ref (request));
do
{
guint8 *message;
gsize message_length;
- message = recv_message (greeter, &message_length, TRUE);
- if (!message)
- break;
+ if (!recv_message (greeter, TRUE, &message, &message_length, error))
+ return FALSE;
handle_message (greeter, message, message_length);
g_free (message);
} while (!request->complete);
- g_object_unref (request);
-
- return request->complete;
+ return lightdm_greeter_connect_to_daemon_finish (greeter, G_ASYNC_RESULT (request), error);
}
/**
* lightdm_greeter_authenticate:
* @greeter: A #LightDMGreeter
* @username: (allow-none): A username or #NULL to prompt for a username.
+ * @error: return location for a #GError, or %NULL
*
* Starts the authentication procedure for a user.
+ *
+ * Return value: #TRUE if authentication request sent.
**/
-void
-lightdm_greeter_authenticate (LightDMGreeter *greeter, const gchar *username)
+gboolean
+lightdm_greeter_authenticate (LightDMGreeter *greeter, const gchar *username, GError **error)
{
LightDMGreeterPrivate *priv;
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
- g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
+ g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
priv = GET_PRIVATE (greeter);
- g_return_if_fail (priv->connected);
+ g_return_val_if_fail (priv->connected, FALSE);
priv->cancelling_authentication = FALSE;
priv->authenticate_sequence_number++;
}
g_debug ("Starting authentication for user %s...", username);
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_AUTHENTICATE, int_length () + string_length (username), &offset);
- write_int (message, MAX_MESSAGE_LENGTH, priv->authenticate_sequence_number, &offset);
- write_string (message, MAX_MESSAGE_LENGTH, username, &offset);
- send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_AUTHENTICATE, int_length () + string_length (username), &offset, error) &&
+ write_int (message, MAX_MESSAGE_LENGTH, priv->authenticate_sequence_number, &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, username, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
/**
* lightdm_greeter_authenticate_as_guest:
* @greeter: A #LightDMGreeter
+ * @error: return location for a #GError, or %NULL
*
* Starts the authentication procedure for the guest user.
+ *
+ * Return value: #TRUE if authentication request sent.
**/
-void
-lightdm_greeter_authenticate_as_guest (LightDMGreeter *greeter)
+gboolean
+lightdm_greeter_authenticate_as_guest (LightDMGreeter *greeter, GError **error)
{
LightDMGreeterPrivate *priv;
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
- g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
+ g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
priv = GET_PRIVATE (greeter);
- g_return_if_fail (priv->connected);
+ g_return_val_if_fail (priv->connected, FALSE);
priv->cancelling_authentication = FALSE;
priv->authenticate_sequence_number++;
priv->authentication_user = NULL;
g_debug ("Starting authentication for guest account...");
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_AUTHENTICATE_AS_GUEST, int_length (), &offset);
- write_int (message, MAX_MESSAGE_LENGTH, priv->authenticate_sequence_number, &offset);
- send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_AUTHENTICATE_AS_GUEST, int_length (), &offset, error) &&
+ write_int (message, MAX_MESSAGE_LENGTH, priv->authenticate_sequence_number, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
/**
* lightdm_greeter_authenticate_autologin:
* @greeter: A #LightDMGreeter
+ * @error: return location for a #GError, or %NULL
*
* Starts the authentication procedure for the automatic login user.
+ *
+ * Return value: #TRUE if authentication request sent.
**/
-void
-lightdm_greeter_authenticate_autologin (LightDMGreeter *greeter)
+gboolean
+lightdm_greeter_authenticate_autologin (LightDMGreeter *greeter, GError **error)
{
const gchar *user;
user = lightdm_greeter_get_autologin_user_hint (greeter);
if (lightdm_greeter_get_autologin_guest_hint (greeter))
- lightdm_greeter_authenticate_as_guest (greeter);
+ return lightdm_greeter_authenticate_as_guest (greeter, error);
else if (user)
- lightdm_greeter_authenticate (greeter, user);
+ return lightdm_greeter_authenticate (greeter, user, error);
+ else
+ {
+ g_set_error_literal (error, LIGHTDM_GREETER_ERROR, LIGHTDM_GREETER_ERROR_NO_AUTOLOGIN,
+ "Can't authenticate autologin; autologin not configured");
+ return FALSE;
+ }
}
/**
* @greeter: A #LightDMGreeter
* @session: The name of a remote session
* @username: (allow-none): A username of #NULL to prompt for a username.
+ * @error: return location for a #GError, or %NULL
*
* Start authentication for a remote session type.
+ *
+ * Return value: #TRUE if authentication request sent.
**/
-void
-lightdm_greeter_authenticate_remote (LightDMGreeter *greeter, const gchar *session, const gchar *username)
+gboolean
+lightdm_greeter_authenticate_remote (LightDMGreeter *greeter, const gchar *session, const gchar *username, GError **error)
{
LightDMGreeterPrivate *priv;
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
- g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
+ g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
priv = GET_PRIVATE (greeter);
- g_return_if_fail (priv->connected);
+ g_return_val_if_fail (priv->connected, FALSE);
priv->cancelling_authentication = FALSE;
priv->authenticate_sequence_number++;
g_debug ("Starting authentication for remote session %s as user %s...", session, username);
else
g_debug ("Starting authentication for remote session %s...", session);
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_AUTHENTICATE_REMOTE, int_length () + string_length (session) + string_length (username), &offset);
- write_int (message, MAX_MESSAGE_LENGTH, priv->authenticate_sequence_number, &offset);
- write_string (message, MAX_MESSAGE_LENGTH, session, &offset);
- write_string (message, MAX_MESSAGE_LENGTH, username, &offset);
- send_message (greeter, message, offset);
+
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_AUTHENTICATE_REMOTE, int_length () + string_length (session) + string_length (username), &offset, error) &&
+ write_int (message, MAX_MESSAGE_LENGTH, priv->authenticate_sequence_number, &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, session, &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, username, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
/**
* lightdm_greeter_respond:
* @greeter: A #LightDMGreeter
* @response: Response to a prompt
+ * @error: return location for a #GError, or %NULL
*
* Provide response to a prompt. May be one in a series.
+ *
+ * Return value: #TRUE if response sent.
**/
-void
-lightdm_greeter_respond (LightDMGreeter *greeter, const gchar *response)
+gboolean
+lightdm_greeter_respond (LightDMGreeter *greeter, const gchar *response, GError **error)
{
LightDMGreeterPrivate *priv;
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
- g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
- g_return_if_fail (response != NULL);
+ g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
+ g_return_val_if_fail (response != NULL, FALSE);
priv = GET_PRIVATE (greeter);
- g_return_if_fail (priv->connected);
- g_return_if_fail (priv->n_responses_waiting > 0);
+ g_return_val_if_fail (priv->connected, FALSE);
+ g_return_val_if_fail (priv->n_responses_waiting > 0, FALSE);
priv->n_responses_waiting--;
priv->responses_received = g_list_append (priv->responses_received, g_strdup (response));
for (iter = priv->responses_received; iter; iter = iter->next)
msg_length += string_length ((gchar *)iter->data);
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_CONTINUE_AUTHENTICATION, msg_length, &offset);
- write_int (message, MAX_MESSAGE_LENGTH, g_list_length (priv->responses_received), &offset);
+ if (!write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_CONTINUE_AUTHENTICATION, msg_length, &offset, error) ||
+ !write_int (message, MAX_MESSAGE_LENGTH, g_list_length (priv->responses_received), &offset, error))
+ return FALSE;
for (iter = priv->responses_received; iter; iter = iter->next)
- write_string (message, MAX_MESSAGE_LENGTH, (gchar *)iter->data, &offset);
- send_message (greeter, message, offset);
+ {
+ if (!write_string (message, MAX_MESSAGE_LENGTH, (gchar *)iter->data, &offset, error))
+ return FALSE;
+ }
+ if (!send_message (greeter, message, offset, error))
+ return FALSE;
g_list_free_full (priv->responses_received, g_free);
priv->responses_received = NULL;
}
+
+ return TRUE;
}
/**
* lightdm_greeter_cancel_authentication:
* @greeter: A #LightDMGreeter
+ * @error: return location for a #GError, or %NULL
*
* Cancel the current user authentication.
+ *
+ * Return value: #TRUE if cancel request sent.
**/
-void
-lightdm_greeter_cancel_authentication (LightDMGreeter *greeter)
+gboolean
+lightdm_greeter_cancel_authentication (LightDMGreeter *greeter, GError **error)
{
LightDMGreeterPrivate *priv;
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
- g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
+ g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
priv = GET_PRIVATE (greeter);
- g_return_if_fail (priv->connected);
+ g_return_val_if_fail (priv->connected, FALSE);
priv->cancelling_authentication = TRUE;
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_CANCEL_AUTHENTICATION, 0, &offset);
- send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_CANCEL_AUTHENTICATION, 0, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
/**
* lightdm_greeter_set_language:
* @greeter: A #LightDMGreeter
* @language: The language to use for this user in the form of a locale specification (e.g. "de_DE.UTF-8").
+ * @error: return location for a #GError, or %NULL
*
* Set the language for the currently authenticated user.
+ *
+ * Return value: #TRUE if set language request sent.
**/
-void
-lightdm_greeter_set_language (LightDMGreeter *greeter, const gchar *language)
+gboolean
+lightdm_greeter_set_language (LightDMGreeter *greeter, const gchar *language, GError **error)
{
LightDMGreeterPrivate *priv;
guint8 message[MAX_MESSAGE_LENGTH];
gsize offset = 0;
- g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
+ g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
priv = GET_PRIVATE (greeter);
- g_return_if_fail (priv->connected);
+ g_return_val_if_fail (priv->connected, FALSE);
- write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_SET_LANGUAGE, string_length (language), &offset);
- write_string (message, MAX_MESSAGE_LENGTH, language, &offset);
- send_message (greeter, message, offset);
+ return write_header (message, MAX_MESSAGE_LENGTH, GREETER_MESSAGE_SET_LANGUAGE, string_length (language), &offset, error) &&
+ write_string (message, MAX_MESSAGE_LENGTH, language, &offset, error) &&
+ send_message (greeter, message, offset, error);
}
/**
{
LightDMGreeterPrivate *priv;
Request *request;
+ GError *error = NULL;
g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
priv = GET_PRIVATE (greeter);
- send_start_session (greeter, session);
- request = request_new (cancellable, callback, user_data);
+ request = request_new (greeter, cancellable, callback, user_data);
priv->start_session_requests = g_list_append (priv->start_session_requests, request);
+ if (!send_start_session (greeter, session, &error))
+ {
+ request->error = error;
+ request_complete (request);
+ }
}
/**
gboolean
lightdm_greeter_start_session_finish (LightDMGreeter *greeter, GAsyncResult *result, GError **error)
{
+ Request *request = REQUEST (result);
+
g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
- return REQUEST (result)->return_code == 0;
+
+ if (request->error)
+ g_propagate_error (error, request->error);
+ return request->result;
}
/**
{
LightDMGreeterPrivate *priv;
Request *request;
- guint32 return_code;
g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), FALSE);
g_return_val_if_fail (priv->is_authenticated, FALSE);
/* Read until the session is started */
- send_start_session (greeter, session);
- request = request_new (NULL, NULL, NULL);
+ if (!send_start_session (greeter, session, error))
+ return FALSE;
+ request = request_new (greeter, NULL, NULL, NULL);
priv->start_session_requests = g_list_append (priv->start_session_requests, g_object_ref (request));
do
{
guint8 *message;
gsize message_length;
- message = recv_message (greeter, &message_length, TRUE);
- if (!message)
- break;
+ if (!recv_message (greeter, TRUE, &message, &message_length, error))
+ return FALSE;
handle_message (greeter, message, message_length);
g_free (message);
} while (!request->complete);
- return_code = request->return_code;
- g_object_unref (request);
-
- return return_code == 0;
+ return lightdm_greeter_start_session_finish (greeter, G_ASYNC_RESULT (request), error);
}
/**
{
LightDMGreeterPrivate *priv;
Request *request;
+ GError *error = NULL;
g_return_if_fail (LIGHTDM_IS_GREETER (greeter));
priv = GET_PRIVATE (greeter);
- send_ensure_shared_data_dir (greeter, username);
- request = request_new (cancellable, callback, user_data);
+ request = request_new (greeter, cancellable, callback, user_data);
priv->ensure_shared_data_dir_requests = g_list_append (priv->ensure_shared_data_dir_requests, request);
+ if (!send_ensure_shared_data_dir (greeter, username, &error))
+ {
+ request->error = error;
+ request_complete (request);
+ }
}
/**
* lightdm_greeter_ensure_shared_data_dir_finish:
* @result: A #GAsyncResult.
* @greeter: A #LightDMGreeter
+ * @error: return location for a #GError, or %NULL
*
* Function to call from lightdm_greeter_ensure_shared_data_dir callback.
*
* Return value: The path to the shared directory, free with g_free.
**/
gchar *
-lightdm_greeter_ensure_shared_data_dir_finish (LightDMGreeter *greeter, GAsyncResult *result)
+lightdm_greeter_ensure_shared_data_dir_finish (LightDMGreeter *greeter, GAsyncResult *result, GError **error)
{
+ Request *request = REQUEST (result);
+
g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), NULL);
- return g_strdup (REQUEST (result)->dir);
+
+ if (request->error)
+ g_propagate_error (error, request->error);
+ return g_strdup (request->dir);
}
/**
* lightdm_greeter_ensure_shared_data_dir_sync:
* @greeter: A #LightDMGreeter
* @username: A username
+ * @error: return location for a #GError, or %NULL
*
* Ensure that a shared data dir for the given user is available. Both the
* greeter user and @username will have write access to that folder. The
* Return value: The path to the shared directory, free with g_free.
**/
gchar *
-lightdm_greeter_ensure_shared_data_dir_sync (LightDMGreeter *greeter, const gchar *username)
+lightdm_greeter_ensure_shared_data_dir_sync (LightDMGreeter *greeter, const gchar *username, GError **error)
{
LightDMGreeterPrivate *priv;
Request *request;
- gchar *data_dir;
g_return_val_if_fail (LIGHTDM_IS_GREETER (greeter), NULL);
g_return_val_if_fail (priv->connected, NULL);
/* Read until a response */
- send_ensure_shared_data_dir (greeter, username);
- request = request_new (NULL, NULL, NULL);
+ if (!send_ensure_shared_data_dir (greeter, username, error))
+ return NULL;
+ request = request_new (greeter, NULL, NULL, NULL);
priv->ensure_shared_data_dir_requests = g_list_append (priv->ensure_shared_data_dir_requests, g_object_ref (request));
do
{
guint8 *message;
gsize message_length;
- message = recv_message (greeter, &message_length, TRUE);
- if (!message)
- break;
+ if (!recv_message (greeter, TRUE, &message, &message_length, error))
+ return FALSE;
handle_message (greeter, message, message_length);
g_free (message);
} while (!request->complete);
- data_dir = g_strdup (request->dir);
- g_object_unref (request);
-
- return data_dir;
+ return lightdm_greeter_ensure_shared_data_dir_finish (greeter, G_ASYNC_RESULT (request), error);
}
static void
lightdm_greeter_init (LightDMGreeter *greeter)
{
LightDMGreeterPrivate *priv = GET_PRIVATE (greeter);
- const gchar *fd;
priv->read_buffer = g_malloc (HEADER_SIZE);
priv->hints = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
-
- fd = g_getenv ("LIGHTDM_TO_SERVER_FD");
- if (fd)
- {
- GError *error = NULL;
-
- priv->to_server_channel = g_io_channel_unix_new (atoi (fd));
- g_io_channel_set_encoding (priv->to_server_channel, NULL, &error);
- if (error)
- g_warning ("Failed to set encoding on to server channel to binary: %s\n", error->message);
- g_clear_error (&error);
- }
- else
- g_warning ("No LIGHTDM_TO_SERVER_FD environment variable");
-
- fd = g_getenv ("LIGHTDM_FROM_SERVER_FD");
- if (fd)
- {
- GError *error = NULL;
-
- priv->from_server_channel = g_io_channel_unix_new (atoi (fd));
- g_io_channel_set_encoding (priv->from_server_channel, NULL, &error);
- if (error)
- g_warning ("Failed to set encoding on from server channel to binary: %s\n", error->message);
- g_clear_error (&error);
- g_io_add_watch (priv->from_server_channel, G_IO_IN, from_server_cb, greeter);
- }
- else
- g_warning ("No LIGHTDM_FROM_SERVER_FD environment variable");
}
static void
lightdm_greeter_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
static void
lightdm_greeter_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
LightDMGreeter *self;
LightDMGreeter *self = LIGHTDM_GREETER (object);
LightDMGreeterPrivate *priv = GET_PRIVATE (self);
+ g_clear_object (&priv->socket);
if (priv->to_server_channel)
g_io_channel_unref (priv->to_server_channel);
if (priv->from_server_channel)
g_io_channel_unref (priv->from_server_channel);
- g_free (priv->authentication_user);
+ if (priv->from_server_watch)
+ g_source_remove (priv->from_server_watch);
+ priv->from_server_watch = 0;
+ g_clear_pointer (&priv->read_buffer, g_free);
+ g_list_free_full (priv->responses_received, g_free);
+ priv->responses_received = NULL;
+ g_list_free_full (priv->connect_requests, g_object_unref);
+ priv->connect_requests = NULL;
+ g_list_free_full (priv->start_session_requests, g_object_unref);
+ priv->start_session_requests = NULL;
+ g_list_free_full (priv->ensure_shared_data_dir_requests, g_object_unref);
+ priv->ensure_shared_data_dir_requests = NULL;
+ g_clear_pointer (&priv->authentication_user, g_free);
g_hash_table_unref (priv->hints);
+ priv->hints = NULL;
G_OBJECT_CLASS (lightdm_greeter_parent_class)->finalize (object);
}
{
Request *request = REQUEST (object);
+ g_clear_object (&request->cancellable);
g_free (request->dir);
- if (request->cancellable)
- g_object_unref (request->cancellable);
G_OBJECT_CLASS (request_parent_class)->finalize (object);
}
}
static GObject *
-request_get_source_object (GAsyncResult *res)
+request_get_source_object (GAsyncResult *result)
{
- return NULL;
+ return g_object_ref (REQUEST (result)->greeter);
}
static void