Skip to content

N
NetworkManager-l2tp
Commit 006b8091 authored by Сергей Прохоров's avatar Сергей Прохоров
Browse files
Options

Update auth-dialog like in network-manager-pptp (master 8b5c8b6ca3d24f7b5f736b8a7a29956f0bce35f3)

parent 06c2ffd8
Show whitespace changes
Inline Side-by-side
Showing with 687 additions and 924 deletions
auth-dialog/Makefile.am
View file @ 006b8091
......@@ -19,8 +19,8 @@ nm_l2tp_auth_dialog_CPPFLAGS = \
nm_l2tp_auth_dialog_SOURCES = \
main.c \
gnome-two-password-dialog.c \
gnome-two-password-dialog.h
vpn-password-dialog.c \
vpn-password-dialog.h
nm_l2tp_auth_dialog_LDADD = \
$(GTK_LIBS) \
......
auth-dialog/gnome-two-password-dialog.c deleted 100644 → 0
View file @ 06c2ffd8
/* -*- 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 deleted 100644 → 0
View file @ 06c2ffd8
/* -*- 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
View file @ 006b8091
......@@ -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 Red Hat, Inc.
* (C) Copyright 2008 - 2011 Red Hat, Inc.
*/
#ifdef HAVE_CONFIG_H
......@@ -26,91 +26,121 @@
#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 "common-gnome/keyring-helpers.h"
#include "gnome-two-password-dialog.h"
#include "vpn-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,
char **password)
gboolean allow_interaction,
const char *in_pw,
char **out_pw,
NMSettingSecretFlags pw_flags)
{
GnomeTwoPasswordDialog *dialog;
gboolean is_session = TRUE;
char *prompt;
VpnPasswordDialog *dialog;
char *prompt, *pw = NULL;
const char *new_password = NULL;
g_return_val_if_fail (vpn_uuid != NULL, FALSE);
g_return_val_if_fail (vpn_name != NULL, FALSE);
g_return_val_if_fail (password != NULL, FALSE);
g_return_val_if_fail (*password == 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);
}
/* Don't ask if the passwords is unused */
if (pw_flags & NM_SETTING_SECRET_FLAG_NOT_REQUIRED) {
gnome_keyring_memory_free (pw);
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;
}
}
*password = keyring_helpers_lookup_secret (vpn_uuid, NM_L2TP_KEY_PASSWORD, &is_session);
if (!retry && *password)
/* 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 = GNOME_TWO_PASSWORD_DIALOG (gnome_two_password_dialog_new (_("Authenticate VPN"), prompt, NULL, NULL, FALSE));
dialog = (VpnPasswordDialog *) vpn_password_dialog_new (_("Authenticate VPN"), prompt, NULL);
g_free (prompt);
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);
vpn_password_dialog_set_show_password_secondary (dialog, FALSE);
/* if retrying, pre-fill dialog with the password */
if (*password) {
gnome_two_password_dialog_set_password (dialog, *password);
g_free (*password);
*password = NULL;
}
/* pre-fill dialog with the password */
if (pw && !(pw_flags & NM_SETTING_SECRET_FLAG_NOT_SAVED))
vpn_password_dialog_set_password (dialog, pw);
gtk_widget_show (GTK_WIDGET (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;
}
if (vpn_password_dialog_run_and_block (dialog)) {
if (save) {
if (*password) {
keyring_helpers_save_secret (vpn_uuid, vpn_name, keyring,
NM_L2TP_KEY_PASSWORD, *password);
}
}
new_password = vpn_password_dialog_get_password (dialog);
if (new_password)
*out_pw = gnome_keyring_memory_strdup (new_password);
}
gtk_widget_hide (GTK_WIDGET (dialog));
......@@ -119,22 +149,45 @@ 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;
gchar *vpn_name = NULL;
gchar *vpn_uuid = NULL;
gchar *vpn_service = NULL;
char *password = NULL;
char buf[1];
int ret;
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;
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 }
};
......@@ -149,34 +202,47 @@ main (int argc, char *argv[])
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
if (vpn_uuid == NULL || vpn_name == NULL || vpn_service == NULL) {
fprintf (stderr, "Have to supply UUID, name, and service\n");
return EXIT_FAILURE;
if (!vpn_uuid || !vpn_service || !vpn_name) {
fprintf (stderr, "A connection UUID, name, and VPN plugin service name are required.\n");
return 1;
}
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 EXIT_FAILURE;
return 1;
}
if (!get_secrets (vpn_uuid, vpn_name, vpn_service, retry, &password))
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;
/* dump the passwords to stdout */
if (password)
printf ("%s\n%s\n", NM_L2TP_KEY_PASSWORD, password);
printf ("\n\n");
if (password) {
memset (password, 0, strlen (password));
if (password)
gnome_keyring_memory_free (password);
}
/* for good measure, flush stdout since Kansas is going Bye-Bye */
fflush (stdout);
/* wait for data on stdin */
ret = fread (buf, sizeof (char), sizeof (buf), stdin);
/* Wait for quit signal */
wait_for_quit ();
return EXIT_SUCCESS;
if (data)
g_hash_table_unref (data);
if (secrets)
g_hash_table_unref (secrets);
return 0;
}
auth-dialog/vpn-password-dialog.c 0 → 100644
View file @ 006b8091
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* vpn-password-dialog.c - A use password prompting dialog widget.
*
* 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.
*
* Copyright (C) 1999, 2000 Eazel, Inc.
* Copyright (C) 2011 Red Hat, Inc.
*
* Authors: Ramiro Estrugo <ramiro@eazel.com>
* Dan Williams <dcbw@redhat.com>
*/
#include <config.h>
#include <gnome-keyring-memory.h>
#include <glib/gi18n.h>
#include <gtk/gtk.h>
#include "vpn-password-dialog.h"
G_DEFINE_TYPE (VpnPasswordDialog, vpn_password_dialog, GTK_TYPE_DIALOG)
#define VPN_PASSWORD_DIALOG_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
VPN_TYPE_PASSWORD_DIALOG, \
VpnPasswordDialogPrivate))
typedef struct {
/* Attributes */
gboolean show_password;
gboolean show_password_secondary;
/* Internal widgetry and flags */
GtkWidget *password_entry;
GtkWidget *password_entry_secondary;
GtkWidget *show_passwords_checkbox;
GtkWidget *table_alignment;
GtkWidget *table;
GtkSizeGroup *group;
char *primary_password_label;
char *secondary_password_label;
} VpnPasswordDialogPrivate;
/* VpnPasswordDialogClass methods */
static void vpn_password_dialog_class_init (VpnPasswordDialogClass *password_dialog_class);
static void vpn_password_dialog_init (VpnPasswordDialog *password_dialog);
/* GtkDialog callbacks */
static void dialog_show_callback (GtkWidget *widget, gpointer callback_data);
static void dialog_close_callback (GtkWidget *widget, gpointer callback_data);
static void
finalize (GObject *object)
{
VpnPasswordDialogPrivate *priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (object);
g_object_unref (priv->password_entry);
g_object_unref (priv->password_entry_secondary);
g_object_unref (priv->group);
g_free (priv->primary_password_label);
g_free (priv->secondary_password_label);
G_OBJECT_CLASS (vpn_password_dialog_parent_class)->finalize (object);
}
static void
vpn_password_dialog_class_init (VpnPasswordDialogClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (object_class, sizeof (VpnPasswordDialogPrivate));
object_class->finalize = finalize;
}
static void
vpn_password_dialog_init (VpnPasswordDialog *dialog)
{
VpnPasswordDialogPrivate *priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
priv->show_password = TRUE;
priv->primary_password_label = g_strdup ( _("_Password:") );
priv->show_password_secondary = TRUE;
priv->secondary_password_label = g_strdup ( _("_Secondary Password:") );
}
/* GtkDialog callbacks */
static void
dialog_show_callback (GtkWidget *widget, gpointer callback_data)
{
VpnPasswordDialog *dialog = VPN_PASSWORD_DIALOG (callback_data);
VpnPasswordDialogPrivate *priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
if (gtk_widget_get_visible (priv->password_entry))
gtk_widget_grab_focus (priv->password_entry);
else if (gtk_widget_get_visible (priv->password_entry_secondary))
gtk_widget_grab_focus (priv->password_entry_secondary);
}
static void
dialog_close_callback (GtkWidget *widget, gpointer callback_data)
{
gtk_widget_hide (widget);
}
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 (VpnPasswordDialog *dialog)
{
VpnPasswordDialogPrivate *priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
int row;
int offset = 0;
gtk_alignment_set_padding (GTK_ALIGNMENT (priv->table_alignment), 0, 0, offset, 0);
/* This will not kill the entries, since they are ref:ed */
gtk_container_foreach (GTK_CONTAINER (priv->table), (GtkCallback) remove_child, priv->table);
row = 0;
if (priv->show_password)
add_row (priv->table, row++, priv->primary_password_label, priv->password_entry);
if (priv->show_password_secondary)
add_row (priv->table, row++, priv->secondary_password_label, priv->password_entry_secondary);
gtk_table_attach_defaults (GTK_TABLE (priv->table), priv->show_passwords_checkbox, 1, 2, row, row + 1);
gtk_widget_show_all (priv->table);
}
static void
show_passwords_toggled_cb (GtkWidget *widget, gpointer user_data)
{
VpnPasswordDialog *dialog = VPN_PASSWORD_DIALOG (user_data);
VpnPasswordDialogPrivate *priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
gboolean visible;
visible = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), visible);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), visible);
}
/* Public VpnPasswordDialog methods */
GtkWidget *
vpn_password_dialog_new (const char *title,
const char *message,
const char *password)
{
GtkWidget *dialog;
VpnPasswordDialogPrivate *priv;
GtkLabel *message_label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *main_vbox;
GtkWidget *dialog_icon;
GtkBox *content, *action_area;
dialog = gtk_widget_new (VPN_TYPE_PASSWORD_DIALOG, NULL);
if (!dialog)
return NULL;
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
gtk_window_set_title (GTK_WINDOW (dialog), title);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
action_area = GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog)));
/* Setup the dialog */
#if !GTK_CHECK_VERSION (2,22,0)
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
#endif
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (content, 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (action_area, 6);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_signal_connect (dialog, "show",
G_CALLBACK (dialog_show_callback),
dialog);
g_signal_connect (dialog, "close",
G_CALLBACK (dialog_close_callback),
dialog);
/* The table that holds the captions */
priv->table_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->table = gtk_table_new (4, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (priv->table), 12);
gtk_table_set_row_spacings (GTK_TABLE (priv->table), 6);
gtk_container_add (GTK_CONTAINER (priv->table_alignment), priv->table);
priv->password_entry = gtk_entry_new ();
priv->password_entry_secondary = gtk_entry_new ();
priv->show_passwords_checkbox = gtk_check_button_new_with_mnemonic (_("Sh_ow passwords"));
/* We want to hold on to these during the table rearrangement */
g_object_ref_sink (priv->password_entry);
g_object_ref_sink (priv->password_entry_secondary);
g_object_ref_sink (priv->show_passwords_checkbox);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), FALSE);
g_signal_connect_swapped (priv->password_entry, "activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
g_signal_connect_swapped (priv->password_entry_secondary, "activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
g_signal_connect (priv->show_passwords_checkbox, "toggled",
G_CALLBACK (show_passwords_toggled_cb),
dialog);
add_table_rows (VPN_PASSWORD_DIALOG (dialog));
/* Adds some eye-candy to the dialog */
#if GTK_CHECK_VERSION (3,1,6)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
hbox = gtk_hbox_new (FALSE, 12);
#endif
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 */
#if GTK_CHECK_VERSION (3,1,6)
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
#else
main_vbox = gtk_vbox_new (FALSE, 18);
#endif
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_label_set_max_width_chars (message_label, 35);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (message_label));
gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0);
gtk_size_group_add_widget (priv->group, priv->table_alignment);
}
#if GTK_CHECK_VERSION (3,1,6)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), priv->table_alignment, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0);
gtk_box_pack_start (content, hbox, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (content));
vpn_password_dialog_set_password (VPN_PASSWORD_DIALOG (dialog), password);
return GTK_WIDGET (dialog);
}
gboolean
vpn_password_dialog_run_and_block (VpnPasswordDialog *dialog)
{
gint button_clicked;
g_return_val_if_fail (dialog != NULL, FALSE);
g_return_val_if_fail (VPN_IS_PASSWORD_DIALOG (dialog), FALSE);
button_clicked = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (GTK_WIDGET (dialog));
return button_clicked == GTK_RESPONSE_OK;
}
void
vpn_password_dialog_set_password (VpnPasswordDialog *dialog,
const char *password)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
gtk_entry_set_text (GTK_ENTRY (priv->password_entry), password ? password : "");
}
void
vpn_password_dialog_set_password_secondary (VpnPasswordDialog *dialog,
const char *password_secondary)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
gtk_entry_set_text (GTK_ENTRY (priv->password_entry_secondary),
password_secondary ? password_secondary : "");
}
void
vpn_password_dialog_set_show_password (VpnPasswordDialog *dialog, gboolean show)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (dialog != NULL);
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
show = !!show;
if (priv->show_password != show) {
priv->show_password = show;
add_table_rows (dialog);
}
}
void
vpn_password_dialog_set_show_password_secondary (VpnPasswordDialog *dialog,
gboolean show)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (dialog != NULL);
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
show = !!show;
if (priv->show_password_secondary != show) {
priv->show_password_secondary = show;
add_table_rows (dialog);
}
}
void
vpn_password_dialog_focus_password (VpnPasswordDialog *dialog)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (dialog != NULL);
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
if (priv->show_password)
gtk_widget_grab_focus (priv->password_entry);
}
void
vpn_password_dialog_focus_password_secondary (VpnPasswordDialog *dialog)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (dialog != NULL);
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
if (priv->show_password_secondary)
gtk_widget_grab_focus (priv->password_entry_secondary);
}
const char *
vpn_password_dialog_get_password (VpnPasswordDialog *dialog)
{
VpnPasswordDialogPrivate *priv;
g_return_val_if_fail (VPN_IS_PASSWORD_DIALOG (dialog), NULL);
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
return gtk_entry_get_text (GTK_ENTRY (priv->password_entry));
}
const char *
vpn_password_dialog_get_password_secondary (VpnPasswordDialog *dialog)
{
VpnPasswordDialogPrivate *priv;
g_return_val_if_fail (VPN_IS_PASSWORD_DIALOG (dialog), NULL);
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
return gtk_entry_get_text (GTK_ENTRY (priv->password_entry_secondary));
}
void vpn_password_dialog_set_password_label (VpnPasswordDialog *dialog,
const char *label)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (dialog != NULL);
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
g_free (priv->primary_password_label);
priv->primary_password_label = g_strdup (label);
if (priv->show_password)
add_table_rows (dialog);
}
void vpn_password_dialog_set_password_secondary_label (VpnPasswordDialog *dialog,
const char *label)
{
VpnPasswordDialogPrivate *priv;
g_return_if_fail (dialog != NULL);
g_return_if_fail (VPN_IS_PASSWORD_DIALOG (dialog));
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
g_free (priv->secondary_password_label);
priv->secondary_password_label = g_strdup (label);
if (priv->show_password_secondary)
add_table_rows (dialog);
}
auth-dialog/vpn-password-dialog.h 0 → 100644
View file @ 006b8091
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* vpn-password-dialog.c - A use password prompting dialog widget.
*
* 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.
*
* Copyright (C) 1999, 2000 Eazel, Inc.
* Copyright (C) 2011 Red Hat, Inc.
*
* Authors: Ramiro Estrugo <ramiro@eazel.com>
* Dan Williams <dcbw@redhat.com>
*/
#ifndef VPN_PASSWORD_DIALOG_H
#define VPN_PASSWORD_DIALOG_H
#include <gtk/gtk.h>
G_BEGIN_DECLS
#define VPN_TYPE_PASSWORD_DIALOG (vpn_password_dialog_get_type ())
#define VPN_PASSWORD_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VPN_TYPE_PASSWORD_DIALOG, VpnPasswordDialog))
#define VPN_PASSWORD_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VPN_TYPE_PASSWORD_DIALOG, VpnPasswordDialogClass))
#define VPN_IS_PASSWORD_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VPN_TYPE_PASSWORD_DIALOG))
#define VPN_IS_PASSWORD_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VPN_TYPE_PASSWORD_DIALOG))
typedef struct VpnPasswordDialog VpnPasswordDialog;
typedef struct VpnPasswordDialogClass VpnPasswordDialogClass;
struct VpnPasswordDialog {
GtkDialog parent;
};
struct VpnPasswordDialogClass {
GtkDialogClass parent_class;
};
GType vpn_password_dialog_get_type (void);
GtkWidget* vpn_password_dialog_new (const char *title,
const char *message,
const char *password);
gboolean vpn_password_dialog_run_and_block (VpnPasswordDialog *dialog);
/* Attribute mutators */
void vpn_password_dialog_set_show_password (VpnPasswordDialog *dialog,
gboolean show);
void vpn_password_dialog_focus_password (VpnPasswordDialog *dialog);
void vpn_password_dialog_set_password (VpnPasswordDialog *dialog,
const char *password);
void vpn_password_dialog_set_password_label (VpnPasswordDialog *dialog,
const char *label);
void vpn_password_dialog_set_show_password_secondary (VpnPasswordDialog *dialog,
gboolean show);
void vpn_password_dialog_focus_password_secondary (VpnPasswordDialog *dialog);
void vpn_password_dialog_set_password_secondary (VpnPasswordDialog *dialog,
const char *password_secondary);
void vpn_password_dialog_set_password_secondary_label (VpnPasswordDialog *dialog,
const char *label);
/* Attribute accessors */
const char *vpn_password_dialog_get_password (VpnPasswordDialog *dialog);
const char *vpn_password_dialog_get_password_secondary (VpnPasswordDialog *dialog);
G_END_DECLS
#endif /* VPN_PASSWORD_DIALOG_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment