--- evolution-data-server-1.11.4/libedataserverui/e-passwords.h.e-passwords	2007-04-18 06:10:16.000000000 -0400

+++ evolution-data-server-1.11.4/libedataserverui/e-passwords.h	2007-06-18 16:19:44.000000000 -0400

@@ -28,45 +28,65 @@

 G_BEGIN_DECLS

-/*

-  initialization is now implicit when you call any of the functions

-  below, although this is only correct if the functions are called

-  from the main thread.

-

-  e_passwords_shutdown should be called at exit time to synch the

-  password on-disk storage, and to free up in-memory storage. */

-void e_passwords_init (void);

-

-void        e_passwords_shutdown          (void);

-void	    e_passwords_cancel(void);

-void        e_passwords_set_online(int state);

-void        e_passwords_remember_password (const char *component, const char *key);

-void        e_passwords_add_password      (const char *key, const char *passwd);

-char       *e_passwords_get_password      (const char *component, const char *key);

-void        e_passwords_forget_password   (const char *component, const char *key);

-void        e_passwords_forget_passwords  (void);

-void        e_passwords_clear_passwords (const char *component);

-

+/**

+ * EPasswordsRememberType:

+ * @E_PASSWORDS_REMEMBER_NEVER:

+ * 	Do not remember the password.

+ * @E_PASSWORDS_REMEMBER_SESSION:

+ * 	Remember the password for this session only.

+ * @E_PASSWORDS_REMEMBER_FOREVER:

+ * 	Remember the password across multiple sessions.

+ * @E_PASSWORDS_REMEMBER_MASK:

+ * 	Mask value separates the mutually-exclusive values

+ * 	of the enumeration from the flags.

+ * @E_PASSWORDS_SECRET:

+ * 	Do not show the password as it's being typed.

+ * @E_PASSWORDS_REPROMPT:

+ * 	Populate the dialog with the current password (if one exists).

+ * @E_PASSWORDS_ONLINE:

+ * 	Only prompt the user for a password if we're online.

+ * @E_PASSWORDS_DISABLE_REMEMBER:

+ * 	Disable the "remember password" option on the dialog.

+ * @E_PASSWORDS_PASSPHRASE:

+ * 	Ask for a passphrase instead of a password.

+ **/

 typedef enum {

 	E_PASSWORDS_REMEMBER_NEVER,

 	E_PASSWORDS_REMEMBER_SESSION,

 	E_PASSWORDS_REMEMBER_FOREVER,

 	E_PASSWORDS_REMEMBER_MASK = 0xf,

-	/* option bits */

-	E_PASSWORDS_SECRET = 1<<8,

-	E_PASSWORDS_REPROMPT = 1<<9,

-	E_PASSWORDS_ONLINE = 1<<10, /* only ask if we're online */

-	E_PASSWORDS_DISABLE_REMEMBER = 1<<11, /* disable the 'remember password' checkbox */

-	E_PASSWORDS_PASSPHRASE = 1<<12, /* We are asking a passphrase */

+	/* flags */

+	E_PASSWORDS_SECRET           = 1 << 8,

+	E_PASSWORDS_REPROMPT         = 1 << 9,

+	E_PASSWORDS_ONLINE           = 1 << 10,

+	E_PASSWORDS_DISABLE_REMEMBER = 1 << 11,

+	E_PASSWORDS_PASSPHRASE       = 1 << 12,

 } EPasswordsRememberType;

-char *      e_passwords_ask_password      (const char *title, 

-					   const char*component_name, const char *key,

-					   const char *prompt,

-					   EPasswordsRememberType remember_type,

-					   gboolean *remember,

-					   GtkWindow *parent);

+#ifndef EDS_DISABLE_DEPRECATED

+void		e_passwords_init		(void);

+void		e_passwords_shutdown		(void);

+void		e_passwords_cancel		(void);

+#endif

+void		e_passwords_set_online		(gboolean online);

+void		e_passwords_remember_password	(const gchar *component,

+						 const gchar *key);

+void		e_passwords_add_password	(const gchar *key,

+						 const gchar *password);

+gchar *		e_passwords_get_password	(const gchar *component,

+						 const gchar *key);

+void		e_passwords_forget_password	(const gchar *component,

+						 const gchar *key);

+void		e_passwords_forget_passwords	(void);

+void		e_passwords_clear_passwords	(const gchar *component);

+gchar *		e_passwords_ask_password	(const gchar *title, 

+						 const gchar *component,

+						 const gchar *key,

+						 const gchar *prompt,

+						 EPasswordsRememberType remember_type,

+						 gboolean *remember,

+						 GtkWindow *parent);

 G_END_DECLS

--- evolution-data-server-1.11.4/libedataserverui/e-passwords.c.e-passwords	2007-06-17 23:25:35.000000000 -0400

+++ evolution-data-server-1.11.4/libedataserverui/e-passwords.c	2007-06-18 16:26:02.000000000 -0400

@@ -23,18 +23,29 @@

  */

 /*

- * This looks a lot more complicated than it is, and than you'd think

- * it would need to be.  There is however, method to the madness.

+ * The threading model was changed in version 1.11.  Here's the details.

  *

- * The code most cope with being called from any thread at any time,

- * recursively from the main thread, and then serialising every

- * request so that sane and correct values are always returned, and

- * duplicate requests are never made.

+ * We now use a dedicated "dispatcher" thread to process password messages.

+ * The callback functions do not use synchronization guards when accessing

+ * the password store, so those functions must only be called from the

+ * dispatcher thread.

  *

- * To this end, every call is marshalled and queued and a dispatch

- * method invoked until that request is satisfied.  If mainloop

- * recursion occurs, then the sub-call will necessarily return out of

- * order, but will not be processed out of order.

+ * Message processing behind a visible password dialog is the trickiest

+ * part to get right.  We want to, at all costs, avoid repeatedly prompting

+ * the user for the same password.  To that end, when the password dialog

+ * for some key 'X' is visible, the dispatcher thread is blocked and

+ * subsequent messages for key 'X' are expedited by redirecting them to a

+ * special "express queue" [1].

+ *

+ * Once the password dialog is closed, all messages in the express queue

+ * are either (depending on the user's response) cancelled or loaded with

+ * the new password and returned to the sender.  The express queue is then

+ * closed so that no new messages can enter, and the dispatcher thread

+ * resumes its normal processing.

+ *

+ * [1] Yes, it's a stupid name, but it's the best I could think of.  It's

+ *     somewhat analogous to an express lane on a freeway because messages

+ *     get through faster.

  */

 #ifdef HAVE_CONFIG_H

@@ -42,159 +53,381 @@

 #endif

 #include <string.h>

-#include <libgnome/gnome-config.h>

+#include <gtk/gtk.h>

 #include <glib/gi18n-lib.h>

-#include <gtk/gtkversion.h>

-#include <gtk/gtkentry.h>

-#include <gtk/gtkvbox.h>

-#include <gtk/gtkcheckbutton.h>

-#include <gtk/gtkmessagedialog.h>

 #include "e-passwords.h"

-#include "libedataserver/e-msgport.h"

+#include "libedataserver/e-flag.h"

 #include "libedataserver/e-url.h"

 #ifdef WITH_GNOME_KEYRING

 #include <gnome-keyring.h>

 #endif

-#ifndef ENABLE_THREADS

-#define ENABLE_THREADS (1)

-#endif

-

-#ifdef ENABLE_THREADS

-#include <pthread.h>

-

-static pthread_t main_thread;

-static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

-#define LOCK() pthread_mutex_lock(&lock)

-#define UNLOCK() pthread_mutex_unlock(&lock)

-#else

-#define LOCK()

-#define UNLOCK()

-#endif

+#define d(x)

-#define d(x) x

+typedef struct _EPassMsg EPassMsg;

+typedef struct _EPassDialogData EPassDialogData;

+typedef void (*EPassCallback) (EPassMsg *msg);

 struct _EPassMsg {

-	EMsg msg;

-	void (*dispatch)(struct _EPassMsg *);

+	/* The 'expedite' flag indicates that the message

+	 * is eligible for entry into the express queue. */

-	/* input */

-	struct _GtkWindow *parent;	

-	const char *component;

-	const char *key;

-	const char *title;

-	const char *prompt;

-	const char *oldpass;

-	guint32 flags;

+	/* dispatching */

+	EPassCallback callback;

+	gboolean expedite;

+	EFlag *done;

+

+	/* input/output */

+	const gchar *component;

+	const gchar *key;

+	gchar *password;

+	gpointer data;

+};

-	/* output */

-	gboolean *remember;

-	char *password;

+struct _EPassDialogData {

-	/* work variables */

-	GtkWidget *entry;

-	GtkWidget *check;

-	guint ismain:1;

-	guint noreply:1;	/* supress replies; when calling

-				 * dispatch functions from others */

+	/* settings */

+	GtkWindow *parent;

+	const gchar *title;

+	const gchar *prompt;

+	gint flags;

+

+	/* input/output */

+	gboolean remember;

+	gint response;

+

+	/* synchronization */

+	EFlag *done;

 };

-typedef struct _EPassMsg EPassMsg;

+/* Forward Declarations */

+static void ep_msg_dispatch (EPassMsg *msg);

-static GHashTable *passwords = NULL;

-static GtkDialog *password_dialog;

-static EDList request_list = E_DLIST_INITIALISER(request_list);

-static int idle_id;

-static int ep_online_state = TRUE;

-

-static char *decode_base64 (char *base64);

-static int base64_encode_close(unsigned char *in, int inlen, gboolean break_lines, unsigned char *out, int *state, int *save);

-static int base64_encode_step(unsigned char *in, int len, gboolean break_lines, unsigned char *out, int *state, int *save);

+static GThreadPool *dispatcher = NULL;

+static GHashTable *password_cache = NULL;

+static gboolean ep_online_state = TRUE;

-static gboolean

-ep_idle_dispatch(void *data)

+/* The queue's lock also guards the key. */

+static const gchar *express_key = NULL;

+static GAsyncQueue *express_queue = NULL;

+

+#define KEY_FILE_GROUP_PREFIX "Passwords-"

+static GKeyFile *key_file = NULL;

+

+static gchar *

+ep_key_file_get_filename (void)

 {

-	EPassMsg *msg;

+	/* XXX It would be nice to someday move this data elsewhere, or else

+	 * fully migrate to GNOME Keyring or whatever software supercedes it.

+	 * Evolution is one of the few remaining GNOME-2 applications that

+	 * still uses the deprecated ~/.gnome2-private directory. */

-	/* As soon as a password window is up we stop; it will

-	   re-invoke us when it has been closed down */

-	LOCK();

-	while (password_dialog == NULL && (msg = (EPassMsg *)e_dlist_remhead(&request_list))) {

-		UNLOCK();

+	return g_build_filename (g_get_home_dir (),

+		".gnome2_private", "Evolution", NULL);

+}

-		msg->dispatch(msg);

+static gchar *

+ep_key_file_get_group (const gchar *component)

+{

+	return g_strconcat (KEY_FILE_GROUP_PREFIX, component, NULL);

+}

+

+static gchar *

+ep_key_file_normalize_key (const gchar *key)

+{

+	/* XXX Previous code converted all slashes and equal signs in the

+	 * key to underscores for use with "gnome-config" functions.  While

+	 * it may not be necessary to convert slashes for use with GKeyFile,

+	 * and an equal sign was most likely never encountered in a key, we

+	 * continue to do the same for backward-compatibility. */

+

+	gchar *normalized_key, *cp;

+

+	normalized_key = g_strdup (key);

+	for (cp = normalized_key; *cp != '\0'; cp++)

+		if (*cp == '/' || *cp == '=')

+			*cp = '_';

+

+	return normalized_key;

+}

+

+static void

+ep_key_file_load (void)

+{

+	gchar *filename;

+	GError *error = NULL;

+

+	filename = ep_key_file_get_filename ();

-		LOCK();

+	if (!g_file_test (filename, G_FILE_TEST_EXISTS))

+		goto exit;

+

+	g_key_file_load_from_file (key_file, filename,

+		G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS,

+		&error);

+

+	if (error != NULL) {

+		g_warning ("%s", error->message);

+		g_error_free (error);

 	}

-	idle_id = 0;

-	UNLOCK();

+exit:

+	g_free (filename);

+}

-	return FALSE;

+static void

+ep_key_file_save (void)

+{

+	gchar *contents;

+	gchar *filename;

+	gsize length;

+	GError *error = NULL;

+

+	filename = ep_key_file_get_filename ();

+	contents = g_key_file_to_data (key_file, &length, NULL);

+

+	g_file_set_contents (filename, contents, length, &error);

+

+	if (error != NULL) {

+		g_warning ("%s", error->message);

+		g_error_free (error);

+	}

+

+	g_free (contents);

+	g_free (filename);

 }

-static EPassMsg *

-ep_msg_new(void (*dispatch)(EPassMsg *))

+static gchar *

+ep_password_encode (const gchar *password)

 {

-	EPassMsg *msg;

+	/* XXX The previous Base64 encoding function did not encode the

+	 * password's trailing nul byte.  This makes decoding the Base64

+	 * string into a nul-terminated password more difficult, but we

+	 * continue to do it this way for backward-compatibility. */

+

+	gsize length = strlen (password);

+	return g_base64_encode ((const guchar *) password, length);

+}

+

+static gchar *

+ep_password_decode (const gchar *encoded_password)

+{

+	/* XXX The previous Base64 encoding function did not encode the

+	 * password's trailing nul byte, so we have to append a nul byte

+	 * to the decoded data to make it a nul-terminated string. */

+

+	gchar *password;

+	gsize length;

+

+	password = (gchar *) g_base64_decode (encoded_password, &length);

+	password = g_realloc (password, length + 1);

+	password[length] = '\0';

+

+	return password;

+}

+

+static gpointer

+ep_init (gpointer data)

+{

+	/* Initialize the data structures with unbounded lifetimes. */

+

+	dispatcher = g_thread_pool_new (

+		(GFunc) ep_msg_dispatch, NULL, 1, FALSE, NULL);

+

+	password_cache = g_hash_table_new_full (

+		g_str_hash, g_str_equal, g_free, g_free);

-	e_passwords_init();

+	express_queue = g_async_queue_new ();

-	msg = g_malloc0(sizeof(*msg));

-	msg->dispatch = dispatch;

-	msg->msg.reply_port = e_msgport_new();

-#ifdef ENABLE_THREADS

-	msg->ismain = pthread_equal(pthread_self(), main_thread);

+#ifdef WITH_GNOME_KEYRING

+	if (!gnome_keyring_is_available ()) {

+		key_file = g_key_file_new ();

+		ep_key_file_load ();

+	}

 #else

-	msg->ismain = TRUE;

+	key_file = g_key_file_new ();

+	ep_key_file_load ();

 #endif

+

+	return NULL;

+}

+

+static EPassMsg *

+ep_msg_new (EPassCallback callback, gboolean expedite)

+{

+	static GOnce once = G_ONCE_INIT;

+	EPassMsg *msg;

+

+	g_once (&once, ep_init, NULL);

+

+	msg = g_slice_new0 (EPassMsg);

+	msg->callback = callback;

+	msg->expedite = expedite;

+	msg->done = e_flag_new ();

+

 	return msg;

 }

 static void

-ep_msg_free(EPassMsg *msg)

+ep_msg_dispatch (EPassMsg *msg)

+{

+	msg->callback (msg);

+	e_flag_set (msg->done);

+}

+

+static gboolean

+ep_msg_expedite (EPassMsg *msg)

+{

+	gboolean success = FALSE;

+

+	g_async_queue_lock (express_queue);

+	if (express_key != NULL && strcmp (msg->key, express_key) == 0) {

+		g_async_queue_push_unlocked (express_queue, msg);

+		success = TRUE;

+	}

+	g_async_queue_unlock (express_queue);

+

+	return success;

+}

+

+static void

+ep_msg_send (EPassMsg *msg)

 {

-	e_msgport_destroy(msg->msg.reply_port);

-	g_free(msg->password);

-	g_free(msg);

+	GMainContext *context;

+

+	context = g_main_context_default (); 

+

+	/* Expedite flag requires a key. */

+	g_assert (!msg->expedite || msg->key != NULL);

+

+	if (!(msg->expedite && ep_msg_expedite (msg)))

+		g_thread_pool_push (dispatcher, msg, NULL);

+

+	/* Don't block the main loop. */

+	if (g_main_context_is_owner (context))

+		while (!e_flag_is_set (msg->done))

+			g_main_context_iteration (context, TRUE);

+	else

+		e_flag_wait (msg->done);

 }

 static void

-ep_msg_send(EPassMsg *msg)

+ep_msg_free (EPassMsg *msg)

 {

-	int needidle = 0;

+	e_flag_free (msg->done);

+	g_slice_free (EPassMsg, msg);

+}

+

+static EPassDialogData *

+ep_dialog_data_new (GtkWindow *parent, const gchar *title,

+                    const gchar *prompt, gboolean remember, gint flags)

+{

+	EPassDialogData *data;

+

+	data = g_slice_new0 (EPassDialogData);

+	data->done = e_flag_new ();

+

+	data->parent = parent;

+	data->title = title;

+	data->prompt = prompt;

+	data->remember = remember;

+	data->flags = flags;

+

+	return data;

+}

+

+static void

+ep_dialog_data_free (EPassDialogData *data)

+{

+	e_flag_free (data->done);

+	g_slice_free (EPassDialogData, data);

+}

-	LOCK();

-	e_dlist_addtail(&request_list, (EDListNode *)&msg->msg);

-	if (!idle_id) {

-		if (!msg->ismain)

-			idle_id = g_idle_add(ep_idle_dispatch, NULL);

+static gboolean

+ep_dialog_run (EPassMsg *msg)

+{

+	/* This function must run in the main thread. */

+

+	EPassDialogData *data = msg->data;

+	GtkBox *box;

+	GtkWidget *dialog;

+	GtkWidget *entry;

+	GtkWidget *check_button = NULL;

+	gboolean visible;

+	gint remember;

+

+	visible = !(data->flags & E_PASSWORDS_SECRET);

+	remember = data->flags & E_PASSWORDS_REMEMBER_MASK;

+

+	/* Create a standard message dialog. */

+	dialog = gtk_message_dialog_new (

+		data->parent, 0, GTK_MESSAGE_QUESTION,

+		GTK_BUTTONS_OK_CANCEL, "%s", data->prompt);

+	gtk_window_set_title (GTK_WINDOW (dialog), data->title);

+	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

+

+	box = GTK_BOX (GTK_DIALOG (dialog)->vbox);

+

+	/* Add a GtkEntry for the password. */

+	entry = gtk_entry_new ();

+	gtk_box_pack_start (box, entry, TRUE, FALSE, 3);

+	gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);

+	gtk_entry_set_visibility (GTK_ENTRY (entry), visible);

+	if (msg->password != NULL) {

+		gtk_entry_set_text (GTK_ENTRY (entry), msg->password);

+		g_free (msg->password);

+		msg->password = NULL;

+	}

+	atk_object_set_description (

+		gtk_widget_get_accessible (entry), data->prompt);

+	gtk_widget_grab_focus (entry);

+	gtk_widget_show (entry);

+

+	/* Add a GtkCheckButton for the "remember" option. */

+	if (remember != E_PASSWORDS_REMEMBER_NEVER) {

+		if (data->flags & E_PASSWORDS_PASSPHRASE)

+			check_button = gtk_check_button_new_with_mnemonic (

+				(remember == E_PASSWORDS_REMEMBER_FOREVER) ?

+				_("_Remember this passphrase") :

+				_("_Remember this passphrase for the "

+				"remainder of this session"));

 		else

-			needidle = 1;

-	}

-	UNLOCK();

+			check_button = gtk_check_button_new_with_mnemonic (

+				(remember == E_PASSWORDS_REMEMBER_FOREVER) ?

+				_("_Remember this password") :

+				_("_Remember this password for the "

+				"remainder of this session"));

+		gtk_box_pack_start (box, check_button, TRUE, FALSE, 3);

+		gtk_toggle_button_set_active (

+			GTK_TOGGLE_BUTTON (check_button), data->remember);

+		if (data->flags & E_PASSWORDS_DISABLE_REMEMBER)

+			gtk_widget_set_sensitive (check_button, FALSE);

+		gtk_widget_show (check_button);

+	}

+

+	/* Run the dialog and collect the results. */

+	data->response = gtk_dialog_run (GTK_DIALOG (dialog));

+	msg->password = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));

+	if (check_button != NULL)

+		data->remember = gtk_toggle_button_get_active (

+			GTK_TOGGLE_BUTTON (check_button));

+	else

+		data->remember = FALSE;

-	if (msg->ismain) {

-		EPassMsg *m;

+	gtk_widget_destroy (dialog);

+	e_flag_set (data->done);

-		if (needidle)

-			ep_idle_dispatch(NULL);

-		while ((m = (EPassMsg *)e_msgport_get(msg->msg.reply_port)) == NULL)

-			g_main_context_iteration(NULL, TRUE);

-		g_assert(m == msg);

-	} else {

-		EMsg *reply_msg = e_msgport_wait(msg->msg.reply_port);

-		g_assert(reply_msg == &msg->msg);

-	}

+	return FALSE;

 }

-/* the functions that actually do the work */

+/* The rest of these static functions must run in the dispatcher thread. */

+

 #ifdef WITH_GNOME_KEYRING

 static void

-ep_clear_passwords_keyring(EPassMsg *msg)

+ep_clear_passwords_keyring (EPassMsg *msg)

 {

 	GnomeKeyringAttributeList *attributes;

 	GnomeKeyringAttribute attribute;

@@ -205,11 +438,8 @@ ep_clear_passwords_keyring(EPassMsg *msg

 	result = gnome_keyring_get_default_keyring_sync (&default_keyring);

 	if (!default_keyring) {

-	        if (gnome_keyring_create_sync ("default", NULL) != GNOME_KEYRING_RESULT_OK) {

-				if (!msg->noreply)

-					e_msgport_reply(&msg->msg);

-				return;

-		}

+	        if (gnome_keyring_create_sync ("default", NULL) != GNOME_KEYRING_RESULT_OK)

+			return;

 	        default_keyring = g_strdup ("default");			

 	}

@@ -239,38 +469,44 @@ ep_clear_passwords_keyring(EPassMsg *msg

 	}

 	g_free (default_keyring);

-	if (!msg->noreply)

-		e_msgport_reply(&msg->msg);

 }

 #endif

+

 static void

-ep_clear_passwords_file(EPassMsg *msg)

+ep_clear_passwords_keyfile (EPassMsg *msg)

 {

-	char *path;

-

-	path = g_strdup_printf ("/Evolution/Passwords-%s", msg->component);

+	gchar *group;

+	GError *error = NULL;

-	gnome_config_private_clean_section (path);

-	gnome_config_private_sync_file ("/Evolution");

+	group = ep_key_file_get_group (msg->component);

-	g_free (path);

+	g_key_file_remove_group (key_file, group, &error);

+	if (error == NULL)

+		ep_key_file_save ();

+	else {

+		g_warning ("%s", error->message);

+		g_error_free (error);

+	}

-	if (!msg->noreply)

-		e_msgport_reply(&msg->msg);

+	g_free (group);

 }

-static gboolean

-free_entry (gpointer key, gpointer value, gpointer user_data)

+static void

+ep_clear_passwords (EPassMsg *msg)

 {

-	g_free (key);

-	memset (value, 0, strlen (value));

-	g_free (value);

-	return TRUE;

+#ifdef WITH_GNOME_KEYRING

+	if (gnome_keyring_is_available ())

+		ep_clear_passwords_keyring (msg);

+	else

+		ep_clear_passwords_keyfile (msg);

+#else

+	ep_clear_passwords_keyfile (msg);

+#endif

 }

 #ifdef WITH_GNOME_KEYRING

 static void

-ep_forget_passwords_keyring(EPassMsg *msg)

+ep_forget_passwords_keyring (EPassMsg *msg)

 {

 	GnomeKeyringAttributeList *attributes;

 	GnomeKeyringAttribute attribute;

@@ -281,11 +517,8 @@ ep_forget_passwords_keyring(EPassMsg *ms

 	result = gnome_keyring_get_default_keyring_sync (&default_keyring);

 	if (!default_keyring) {

-	        if (gnome_keyring_create_sync ("default", NULL) != GNOME_KEYRING_RESULT_OK) {

-				if (!msg->noreply)

-					e_msgport_reply(&msg->msg);

-				return;

-		}

+	        if (gnome_keyring_create_sync ("default", NULL) != GNOME_KEYRING_RESULT_OK)

+			return;

 	        default_keyring = g_strdup ("default");			

 	}	

 	d(g_print("Get Default %d\n", result));

@@ -316,69 +549,54 @@ ep_forget_passwords_keyring(EPassMsg *ms

 	g_free (default_keyring);

 	/* free up the session passwords */

-	g_hash_table_foreach_remove (passwords, free_entry, NULL);

-

-	if (!msg->noreply)

-		e_msgport_reply(&msg->msg);

+	g_hash_table_remove_all (password_cache);

 }

 #endif

 static void

-ep_forget_passwords_file(EPassMsg *msg)

+ep_forget_passwords_keyfile (EPassMsg *msg)

 {

-	void *it;

-	char *key;

+	gchar **groups;

+	gsize length, ii;

-	it = gnome_config_private_init_iterator_sections("/Evolution");

-	while ( (it = gnome_config_iterator_next(it, &key, NULL)) ) {

-		if (0 == strncmp(key, "Passwords-", 10)) {

-			char *section = g_strdup_printf("/Evolution/%s", key);

+	g_hash_table_remove_all (password_cache);

-			gnome_config_private_clean_section (section);

-			g_free(section);

-		}

-		g_free(key);

+	groups = g_key_file_get_groups (key_file, &length);

+	for (ii = 0; ii < length; ii++) {

+		if (!g_str_has_prefix (groups[ii], KEY_FILE_GROUP_PREFIX))

+			continue;

+		g_key_file_remove_group (key_file, groups[ii], NULL);

 	}

-

-	gnome_config_private_sync_file ("/Evolution");

-

-	/* free up the session passwords */

-	g_hash_table_foreach_remove (passwords, free_entry, NULL);

-

-	if (!msg->noreply)

-		e_msgport_reply(&msg->msg);

+	ep_key_file_save ();

+	g_strfreev (groups);

 }

-static char *

-password_path (const char *component_name, const char *key)

+static void

+ep_forget_passwords (EPassMsg *msg)

 {

-	char *keycopy, *path;

-	int i;

-	keycopy = g_strdup (key);

-

-	for (i = 0; i < strlen (keycopy); i ++)

-		if (keycopy[i] == '/' || keycopy[i] =='=')

-			keycopy[i] = '_';

-	

-	path = g_strdup_printf ("/Evolution/Passwords-%s/%s", component_name, keycopy);

-

-	g_free (keycopy);

-

-	return path;

+#ifdef WITH_GNOME_KEYRING

+	if (gnome_keyring_is_available ())

+		ep_forget_passwords_keyring (msg);

+	else

+		ep_forget_passwords_keyfile (msg);

+#else

+	ep_forget_passwords_keyfile (msg);

+#endif

 }

 #ifdef WITH_GNOME_KEYRING

 static void

-ep_remember_password_keyring(EPassMsg *msg)

+ep_remember_password_keyring (EPassMsg *msg)

 {

-	gpointer okey, value;

+	gpointer value;

-	if (g_hash_table_lookup_extended (passwords, msg->key, &okey, &value)) {

+	value = g_hash_table_lookup (password_cache, msg->key);

+	if (value != NULL) {

 		/* add it to the on-disk cache of passwords */

 		GnomeKeyringAttributeList *attributes;

 		GnomeKeyringAttribute attribute;

 		GnomeKeyringResult result;

-		EUri *uri = e_uri_new (okey);

+		EUri *uri = e_uri_new (msg->key);

 		guint32 item_id;

 		if (!strcmp (uri->protocol, "ldap") && !uri->user) {

@@ -419,48 +637,48 @@ ep_remember_password_keyring(EPassMsg *m

 		d(g_print("Remember %s: %d/%d\n", msg->key, result, item_id));

 		/* now remove it from our session hash */

-		g_hash_table_remove (passwords, msg->key);

-		g_free (okey);

-		g_free (value);

+		g_hash_table_remove (password_cache, msg->key);

 		e_uri_free (uri);

 	}

-

-	if (!msg->noreply)

-		e_msgport_reply(&msg->msg);

 }

 #endif

 static void

-ep_remember_password_file(EPassMsg *msg)

+ep_remember_password_keyfile (EPassMsg *msg)

 {

-	gpointer okey, value;

-	char *path, *pass64;

-	int len, state, save;

+	gchar *group, *key, *password;

-	if (g_hash_table_lookup_extended (passwords, msg->key, &okey, &value)) {

-		/* add it to the on-disk cache of passwords */

-		path = password_path (msg->component, okey);

+	password = g_hash_table_lookup (password_cache, msg->key);

+	if (password == NULL) {

+		g_warning ("Password for key \"%s\" not found", msg->key);

+		return;

+	}

-		len = strlen (value);

-		pass64 = g_malloc0 ((len + 2) * 4 / 3 + 1);

-		state = save = 0;

-		base64_encode_close (value, len, FALSE, (guchar *)pass64, &state, &save);

-

-		gnome_config_private_set_string (path, pass64);

-		g_free (path);

-		g_free (pass64);

+	group = ep_key_file_get_group (msg->component);

+	key = ep_key_file_normalize_key (msg->key);

+	password = ep_password_encode (password);

-		/* now remove it from our session hash */

-		g_hash_table_remove (passwords, msg->key);

-		g_free (okey);

-		g_free (value);

+	g_hash_table_remove (password_cache, msg->key);

+	g_key_file_set_string (key_file, group, key, password);

+	ep_key_file_save ();

-		gnome_config_private_sync_file ("/Evolution");

-	}

+	g_free (group);

+	g_free (key);

+	g_free (password);

+}

-	if (!msg->noreply)