moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 1136 insertions, 0 deletions

diff --git a/capplets/about-me/mate-about-me-password.c b/capplets/about-me/mate-about-me-password.c
new file mode 100644
index 00000000..0699c28d
--- /dev/null
+++ b/capplets/about-me/mate-about-me-password.c
@@ -0,0 +1,1136 @@
+/* mate-about-me.c
+ * Copyright (C) 2002 Diego Gonzalez
+ * Copyright (C) 2006 Johannes H. Jensen
+ *
+ * Written by: Diego Gonzalez <[email protected]>
+ * Modified by: Johannes H. Jensen <[email protected]>
+ *
+ * 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, 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., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Parts of this code come from Mate-System-Tools.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+/* Are all of these needed? */
+#include <gdk/gdkkeysyms.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/wait.h>
+
+#if __sun
+#include <sys/types.h>
+#include <signal.h>
+#endif
+
+#include "capplet-util.h"
+#include "eel-alert-dialog.h"
+
+/* Passwd states */
+typedef enum {
+	PASSWD_STATE_NONE,		/* Passwd is not asking for anything */
+	PASSWD_STATE_AUTH,		/* Passwd is asking for our current password */
+	PASSWD_STATE_NEW,		/* Passwd is asking for our new password */
+	PASSWD_STATE_RETYPE,	/* Passwd is asking for our retyped new password */
+	PASSWD_STATE_ERR		/* Passwd reported an error but has not yet exited */
+} PasswdState;
+
+typedef struct {
+	GtkBuilder  *ui;
+
+	/* Commonly used widgets */
+	GtkEntry *current_password;
+	GtkEntry *new_password;
+	GtkEntry *retyped_password;
+	GtkImage *dialog_image;
+	GtkLabel *status_label;
+
+	/* Whether we have authenticated */
+	gboolean authenticated;
+
+	/* Communication with the passwd program */
+	GPid backend_pid;
+
+	GIOChannel *backend_stdin;
+	GIOChannel *backend_stdout;
+
+	GQueue *backend_stdin_queue;		/* Write queue to backend_stdin */
+
+	/* GMainLoop IDs */
+	guint backend_child_watch_id;		/* g_child_watch_add (PID) */
+	guint backend_stdout_watch_id;		/* g_io_add_watch (stdout) */
+
+	/* State of the passwd program */
+	PasswdState backend_state;
+
+} PasswordDialog;
+
+/* Buffer size for backend output */
+#define BUFSIZE 64
+
+/*
+ * Error handling {{
+ */
+#define PASSDLG_ERROR (mate_about_me_password_error_quark())
+
+GQuark mate_about_me_password_error_quark(void)
+{
+	static GQuark q = 0;
+
+	if (q == 0) {
+		q = g_quark_from_static_string("mate_about_me_password_error");
+	}
+
+	return q;
+}
+
+/* error codes */
+enum {
+	PASSDLG_ERROR_NONE,
+	PASSDLG_ERROR_NEW_PASSWORD_EMPTY,
+	PASSDLG_ERROR_RETYPED_PASSWORD_EMPTY,
+	PASSDLG_ERROR_PASSWORDS_NOT_EQUAL,
+	PASSDLG_ERROR_BACKEND,	/* Backend error */
+	PASSDLG_ERROR_USER,		/* Generic user error */
+	PASSDLG_ERROR_FAILED	/* Fatal failure, error->message should explain */
+};
+
+/*
+ * }} Error handling
+ */
+
+/*
+ * Prototypes {{
+ */
+static void
+stop_passwd (PasswordDialog *pdialog);
+
+static void
+free_passwd_resources (PasswordDialog *pdialog);
+
+static gboolean
+io_watch_stdout (GIOChannel *source, GIOCondition condition, PasswordDialog *pdialog);
+
+static void
+passdlg_set_auth_state (PasswordDialog *pdialog, gboolean state);
+
+static void
+passdlg_set_status (PasswordDialog *pdialog, gchar *msg);
+
+static void
+passdlg_set_busy (PasswordDialog *pdialog, gboolean busy);
+
+static void
+passdlg_clear (PasswordDialog *pdialog);
+
+static guint
+passdlg_refresh_password_state (PasswordDialog *pdialog);
+
+/*
+ * }} Prototypes
+ */
+
+/*
+ * Spawning and closing of backend {{
+ */
+
+/* Child watcher */
+static void
+child_watch_cb (GPid pid, gint status, PasswordDialog *pdialog)
+{
+	if (WIFEXITED (status)) {
+		if (WEXITSTATUS (status) >= 255) {
+			g_warning (_("Child exited unexpectedly"));
+		}
+	}
+
+	free_passwd_resources (pdialog);
+}
+
+/* Spawn passwd backend
+ * Returns: TRUE on success, FALSE otherwise and sets error appropriately */
+static gboolean
+spawn_passwd (PasswordDialog *pdialog, GError **error)
+{
+	gchar	*argv[2];
+	gchar	*envp[1];
+	gint	my_stdin, my_stdout, my_stderr;
+
+	argv[0] = "/usr/bin/passwd";	/* Is it safe to rely on a hard-coded path? */
+	argv[1] = NULL;
+
+	envp[0] = NULL;					/* If we pass an empty array as the environment,
+									 * will the childs environment be empty, and the
+									 * locales set to the C default? From the manual:
+									 * "If envp is NULL, the child inherits its
+									 * parent'senvironment."
+									 * If I'm wrong here, we somehow have to set
+									 * the locales here.
+									 */
+
+	if (!g_spawn_async_with_pipes (NULL,						/* Working directory */
+								   argv,						/* Argument vector */
+								   envp,						/* Environment */
+								   G_SPAWN_DO_NOT_REAP_CHILD,	/* Flags */
+								   NULL,						/* Child setup */
+								   NULL,						/* Data to child setup */
+								   &pdialog->backend_pid,		/* PID */
+								   &my_stdin,						/* Stdin */
+								   &my_stdout,						/* Stdout */
+								   &my_stderr,						/* Stderr */
+								   error)) {					/* GError */
+
+		/* An error occured */
+		free_passwd_resources (pdialog);
+
+		return FALSE;
+	}
+
+	/* 2>&1 */
+	if (dup2 (my_stderr, my_stdout) == -1) {
+		/* Failed! */
+		g_set_error (error,
+					 PASSDLG_ERROR,
+					 PASSDLG_ERROR_BACKEND,
+					 strerror (errno));
+
+		/* Clean up */
+		stop_passwd (pdialog);
+
+		return FALSE;
+	}
+
+	/* Open IO Channels */
+	pdialog->backend_stdin = g_io_channel_unix_new (my_stdin);
+	pdialog->backend_stdout = g_io_channel_unix_new (my_stdout);
+
+	/* Set raw encoding */
+	/* Set nonblocking mode */
+	if (g_io_channel_set_encoding (pdialog->backend_stdin, NULL, error) != G_IO_STATUS_NORMAL ||
+		g_io_channel_set_encoding (pdialog->backend_stdout, NULL, error) != G_IO_STATUS_NORMAL ||
+		g_io_channel_set_flags (pdialog->backend_stdin, G_IO_FLAG_NONBLOCK, error) != G_IO_STATUS_NORMAL ||
+		g_io_channel_set_flags (pdialog->backend_stdout, G_IO_FLAG_NONBLOCK, error) != G_IO_STATUS_NORMAL ) {
+
+		/* Clean up */
+		stop_passwd (pdialog);
+		return FALSE;
+	}
+
+	/* Turn off buffering */
+	g_io_channel_set_buffered (pdialog->backend_stdin, FALSE);
+	g_io_channel_set_buffered (pdialog->backend_stdout, FALSE);
+
+	/* Add IO Channel watcher */
+	pdialog->backend_stdout_watch_id = g_io_add_watch (pdialog->backend_stdout,
+													   G_IO_IN | G_IO_PRI,
+													   (GIOFunc) io_watch_stdout, pdialog);
+
+	/* Add child watcher */
+	pdialog->backend_child_watch_id = g_child_watch_add (pdialog->backend_pid, (GChildWatchFunc) child_watch_cb, pdialog);
+
+	/* Success! */
+
+	return TRUE;
+}
+
+/* Stop passwd backend */
+static void
+stop_passwd (PasswordDialog *pdialog)
+{
+	/* This is the standard way of returning from the dialog with passwd.
+	 * If we return this way we can safely kill passwd as it has completed
+	 * its task.
+	 */
+
+	if (pdialog->backend_pid != -1) {
+		kill (pdialog->backend_pid, 9);
+	}
+
+	/* We must run free_passwd_resources here and not let our child
+	 * watcher do it, since it will access invalid memory after the
+	 * dialog has been closed and cleaned up.
+	 *
+	 * If we had more than a single thread we'd need to remove
+	 * the child watch before trying to kill the child.
+	 */
+	free_passwd_resources (pdialog);
+}
+
+/* Clean up passwd resources */
+static void
+free_passwd_resources (PasswordDialog *pdialog)
+{
+	GError	*error = NULL;
+
+	/* Remove the child watcher */
+	if (pdialog->backend_child_watch_id != 0) {
+
+		g_source_remove (pdialog->backend_child_watch_id);
+
+		pdialog->backend_child_watch_id = 0;
+	}
+
+
+	/* Close IO channels (internal file descriptors are automatically closed) */
+	if (pdialog->backend_stdin != NULL) {
+
+		if (g_io_channel_shutdown (pdialog->backend_stdin, TRUE, &error) != G_IO_STATUS_NORMAL) {
+			g_warning (_("Could not shutdown backend_stdin IO channel: %s"), error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+
+		g_io_channel_unref (pdialog->backend_stdin);
+
+		pdialog->backend_stdin = NULL;
+	}
+
+	if (pdialog->backend_stdout != NULL) {
+
+		if (g_io_channel_shutdown (pdialog->backend_stdout, TRUE, &error) != G_IO_STATUS_NORMAL) {
+			g_warning (_("Could not shutdown backend_stdout IO channel: %s"), error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+
+		g_io_channel_unref (pdialog->backend_stdout);
+
+		pdialog->backend_stdout = NULL;
+	}
+
+	/* Remove IO watcher */
+	if (pdialog->backend_stdout_watch_id != 0) {
+
+		g_source_remove (pdialog->backend_stdout_watch_id);
+
+		pdialog->backend_stdout_watch_id = 0;
+	}
+
+	/* Close PID */
+	if (pdialog->backend_pid != -1) {
+
+		g_spawn_close_pid (pdialog->backend_pid);
+
+		pdialog->backend_pid = -1;
+	}
+
+	/* Clear backend state */
+	pdialog->backend_state = PASSWD_STATE_NONE;
+}
+
+/*
+ * }} Spawning and closing of backend
+ */
+
+/*
+ * Backend communication code {{
+ */
+
+/* Write the first element of queue through channel */
+static void
+io_queue_pop (GQueue *queue, GIOChannel *channel)
+{
+	gchar	*buf;
+	gsize	bytes_written;
+	GError	*error = NULL;
+
+	buf = g_queue_pop_head (queue);
+
+	if (buf != NULL) {
+
+		if (g_io_channel_write_chars (channel, buf, -1, &bytes_written, &error) != G_IO_STATUS_NORMAL) {
+			g_warning ("Could not write queue element \"%s\" to channel: %s", buf, error->message);
+			g_error_free (error);
+		}
+
+		g_free (buf);
+	}
+}
+
+/* Goes through the argument list, checking if one of them occurs in str
+ * Returns: TRUE as soon as an element is found to match, FALSE otherwise */
+static gboolean
+is_string_complete (gchar *str, ...)
+{
+	va_list	ap;
+	gchar	*arg;
+
+	if (strlen (str) == 0) {
+		return FALSE;
+	}
+
+	va_start (ap, str);
+
+	while ((arg = va_arg (ap, char *)) != NULL) {
+		if (g_strrstr (str, arg) != NULL) {
+			va_end (ap);
+			return TRUE;
+		}
+	}
+
+	va_end (ap);
+
+	return FALSE;
+}
+
+/* Authentication attempt succeeded. Update the GUI accordingly. */
+static void
+authenticated_user (PasswordDialog *pdialog)
+{
+	pdialog->backend_state = PASSWD_STATE_NEW;
+
+	if (pdialog->authenticated) {
+		/* This is a re-authentication
+		 * It succeeded, so pop our new password from the queue */
+		io_queue_pop (pdialog->backend_stdin_queue, pdialog->backend_stdin);
+	}
+
+	/* Update UI state */
+	passdlg_set_auth_state (pdialog, TRUE);
+	passdlg_set_status (pdialog, _("Authenticated!"));
+
+	/* Check to see if the passwords are valid
+	 * (They might be non-empty if the user had to re-authenticate,
+	 *  and thus we need to enable the change-password-button) */
+	passdlg_refresh_password_state (pdialog);
+}
+
+/*
+ * IO watcher for stdout, called whenever there is data to read from the backend.
+ * This is where most of the actual IO handling happens.
+ */
+static gboolean
+io_watch_stdout (GIOChannel *source, GIOCondition condition, PasswordDialog *pdialog)
+{
+	static GString *str = NULL;	/* Persistent buffer */
+
+	gchar		buf[BUFSIZE];		/* Temporary buffer */
+	gsize		bytes_read;
+	GError		*error = NULL;
+
+	gchar		*msg = NULL;		/* Status error message */
+	GtkBuilder	*dialog;
+
+	gboolean	reinit = FALSE;
+
+	/* Initialize buffer */
+	if (str == NULL) {
+		str = g_string_new ("");
+	}
+
+	dialog = pdialog->ui;
+
+	if (g_io_channel_read_chars (source, buf, BUFSIZE, &bytes_read, &error) != G_IO_STATUS_NORMAL) {
+		g_warning ("IO Channel read error: %s", error->message);
+		g_error_free (error);
+
+		return TRUE;
+	}
+
+	str = g_string_append_len (str, buf, bytes_read);
+
+	/* In which state is the backend? */
+	switch (pdialog->backend_state) {
+		case PASSWD_STATE_AUTH:
+			/* Passwd is asking for our current password */
+
+			if (is_string_complete (str->str, "assword: ", "failure", "wrong", "error", NULL)) {
+				/* Which response did we get? */
+				passdlg_set_busy (pdialog, FALSE);
+
+				if (g_strrstr (str->str, "assword: ") != NULL) {
+					/* Authentication successful */
+
+					authenticated_user (pdialog);
+
+				} else {
+					/* Authentication failed */
+
+					if (pdialog->authenticated) {
+						/* This is a re-auth, and it failed.
+						 * The password must have been changed in the meantime!
+						 * Ask the user to re-authenticate
+						 */
+
+						/* Update status message and auth state */
+						passdlg_set_status (pdialog, _("Your password has been changed since you initially authenticated! Please re-authenticate."));
+					} else {
+						passdlg_set_status (pdialog, _("That password was incorrect."));
+					}
+
+					/* Focus current password */
+					gtk_widget_grab_focus (GTK_WIDGET (pdialog->current_password));
+				}
+
+				reinit = TRUE;
+			}
+			break;
+		case PASSWD_STATE_NEW:
+			/* Passwd is asking for our new password */
+
+			if (is_string_complete (str->str, "assword: ", NULL)) {
+				/* Advance to next state */
+				pdialog->backend_state = PASSWD_STATE_RETYPE;
+
+				/* Pop retyped password from queue and into IO channel */
+				io_queue_pop (pdialog->backend_stdin_queue, pdialog->backend_stdin);
+
+				reinit = TRUE;
+			}
+			break;
+		case PASSWD_STATE_RETYPE:
+			/* Passwd is asking for our retyped new password */
+
+			if (is_string_complete (str->str, "successfully",
+							  "short",
+							  "longer",
+							  "palindrome",
+							  "dictionary",
+							  "simpl", /* catches both simple and simplistic */
+							  "similar",
+							  "different",
+							  "case",
+							  "wrapped",
+							  "recovered",
+							  "recent"
+							  "unchanged",
+							  "match",
+							  "1 numeric or special",
+							  "failure",
+							  NULL)) {
+
+				/* What response did we get? */
+				passdlg_set_busy (pdialog, FALSE);
+
+				if (g_strrstr (str->str, "successfully") != NULL) {
+					/* Hooray! */
+
+					passdlg_clear (pdialog);
+					passdlg_set_status (pdialog, _("Your password has been changed."));
+				} else {
+					/* Ohnoes! */
+
+					/* Focus new password */
+					gtk_widget_grab_focus (GTK_WIDGET (pdialog->new_password));
+
+					if (g_strrstr (str->str, "recovered") != NULL) {
+						/* What does this indicate?
+						 * "Authentication information cannot be recovered?" from libpam? */
+						msg = g_strdup_printf (_("System error: %s."), str->str);
+					} else if (g_strrstr (str->str, "short") != NULL ||
+						   g_strrstr (str->str, "longer") != NULL) {
+						msg = g_strdup (_("The password is too short."));
+					} else if (g_strrstr (str->str, "palindrome") != NULL ||
+						   g_strrstr (str->str, "simpl") != NULL ||
+						   g_strrstr (str->str, "dictionary") != NULL) {
+						msg = g_strdup (_("The password is too simple."));
+					} else if (g_strrstr (str->str, "similar") != NULL ||
+					           g_strrstr (str->str, "different") != NULL ||
+					           g_strrstr (str->str, "case") != NULL ||
+						   g_strrstr (str->str, "wrapped") != NULL) {
+						msg = g_strdup (_("The old and new passwords are too similar."));
+					} else if (g_strrstr (str->str, "1 numeric or special") != NULL) {
+						msg = g_strdup (_("The new password must contain numeric or special character(s)."));
+					} else if (g_strrstr (str->str, "unchanged") != NULL ||
+						   g_strrstr (str->str, "match") != NULL) {
+						msg = g_strdup (_("The old and new passwords are the same."));
+					} else if (g_strrstr (str->str, "recent") != NULL) {
+						msg = g_strdup (_("The new password has already been used recently."));
+					} else if (g_strrstr (str->str, "failure") != NULL) {
+						/* Authentication failure */
+						msg = g_strdup (_("Your password has been changed since you initially authenticated! Please re-authenticate."));
+
+						passdlg_set_auth_state (pdialog, FALSE);
+					}
+				}
+
+				reinit = TRUE;
+
+				if (msg != NULL) {
+					/* An error occured! */
+					passdlg_set_status (pdialog, msg);
+					g_free (msg);
+
+					/* At this point, passwd might have exited, in which case
+					 * child_watch_cb should clean up for us and remove this watcher.
+					 * On some error conditions though, passwd just re-prompts us
+					 * for our new password. */
+
+					pdialog->backend_state = PASSWD_STATE_ERR;
+				}
+
+				/* child_watch_cb should clean up for us now */
+			}
+			break;
+		case PASSWD_STATE_NONE:
+			/* Passwd is not asking for anything yet */
+			if (is_string_complete (str->str, "assword: ", NULL)) {
+
+				/* If the user does not have a password set,
+				 * passwd will immediately ask for the new password,
+				 * so skip the AUTH phase */
+				if (is_string_complete (str->str, "new", "New", NULL)) {
+					gchar *pw;
+
+					pdialog->backend_state = PASSWD_STATE_NEW;
+
+					passdlg_set_busy (pdialog, FALSE);
+					authenticated_user (pdialog);
+
+					/* since passwd didn't ask for our old password
+					 * in this case, simply remove it from the queue */
+					pw = g_queue_pop_head (pdialog->backend_stdin_queue);
+					g_free (pw);
+				} else {
+
+					pdialog->backend_state = PASSWD_STATE_AUTH;
+
+					/* Pop the IO queue, i.e. send current password */
+					io_queue_pop (pdialog->backend_stdin_queue, pdialog->backend_stdin);
+				}
+
+				reinit = TRUE;
+			}
+			break;
+		default:
+			/* Passwd has returned an error */
+			reinit = TRUE;
+			break;
+	}
+
+	if (reinit) {
+		g_string_free (str, TRUE);
+		str = NULL;
+	}
+
+	/* Continue calling us */
+	return TRUE;
+}
+
+/*
+ * }} Backend communication code
+ */
+
+/* Adds the current password to the IO queue */
+static void
+authenticate (PasswordDialog *pdialog)
+{
+	gchar	*s;
+
+	s = g_strdup_printf ("%s\n", gtk_entry_get_text (pdialog->current_password));
+
+	g_queue_push_tail (pdialog->backend_stdin_queue, s);
+}
+
+/* Adds the new password twice to the IO queue */
+static void
+update_password (PasswordDialog *pdialog)
+{
+	gchar	*s;
+
+	s = g_strdup_printf ("%s\n", gtk_entry_get_text (pdialog->new_password));
+
+	g_queue_push_tail (pdialog->backend_stdin_queue, s);
+	/* We need to allocate new space because io_queue_pop() g_free()s
+	 * every element of the queue after it's done */
+	g_queue_push_tail (pdialog->backend_stdin_queue, g_strdup (s));
+}
+
+/* Sets dialog busy state according to busy
+ *
+ * When busy:
+ *	Sets the cursor to busy
+ *  Disables the interface to prevent that the user interferes
+ * Reverts all this when non-busy
+ *
+ * Note that this function takes into account the
+ * authentication state of the dialog. So setting the
+ * dialog to busy and then back to normal should leave
+ * the dialog unchanged.
+ */
+static void
+passdlg_set_busy (PasswordDialog *pdialog, gboolean busy)
+{
+	GtkBuilder *dialog;
+	GtkWidget  *toplevel;
+	GdkCursor  *cursor = NULL;
+	GdkDisplay *display;
+
+	dialog = pdialog->ui;
+
+	/* Set cursor */
+	toplevel = WID ("change-password");
+	display = gtk_widget_get_display (toplevel);
+	if (busy) {
+		cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
+	}
+
+	gdk_window_set_cursor (gtk_widget_get_window (toplevel), cursor);
+	gdk_display_flush (display);
+
+	if (busy) {
+		gdk_cursor_unref (cursor);
+	}
+
+	/* Disable/Enable UI */
+	if (pdialog->authenticated) {
+		/* Authenticated state */
+
+		/* Enable/disable new password section */
+		g_object_set (pdialog->new_password, "sensitive", !busy, NULL);
+		g_object_set (pdialog->retyped_password, "sensitive", !busy, NULL);
+		g_object_set (WID ("new-password-label"), "sensitive", !busy, NULL);
+		g_object_set (WID ("retyped-password-label"), "sensitive", !busy, NULL);
+
+		/* Enable/disable change password button */
+		g_object_set (WID ("change-password-button"), "sensitive", !busy, NULL);
+
+	} else {
+		/* Not-authenticated state */
+
+		/* Enable/disable auth section state */
+		g_object_set (pdialog->current_password, "sensitive", !busy, NULL);
+		g_object_set (WID ("authenticate-button"), "sensitive", !busy, NULL);
+		g_object_set (WID ("current-password-label"), "sensitive", !busy, NULL);
+	}
+}
+
+/* Launch an error dialog */
+static void
+passdlg_error_dialog (GtkWindow *parent, const gchar *title,
+		      const gchar *msg, const gchar *details)
+{
+	GtkWidget *dialog;
+
+	dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL,
+					 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+					 msg);
+	if (title)
+		gtk_window_set_title (GTK_WINDOW (dialog), title);
+
+	if (details)
+		gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+							  details);
+	gtk_dialog_run (GTK_DIALOG (dialog));
+	gtk_widget_destroy (dialog);
+}
+
+/* Set authenticated state of dialog according to state
+ *
+ * When in authenticated state:
+ * 	Disables authentication-part of interface
+ *  Enables new-password-part of interface
+ * When in not-authenticated state:
+ * 	Enables authentication-part of interface
+ *  Disables new-password-part of interface
+ * 	Disables the change-password-button
+ */
+static void
+passdlg_set_auth_state (PasswordDialog *pdialog, gboolean state)
+{
+	GtkBuilder *dialog;
+
+	dialog = pdialog->ui;
+
+	/* Widgets which require a not-authenticated state to be accessible */
+	g_object_set (pdialog->current_password, "sensitive", !state, NULL);
+	g_object_set (WID ("current-password-label"), "sensitive", !state, NULL);
+	g_object_set (WID ("authenticate-button"), "sensitive", !state, NULL);
+
+	/* Widgets which require authentication to be accessible */
+	g_object_set (pdialog->new_password, "sensitive", state, NULL);
+	g_object_set (pdialog->retyped_password, "sensitive", state, NULL);
+	g_object_set (WID ("new-password-label"), "sensitive", state, NULL);
+	g_object_set (WID ("retyped-password-label"), "sensitive", state, NULL);
+
+	if (!state) {
+		/* Disable change-password-button when in not-authenticated state */
+		g_object_set (WID ("change-password-button"), "sensitive", FALSE, NULL);
+	}
+
+	pdialog->authenticated = state;
+
+	if (state) {
+		/* Authenticated state */
+
+		/* Focus new password */
+		gtk_widget_grab_focus (GTK_WIDGET (pdialog->new_password));
+
+		/* Set open lock image */
+		gtk_image_set_from_icon_name (GTK_IMAGE (pdialog->dialog_image), "changes-allow", GTK_ICON_SIZE_DIALOG);
+	} else {
+		/* Not authenticated state */
+
+		/* Focus current password */
+		gtk_widget_grab_focus (GTK_WIDGET (pdialog->current_password));
+
+		/* Set closed lock image */
+		gtk_image_set_from_icon_name (GTK_IMAGE (pdialog->dialog_image), "changes-prevent", GTK_ICON_SIZE_DIALOG);
+	}
+}
+
+/* Set status field message */
+static void
+passdlg_set_status (PasswordDialog *pdialog, gchar *msg)
+{
+	g_object_set (pdialog->status_label, "label", msg, NULL);
+}
+
+/* Clear dialog (except the status message) */
+static void
+passdlg_clear (PasswordDialog *pdialog)
+{
+	/* Set non-authenticated state */
+	passdlg_set_auth_state (pdialog, FALSE);
+
+	/* Clear password entries */
+	gtk_entry_set_text (pdialog->current_password, "");
+	gtk_entry_set_text (pdialog->new_password, "");
+	gtk_entry_set_text (pdialog->retyped_password, "");
+}
+
+/* Start backend and handle errors
+ * If backend is already running, stop it
+ * If an error occurs, show error dialog */
+static gboolean
+passdlg_spawn_passwd (PasswordDialog *pdialog)
+{
+	GError	*error = NULL;
+	gchar	*details;
+
+	/* If backend is running, stop it */
+	stop_passwd (pdialog);
+
+	/* Spawn backend */
+	if (!spawn_passwd (pdialog, &error)) {
+		GtkWidget *parent = GTK_WIDGET (gtk_builder_get_object (pdialog->ui, "change-password"));
+
+		/* translators: Unable to launch <program>: <error message> */
+		details = g_strdup_printf (_("Unable to launch %s: %s"),
+					   "/usr/bin/passwd", error->message);
+
+		passdlg_error_dialog (GTK_WINDOW (parent),
+				      _("Unable to launch backend"),
+				      _("A system error has occurred"),
+				      details);
+
+		g_free (details);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/* Called when the "Authenticate" button is clicked */
+static void
+passdlg_authenticate (GtkButton *button, PasswordDialog *pdialog)
+{
+	/* Set busy as this can be a long process */
+	passdlg_set_busy (pdialog, TRUE);
+
+	/* Update status message */
+	passdlg_set_status (pdialog, _("Checking password..."));
+
+	/* Spawn backend */
+	if (!passdlg_spawn_passwd (pdialog)) {
+		passdlg_set_busy (pdialog, FALSE);
+		return;
+	}
+
+	authenticate (pdialog);
+
+	/* Our IO watcher should now handle the rest */
+}
+
+/* Validate passwords
+ * Returns:
+ * PASSDLG_ERROR_NONE (0) if passwords are valid
+ * PASSDLG_ERROR_NEW_PASSWORD_EMPTY
+ * PASSDLG_ERROR_RETYPED_PASSWORD_EMPTY
+ * PASSDLG_ERROR_PASSWORDS_NOT_EQUAL
+ */
+static guint
+passdlg_validate_passwords (PasswordDialog *pdialog)
+{
+	GtkBuilder	*dialog;
+	const gchar	*new_password, *retyped_password;
+	glong			nlen, rlen;
+
+	dialog = pdialog->ui;
+
+	new_password = gtk_entry_get_text (pdialog->new_password);
+	retyped_password = gtk_entry_get_text (pdialog->retyped_password);
+
+	nlen = g_utf8_strlen (new_password, -1);
+	rlen = g_utf8_strlen (retyped_password, -1);
+
+	if (nlen == 0) {
+		/* New password empty */
+		return PASSDLG_ERROR_NEW_PASSWORD_EMPTY;
+	}
+
+	if (rlen == 0) {
+		/* Retyped password empty */
+		return PASSDLG_ERROR_RETYPED_PASSWORD_EMPTY;
+	}
+
+	if (nlen != rlen || strncmp (new_password, retyped_password, nlen) != 0) {
+		/* Passwords not equal */
+		return PASSDLG_ERROR_PASSWORDS_NOT_EQUAL;
+	}
+
+	/* Success */
+	return PASSDLG_ERROR_NONE;
+}
+
+/* Refresh the valid password UI state, i.e. re-validate
+ * and enable/disable the Change Password button.
+ * Returns: Return value of passdlg_validate_passwords */
+static guint
+passdlg_refresh_password_state (PasswordDialog *pdialog)
+{
+	GtkBuilder *dialog;
+	guint		ret;
+	gboolean	valid = FALSE;
+
+	dialog = pdialog->ui;
+
+	ret = passdlg_validate_passwords (pdialog);
+
+	if (ret == PASSDLG_ERROR_NONE) {
+		valid = TRUE;
+	}
+
+	g_object_set (WID ("change-password-button"), "sensitive", valid, NULL);
+
+	return ret;
+}
+
+/* Called whenever any of the new password fields have changed */
+static void
+passdlg_check_password (GtkEntry *entry, PasswordDialog *pdialog)
+{
+	guint	ret;
+
+	ret = passdlg_refresh_password_state (pdialog);
+
+	switch (ret) {
+		case PASSDLG_ERROR_NONE:
+			passdlg_set_status (pdialog, _("Click <b>Change password</b> to change your password."));
+			break;
+		case PASSDLG_ERROR_NEW_PASSWORD_EMPTY:
+			passdlg_set_status (pdialog, _("Please type your password in the <b>New password</b> field."));
+			break;
+		case PASSDLG_ERROR_RETYPED_PASSWORD_EMPTY:
+			passdlg_set_status (pdialog, _("Please type your password again in the <b>Retype new password</b> field."));
+			break;
+		case PASSDLG_ERROR_PASSWORDS_NOT_EQUAL:
+			passdlg_set_status (pdialog, _("The two passwords are not equal."));
+			break;
+		default:
+			g_warning ("Unknown passdlg_check_password error: %d", ret);
+			break;
+	}
+}
+
+/* Called when the "Change password" dialog-button is clicked
+ * Returns: TRUE if we want to keep the dialog running, FALSE otherwise */
+static gboolean
+passdlg_process_response (PasswordDialog *pdialog, gint response_id)
+{
+
+	if (response_id == GTK_RESPONSE_OK) {
+		/* Set busy as this can be a long process */
+		passdlg_set_busy (pdialog, TRUE);
+
+		/* Stop passwd if an error occured and it is still running */
+		if (pdialog->backend_state == PASSWD_STATE_ERR) {
+
+			/* Stop passwd, free resources */
+			stop_passwd (pdialog);
+		}
+
+		/* Check that the backend is still running, or that an error
+		 * hass occured but it has not yet exited */
+		if (pdialog->backend_pid == -1) {
+			/* If it is not, re-run authentication */
+
+			/* Spawn backend */
+			if (!passdlg_spawn_passwd (pdialog)) {
+				return TRUE;
+			}
+
+			/* Add current and new passwords to queue */
+			authenticate (pdialog);
+			update_password (pdialog);
+		} else {
+			/* Only add new passwords to queue */
+			update_password (pdialog);
+
+			/* Pop new password through the backend */
+			io_queue_pop (pdialog->backend_stdin_queue, pdialog->backend_stdin);
+		}
+
+		/* Our IO watcher should now handle the rest */
+
+		/* Keep the dialog running */
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+/* Activates (moves focus or activates) widget w */
+static void
+passdlg_activate (GtkEntry *entry, GtkWidget *w)
+{
+	if (GTK_IS_BUTTON (w)) {
+		gtk_widget_activate (w);
+	} else {
+		gtk_widget_grab_focus (w);
+	}
+}
+
+/* Initialize password dialog */
+static void
+passdlg_init (PasswordDialog *pdialog, GtkWindow *parent)
+{
+	GtkBuilder		*dialog;
+	GtkWidget		*wpassdlg;
+	GtkAccelGroup	*group;
+
+	/* Initialize dialog */
+	dialog = gtk_builder_new ();
+    gtk_builder_add_from_file (dialog, MATECC_UI_DIR "/mate-about-me-password.ui", NULL);
+	pdialog->ui = dialog;
+
+	wpassdlg = WID ("change-password");
+	capplet_set_icon (wpassdlg, "user-info");
+
+	group = gtk_accel_group_new ();
+
+	/*
+	 * Initialize backend
+	 */
+
+	/* Initialize backend_pid. -1 means the backend is not running */
+	pdialog->backend_pid = -1;
+
+	/* Initialize IO Channels */
+	pdialog->backend_stdin = NULL;
+	pdialog->backend_stdout = NULL;
+
+	/* Initialize write queue */
+	pdialog->backend_stdin_queue = g_queue_new ();
+
+	/* Initialize watchers */
+	pdialog->backend_child_watch_id = 0;
+	pdialog->backend_stdout_watch_id = 0;
+
+	/* Initialize backend state */
+	pdialog->backend_state = PASSWD_STATE_NONE;
+
+	/*
+	 * Initialize UI
+	 */
+
+	/* Initialize pdialog widgets */
+	pdialog->current_password	= GTK_ENTRY (WID ("current-password"));
+	pdialog->new_password		= GTK_ENTRY (WID ("new-password"));
+	pdialog->retyped_password	= GTK_ENTRY (WID ("retyped-password"));
+	pdialog->dialog_image		= GTK_IMAGE (WID ("dialog-image"));
+	pdialog->status_label		= GTK_LABEL (WID ("status-label"));
+
+	/* Initialize accelerators */
+	gtk_widget_add_accelerator (GTK_WIDGET (pdialog->current_password),
+								"activate", group,
+								GDK_Return, 0,
+								0);
+
+	gtk_widget_add_accelerator (GTK_WIDGET (pdialog->new_password),
+								"activate", group,
+								GDK_Return, 0,
+								0);
+
+	/* Activate authenticate-button when enter is pressed in current-password */
+	g_signal_connect (G_OBJECT (pdialog->current_password), "activate",
+					  G_CALLBACK (passdlg_activate), WID ("authenticate-button"));
+
+	/* Activate retyped-password when enter is pressed in new-password */
+	g_signal_connect (G_OBJECT (pdialog->new_password), "activate",
+					  G_CALLBACK (passdlg_activate), pdialog->retyped_password);
+
+	/* Clear status message */
+	passdlg_set_status (pdialog, "");
+
+	/* Set non-authenticated state */
+	passdlg_set_auth_state (pdialog, FALSE);
+
+	/* Connect signal handlers */
+	g_signal_connect (G_OBJECT (WID ("authenticate-button")), "clicked",
+					  G_CALLBACK (passdlg_authenticate), pdialog);
+
+	/* Verify new passwords on-the-fly */
+	g_signal_connect (G_OBJECT (WID ("new-password")), "changed",
+					  G_CALLBACK (passdlg_check_password), pdialog);
+	g_signal_connect (G_OBJECT (WID ("retyped-password")), "changed",
+					  G_CALLBACK (passdlg_check_password), pdialog);
+
+	/* Set misc dialog properties */
+	gtk_window_set_resizable (GTK_WINDOW (wpassdlg), FALSE);
+	gtk_window_set_transient_for (GTK_WINDOW (wpassdlg), GTK_WINDOW (parent));
+}
+
+/* Main */
+void
+mate_about_me_password (GtkWindow *parent)
+{
+	PasswordDialog	*pdialog;
+	GtkBuilder		*dialog;
+	GtkWidget		*wpassdlg;
+
+	gint			result;
+	gboolean		response;
+
+	/* Initialize dialog */
+	pdialog = g_new0 (PasswordDialog, 1);
+	passdlg_init (pdialog, parent);
+
+	dialog = pdialog->ui;
+	wpassdlg = WID ("change-password");
+
+	/* Go! */
+	gtk_widget_show_all (wpassdlg);
+
+	do {
+		result = gtk_dialog_run (GTK_DIALOG (wpassdlg));
+		response = passdlg_process_response (pdialog, result);
+	} while (response);
+
+	/* Clean up */
+	stop_passwd (pdialog);
+	gtk_widget_destroy (wpassdlg);
+	g_queue_free (pdialog->backend_stdin_queue);
+	g_object_unref (dialog);
+	g_free (pdialog);
+}