l2tp vpn properties editor backported to NetworkManager 0.8

Makefile.am

@@ -3,7 +3,7 @@ AUTOMAKE_OPTIONS = foreign
 SUBDIRS = src
 
 if WITH_GNOME
-SUBDIRS += auth-dialog properties po
+SUBDIRS += common-gnome auth-dialog properties po
 endif
 
 dbusservicedir = $(sysconfdir)/dbus-1/system.d

auth-dialog/Makefile.am

@@ -3,26 +3,28 @@ INCLUDES = -I${top_srcdir}
 libexec_PROGRAMS = nm-l2tp-auth-dialog
 
 nm_l2tp_auth_dialog_CPPFLAGS =			\
-	$(NM_CFLAGS)		\
+	$(NM_CFLAGS)			\
 	$(GTHREAD_CFLAGS)			\
 	$(GTK_CFLAGS)				\
+	$(GCONF_CFLAGS)				\
 	$(GNOMEKEYRING_CFLAGS)			\
 	-DICONDIR=\""$(datadir)/pixmaps"\"	\
-	-DUIDIR=\""$(uidir)"\"			\
+	-DGLADEDIR=\""$(gladedir)"\"		\
 	-DBINDIR=\""$(bindir)"\"		\
 	-DG_DISABLE_DEPRECATED			\
 	-DGDK_DISABLE_DEPRECATED		\
-	-DGTK_DISABLE_DEPRECATED		\
+	-DGNOME_DISABLE_DEPRECATED		\
+	-DGNOMELOCALEDIR=\"$(datadir)/locale\"	\
 	-DVERSION=\"$(VERSION)\"
 
 nm_l2tp_auth_dialog_SOURCES =			\
-	main.c \
-	vpn-password-dialog.c \
-	vpn-password-dialog.h
+	main.c					\
+	gnome-two-password-dialog.c		\
+	gnome-two-password-dialog.h
 
 nm_l2tp_auth_dialog_LDADD =			\
-	$(NM_LIBS) \
-	$(GTK_LIBS) \
-	$(GNOMEKEYRING_LIBS)
+	$(GTK_LIBS)				\
+	$(GCONF_LIBS)				\
+	$(top_builddir)/common-gnome/libnm-l2tp-common-gnome.la
 
 CLEANFILES = *~

auth-dialog/gnome-two-password-dialog.c

+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* gnome-password-dialog.c - A use password prompting dialog widget.
+
+   Copyright (C) 1999, 2000 Eazel, Inc.
+
+   The Gnome Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the ree Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The Gnome Library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+   Authors: Ramiro Estrugo <ramiro@eazel.com>
+*/
+
+#include <config.h>
+#include "gnome-two-password-dialog.h"
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+
+struct GnomeTwoPasswordDialogDetails
+{
+	/* Attributes */
+	gboolean readonly_username;
+	gboolean readonly_domain;
+
+	gboolean show_username;
+	gboolean show_domain;
+	gboolean show_password;
+	gboolean show_password_secondary;
+	
+	/* TODO: */
+	gboolean remember;
+	char *remember_label_text;
+
+	/* Internal widgetry and flags */
+	GtkWidget *username_entry;
+	GtkWidget *password_entry;
+	GtkWidget *password_entry_secondary;
+	GtkWidget *domain_entry;
+
+	GtkWidget *table_alignment;
+	GtkWidget *table;
+	
+	GtkWidget *remember_session_button;
+	GtkWidget *remember_forever_button;
+
+	GtkWidget *radio_vbox;
+	GtkWidget *connect_with_no_userpass_button;
+	GtkWidget *connect_with_userpass_button;
+
+	gboolean anon_support_on;
+
+	char *secondary_password_label;
+};
+
+/* Caption table rows indices */
+static const guint CAPTION_TABLE_USERNAME_ROW = 0;
+static const guint CAPTION_TABLE_PASSWORD_ROW = 1;
+
+/* GnomeTwoPasswordDialogClass methods */
+static void gnome_two_password_dialog_class_init (GnomeTwoPasswordDialogClass *password_dialog_class);
+static void gnome_two_password_dialog_init       (GnomeTwoPasswordDialog      *password_dialog);
+
+/* GObjectClass methods */
+static void gnome_two_password_dialog_finalize         (GObject                *object);
+
+
+/* GtkDialog callbacks */
+static void dialog_show_callback                 (GtkWidget              *widget,
+						  gpointer                callback_data);
+static void dialog_close_callback                (GtkWidget              *widget,
+						  gpointer                callback_data);
+
+static gpointer parent_class;
+
+GType
+gnome_two_password_dialog_get_type (void)
+{
+	static GType type = 0;
+
+	if (!type) {
+		static const GTypeInfo info = {
+			sizeof (GnomeTwoPasswordDialogClass),
+                        NULL, NULL,
+			(GClassInitFunc) gnome_two_password_dialog_class_init,
+                        NULL, NULL,
+			sizeof (GnomeTwoPasswordDialog), 0,
+			(GInstanceInitFunc) gnome_two_password_dialog_init,
+			NULL
+		};
+
+                type = g_type_register_static (gtk_dialog_get_type(), 
+					       "GnomeTwoPasswordDialog", 
+					       &info, 0);
+
+		parent_class = g_type_class_ref (gtk_dialog_get_type());
+	}
+
+	return type;
+}
+
+
+static void
+gnome_two_password_dialog_class_init (GnomeTwoPasswordDialogClass * klass)
+{
+	G_OBJECT_CLASS (klass)->finalize = gnome_two_password_dialog_finalize;
+}
+
+static void
+gnome_two_password_dialog_init (GnomeTwoPasswordDialog *password_dialog)
+{
+	password_dialog->details = g_new0 (GnomeTwoPasswordDialogDetails, 1);
+	password_dialog->details->show_username = TRUE;
+	password_dialog->details->show_password = TRUE;
+	password_dialog->details->show_password_secondary = TRUE;
+	password_dialog->details->anon_support_on = FALSE;
+
+	password_dialog->details->secondary_password_label = g_strdup ( _("_Secondary Password:") );
+}
+
+/* GObjectClass methods */
+static void
+gnome_two_password_dialog_finalize (GObject *object)
+{
+	GnomeTwoPasswordDialog *password_dialog;
+	
+	password_dialog = GNOME_TWO_PASSWORD_DIALOG (object);
+
+	g_object_unref (password_dialog->details->username_entry);
+	g_object_unref (password_dialog->details->domain_entry);
+	g_object_unref (password_dialog->details->password_entry);
+	g_object_unref (password_dialog->details->password_entry_secondary);
+
+	g_free (password_dialog->details->remember_label_text);
+	g_free (password_dialog->details->secondary_password_label);
+	g_free (password_dialog->details);
+
+	if (G_OBJECT_CLASS (parent_class)->finalize != NULL)
+		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+}
+
+/* GtkDialog callbacks */
+static void
+dialog_show_callback (GtkWidget *widget, gpointer callback_data)
+{
+	GnomeTwoPasswordDialog *password_dialog;
+
+	password_dialog = GNOME_TWO_PASSWORD_DIALOG (callback_data);
+
+	if (GTK_WIDGET_VISIBLE (password_dialog->details->username_entry) &&
+	    !password_dialog->details->readonly_username) {
+		gtk_widget_grab_focus (password_dialog->details->username_entry);
+	} else if (GTK_WIDGET_VISIBLE (password_dialog->details->domain_entry) &&
+		   !password_dialog->details->readonly_domain) {
+		gtk_widget_grab_focus (password_dialog->details->domain_entry);
+	} else if (GTK_WIDGET_VISIBLE (password_dialog->details->password_entry)) {
+		gtk_widget_grab_focus (password_dialog->details->password_entry);
+	} else if (GTK_WIDGET_VISIBLE (password_dialog->details->password_entry_secondary)) {
+		gtk_widget_grab_focus (password_dialog->details->password_entry_secondary);
+	}
+}
+
+static void
+dialog_close_callback (GtkWidget *widget, gpointer callback_data)
+{
+	gtk_widget_hide (widget);
+}
+
+static void
+userpass_radio_button_clicked (GtkWidget *widget, gpointer callback_data)
+{
+	GnomeTwoPasswordDialog *password_dialog;
+
+	password_dialog = GNOME_TWO_PASSWORD_DIALOG (callback_data);
+
+	if (widget == password_dialog->details->connect_with_no_userpass_button) {
+		gtk_widget_set_sensitive (
+			password_dialog->details->table, FALSE);
+	}
+	else { /* the other button */
+		gtk_widget_set_sensitive (
+                        password_dialog->details->table, TRUE);
+	}	
+}
+
+static void
+add_row (GtkWidget *table, int row, const char *label_text, GtkWidget *entry)
+{
+	GtkWidget *label;
+
+	label = gtk_label_new_with_mnemonic (label_text);
+	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+
+	gtk_table_attach_defaults (GTK_TABLE (table), label,
+				   0, 1, row, row + 1);
+	gtk_table_attach_defaults (GTK_TABLE (table), entry,
+				   1, 2, row, row + 1);
+
+	gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
+}
+
+static void
+remove_child (GtkWidget *child, GtkWidget *table)
+{
+	gtk_container_remove (GTK_CONTAINER (table), child);
+}
+
+static void
+add_table_rows (GnomeTwoPasswordDialog *password_dialog)
+{
+	int row;
+	GtkWidget *table;
+	int offset;
+
+	if (password_dialog->details->anon_support_on) {
+		offset = 12;
+	}
+	else {
+		offset = 0;
+	}
+
+	gtk_alignment_set_padding (GTK_ALIGNMENT (password_dialog->details->table_alignment),
+				   0, 0, offset, 0);
+
+	table = password_dialog->details->table;
+	/* This will not kill the entries, since they are ref:ed */
+	gtk_container_foreach (GTK_CONTAINER (table),
+			       (GtkCallback)remove_child, table);
+	
+	row = 0;
+	if (password_dialog->details->show_username)
+		add_row (table, row++, _("_Username:"), password_dialog->details->username_entry);
+	if (password_dialog->details->show_domain)
+		add_row (table, row++, _("_Domain:"), password_dialog->details->domain_entry);
+	if (password_dialog->details->show_password)
+		add_row (table, row++, _("_Password:"), password_dialog->details->password_entry);
+	if (password_dialog->details->show_password_secondary)
+		add_row (table, row++, password_dialog->details->secondary_password_label, 
+			 password_dialog->details->password_entry_secondary);
+
+	gtk_widget_show_all (table);
+}
+
+static void
+username_entry_activate (GtkWidget *widget, GtkWidget *dialog)
+{
+	GnomeTwoPasswordDialog *password_dialog;
+
+	password_dialog = GNOME_TWO_PASSWORD_DIALOG (dialog);
+	
+	if (GTK_WIDGET_VISIBLE (password_dialog->details->domain_entry) &&
+	    GTK_WIDGET_SENSITIVE (password_dialog->details->domain_entry))
+		gtk_widget_grab_focus (password_dialog->details->domain_entry);
+	else if (GTK_WIDGET_VISIBLE (password_dialog->details->password_entry) &&
+		 GTK_WIDGET_SENSITIVE (password_dialog->details->password_entry))
+		gtk_widget_grab_focus (password_dialog->details->password_entry);
+	else if (GTK_WIDGET_VISIBLE (password_dialog->details->password_entry_secondary) &&
+		 GTK_WIDGET_SENSITIVE (password_dialog->details->password_entry_secondary))
+		gtk_widget_grab_focus (password_dialog->details->password_entry_secondary);
+}
+
+static void
+domain_entry_activate (GtkWidget *widget, GtkWidget *dialog)
+{
+	GnomeTwoPasswordDialog *password_dialog;
+
+	password_dialog = GNOME_TWO_PASSWORD_DIALOG (dialog);
+	
+	if (GTK_WIDGET_VISIBLE (password_dialog->details->password_entry) &&
+	    GTK_WIDGET_SENSITIVE (password_dialog->details->password_entry))
+		gtk_widget_grab_focus (password_dialog->details->password_entry);
+	else if (GTK_WIDGET_VISIBLE (password_dialog->details->password_entry_secondary) &&
+		 GTK_WIDGET_SENSITIVE (password_dialog->details->password_entry_secondary))
+		gtk_widget_grab_focus (password_dialog->details->password_entry_secondary);
+}
+
+
+/* Public GnomeTwoPasswordDialog methods */
+GtkWidget *
+gnome_two_password_dialog_new (const char	*dialog_title,
+			   const char	*message,
+			   const char	*username,
+			   const char	*password,
+			   gboolean	 readonly_username)
+{
+	GnomeTwoPasswordDialog *password_dialog;
+	GtkDialog *dialog;
+	GtkWidget *table;
+	GtkLabel *message_label;
+	GtkWidget *hbox;
+	GtkWidget *vbox;
+	GtkWidget *main_vbox;
+	GtkWidget *dialog_icon;
+	GSList *group;
+
+	password_dialog = GNOME_TWO_PASSWORD_DIALOG (gtk_widget_new (gnome_two_password_dialog_get_type (), NULL));
+	dialog = GTK_DIALOG (password_dialog);
+
+	gtk_window_set_title (GTK_WINDOW (password_dialog), dialog_title);
+	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+
+	gtk_dialog_add_buttons (dialog,
+				GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+				GTK_STOCK_OK, GTK_RESPONSE_OK,
+				NULL);
+	gtk_dialog_set_default_response (GTK_DIALOG (password_dialog), GTK_RESPONSE_OK);
+
+	/* Setup the dialog */
+	gtk_dialog_set_has_separator (dialog, FALSE);
+        gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
+        gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
+        gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
+        gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
+
+ 	gtk_window_set_position (GTK_WINDOW (password_dialog), GTK_WIN_POS_CENTER);
+	gtk_window_set_modal (GTK_WINDOW (password_dialog), TRUE);
+
+	g_signal_connect (password_dialog, "show",
+			  G_CALLBACK (dialog_show_callback), password_dialog);
+	g_signal_connect (password_dialog, "close",
+			  G_CALLBACK (dialog_close_callback), password_dialog);
+
+	/* the radio buttons for anonymous login */
+	password_dialog->details->connect_with_no_userpass_button =
+                gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously"));
+	group = gtk_radio_button_get_group (
+			GTK_RADIO_BUTTON (password_dialog->details->connect_with_no_userpass_button));
+        password_dialog->details->connect_with_userpass_button =
+                gtk_radio_button_new_with_mnemonic (
+			group, _("Connect as _user:"));
+
+	if (username != NULL && *username != 0) {
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (password_dialog->details->connect_with_userpass_button), TRUE);
+	} else {
+		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (password_dialog->details->connect_with_no_userpass_button), TRUE);
+	}
+	
+	password_dialog->details->radio_vbox = gtk_vbox_new (FALSE, 6);
+	gtk_box_pack_start (GTK_BOX (password_dialog->details->radio_vbox),
+		password_dialog->details->connect_with_no_userpass_button,
+		FALSE, FALSE, 0);	
+	gtk_box_pack_start (GTK_BOX (password_dialog->details->radio_vbox),
+                password_dialog->details->connect_with_userpass_button,
+                FALSE, FALSE, 0);
+	g_signal_connect (password_dialog->details->connect_with_no_userpass_button, "clicked",
+                          G_CALLBACK (userpass_radio_button_clicked), password_dialog);
+	g_signal_connect (password_dialog->details->connect_with_userpass_button, "clicked",
+                          G_CALLBACK (userpass_radio_button_clicked), password_dialog);	
+
+	/* The table that holds the captions */
+	password_dialog->details->table_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
+
+	password_dialog->details->table = table = gtk_table_new (3, 2, FALSE);
+	gtk_table_set_col_spacings (GTK_TABLE (table), 12);
+	gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+	gtk_container_add (GTK_CONTAINER (password_dialog->details->table_alignment), table);
+
+	password_dialog->details->username_entry = gtk_entry_new ();
+	password_dialog->details->domain_entry = gtk_entry_new ();
+	password_dialog->details->password_entry = gtk_entry_new ();
+	password_dialog->details->password_entry_secondary = gtk_entry_new ();
+
+	/* We want to hold on to these during the table rearrangement */
+#if GLIB_CHECK_VERSION (2, 10, 0)
+	g_object_ref_sink (password_dialog->details->username_entry);
+	g_object_ref_sink (password_dialog->details->domain_entry);
+        g_object_ref_sink (password_dialog->details->password_entry);
+        g_object_ref_sink (password_dialog->details->password_entry_secondary);
+#else
+	g_object_ref (password_dialog->details->username_entry);
+	gtk_object_sink (GTK_OBJECT (password_dialog->details->username_entry));
+	g_object_ref (password_dialog->details->domain_entry);
+	gtk_object_sink (GTK_OBJECT (password_dialog->details->domain_entry));
+        g_object_ref (password_dialog->details->password_entry);
+	gtk_object_sink (GTK_OBJECT (password_dialog->details->password_entry));
+        g_object_ref (password_dialog->details->password_entry_secondary);
+	gtk_object_sink (GTK_OBJECT (password_dialog->details->password_entry_secondary));
+#endif
+	
+	gtk_entry_set_visibility (GTK_ENTRY (password_dialog->details->password_entry), FALSE);
+	gtk_entry_set_visibility (GTK_ENTRY (password_dialog->details->password_entry_secondary), FALSE);
+
+	g_signal_connect (password_dialog->details->username_entry,
+			  "activate",
+			  G_CALLBACK (username_entry_activate),
+			  password_dialog);
+	g_signal_connect (password_dialog->details->domain_entry,
+			  "activate",
+			  G_CALLBACK (domain_entry_activate),
+			  password_dialog);
+	g_signal_connect_swapped (password_dialog->details->password_entry,
+				  "activate",
+				  G_CALLBACK (gtk_window_activate_default),
+				  password_dialog);
+	g_signal_connect_swapped (password_dialog->details->password_entry_secondary,
+				  "activate",
+				  G_CALLBACK (gtk_window_activate_default),
+				  password_dialog);
+	add_table_rows (password_dialog);
+
+	/* Adds some eye-candy to the dialog */
+	hbox = gtk_hbox_new (FALSE, 12);
+ 	gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+	dialog_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
+	gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0);
+	gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0);
+
+	/* Fills the vbox */
+	main_vbox = gtk_vbox_new (FALSE, 18);
+
+	if (message) {
+		message_label = GTK_LABEL (gtk_label_new (message));
+		gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT);
+		gtk_label_set_line_wrap (message_label, TRUE);
+
+		gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label),
+				    FALSE, FALSE, 0);
+	}
+
+	vbox = gtk_vbox_new (FALSE, 6);
+	gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
+
+	gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->radio_vbox,
+                            FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->table_alignment,
+			    FALSE, FALSE, 0);
+
+	gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0);
+
+	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (password_dialog)->vbox),
+			    hbox,
+			    TRUE,	/* expand */
+			    TRUE,	/* fill */
+			    0);       	/* padding */
+	
+	gtk_widget_show_all (GTK_DIALOG (password_dialog)->vbox);
+
+	password_dialog->details->remember_session_button =
+		gtk_check_button_new_with_mnemonic (_("_Remember passwords for this session"));
+	password_dialog->details->remember_forever_button =
+		gtk_check_button_new_with_mnemonic (_("_Save passwords in keyring"));
+
+	gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->remember_session_button, 
+			    FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (vbox), password_dialog->details->remember_forever_button, 
+			    FALSE, FALSE, 0);
+
+	gnome_two_password_dialog_set_username (password_dialog, username);
+	gnome_two_password_dialog_set_password (password_dialog, password);
+	gnome_two_password_dialog_set_readonly_domain (password_dialog, readonly_username);
+	
+	return GTK_WIDGET (password_dialog);
+}
+
+gboolean
+gnome_two_password_dialog_run_and_block (GnomeTwoPasswordDialog *password_dialog)
+{
+	gint button_clicked;
+
+	g_return_val_if_fail (password_dialog != NULL, FALSE);
+	g_return_val_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog), FALSE);
+
+	button_clicked = gtk_dialog_run (GTK_DIALOG (password_dialog));
+	gtk_widget_hide (GTK_WIDGET (password_dialog));
+
+	return button_clicked == GTK_RESPONSE_OK;
+}
+
+void
+gnome_two_password_dialog_set_username (GnomeTwoPasswordDialog	*password_dialog,
+				       const char		*username)
+{
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+	g_return_if_fail (password_dialog->details->username_entry != NULL);
+
+	gtk_entry_set_text (GTK_ENTRY (password_dialog->details->username_entry),
+			    username?username:"");
+}
+
+void
+gnome_two_password_dialog_set_password (GnomeTwoPasswordDialog	*password_dialog,
+				       const char		*password)
+{
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	gtk_entry_set_text (GTK_ENTRY (password_dialog->details->password_entry),
+			    password ? password : "");
+}
+
+void
+gnome_two_password_dialog_set_password_secondary (GnomeTwoPasswordDialog	*password_dialog,
+						  const char		        *password_secondary)
+{
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	gtk_entry_set_text (GTK_ENTRY (password_dialog->details->password_entry_secondary),
+			    password_secondary ? password_secondary : "");
+}
+
+void
+gnome_two_password_dialog_set_domain (GnomeTwoPasswordDialog	*password_dialog,
+				  const char		*domain)
+{
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+	g_return_if_fail (password_dialog->details->domain_entry != NULL);
+
+	gtk_entry_set_text (GTK_ENTRY (password_dialog->details->domain_entry),
+			    domain ? domain : "");
+}
+
+
+void
+gnome_two_password_dialog_set_show_username (GnomeTwoPasswordDialog *password_dialog,
+					 gboolean             show)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	show = !!show;
+	if (password_dialog->details->show_username != show) {
+		password_dialog->details->show_username = show;
+		add_table_rows (password_dialog);
+	}
+}
+
+void
+gnome_two_password_dialog_set_show_domain (GnomeTwoPasswordDialog *password_dialog,
+				       gboolean             show)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	show = !!show;
+	if (password_dialog->details->show_domain != show) {
+		password_dialog->details->show_domain = show;
+		add_table_rows (password_dialog);
+	}
+}
+
+void
+gnome_two_password_dialog_set_show_password (GnomeTwoPasswordDialog *password_dialog,
+					 gboolean             show)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	show = !!show;
+	if (password_dialog->details->show_password != show) {
+		password_dialog->details->show_password = show;
+		add_table_rows (password_dialog);
+	}
+}
+
+void
+gnome_two_password_dialog_set_show_password_secondary (GnomeTwoPasswordDialog *password_dialog,
+						       gboolean             show)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	show = !!show;
+	if (password_dialog->details->show_password_secondary != show) {
+		password_dialog->details->show_password_secondary = show;
+		add_table_rows (password_dialog);
+	}
+}
+
+void
+gnome_two_password_dialog_set_readonly_username (GnomeTwoPasswordDialog	*password_dialog,
+						gboolean		readonly)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	password_dialog->details->readonly_username = readonly;
+
+	gtk_widget_set_sensitive (password_dialog->details->username_entry,
+				  !readonly);
+}
+
+void
+gnome_two_password_dialog_set_readonly_domain (GnomeTwoPasswordDialog	*password_dialog,
+					   gboolean		readonly)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	password_dialog->details->readonly_domain = readonly;
+
+	gtk_widget_set_sensitive (password_dialog->details->domain_entry,
+				  !readonly);
+}
+
+char *
+gnome_two_password_dialog_get_username (GnomeTwoPasswordDialog *password_dialog)
+{
+	g_return_val_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog), NULL);
+
+	return g_strdup (gtk_entry_get_text (GTK_ENTRY (password_dialog->details->username_entry)));
+}
+
+char *
+gnome_two_password_dialog_get_domain (GnomeTwoPasswordDialog *password_dialog)
+{
+	g_return_val_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog), NULL);
+	
+	return g_strdup (gtk_entry_get_text (GTK_ENTRY (password_dialog->details->domain_entry)));
+}
+
+char *
+gnome_two_password_dialog_get_password (GnomeTwoPasswordDialog *password_dialog)
+{
+	g_return_val_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog), NULL);
+
+	return g_strdup (gtk_entry_get_text (GTK_ENTRY (password_dialog->details->password_entry)));
+}
+
+char *
+gnome_two_password_dialog_get_password_secondary (GnomeTwoPasswordDialog *password_dialog)
+{
+	g_return_val_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog), NULL);
+
+	return g_strdup (gtk_entry_get_text (GTK_ENTRY (password_dialog->details->password_entry_secondary)));
+}
+
+void
+gnome_two_password_dialog_set_show_userpass_buttons (GnomeTwoPasswordDialog         *password_dialog,
+						     gboolean                     show_userpass_buttons)
+{
+        if (show_userpass_buttons) {
+                password_dialog->details->anon_support_on = TRUE;
+                gtk_widget_show (password_dialog->details->radio_vbox);
+                if (gtk_toggle_button_get_active (
+                        GTK_TOGGLE_BUTTON (password_dialog->details->connect_with_no_userpass_button))) {
+                        gtk_widget_set_sensitive (password_dialog->details->table, FALSE);
+                }
+                else {
+                        gtk_widget_set_sensitive (password_dialog->details->table, TRUE);
+                }
+        } else {
+                password_dialog->details->anon_support_on = FALSE;
+                gtk_widget_hide (password_dialog->details->radio_vbox);
+                gtk_widget_set_sensitive (password_dialog->details->table, TRUE);
+        }
+                                                                                                                             
+        add_table_rows (password_dialog);
+}
+
+gboolean
+gnome_two_password_dialog_anon_selected (GnomeTwoPasswordDialog *password_dialog)
+{
+	return password_dialog->details->anon_support_on &&
+		gtk_toggle_button_get_active (
+        		GTK_TOGGLE_BUTTON (
+				password_dialog->details->connect_with_no_userpass_button));
+}
+
+void
+gnome_two_password_dialog_set_show_remember (GnomeTwoPasswordDialog         *password_dialog,
+					 gboolean                     show_remember)
+{
+	if (show_remember) {
+		gtk_widget_show (password_dialog->details->remember_session_button);
+		gtk_widget_show (password_dialog->details->remember_forever_button);
+	} else {
+		gtk_widget_hide (password_dialog->details->remember_session_button);
+		gtk_widget_hide (password_dialog->details->remember_forever_button);
+	}
+}
+
+void
+gnome_two_password_dialog_set_remember      (GnomeTwoPasswordDialog         *password_dialog,
+					 GnomeTwoPasswordDialogRemember  remember)
+{
+	gboolean session, forever;
+
+	session = FALSE;
+	forever = FALSE;
+	if (remember == GNOME_TWO_PASSWORD_DIALOG_REMEMBER_SESSION) {
+		session = TRUE;
+	} else if (remember == GNOME_TWO_PASSWORD_DIALOG_REMEMBER_FOREVER){
+		forever = TRUE;
+	}
+	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (password_dialog->details->remember_session_button),
+				      session);
+	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (password_dialog->details->remember_forever_button),
+				      forever);
+}
+
+GnomeTwoPasswordDialogRemember
+gnome_two_password_dialog_get_remember (GnomeTwoPasswordDialog         *password_dialog)
+{
+	gboolean session, forever;
+
+	session = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (password_dialog->details->remember_session_button));
+	forever = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (password_dialog->details->remember_forever_button));
+	if (forever) {
+		return GNOME_TWO_PASSWORD_DIALOG_REMEMBER_FOREVER;
+	} else if (session) {
+		return GNOME_TWO_PASSWORD_DIALOG_REMEMBER_SESSION;
+	}
+	return GNOME_TWO_PASSWORD_DIALOG_REMEMBER_NOTHING;
+}
+
+void gnome_two_password_dialog_set_password_secondary_label (GnomeTwoPasswordDialog  *password_dialog,
+							     const char              *password_secondary_label)
+{
+	g_return_if_fail (password_dialog != NULL);
+	g_return_if_fail (GNOME_IS_TWO_PASSWORD_DIALOG (password_dialog));
+
+	g_free (password_dialog->details->secondary_password_label);
+	password_dialog->details->secondary_password_label = g_strdup (password_secondary_label);
+
+	if (password_dialog->details->show_password_secondary) {
+		add_table_rows (password_dialog);
+	}
+}

auth-dialog/gnome-two-password-dialog.h

+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* gnome-two-password-dialog.h - A use password prompting dialog widget
+                                 asking for two passwords. Based of
+                                 gnome-password-dialog.[ch] from libgnomeui
+
+   Copyright (C) 1999, 2000 Eazel, Inc.
+   Copyright (C) 2005, Red Hat, Inc.
+
+   The Gnome Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The Gnome Library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+   Authors: Ramiro Estrugo <ramiro@eazel.com>
+*/
+
+#ifndef GNOME_TWO_PASSWORD_DIALOG_H
+#define GNOME_TWO_PASSWORD_DIALOG_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GNOME_TYPE_TWO_PASSWORD_DIALOG            (gnome_two_password_dialog_get_type ())
+#define GNOME_TWO_PASSWORD_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_TYPE_TWO_PASSWORD_DIALOG, GnomeTwoPasswordDialog))
+#define GNOME_TWO_PASSWORD_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_TYPE_TWO_PASSWORD_DIALOG, GnomeTwoPasswordDialogClass))
+#define GNOME_IS_TWO_PASSWORD_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_TYPE_TWO_PASSWORD_DIALOG))
+#define GNOME_IS_TWO_PASSWORD_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_TYPE_TWO_PASSWORD_DIALOG))
+
+typedef struct GnomeTwoPasswordDialog        GnomeTwoPasswordDialog;
+typedef struct GnomeTwoPasswordDialogClass   GnomeTwoPasswordDialogClass;
+typedef struct GnomeTwoPasswordDialogDetails GnomeTwoPasswordDialogDetails;
+
+struct GnomeTwoPasswordDialog
+{
+	GtkDialog gtk_dialog;
+
+	GnomeTwoPasswordDialogDetails *details;
+};
+
+struct GnomeTwoPasswordDialogClass
+{
+	GtkDialogClass parent_class;
+};
+
+typedef enum {
+	GNOME_TWO_PASSWORD_DIALOG_REMEMBER_NOTHING,
+	GNOME_TWO_PASSWORD_DIALOG_REMEMBER_SESSION,
+	GNOME_TWO_PASSWORD_DIALOG_REMEMBER_FOREVER
+} GnomeTwoPasswordDialogRemember;
+
+
+GType    gnome_two_password_dialog_get_type (void);
+GtkWidget* gnome_two_password_dialog_new      (const char *dialog_title,
+					   const char *message,
+					   const char *username,
+					   const char *password,
+					   gboolean    readonly_username);
+
+gboolean   gnome_two_password_dialog_run_and_block           (GnomeTwoPasswordDialog *password_dialog);
+
+/* Attribute mutators */
+void gnome_two_password_dialog_set_show_username           (GnomeTwoPasswordDialog *password_dialog,
+							    gboolean                show);
+void gnome_two_password_dialog_set_show_domain             (GnomeTwoPasswordDialog *password_dialog,
+							    gboolean                show);
+void gnome_two_password_dialog_set_show_password           (GnomeTwoPasswordDialog *password_dialog,
+							    gboolean                show);
+void gnome_two_password_dialog_set_show_password_secondary (GnomeTwoPasswordDialog *password_dialog,
+							    gboolean                show);
+void gnome_two_password_dialog_set_username                (GnomeTwoPasswordDialog  *password_dialog,
+							    const char              *username);
+void gnome_two_password_dialog_set_domain                  (GnomeTwoPasswordDialog  *password_dialog,
+							    const char              *domain);
+void gnome_two_password_dialog_set_password                (GnomeTwoPasswordDialog  *password_dialog,
+							    const char              *password);
+void gnome_two_password_dialog_set_password_secondary      (GnomeTwoPasswordDialog  *password_dialog,
+							    const char              *password_secondary);
+void gnome_two_password_dialog_set_readonly_username       (GnomeTwoPasswordDialog  *password_dialog,
+							    gboolean                 readonly);
+void gnome_two_password_dialog_set_readonly_domain         (GnomeTwoPasswordDialog  *password_dialog,
+							    gboolean                 readonly);
+
+void gnome_two_password_dialog_set_password_secondary_label (GnomeTwoPasswordDialog  *password_dialog,
+							     const char              *password_secondary_description);
+
+void                           gnome_two_password_dialog_set_show_remember         (GnomeTwoPasswordDialog         *password_dialog,
+										    gboolean                        show_remember);
+void                           gnome_two_password_dialog_set_remember              (GnomeTwoPasswordDialog         *password_dialog,
+										    GnomeTwoPasswordDialogRemember  remember);
+GnomeTwoPasswordDialogRemember gnome_two_password_dialog_get_remember              (GnomeTwoPasswordDialog         *password_dialog);
+void                           gnome_two_password_dialog_set_show_userpass_buttons (GnomeTwoPasswordDialog         *password_dialog,
+										    gboolean                        show_userpass_buttons);
+
+/* Attribute accessors */
+char *     gnome_two_password_dialog_get_username            (GnomeTwoPasswordDialog *password_dialog);
+char *     gnome_two_password_dialog_get_domain              (GnomeTwoPasswordDialog *password_dialog);
+char *     gnome_two_password_dialog_get_password            (GnomeTwoPasswordDialog *password_dialog);
+char *     gnome_two_password_dialog_get_password_secondary  (GnomeTwoPasswordDialog *password_dialog);
+
+gboolean   gnome_two_password_dialog_anon_selected           (GnomeTwoPasswordDialog *password_dialog);
+
+G_END_DECLS
+
+#endif /* GNOME_TWO_PASSWORD_DIALOG_H */

auth-dialog/main.c

@@ -17,7 +17,7 @@
  * with this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
- * (C) Copyright 2008 - 2011 Red Hat, Inc.
+ * (C) Copyright 2008 Red Hat, Inc.
  */
 
 #ifdef HAVE_CONFIG_H
@@ -26,121 +26,91 @@
 
 #include <string.h>
 #include <stdlib.h>
-#include <errno.h>
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 
-#include <gnome-keyring.h>
-#include <gnome-keyring-memory.h>
-
 #include <nm-setting-vpn.h>
-#include <nm-vpn-plugin-utils.h>
 
 #include "src/nm-l2tp-service.h"
-#include "vpn-password-dialog.h"
+#include "common-gnome/keyring-helpers.h"
+#include "gnome-two-password-dialog.h"
 
 #define KEYRING_UUID_TAG "connection-uuid"
 #define KEYRING_SN_TAG "setting-name"
 #define KEYRING_SK_TAG "setting-key"
 
-static char *
-keyring_lookup_secret (const char *uuid, const char *secret_name)
-{
-	GList *found_list = NULL;
-	GnomeKeyringResult ret;
-	GnomeKeyringFound *found;
-	char *secret = NULL;
-
-	ret = gnome_keyring_find_itemsv_sync (GNOME_KEYRING_ITEM_GENERIC_SECRET,
-	                                      &found_list,
-	                                      KEYRING_UUID_TAG,
-	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
-	                                      uuid,
-	                                      KEYRING_SN_TAG,
-	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
-	                                      NM_SETTING_VPN_SETTING_NAME,
-	                                      KEYRING_SK_TAG,
-	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
-	                                      secret_name,
-	                                      NULL);
-	if (ret == GNOME_KEYRING_RESULT_OK && found_list) {
-		found = g_list_nth_data (found_list, 0);
-		secret = gnome_keyring_memory_strdup (found->secret);
-	}
-
-	gnome_keyring_found_list_free (found_list);
-	return secret;
-}
-
 static gboolean
 get_secrets (const char *vpn_uuid,
              const char *vpn_name,
+             const char *vpn_service,
              gboolean retry,
-             gboolean allow_interaction,
-             const char *in_pw,
-             char **out_pw,
-             NMSettingSecretFlags pw_flags)
+             char **password)
 {
-	VpnPasswordDialog *dialog;
-	char *prompt, *pw = NULL;
-	const char *new_password = NULL;
+	GnomeTwoPasswordDialog *dialog;
+	gboolean is_session = TRUE;
+	char *prompt;
 
 	g_return_val_if_fail (vpn_uuid != NULL, FALSE);
 	g_return_val_if_fail (vpn_name != NULL, FALSE);
-	g_return_val_if_fail (out_pw != NULL, FALSE);
-	g_return_val_if_fail (*out_pw == NULL, FALSE);
-
-	/* Get the existing secret, if any */
-	if (   !(pw_flags & NM_SETTING_SECRET_FLAG_NOT_SAVED)
-	    && !(pw_flags & NM_SETTING_SECRET_FLAG_NOT_REQUIRED)) {
-		if (in_pw)
-			pw = gnome_keyring_memory_strdup (in_pw);
-		else
-			pw = keyring_lookup_secret (vpn_uuid, NM_L2TP_KEY_PASSWORD);
-	}
+	g_return_val_if_fail (password != NULL, FALSE);
+	g_return_val_if_fail (*password == NULL, FALSE);
 
-	/* Don't ask if the passwords is unused */
-	if (pw_flags & NM_SETTING_SECRET_FLAG_NOT_REQUIRED) {
-		gnome_keyring_memory_free (pw);
+	*password = keyring_helpers_lookup_secret (vpn_uuid, NM_L2TP_KEY_PASSWORD, &is_session);
+	if (!retry && *password)
 		return TRUE;
-	}
 
-	if (!retry) {
-		/* Don't ask the user if we don't need a new password (ie, !retry),
-		 * we have an existing PW, and the password is saved.
-		 */
-		if (pw && !(pw_flags & NM_SETTING_SECRET_FLAG_NOT_SAVED)) {
-			*out_pw = pw;
-			return TRUE;
-		}
-	}
-
-	/* If interaction isn't allowed, just return existing secrets */
-	if (allow_interaction == FALSE) {
-		*out_pw = pw;
-		return TRUE;
-	}
-
-	/* Otherwise, we have no saved password, or the password flags indicated
-	 * that the password should never be saved.
-	 */
 	prompt = g_strdup_printf (_("You need to authenticate to access the Virtual Private Network '%s'."), vpn_name);
-	dialog = (VpnPasswordDialog *) vpn_password_dialog_new (_("Authenticate VPN"), prompt, NULL);
+	dialog = GNOME_TWO_PASSWORD_DIALOG (gnome_two_password_dialog_new (_("Authenticate VPN"), prompt, NULL, NULL, FALSE));
 	g_free (prompt);
 
-	vpn_password_dialog_set_show_password_secondary (dialog, FALSE);
-
-	/* pre-fill dialog with the password */
-	if (pw && !(pw_flags & NM_SETTING_SECRET_FLAG_NOT_SAVED))
-		vpn_password_dialog_set_password (dialog, pw);
+	gnome_two_password_dialog_set_show_username (dialog, FALSE);
+	gnome_two_password_dialog_set_show_userpass_buttons (dialog, FALSE);
+	gnome_two_password_dialog_set_show_domain (dialog, FALSE);
+	gnome_two_password_dialog_set_show_remember (dialog, TRUE);
+	gnome_two_password_dialog_set_show_password_secondary (dialog, FALSE);
+
+	/* If nothing was found in the keyring, default to not remembering any secrets */
+	if (*password) {
+		/* Otherwise set default remember based on which keyring the secrets were found in */
+		if (is_session)
+			gnome_two_password_dialog_set_remember (dialog, GNOME_TWO_PASSWORD_DIALOG_REMEMBER_SESSION);
+		else
+			gnome_two_password_dialog_set_remember (dialog, GNOME_TWO_PASSWORD_DIALOG_REMEMBER_FOREVER);
+	} else
+		gnome_two_password_dialog_set_remember (dialog, GNOME_TWO_PASSWORD_DIALOG_REMEMBER_NOTHING);
+
+	/* if retrying, pre-fill dialog with the password */
+	if (*password) {
+		gnome_two_password_dialog_set_password (dialog, *password);
+		g_free (*password);
+		*password = NULL;
+	}
 
 	gtk_widget_show (GTK_WIDGET (dialog));
 
-	if (vpn_password_dialog_run_and_block (dialog)) {
+	if (gnome_two_password_dialog_run_and_block (dialog)) {
+		const char *keyring = NULL;
+		gboolean save = FALSE;
+
+		*password = gnome_two_password_dialog_get_password (dialog);
+
+		switch (gnome_two_password_dialog_get_remember (dialog)) {
+		case GNOME_TWO_PASSWORD_DIALOG_REMEMBER_SESSION:
+			keyring = "session";
+			/* Fall through */
+		case GNOME_TWO_PASSWORD_DIALOG_REMEMBER_FOREVER:
+			save = TRUE;
+			break;
+		default:
+			break;
+		}
 
-		new_password = vpn_password_dialog_get_password (dialog);
-		if (new_password)
-			*out_pw = gnome_keyring_memory_strdup (new_password);
+		if (save) {
+			if (*password) {
+				keyring_helpers_save_secret (vpn_uuid, vpn_name, keyring,
+					   	NM_L2TP_KEY_PASSWORD, *password);
+			}
+		}
 	}
 
 	gtk_widget_hide (GTK_WIDGET (dialog));
@@ -149,45 +119,22 @@ get_secrets (const char *vpn_uuid,
 	return TRUE;
 }
 
-static void
-wait_for_quit (void)
-{
-	GString *str;
-	char c;
-	ssize_t n;
-	time_t start;
-
-	str = g_string_sized_new (10);
-	start = time (NULL);
-	do {
-		errno = 0;
-		n = read (0, &c, 1);
-		if (n == 0 || (n < 0 && errno == EAGAIN))
-			g_usleep (G_USEC_PER_SEC / 10);
-		else if (n == 1) {
-			g_string_append_c (str, c);
-			if (strstr (str->str, "QUIT") || (str->len > 10))
-				break;
-		} else
-			break;
-	} while (time (NULL) < start + 20);
-	g_string_free (str, TRUE);
-}
-
 int 
 main (int argc, char *argv[])
 {
-	gboolean retry = FALSE, allow_interaction = FALSE;
-	char *vpn_name = NULL, *vpn_uuid = NULL, *vpn_service = NULL, *password = NULL;
-	GHashTable *data = NULL, *secrets = NULL;
-	NMSettingSecretFlags pw_flags = NM_SETTING_SECRET_FLAG_NONE;
+	gboolean retry = FALSE;
+	gchar *vpn_name = NULL;
+	gchar *vpn_uuid = NULL;
+	gchar *vpn_service = NULL;
+	char *password = NULL;
+	char buf[1];
+	int ret;
 	GOptionContext *context;
 	GOptionEntry entries[] = {
 			{ "reprompt", 'r', 0, G_OPTION_ARG_NONE, &retry, "Reprompt for passwords", NULL},
 			{ "uuid", 'u', 0, G_OPTION_ARG_STRING, &vpn_uuid, "UUID of VPN connection", NULL},
 			{ "name", 'n', 0, G_OPTION_ARG_STRING, &vpn_name, "Name of VPN connection", NULL},
 			{ "service", 's', 0, G_OPTION_ARG_STRING, &vpn_service, "VPN service type", NULL},
-			{ "allow-interaction", 'i', 0, G_OPTION_ARG_NONE, &allow_interaction, "Allow user interaction", NULL},
 			{ NULL }
 		};
 
@@ -202,47 +149,34 @@ main (int argc, char *argv[])
 	g_option_context_parse (context, &argc, &argv, NULL);
 	g_option_context_free (context);
 
-	if (!vpn_uuid || !vpn_service || !vpn_name) {
-		fprintf (stderr, "A connection UUID, name, and VPN plugin service name are required.\n");
-		return 1;
+
+	if (vpn_uuid == NULL || vpn_name == NULL || vpn_service == NULL) {
+		fprintf (stderr, "Have to supply UUID, name, and service\n");
+		return EXIT_FAILURE;
 	}
 
 	if (strcmp (vpn_service, NM_DBUS_SERVICE_L2TP) != 0) {
 		fprintf (stderr, "This dialog only works with the '%s' service\n", NM_DBUS_SERVICE_L2TP);
-		return 1;
+		return EXIT_FAILURE;
 	}
 
-	if (!nm_vpn_plugin_utils_read_vpn_details (0, &data, &secrets)) {
-		fprintf (stderr, "Failed to read '%s' (%s) data and secrets from stdin.\n",
-		         vpn_name, vpn_uuid);
-		return 1;
-	}
-
-	nm_vpn_plugin_utils_get_secret_flags (secrets, NM_L2TP_KEY_PASSWORD, &pw_flags);
-
-	if (!get_secrets (vpn_uuid, vpn_name, retry, allow_interaction,
-	                  g_hash_table_lookup (secrets, NM_L2TP_KEY_PASSWORD),
-	                  &password,
-	                  pw_flags))
-		return 1;
+	if (!get_secrets (vpn_uuid, vpn_name, vpn_service, retry, &password))
+		return EXIT_FAILURE;
 
 	/* dump the passwords to stdout */
-	if (password)
-		printf ("%s\n%s\n", NM_L2TP_KEY_PASSWORD, password);
+	printf ("%s\n%s\n", NM_L2TP_KEY_PASSWORD, password);
 	printf ("\n\n");
 
-	if (password)
+	if (password) {
+		memset (password, 0, strlen (password));
 		gnome_keyring_memory_free (password);
+	}
 
 	/* for good measure, flush stdout since Kansas is going Bye-Bye */
 	fflush (stdout);
 
-	/* Wait for quit signal */
-	wait_for_quit ();
+	/* wait for data on stdin  */
+	ret = fread (buf, sizeof (char), sizeof (buf), stdin);
 
-	if (data)
-		g_hash_table_unref (data);
-	if (secrets)
-		g_hash_table_unref (secrets);
-	return 0;
+	return EXIT_SUCCESS;
 }

common-gnome/Makefile.am

+noinst_LTLIBRARIES=libnm-l2tp-common-gnome.la
+
+libnm_l2tp_common_gnome_la_CPPFLAGS = \
+	$(NM_CFLAGS) \
+	$(GLIB_CFLAGS) \
+	$(GNOMEKEYRING_CFLAGS) \
+	-DG_DISABLE_DEPRECATED
+
+libnm_l2tp_common_gnome_la_SOURCES= \
+	keyring-helpers.c \
+	keyring-helpers.h
+
+libnm_l2tp_common_gnome_la_LIBADD = \
+	$(NM_LIBS) \
+	$(GLIB_LIBS) \
+	$(GNOMEKEYRING_LIBS)
+

common-gnome/keyring-helpers.c

+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager Wireless Applet -- Display wireless access points and allow user control
+ *
+ * Dan Williams <dcbw@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * (C) Copyright 2004 - 2008 Red Hat, Inc.
+ */
+
+#include <string.h>
+#include <gnome-keyring-memory.h>
+
+#include <nm-setting-vpn.h>
+
+#include "keyring-helpers.h"
+#include "../src/nm-l2tp-service.h"
+
+#define KEYRING_UUID_TAG "connection-uuid"
+#define KEYRING_SN_TAG "setting-name"
+#define KEYRING_SK_TAG "setting-key"
+
+char *
+keyring_helpers_lookup_secret (const char *vpn_uuid,
+                   const char *secret_name,
+                   gboolean *is_session)
+{
+	GList *found_list = NULL;
+	GnomeKeyringResult ret;
+	GnomeKeyringFound *found;
+	char *secret;
+
+	ret = gnome_keyring_find_itemsv_sync (GNOME_KEYRING_ITEM_GENERIC_SECRET,
+	                                      &found_list,
+	                                      KEYRING_UUID_TAG,
+	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
+	                                      vpn_uuid,
+	                                      KEYRING_SN_TAG,
+	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
+	                                      NM_SETTING_VPN_SETTING_NAME,
+	                                      KEYRING_SK_TAG,
+	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
+	                                      secret_name,
+	                                      NULL);
+	if ((ret != GNOME_KEYRING_RESULT_OK) || (g_list_length (found_list) == 0))
+		return NULL;
+
+	found = (GnomeKeyringFound *) found_list->data;
+
+	if (is_session) {
+		if (strcmp (found->keyring, "session") == 0)
+			*is_session = TRUE;
+		else
+			*is_session = FALSE;
+	}
+
+	secret = found->secret ? gnome_keyring_memory_strdup (found->secret) : NULL;
+	gnome_keyring_found_list_free (found_list);
+
+	return secret;
+}
+
+GnomeKeyringResult
+keyring_helpers_save_secret (const char *vpn_uuid,
+                             const char *vpn_name,
+                             const char *keyring,
+                             const char *secret_name,
+                             const char *secret)
+{
+	char *display_name;
+	GnomeKeyringResult ret;
+	GnomeKeyringAttributeList *attrs = NULL;
+	guint32 id = 0;
+
+	display_name = g_strdup_printf ("VPN %s secret for %s/%s/" NM_SETTING_VPN_SETTING_NAME,
+	                                secret_name,
+	                                vpn_name,
+	                                NM_DBUS_SERVICE_L2TP);
+
+	attrs = gnome_keyring_attribute_list_new ();
+	gnome_keyring_attribute_list_append_string (attrs,
+	                                            KEYRING_UUID_TAG,
+	                                            vpn_uuid);
+	gnome_keyring_attribute_list_append_string (attrs,
+	                                            KEYRING_SN_TAG,
+	                                            NM_SETTING_VPN_SETTING_NAME);
+	gnome_keyring_attribute_list_append_string (attrs,
+	                                            KEYRING_SK_TAG,
+	                                            secret_name);
+
+	ret = gnome_keyring_item_create_sync (keyring,
+	                                      GNOME_KEYRING_ITEM_GENERIC_SECRET,
+	                                      display_name,
+	                                      attrs,
+	                                      secret,
+	                                      TRUE,
+	                                      &id);
+	gnome_keyring_attribute_list_free (attrs);
+	g_free (display_name);
+	return ret;
+}
+
+static void
+ignore_callback (GnomeKeyringResult result, gpointer data)
+{
+}
+
+gboolean
+keyring_helpers_delete_secret (const char *vpn_uuid,
+                               const char *secret_name)
+{
+	GList *found = NULL, *iter;
+	GnomeKeyringResult ret;
+
+	g_return_val_if_fail (vpn_uuid != NULL, FALSE);
+	g_return_val_if_fail (secret_name != NULL, FALSE);
+
+	ret = gnome_keyring_find_itemsv_sync (GNOME_KEYRING_ITEM_GENERIC_SECRET,
+	                                      &found,
+	                                      KEYRING_UUID_TAG,
+	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
+	                                      vpn_uuid,
+	                                      KEYRING_SN_TAG,
+	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
+	                                      NM_SETTING_VPN_SETTING_NAME,
+	                                      KEYRING_SK_TAG,
+	                                      GNOME_KEYRING_ATTRIBUTE_TYPE_STRING,
+	                                      secret_name,
+	                                      NULL);
+	if (ret != GNOME_KEYRING_RESULT_OK && ret != GNOME_KEYRING_RESULT_NO_MATCH)
+		return FALSE;
+	if (g_list_length (found) == 0)
+		return TRUE;
+
+	/* delete them all */
+	for (iter = found; iter; iter = g_list_next (iter)) {
+		GnomeKeyringFound *item = (GnomeKeyringFound *) iter->data;
+
+		gnome_keyring_item_delete (item->keyring, item->item_id,
+		                           ignore_callback, NULL, NULL);
+	}
+
+	gnome_keyring_found_list_free (found);
+	return TRUE;
+}
+

common-gnome/keyring-helpers.h

+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager Wireless Applet -- Display wireless access points and allow user control
+ *
+ * Dan Williams <dcbw@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * (C) Copyright 2004 - 2008 Red Hat, Inc.
+ */
+
+#ifndef KEYRING_HELPERS_H
+#define KEYRING_HELPERS_H
+
+#include <glib.h>
+#include <gnome-keyring.h>
+#include <gnome-keyring-memory.h>
+
+char *keyring_helpers_lookup_secret (
+		const char *vpn_uuid,
+		const char *secret_name,
+		gboolean *is_session);
+
+GnomeKeyringResult keyring_helpers_save_secret (
+		const char *vpn_uuid,
+		const char *vpn_name,
+		const char *keyring,
+		const char *secret_name,
+		const char *secret);
+
+gboolean keyring_helpers_delete_secret (
+		const char *vpn_uuid,
+		const char *secret_name);
+
+#endif  /* KEYRING_HELPERS_H */
+

configure.ac

@@ -70,7 +70,7 @@ AC_SUBST(DBUS_GLIB_CFLAGS)
 AC_SUBST(DBUS_GLIB_LIBS)
 
 PKG_CHECK_MODULES(NM,
-                  NetworkManager >= 0.8.1
+                  NetworkManager >= 0.8
 				  libnm-util
 				  libnm-glib
 				  libnm-glib-vpn)
@@ -116,5 +116,6 @@ src/Makefile
 auth-dialog/Makefile
 properties/Makefile
 po/Makefile.in
+common-gnome/Makefile
 ])
 AC_OUTPUT

properties/Makefile.am

@@ -32,6 +32,7 @@ libnm_l2tp_properties_la_LIBADD =    \
         $(GTK_LIBS)                     \
         $(GCONF_LIBS)                   \
         $(LIBGNOMEUI_LIBS)              \
+        $(top_builddir)/common-gnome/libnm-pptp-common-gnome.la	\
         $(NM_LIBS)
 
 libnm_l2tp_properties_la_LDFLAGS =   \

properties/nm-l2tp-dialog.ui

@@ -112,15 +112,11 @@
                             <property name="can_focus">True</property>
                             <property name="hscrollbar_policy">never</property>
                             <property name="shadow_type">in</property>
-                            <property name="min_content_height">80</property>
                             <child>
                               <object class="GtkTreeView" id="ppp_auth_methods">
                                 <property name="visible">True</property>
                                 <property name="can_focus">True</property>
                                 <property name="headers_visible">False</property>
-                                <child internal-child="selection">
-                                  <object class="GtkTreeSelection" id="treeview-selection1"/>
-                                </child>
                               </object>
                             </child>
                           </object>

properties/nm-l2tp.c

@@ -41,6 +41,7 @@
 #include <nm-setting-ip4-config.h>
 
 #include "src/nm-l2tp-service.h"
+#include "common-gnome/keyring-helpers.h"
 #include "nm-l2tp.h"
 #include "import-export.h"
 #include "advanced-dialog.h"
@@ -82,7 +83,6 @@ typedef struct {
 	gboolean window_added;
 	GHashTable *advanced;
 	GHashTable *ipsec;
-	gboolean new_connection;
 } L2tpPluginUiWidgetPrivate;
 
 
@@ -280,18 +280,13 @@ static void
 setup_password_widget (L2tpPluginUiWidget *self,
                        const char *entry_name,
                        NMSettingVPN *s_vpn,
-                       const char *secret_name,
-                       gboolean new_connection)
+                       const char *secret_name)
 {
 	L2tpPluginUiWidgetPrivate *priv = L2TP_PLUGIN_UI_WIDGET_GET_PRIVATE (self);
 	NMSettingSecretFlags secret_flags = NM_SETTING_SECRET_FLAG_NONE;
 	GtkWidget *widget;
 	const char *value;
 
-	/* Default to agent-owned for new connections */
-	if (new_connection)
-		secret_flags = NM_SETTING_SECRET_FLAG_AGENT_OWNED;
-
 	widget = (GtkWidget *) gtk_builder_get_object (priv->builder, entry_name);
 	g_assert (widget);
 	gtk_size_group_add_widget (priv->group, widget);
@@ -299,7 +294,6 @@ setup_password_widget (L2tpPluginUiWidget *self,
 	if (s_vpn) {
 		value = nm_setting_vpn_get_secret (s_vpn, secret_name);
 		gtk_entry_set_text (GTK_ENTRY (widget), value ? value : "");
-		nm_setting_get_secret_flags (NM_SETTING (s_vpn), secret_name, &secret_flags, NULL);
 	}
 	secret_flags &= ~(NM_SETTING_SECRET_FLAG_NOT_SAVED | NM_SETTING_SECRET_FLAG_NOT_REQUIRED);
 	g_object_set_data (G_OBJECT (widget), "flags", GUINT_TO_POINTER (secret_flags));
@@ -374,8 +368,6 @@ init_one_pw_combo (L2tpPluginUiWidget *self,
 		default_idx = 0;
 
 	store = gtk_list_store_new (1, G_TYPE_STRING);
-	if (s_vpn)
-		nm_setting_get_secret_flags (NM_SETTING (s_vpn), secret_key, &pw_flags, NULL);
 
 	gtk_list_store_append (store, &iter);
 	gtk_list_store_set (store, &iter, 0, _("Saved"), -1);
@@ -468,8 +460,7 @@ init_plugin_ui (L2tpPluginUiWidget *self, NMConnection *connection, GError **err
 	setup_password_widget (self,
 	                       "user_password_entry",
 	                       s_vpn,
-	                       NM_L2TP_KEY_PASSWORD,
-	                       priv->new_connection);
+	                       NM_L2TP_KEY_PASSWORD);
 
 	init_one_pw_combo (self,
 	                   s_vpn,
@@ -529,9 +520,6 @@ save_password_and_flags (NMSettingVPN *s_vpn,
 		flags |= NM_SETTING_SECRET_FLAG_NOT_SAVED;
 		break;
 	}
-
-	/* Set new secret flags */
-	nm_setting_set_secret_flags (NM_SETTING (s_vpn), secret_key, flags, NULL);
 }
 
 static gboolean
@@ -564,13 +552,6 @@ update_connection (NMVpnPluginUiWidgetInterface *iface,
 	if (str && strlen (str))
 		nm_setting_vpn_add_data_item (s_vpn, NM_L2TP_KEY_USER, str);
 
-	/* User password and flags */
-	save_password_and_flags (s_vpn,
-	                         priv->builder,
-	                         "user_password_entry",
-	                         "user_pass_type_combo",
-	                         NM_L2TP_KEY_PASSWORD);
-
 	/* Domain */
 	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "domain_entry"));
 	str = gtk_entry_get_text (GTK_ENTRY (widget));
@@ -587,14 +568,41 @@ update_connection (NMVpnPluginUiWidgetInterface *iface,
 
 	return valid;
 }
-
-static void
-is_new_func (const char *key, const char *value, gpointer user_data)
+static gboolean
+save_secrets (NMVpnPluginUiWidgetInterface *iface,
+              NMConnection *connection,
+              GError **error)
 {
-	gboolean *is_new = user_data;
+	L2tpPluginUiWidget *self = L2TP_PLUGIN_UI_WIDGET (iface);
+	L2tpPluginUiWidgetPrivate *priv = L2TP_PLUGIN_UI_WIDGET_GET_PRIVATE (self);
+	GnomeKeyringResult ret;
+	NMSettingConnection *s_con;
+	GtkWidget *widget;
+	const char *str, *uuid, *id;
+
+	s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
+	if (!s_con) {
+		g_set_error (error,
+		             L2TP_PLUGIN_UI_ERROR,
+		             L2TP_PLUGIN_UI_ERROR_INVALID_CONNECTION,
+		             "missing 'connection' setting");
+		return FALSE;
+	}
+
+	id = nm_setting_connection_get_id (s_con);
+	uuid = nm_setting_connection_get_uuid (s_con);
 
-	/* If there are any VPN data items the connection isn't new */
-	*is_new = FALSE;
+	widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "user_password_entry"));
+	g_assert (widget);
+    str = gtk_entry_get_text (GTK_ENTRY (widget));
+    if (str && strlen (str)) {
+        ret = keyring_helpers_save_secret (uuid, id, NULL, NM_L2TP_KEY_PASSWORD, str);
+        if (ret != GNOME_KEYRING_RESULT_OK)
+            g_warning ("%s: failed to save user password to keyring.", __func__);
+    } else
+        keyring_helpers_delete_secret (uuid, NM_L2TP_KEY_PASSWORD);
+
+	return TRUE;
 }
 
 static NMVpnPluginUiWidgetInterface *
@@ -645,11 +653,6 @@ nm_vpn_plugin_ui_widget_interface_new (NMConnection *connection, GError **error)
 
 	priv->window_group = gtk_window_group_new ();
 
-	s_vpn = nm_connection_get_setting_vpn (connection);
-	if (s_vpn)
-		nm_setting_vpn_foreach_data_item (s_vpn, is_new_func, &new);
-	priv->new_connection = new;
-
 	if (!init_plugin_ui (L2TP_PLUGIN_UI_WIDGET (object), connection, error)) {
 		g_object_unref (object);
 		return NULL;
@@ -717,6 +720,7 @@ l2tp_plugin_ui_widget_interface_init (NMVpnPluginUiWidgetInterface *iface_class)
 	/* interface implementation */
 	iface_class->get_widget = get_widget;
 	iface_class->update_connection = update_connection;
+	iface_class->save_secrets = save_secrets;
 }
 
 static NMConnection *
@@ -854,8 +858,8 @@ l2tp_plugin_ui_interface_init (NMVpnPluginUiInterface *iface_class)
 	/* interface implementation */
 	iface_class->ui_factory = ui_factory;
 	iface_class->get_capabilities = get_capabilities;
-	iface_class->import_from_file = import;
-	iface_class->export_to_file = export;
+	iface_class->import = import;
+	iface_class->export = export;
 	iface_class->get_suggested_name = get_suggested_name;
 }
 

properties/nm-l2tp.h

@@ -35,6 +35,18 @@ typedef enum
 	L2TP_PLUGIN_UI_ERROR_FILE_NOT_L2TP
 } L2tpPluginUiError;
 
+/* BACKPORT FROM NM 0.9 */
+typedef enum {
+	NM_SETTING_SECRET_FLAG_NONE         = 0x00000000,
+	NM_SETTING_SECRET_FLAG_AGENT_OWNED  = 0x00000001,
+	NM_SETTING_SECRET_FLAG_NOT_SAVED    = 0x00000002,
+	NM_SETTING_SECRET_FLAG_NOT_REQUIRED = 0x00000004
+
+	/* NOTE: if adding flags, update nm-setting-private.h as well */
+} NMSettingSecretFlags;
+
+/* END BACKPORT */
+
 #define L2TP_TYPE_PLUGIN_UI_ERROR (l2tp_plugin_ui_error_get_type ()) 
 GType l2tp_plugin_ui_error_get_type (void);