From 2fc4078bc842efa253f84398fad8e655a3714568 Mon Sep 17 00:00:00 2001 From: Guido Günther Date: Wed, 8 Feb 2012 15:53:42 +0100 Subject: Initial commit --- auth-dialog/Makefile.am | 30 +++ auth-dialog/main.c | 246 ++++++++++++++++++++ auth-dialog/vpn-password-dialog.c | 461 ++++++++++++++++++++++++++++++++++++++ auth-dialog/vpn-password-dialog.h | 79 +++++++ 4 files changed, 816 insertions(+) create mode 100644 auth-dialog/Makefile.am create mode 100644 auth-dialog/main.c create mode 100644 auth-dialog/vpn-password-dialog.c create mode 100644 auth-dialog/vpn-password-dialog.h (limited to 'auth-dialog') diff --git a/auth-dialog/Makefile.am b/auth-dialog/Makefile.am new file mode 100644 index 0000000..fe45a82 --- /dev/null +++ b/auth-dialog/Makefile.am @@ -0,0 +1,30 @@ +INCLUDES = -I${top_srcdir} + +libexec_PROGRAMS = nm-iodine-auth-dialog + +nm_iodine_auth_dialog_CPPFLAGS = \ + $(NM_CFLAGS) \ + $(GTHREAD_CFLAGS) \ + $(GTK_CFLAGS) \ + $(GNOMEKEYRING_CFLAGS) \ + -DICONDIR=\""$(datadir)/pixmaps"\" \ + -DBINDIR=\""$(bindir)"\" \ + -DG_DISABLE_DEPRECATED \ + -DGDK_DISABLE_DEPRECATED \ + -DGNOME_DISABLE_DEPRECATED \ + -DGNOMELOCALEDIR=\"$(datadir)/locale\" \ + -DVERSION=\"$(VERSION)\" + +nm_iodine_auth_dialog_SOURCES = \ + main.c \ + vpn-password-dialog.c \ + vpn-password-dialog.h \ + $(NULL) + +nm_iodine_auth_dialog_LDADD = \ + $(GTK_LIBS) \ + $(NM_LIBS) \ + $(GNOMEKEYRING_LIBS) + +CLEANFILES = *~ + diff --git a/auth-dialog/main.c b/auth-dialog/main.c new file mode 100644 index 0000000..a7f127b --- /dev/null +++ b/auth-dialog/main.c @@ -0,0 +1,246 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */ +/* + * Authentication dialog for NetworkManager iodine VPN connections + * + * 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. + * + * Copyright © 2012 Guido Günther + * + * Heavily based on network-manager-pptp by Dan Williams + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "src/nm-iodine-service.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, + gboolean retry, + gboolean allow_interaction, + const char *in_pw, + char **out_pw, + NMSettingSecretFlags pw_flags) +{ + 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 (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_IODINE_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; + } + } + + /* 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); + 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); + + gtk_widget_show (GTK_WIDGET (dialog)); + + if (vpn_password_dialog_run_and_block (dialog)) { + + 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)); + gtk_widget_destroy (GTK_WIDGET (dialog)); + + 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; + char *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 } + }; + + bindtextdomain (GETTEXT_PACKAGE, NULL); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); + textdomain (GETTEXT_PACKAGE); + + gtk_init (&argc, &argv); + + context = g_option_context_new ("- iodine auth dialog"); + g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); + g_option_context_parse (context, &argc, &argv, NULL); + g_option_context_free (context); + + 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_IODINE_KEY_PASSWORD, &pw_flags); + + if (!get_secrets (vpn_uuid, vpn_name, retry, allow_interaction, + g_hash_table_lookup (secrets, NM_IODINE_KEY_PASSWORD), + &password, + pw_flags)) + return 1; + + /* dump the passwords to stdout */ + if (password) + printf ("%s\n%s\n", NM_IODINE_KEY_PASSWORD, password); + printf ("\n\n"); + + /* for good measure, flush stdout since Kansas is going Bye-Bye */ + fflush (stdout); + + /* Wait for quit signal */ + wait_for_quit (); + + if (data) + g_hash_table_unref (data); + if (secrets) + g_hash_table_unref (secrets); + return 0; +} diff --git a/auth-dialog/vpn-password-dialog.c b/auth-dialog/vpn-password-dialog.c new file mode 100644 index 0000000..6c976a3 --- /dev/null +++ b/auth-dialog/vpn-password-dialog.c @@ -0,0 +1,461 @@ +/* -*- 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 + * Dan Williams + */ + +#include +#include +#include +#include + +#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); +} + diff --git a/auth-dialog/vpn-password-dialog.h b/auth-dialog/vpn-password-dialog.h new file mode 100644 index 0000000..7d69320 --- /dev/null +++ b/auth-dialog/vpn-password-dialog.h @@ -0,0 +1,79 @@ +/* -*- 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 + * Dan Williams + */ + +#ifndef VPN_PASSWORD_DIALOG_H +#define VPN_PASSWORD_DIALOG_H + +#include + +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 */ -- cgit v1.2.3