--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit/gtk/webkit/webkitsoupauthdialog.c Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,360 @@
+/*
+ * Copyright (C) 2009 Igalia S.L.
+ *
+ * This 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.
+ *
+ * This 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 Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#define LIBSOUP_I_HAVE_READ_BUG_594377_AND_KNOW_SOUP_PASSWORD_MANAGER_MIGHT_GO_AWAY
+
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+#include <libsoup/soup.h>
+
+#include "GtkVersioning.h"
+#include "webkitmarshal.h"
+#include "webkitsoupauthdialog.h"
+
+/**
+ * SECTION:webkitsoupauthdialog
+ * @short_description: A #SoupSessionFeature to provide a simple
+ * authentication dialog for HTTP basic auth support.
+ *
+ * #WebKitSoupAuthDialog is a #SoupSessionFeature that you can attach to your
+ * #SoupSession to provide a simple authentication dialog while
+ * handling HTTP basic auth. It is built as a simple C-only module
+ * to ease reuse.
+ */
+
+static void webkit_soup_auth_dialog_session_feature_init(SoupSessionFeatureInterface* feature_interface, gpointer interface_data);
+static void attach(SoupSessionFeature* manager, SoupSession* session);
+static void detach(SoupSessionFeature* manager, SoupSession* session);
+
+enum {
+ CURRENT_TOPLEVEL,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE_WITH_CODE(WebKitSoupAuthDialog, webkit_soup_auth_dialog, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE(SOUP_TYPE_SESSION_FEATURE,
+ webkit_soup_auth_dialog_session_feature_init))
+
+static void webkit_soup_auth_dialog_class_init(WebKitSoupAuthDialogClass* klass)
+{
+ GObjectClass* object_class = G_OBJECT_CLASS(klass);
+
+ signals[CURRENT_TOPLEVEL] =
+ g_signal_new("current-toplevel",
+ G_OBJECT_CLASS_TYPE(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET(WebKitSoupAuthDialogClass, current_toplevel),
+ NULL, NULL,
+ webkit_marshal_OBJECT__OBJECT,
+ GTK_TYPE_WIDGET, 1,
+ SOUP_TYPE_MESSAGE);
+}
+
+static void webkit_soup_auth_dialog_init(WebKitSoupAuthDialog* instance)
+{
+}
+
+static void webkit_soup_auth_dialog_session_feature_init(SoupSessionFeatureInterface *feature_interface,
+ gpointer interface_data)
+{
+ feature_interface->attach = attach;
+ feature_interface->detach = detach;
+}
+
+typedef struct _WebKitAuthData {
+ SoupMessage* msg;
+ SoupAuth* auth;
+ SoupSession* session;
+ SoupSessionFeature* manager;
+ GtkWidget* loginEntry;
+ GtkWidget* passwordEntry;
+ GtkWidget* checkButton;
+ char *username;
+ char *password;
+} WebKitAuthData;
+
+static void free_authData(WebKitAuthData* authData)
+{
+ g_object_unref(authData->msg);
+ g_free(authData->username);
+ g_free(authData->password);
+ g_slice_free(WebKitAuthData, authData);
+}
+
+#ifdef SOUP_TYPE_PASSWORD_MANAGER
+static void save_password_callback(SoupMessage* msg, WebKitAuthData* authData)
+{
+ /* Anything but 401 and 5xx means the password was accepted */
+ if (msg->status_code != 401 && msg->status_code < 500)
+ soup_auth_save_password(authData->auth, authData->username, authData->password);
+
+ /* Disconnect the callback. If the authentication succeeded we are
+ * done, and if it failed we'll create a new authData and we'll
+ * connect to 'got-headers' again in response_callback */
+ g_signal_handlers_disconnect_by_func(msg, save_password_callback, authData);
+
+ free_authData(authData);
+}
+#endif
+
+static void response_callback(GtkDialog* dialog, gint response_id, WebKitAuthData* authData)
+{
+ gboolean freeAuthData = TRUE;
+
+ if (response_id == GTK_RESPONSE_OK) {
+ authData->username = g_strdup(gtk_entry_get_text(GTK_ENTRY(authData->loginEntry)));
+ authData->password = g_strdup(gtk_entry_get_text(GTK_ENTRY(authData->passwordEntry)));
+
+ soup_auth_authenticate(authData->auth, authData->username, authData->password);
+
+#ifdef SOUP_TYPE_PASSWORD_MANAGER
+ if (authData->checkButton &&
+ gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(authData->checkButton))) {
+ g_signal_connect(authData->msg, "got-headers", G_CALLBACK(save_password_callback), authData);
+ freeAuthData = FALSE;
+ }
+#endif
+ }
+
+ soup_session_unpause_message(authData->session, authData->msg);
+ if (freeAuthData)
+ free_authData(authData);
+ gtk_widget_destroy(GTK_WIDGET(dialog));
+}
+
+static GtkWidget *
+table_add_entry(GtkWidget* table,
+ int row,
+ const char* label_text,
+ const char* value,
+ gpointer user_data)
+{
+ GtkWidget* entry;
+ GtkWidget* label;
+
+ label = gtk_label_new(label_text);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
+
+ entry = gtk_entry_new();
+ gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
+
+ if (value)
+ gtk_entry_set_text(GTK_ENTRY(entry), value);
+
+ gtk_table_attach(GTK_TABLE(table), label,
+ 0, 1, row, row + 1,
+ GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ gtk_table_attach_defaults(GTK_TABLE(table), entry,
+ 1, 2, row, row + 1);
+
+ return entry;
+}
+
+static gboolean session_can_save_passwords(SoupSession* session)
+{
+#ifdef SOUP_TYPE_PASSWORD_MANAGER
+ return soup_session_get_feature(session, SOUP_TYPE_PASSWORD_MANAGER) != NULL;
+#else
+ return FALSE;
+#endif
+}
+
+static void show_auth_dialog(WebKitAuthData* authData, const char* login, const char* password)
+{
+ GtkWidget* toplevel;
+ GtkWidget* widget;
+ GtkDialog* dialog;
+ GtkWindow* window;
+ GtkWidget* entryContainer;
+ GtkWidget* hbox;
+ GtkWidget* mainVBox;
+ GtkWidget* vbox;
+ GtkWidget* icon;
+ GtkWidget* table;
+ GtkWidget* serverMessageDescriptionLabel;
+ GtkWidget* serverMessageLabel;
+ GtkWidget* descriptionLabel;
+ char* description;
+ const char* realm;
+ gboolean hasRealm;
+ SoupURI* uri;
+ GtkWidget* rememberBox;
+ GtkWidget* checkButton;
+
+ /* From GTK+ gtkmountoperation.c, modified and simplified. LGPL 2 license */
+
+ widget = gtk_dialog_new();
+ window = GTK_WINDOW(widget);
+ dialog = GTK_DIALOG(widget);
+
+ gtk_dialog_add_buttons(dialog,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_OK, GTK_RESPONSE_OK,
+ NULL);
+
+ /* Set the dialog up with HIG properties */
+ gtk_dialog_set_has_separator(dialog, FALSE);
+ gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
+ gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area(dialog)), 2); /* 2 * 5 + 2 = 12 */
+ gtk_container_set_border_width(GTK_CONTAINER(gtk_dialog_get_action_area(dialog)), 5);
+ gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_action_area(dialog)), 6);
+
+ gtk_window_set_resizable(window, FALSE);
+ gtk_window_set_title(window, "");
+ gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION);
+
+ gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
+
+ /* Get the current toplevel */
+ g_signal_emit(authData->manager, signals[CURRENT_TOPLEVEL], 0, authData->msg, &toplevel);
+
+ if (toplevel)
+ gtk_window_set_transient_for(window, GTK_WINDOW(toplevel));
+
+ /* Build contents */
+ hbox = gtk_hbox_new(FALSE, 12);
+ gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
+ gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(dialog)), hbox, TRUE, TRUE, 0);
+
+ icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,
+ GTK_ICON_SIZE_DIALOG);
+
+ gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0);
+ gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0);
+
+ mainVBox = gtk_vbox_new(FALSE, 18);
+ gtk_box_pack_start(GTK_BOX(hbox), mainVBox, TRUE, TRUE, 0);
+
+ uri = soup_message_get_uri(authData->msg);
+ description = g_strdup_printf(_("A username and password are being requested by the site %s"), uri->host);
+ descriptionLabel = gtk_label_new(description);
+ g_free(description);
+ gtk_misc_set_alignment(GTK_MISC(descriptionLabel), 0.0, 0.5);
+ gtk_label_set_line_wrap(GTK_LABEL(descriptionLabel), TRUE);
+ gtk_box_pack_start(GTK_BOX(mainVBox), GTK_WIDGET(descriptionLabel),
+ FALSE, FALSE, 0);
+
+ vbox = gtk_vbox_new(FALSE, 6);
+ gtk_box_pack_start(GTK_BOX(mainVBox), vbox, FALSE, FALSE, 0);
+
+ /* The table that holds the entries */
+ entryContainer = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
+
+ gtk_alignment_set_padding(GTK_ALIGNMENT(entryContainer),
+ 0, 0, 0, 0);
+
+ gtk_box_pack_start(GTK_BOX(vbox), entryContainer,
+ FALSE, FALSE, 0);
+
+ realm = soup_auth_get_realm(authData->auth);
+ // Checking that realm is not an empty string
+ hasRealm = (realm && (strlen(realm) > 0));
+
+ table = gtk_table_new(hasRealm ? 3 : 2, 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(entryContainer), table);
+
+ if (hasRealm) {
+ serverMessageDescriptionLabel = gtk_label_new(_("Server message:"));
+ serverMessageLabel = gtk_label_new(realm);
+ gtk_misc_set_alignment(GTK_MISC(serverMessageDescriptionLabel), 0.0, 0.5);
+ gtk_label_set_line_wrap(GTK_LABEL(serverMessageDescriptionLabel), TRUE);
+ gtk_misc_set_alignment(GTK_MISC(serverMessageLabel), 0.0, 0.5);
+ gtk_label_set_line_wrap(GTK_LABEL(serverMessageLabel), TRUE);
+
+ gtk_table_attach_defaults(GTK_TABLE(table), serverMessageDescriptionLabel,
+ 0, 1, 0, 1);
+ gtk_table_attach_defaults(GTK_TABLE(table), serverMessageLabel,
+ 1, 2, 0, 1);
+ }
+
+ authData->loginEntry = table_add_entry(table, hasRealm ? 1 : 0, _("Username:"),
+ login, NULL);
+ authData->passwordEntry = table_add_entry(table, hasRealm ? 2 : 1, _("Password:"),
+ password, NULL);
+
+ gtk_entry_set_visibility(GTK_ENTRY(authData->passwordEntry), FALSE);
+
+ if (session_can_save_passwords(authData->session)) {
+ rememberBox = gtk_vbox_new(FALSE, 6);
+ gtk_box_pack_start(GTK_BOX(vbox), rememberBox,
+ FALSE, FALSE, 0);
+ checkButton = gtk_check_button_new_with_mnemonic(_("_Remember password"));
+ if (login && password)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkButton), TRUE);
+ gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkButton))), TRUE);
+ gtk_box_pack_start(GTK_BOX(rememberBox), checkButton, FALSE, FALSE, 0);
+ authData->checkButton = checkButton;
+ }
+
+ g_signal_connect(dialog, "response", G_CALLBACK(response_callback), authData);
+ gtk_widget_show_all(widget);
+}
+
+static void session_authenticate(SoupSession* session, SoupMessage* msg, SoupAuth* auth, gboolean retrying, gpointer user_data)
+{
+ SoupURI* uri;
+ WebKitAuthData* authData;
+ SoupSessionFeature* manager = (SoupSessionFeature*)user_data;
+#ifdef SOUP_TYPE_PASSWORD_MANAGER
+ GSList* users;
+#endif
+ const char *login, *password;
+
+ soup_session_pause_message(session, msg);
+ /* We need to make sure the message sticks around when pausing it */
+ g_object_ref(msg);
+
+ uri = soup_message_get_uri(msg);
+ authData = g_slice_new0(WebKitAuthData);
+ authData->msg = msg;
+ authData->auth = auth;
+ authData->session = session;
+ authData->manager = manager;
+
+ login = password = NULL;
+
+#ifdef SOUP_TYPE_PASSWORD_MANAGER
+ users = soup_auth_get_saved_users(auth);
+ if (users) {
+ login = users->data;
+ password = soup_auth_get_saved_password(auth, login);
+ g_slist_free(users);
+ }
+#endif
+
+ show_auth_dialog(authData, login, password);
+}
+
+static void attach(SoupSessionFeature* manager, SoupSession* session)
+{
+ g_signal_connect(session, "authenticate", G_CALLBACK(session_authenticate), manager);
+}
+
+static void detach(SoupSessionFeature* manager, SoupSession* session)
+{
+ g_signal_handlers_disconnect_by_func(session, session_authenticate, manager);
+}
+
+