summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog29
-rw-r--r--daemon/ui/Makefile.am2
-rw-r--r--daemon/ui/gkr-ask-tool.c22
-rw-r--r--egg/Makefile.am11
-rw-r--r--egg/egg-secure-entry.c (renamed from daemon/ui/gkr-ask-entry.c)723
-rw-r--r--egg/egg-secure-entry.h (renamed from daemon/ui/gkr-ask-entry.h)70
-rw-r--r--gcr/Makefile.am50
-rw-r--r--gcr/gcr-import-dialog.c452
-rw-r--r--gcr/gcr-import-dialog.glade185
-rw-r--r--gcr/gcr-import-dialog.h86
-rw-r--r--gcr/gcr-importer.c757
-rw-r--r--gcr/gcr-importer.h63
-rw-r--r--gcr/gcr-internal.h8
-rw-r--r--gcr/gcr-library.c (renamed from gcr/gcr-internal.c)107
-rw-r--r--gcr/gcr-parser.c163
-rw-r--r--gcr/gcr-parser.h44
-rw-r--r--gcr/gcr-types.h19
-rw-r--r--gcr/gcr.h46
-rw-r--r--gcr/template/gcr-xxx.c3
-rw-r--r--gcr/template/gcr-xxx.h2
-rw-r--r--gcr/tests/Makefile.am4
-rw-r--r--gcr/tests/unit-test-parser.c2
-rw-r--r--po/ChangeLog4
-rw-r--r--po/POTFILES.skip2
-rw-r--r--tool/Makefile.am20
-rw-r--r--tool/gkr-tool-import.c172
-rw-r--r--tool/gkr-tool.c5
27 files changed, 2146 insertions, 905 deletions
diff --git a/ChangeLog b/ChangeLog
index 4e8579e6..395754ff 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,32 @@
+2009-01-21 Stef Walter <stef@memberwebs.com>
+
+ * daemon/ui/gkr-ask-entry.c: (moved)
+ * daemon/ui/gkr-ask-entry.h: (moved)
+ * daemon/ui/gkr-ask-tool.c:
+ * daemon/ui/Makefile.am:
+ * egg/egg-secure-entry.c: (moved from daemon/ui/gkr-ask-entry.c)
+ * egg/egg-secure-entry.h: (moved from daemon/ui/gkr-ask-entry.h)
+ * egg/Makefile.am:
+ * gcr/gcr.h: (added)
+ * gcr/gcr-import-dialog.c: (added)
+ * gcr/gcr-import-dialog.glade:
+ * gcr/gcr-import-dialog.h: (added)
+ * gcr/gcr-importer.c:
+ * gcr/gcr-importer.h:
+ * gcr/gcr-internal.c: (removed)
+ * gcr/gcr-internal.h:
+ * gcr/gcr-library.c: (added)
+ * gcr/gcr-parser.c:
+ * gcr/gcr-parser.h:
+ * gcr/gcr-types.h:
+ * gcr/Makefile.am:
+ * gcr/tests/Makefile.am:
+ * gcr/tests/unit-test-parser.c:
+ * tool/gkr-tool.c:
+ * tool/gkr-tool-import.c:
+ * tool/Makefile.am: Complete importer in gcr library. Make 'gnome-keyring import'
+ use the new importer.
+
2009-01-20 Stef Walter <stef@memberwebs.com>
* gp11/gp11.h:
diff --git a/daemon/ui/Makefile.am b/daemon/ui/Makefile.am
index 007d7b82..538a18ce 100644
--- a/daemon/ui/Makefile.am
+++ b/daemon/ui/Makefile.am
@@ -15,13 +15,13 @@ INCLUDES= \
$(GTK_CFLAGS)
gnome_keyring_ask_SOURCES = \
- gkr-ask-entry.c gkr-ask-entry.h \
gkr-ask-tool.c gkr-ask-tool.h \
gkr-ask-tool-widgets.c \
gkr-ask-request.h
gnome_keyring_ask_LDADD = \
$(top_builddir)/egg/libegg-secure.la \
+ $(top_builddir)/egg/libegg-secure-entry.la \
$(GTK_LIBS)
noinst_LTLIBRARIES=libgkr-ui.la
diff --git a/daemon/ui/gkr-ask-tool.c b/daemon/ui/gkr-ask-tool.c
index 72a4167b..0a001229 100644
--- a/daemon/ui/gkr-ask-tool.c
+++ b/daemon/ui/gkr-ask-tool.c
@@ -22,10 +22,10 @@
#include "config.h"
-#include "gkr-ask-entry.h"
#include "gkr-ask-tool.h"
#include "gkr-ask-request.h"
+#include "egg/egg-secure-entry.h"
#include "egg/egg-secure-memory.h"
#include <gtk/gtk.h>
@@ -268,7 +268,7 @@ on_password_changed (GtkEditable *editable,
int upper, lower, digit, misc;
gdouble pwstrength;
- password = gkr_ask_entry_get_text (GKR_ASK_ENTRY (editable));
+ password = egg_secure_entry_get_text (EGG_SECURE_ENTRY (editable));
/*
* This code is based on the Master Password dialog in Firefox
@@ -490,8 +490,8 @@ run_dialog (gboolean include_password,
if (include_original) {
gtk_table_resize (GTK_TABLE (ptable), ++row, 2);
label = gtk_label_new_with_mnemonic (_("_Old password:"));
- old = gkr_ask_entry_new ();
- gkr_ask_entry_set_visibility (GKR_ASK_ENTRY (old), FALSE);
+ old = egg_secure_entry_new ();
+ egg_secure_entry_set_visibility (EGG_SECURE_ENTRY (old), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), old);
g_signal_connect_swapped (old,
"activate",
@@ -510,8 +510,8 @@ run_dialog (gboolean include_password,
if (include_password) {
gtk_table_resize (GTK_TABLE (ptable), ++row, 2);
label = gtk_label_new_with_mnemonic (_("_Password:"));
- entry = gkr_ask_entry_new ();
- gkr_ask_entry_set_visibility (GKR_ASK_ENTRY (entry), FALSE);
+ entry = egg_secure_entry_new ();
+ egg_secure_entry_set_visibility (EGG_SECURE_ENTRY (entry), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
g_signal_connect_swapped (entry,
"activate",
@@ -532,8 +532,8 @@ run_dialog (gboolean include_password,
gtk_table_resize (GTK_TABLE (ptable), ++row, 2);
label = gtk_label_new_with_mnemonic (_("_Confirm password:"));
- confirm = gkr_ask_entry_new ();
- gkr_ask_entry_set_visibility (GKR_ASK_ENTRY (confirm), FALSE);
+ confirm = egg_secure_entry_new ();
+ egg_secure_entry_set_visibility (EGG_SECURE_ENTRY (confirm), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), confirm);
g_signal_connect_swapped (confirm,
"activate",
@@ -599,15 +599,15 @@ run_dialog (gboolean include_password,
/* Get the original password */
if (include_original && old != NULL && response >= GKR_ASK_RESPONSE_ALLOW) {
- original = gkr_ask_entry_get_text (GKR_ASK_ENTRY (old));
+ original = egg_secure_entry_get_text (EGG_SECURE_ENTRY (old));
*original_out = egg_secure_strdup (original);
}
/* Get the main password entry, and confirmation */
if (include_password && entry != NULL && response >= GKR_ASK_RESPONSE_ALLOW) {
- password = gkr_ask_entry_get_text (GKR_ASK_ENTRY (entry));
+ password = egg_secure_entry_get_text (EGG_SECURE_ENTRY (entry));
if (include_confirm && confirm != NULL) {
- confirmation = gkr_ask_entry_get_text (GKR_ASK_ENTRY (confirm));
+ confirmation = egg_secure_entry_get_text (EGG_SECURE_ENTRY (confirm));
if (strcmp (password, confirmation) != 0) {
notice_text = create_notice (_("Passwords do not match."));
gtk_label_set_markup (notice, notice_text);
diff --git a/egg/Makefile.am b/egg/Makefile.am
index fc3db78e..30b9d32e 100644
--- a/egg/Makefile.am
+++ b/egg/Makefile.am
@@ -3,7 +3,8 @@ noinst_LTLIBRARIES = \
libegg.la \
libegg-buffer.la \
libegg-creds.la \
- libegg-secure.la
+ libegg-secure.la \
+ libegg-secure-entry.la
BUILT_SOURCES = \
asn1-def-pk.h asn1-def-pkix.h
@@ -45,6 +46,14 @@ DISTCLEANFILES = \
libegg_secure_la_SOURCES = \
egg-secure-memory.c egg-secure-memory.h
+libegg_secure_entry_la_SOURCES = \
+ egg-secure-entry.c egg-secure-entry.h
+
+libegg_secure_entry_la_CFLAGS = \
+ $(GOBJECT_CFLAGS) \
+ $(GLIB_CFLAGS) \
+ $(GTK_CFLAGS)
+
libegg_buffer_la_SOURCES = \
egg-buffer.c egg-buffer.h
diff --git a/daemon/ui/gkr-ask-entry.c b/egg/egg-secure-entry.c
index 9550039d..78822cf5 100644
--- a/daemon/ui/gkr-ask-entry.c
+++ b/egg/egg-secure-entry.c
@@ -46,9 +46,8 @@
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
-#include "gkr-ask-entry.h"
-
-#include "egg/egg-secure-memory.h"
+#include "egg-secure-entry.h"
+#include "egg-secure-memory.h"
#define MIN_ASK_ENTRY_WIDTH 150
#define DRAW_TIMEOUT 20
@@ -85,87 +84,87 @@ enum {
static guint signals[LAST_SIGNAL] = { 0 };
/* GObject, GtkObject methods */
-static void gkr_ask_entry_class_init (GkrAskEntryClass *klass);
-static void gkr_ask_entry_editable_init (GtkEditableClass *iface);
-static void gkr_ask_entry_cell_editable_init (GtkCellEditableIface *iface);
-static void gkr_ask_entry_init (GkrAskEntry *entry);
-static void gkr_ask_entry_set_property (GObject *object, guint prop_id,
+static void egg_secure_entry_class_init (EggSecureEntryClass *klass);
+static void egg_secure_entry_editable_init (GtkEditableClass *iface);
+static void egg_secure_entry_cell_editable_init (GtkCellEditableIface *iface);
+static void egg_secure_entry_init (EggSecureEntry *entry);
+static void egg_secure_entry_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec);
-static void gkr_ask_entry_get_property (GObject *object, guint prop_id,
+static void egg_secure_entry_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec);
-static void gkr_ask_entry_finalize (GObject *object);
+static void egg_secure_entry_finalize (GObject *object);
/* GtkWidget methods */
-static void gkr_ask_entry_realize (GtkWidget *widget);
-static void gkr_ask_entry_unrealize (GtkWidget *widget);
-static void gkr_ask_entry_size_request (GtkWidget *widget, GtkRequisition *requisition);
-static void gkr_ask_entry_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
-static void gkr_ask_entry_draw_frame (GtkWidget *widget);
-static gint gkr_ask_entry_expose (GtkWidget *widget, GdkEventExpose *event);
-static gint gkr_ask_entry_button_press (GtkWidget *widget, GdkEventButton *event);
-static gint gkr_ask_entry_button_release (GtkWidget *widget, GdkEventButton *event);
-static gint gkr_ask_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event);
-static gint gkr_ask_entry_key_press (GtkWidget *widget, GdkEventKey *event);
-static gint gkr_ask_entry_key_release (GtkWidget *widget, GdkEventKey *event);
-static gint gkr_ask_entry_focus_in (GtkWidget *widget, GdkEventFocus *event);
-static gint gkr_ask_entry_focus_out (GtkWidget *widget, GdkEventFocus *event);
-static void gkr_ask_entry_grab_focus (GtkWidget *widget);
-static void gkr_ask_entry_style_set (GtkWidget *widget, GtkStyle *previous_style);
-static void gkr_ask_entry_direction_changed (GtkWidget *widget, GtkTextDirection previous_dir);
-static void gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
-static void gkr_ask_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen);
+static void egg_secure_entry_realize (GtkWidget *widget);
+static void egg_secure_entry_unrealize (GtkWidget *widget);
+static void egg_secure_entry_size_request (GtkWidget *widget, GtkRequisition *requisition);
+static void egg_secure_entry_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
+static void egg_secure_entry_draw_frame (GtkWidget *widget);
+static gint egg_secure_entry_expose (GtkWidget *widget, GdkEventExpose *event);
+static gint egg_secure_entry_button_press (GtkWidget *widget, GdkEventButton *event);
+static gint egg_secure_entry_button_release (GtkWidget *widget, GdkEventButton *event);
+static gint egg_secure_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event);
+static gint egg_secure_entry_key_press (GtkWidget *widget, GdkEventKey *event);
+static gint egg_secure_entry_key_release (GtkWidget *widget, GdkEventKey *event);
+static gint egg_secure_entry_focus_in (GtkWidget *widget, GdkEventFocus *event);
+static gint egg_secure_entry_focus_out (GtkWidget *widget, GdkEventFocus *event);
+static void egg_secure_entry_grab_focus (GtkWidget *widget);
+static void egg_secure_entry_style_set (GtkWidget *widget, GtkStyle *previous_style);
+static void egg_secure_entry_direction_changed (GtkWidget *widget, GtkTextDirection previous_dir);
+static void egg_secure_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
+static void egg_secure_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen);
/* GtkEditable method implementations */
-static void gkr_ask_entry_insert_text (GtkEditable *editable, const gchar *new_text,
+static void egg_secure_entry_insert_text (GtkEditable *editable, const gchar *new_text,
gint new_text_length, gint *position);
-static void gkr_ask_entry_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
-static void gkr_ask_entry_real_set_position (GtkEditable *editable, gint position);
-static gint gkr_ask_entry_get_position (GtkEditable *editable);
-static void gkr_ask_entry_set_selection_bounds (GtkEditable *editable, gint start, gint end);
-static gboolean gkr_ask_entry_get_selection_bounds (GtkEditable *editable, gint *start, gint *end);
+static void egg_secure_entry_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
+static void egg_secure_entry_real_set_position (GtkEditable *editable, gint position);
+static gint egg_secure_entry_get_position (GtkEditable *editable);
+static void egg_secure_entry_set_selection_bounds (GtkEditable *editable, gint start, gint end);
+static gboolean egg_secure_entry_get_selection_bounds (GtkEditable *editable, gint *start, gint *end);
/* GtkCellEditable method implementations */
-static void gkr_ask_entry_start_editing (GtkCellEditable *cell_editable, GdkEvent *event);
+static void egg_secure_entry_start_editing (GtkCellEditable *cell_editable, GdkEvent *event);
/* Default signal handlers */
-static void gkr_ask_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
+static void egg_secure_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
gint new_text_length, gint *position);
-static void gkr_ask_entry_real_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
-static void gkr_ask_entry_move_cursor (GkrAskEntry *entry, GtkMovementStep step,
+static void egg_secure_entry_real_delete_text (GtkEditable *editable, gint start_pos, gint end_pos);
+static void egg_secure_entry_move_cursor (EggSecureEntry *entry, GtkMovementStep step,
gint count, gboolean extend_selection);
-static void gkr_ask_entry_insert_at_cursor (GkrAskEntry *entry, const gchar *str);
-static void gkr_ask_entry_delete_from_cursor (GkrAskEntry *entry, GtkDeleteType type, gint count);
-static void gkr_ask_entry_real_activate (GkrAskEntry *entry);
-static void gkr_ask_entry_keymap_direction_changed (GdkKeymap *keymap, GkrAskEntry *entry);
+static void egg_secure_entry_insert_at_cursor (EggSecureEntry *entry, const gchar *str);
+static void egg_secure_entry_delete_from_cursor (EggSecureEntry *entry, GtkDeleteType type, gint count);
+static void egg_secure_entry_real_activate (EggSecureEntry *entry);
+static void egg_secure_entry_keymap_direction_changed (GdkKeymap *keymap, EggSecureEntry *entry);
/* IM Context Callbacks */
-static void gkr_ask_entry_commit_cb(GtkIMContext *context, const gchar *str, GkrAskEntry *entry);
-static void gkr_ask_entry_preedit_changed_cb (GtkIMContext * context, GkrAskEntry *entry);
-static gboolean gkr_ask_entry_retrieve_surrounding_cb (GtkIMContext *context, GkrAskEntry *entry);
-static gboolean gkr_ask_entry_delete_surrounding_cb (GtkIMContext *context, gint offset,
- gint n_chars, GkrAskEntry *entry);
+static void egg_secure_entry_commit_cb(GtkIMContext *context, const gchar *str, EggSecureEntry *entry);
+static void egg_secure_entry_preedit_changed_cb (GtkIMContext * context, EggSecureEntry *entry);
+static gboolean egg_secure_entry_retrieve_surrounding_cb (GtkIMContext *context, EggSecureEntry *entry);
+static gboolean egg_secure_entry_delete_surrounding_cb (GtkIMContext *context, gint offset,
+ gint n_chars, EggSecureEntry *entry);
/* Internal routines */
-static void gkr_ask_entry_enter_text (GkrAskEntry *entry, const gchar *str);
-static void gkr_ask_entry_set_positions (GkrAskEntry *entry, gint current_pos, gint selection_bound);
-static void gkr_ask_entry_draw_text (GkrAskEntry *entry);
-static void gkr_ask_entry_draw_cursor (GkrAskEntry *entry);
-static PangoLayout *gkr_ask_entry_ensure_layout(GkrAskEntry *entry, gboolean include_preedit);
-static void gkr_ask_entry_reset_layout (GkrAskEntry *entry);
-static void gkr_ask_entry_queue_draw (GkrAskEntry *entry);
-static void gkr_ask_entry_reset_im_context (GkrAskEntry *entry);
-static void gkr_ask_entry_recompute (GkrAskEntry *entry);
-static gint gkr_ask_entry_find_position (GkrAskEntry *entry, gint x);
-static void gkr_ask_entry_get_cursor_locations (GkrAskEntry *entry, gint *strong_x, gint *weak_x);
-static void gkr_ask_entry_adjust_scroll (GkrAskEntry *entry);
-static gint gkr_ask_entry_move_visually (GkrAskEntry *editable, gint start, gint count);
-static gint gkr_ask_entry_move_logically (GkrAskEntry *entry, gint start, gint count);
-static gboolean gkr_ask_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling);
-static void gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
-static void gkr_ask_entry_check_cursor_blink (GkrAskEntry *entry);
-static void gkr_ask_entry_pend_cursor_blink (GkrAskEntry *entry);
-static void get_text_area_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height);
-static void get_widget_window_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height);
+static void egg_secure_entry_enter_text (EggSecureEntry *entry, const gchar *str);
+static void egg_secure_entry_set_positions (EggSecureEntry *entry, gint current_pos, gint selection_bound);
+static void egg_secure_entry_draw_text (EggSecureEntry *entry);
+static void egg_secure_entry_draw_cursor (EggSecureEntry *entry);
+static PangoLayout *egg_secure_entry_ensure_layout(EggSecureEntry *entry, gboolean include_preedit);
+static void egg_secure_entry_reset_layout (EggSecureEntry *entry);
+static void egg_secure_entry_queue_draw (EggSecureEntry *entry);
+static void egg_secure_entry_reset_im_context (EggSecureEntry *entry);
+static void egg_secure_entry_recompute (EggSecureEntry *entry);
+static gint egg_secure_entry_find_position (EggSecureEntry *entry, gint x);
+static void egg_secure_entry_get_cursor_locations (EggSecureEntry *entry, gint *strong_x, gint *weak_x);
+static void egg_secure_entry_adjust_scroll (EggSecureEntry *entry);
+static gint egg_secure_entry_move_visually (EggSecureEntry *editable, gint start, gint count);
+static gint egg_secure_entry_move_logically (EggSecureEntry *entry, gint start, gint count);
+static gboolean egg_secure_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling);
+static void egg_secure_entry_state_changed (GtkWidget *widget, GtkStateType previous_state);
+static void egg_secure_entry_check_cursor_blink (EggSecureEntry *entry);
+static void egg_secure_entry_pend_cursor_blink (EggSecureEntry *entry);
+static void get_text_area_size (EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height);
+static void get_widget_window_size (EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height);
#define _gtk_marshal_VOID__VOID g_cclosure_marshal_VOID__VOID
#define _gtk_marshal_VOID__STRING g_cclosure_marshal_VOID__STRING
@@ -178,36 +177,36 @@ static void _gtk_marshal_VOID__ENUM_INT (GClosure *closure, GValue *return_value
static GtkWidgetClass *parent_class = NULL;
GType
-gkr_ask_entry_get_type(void)
+egg_secure_entry_get_type(void)
{
static GType entry_type = 0;
if (!entry_type) {
static const GTypeInfo entry_info = {
- sizeof(GkrAskEntryClass),
+ sizeof(EggSecureEntryClass),
NULL, /* base_init */
NULL, /* base_finalize */
- (GClassInitFunc) gkr_ask_entry_class_init,
+ (GClassInitFunc) egg_secure_entry_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
- sizeof(GkrAskEntry),
+ sizeof(EggSecureEntry),
0, /* n_preallocs */
- (GInstanceInitFunc) gkr_ask_entry_init,
+ (GInstanceInitFunc) egg_secure_entry_init,
};
static const GInterfaceInfo editable_info = {
- (GInterfaceInitFunc) gkr_ask_entry_editable_init, /* interface_init */
+ (GInterfaceInitFunc) egg_secure_entry_editable_init, /* interface_init */
NULL, /* interface_finalize */
NULL /* interface_data */
};
static const GInterfaceInfo cell_editable_info = {
- (GInterfaceInitFunc) gkr_ask_entry_cell_editable_init, /* interface_init */
+ (GInterfaceInitFunc) egg_secure_entry_cell_editable_init, /* interface_init */
NULL, /* interface_finalize */
NULL /* interface_data */
};
- entry_type = g_type_register_static(GTK_TYPE_WIDGET, "GkrAskEntry", &entry_info, 0);
+ entry_type = g_type_register_static(GTK_TYPE_WIDGET, "EggSecureEntry", &entry_info, 0);
g_type_add_interface_static(entry_type, GTK_TYPE_EDITABLE, &editable_info);
g_type_add_interface_static(entry_type, GTK_TYPE_CELL_EDITABLE, &cell_editable_info);
}
@@ -230,7 +229,7 @@ add_move_binding (GtkBindingSet *binding_set, guint keyval, guint modmask,
}
static void
-gkr_ask_entry_class_init(GkrAskEntryClass *class)
+egg_secure_entry_class_init(EggSecureEntryClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(class);
GtkWidgetClass *widget_class;
@@ -239,33 +238,33 @@ gkr_ask_entry_class_init(GkrAskEntryClass *class)
widget_class = (GtkWidgetClass*) class;
parent_class = g_type_class_peek_parent (class);
- gobject_class->finalize = gkr_ask_entry_finalize;
- gobject_class->set_property = gkr_ask_entry_set_property;
- gobject_class->get_property = gkr_ask_entry_get_property;
-
- widget_class->realize = gkr_ask_entry_realize;
- widget_class->unrealize = gkr_ask_entry_unrealize;
- widget_class->size_request = gkr_ask_entry_size_request;
- widget_class->size_allocate = gkr_ask_entry_size_allocate;
- widget_class->expose_event = gkr_ask_entry_expose;
- widget_class->button_press_event = gkr_ask_entry_button_press;
- widget_class->button_release_event = gkr_ask_entry_button_release;
- widget_class->motion_notify_event = gkr_ask_entry_motion_notify;
- widget_class->key_press_event = gkr_ask_entry_key_press;
- widget_class->key_release_event = gkr_ask_entry_key_release;
- widget_class->focus_in_event = gkr_ask_entry_focus_in;
- widget_class->focus_out_event = gkr_ask_entry_focus_out;
- widget_class->grab_focus = gkr_ask_entry_grab_focus;
- widget_class->style_set = gkr_ask_entry_style_set;
- widget_class->direction_changed = gkr_ask_entry_direction_changed;
- widget_class->state_changed = gkr_ask_entry_state_changed;
- widget_class->screen_changed = gkr_ask_entry_screen_changed;
- widget_class->mnemonic_activate = gkr_ask_entry_mnemonic_activate;
-
- class->move_cursor = gkr_ask_entry_move_cursor;
- class->insert_at_cursor = gkr_ask_entry_insert_at_cursor;
- class->delete_from_cursor = gkr_ask_entry_delete_from_cursor;
- class->activate = gkr_ask_entry_real_activate;
+ gobject_class->finalize = egg_secure_entry_finalize;
+ gobject_class->set_property = egg_secure_entry_set_property;
+ gobject_class->get_property = egg_secure_entry_get_property;
+
+ widget_class->realize = egg_secure_entry_realize;
+ widget_class->unrealize = egg_secure_entry_unrealize;
+ widget_class->size_request = egg_secure_entry_size_request;
+ widget_class->size_allocate = egg_secure_entry_size_allocate;
+ widget_class->expose_event = egg_secure_entry_expose;
+ widget_class->button_press_event = egg_secure_entry_button_press;
+ widget_class->button_release_event = egg_secure_entry_button_release;
+ widget_class->motion_notify_event = egg_secure_entry_motion_notify;
+ widget_class->key_press_event = egg_secure_entry_key_press;
+ widget_class->key_release_event = egg_secure_entry_key_release;
+ widget_class->focus_in_event = egg_secure_entry_focus_in;
+ widget_class->focus_out_event = egg_secure_entry_focus_out;
+ widget_class->grab_focus = egg_secure_entry_grab_focus;
+ widget_class->style_set = egg_secure_entry_style_set;
+ widget_class->direction_changed = egg_secure_entry_direction_changed;
+ widget_class->state_changed = egg_secure_entry_state_changed;
+ widget_class->screen_changed = egg_secure_entry_screen_changed;
+ widget_class->mnemonic_activate = egg_secure_entry_mnemonic_activate;
+
+ class->move_cursor = egg_secure_entry_move_cursor;
+ class->insert_at_cursor = egg_secure_entry_insert_at_cursor;
+ class->delete_from_cursor = egg_secure_entry_delete_from_cursor;
+ class->activate = egg_secure_entry_real_activate;
g_object_class_install_property (gobject_class, PROP_CURSOR_POSITION,
g_param_spec_int ("cursor_position", "Cursor Position", "The current position of the insertion cursor in chars",
@@ -311,24 +310,24 @@ gkr_ask_entry_class_init(GkrAskEntryClass *class)
signals[ACTIVATE] = g_signal_new ("activate", G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_STRUCT_OFFSET (GkrAskEntryClass, activate),
+ G_STRUCT_OFFSET (EggSecureEntryClass, activate),
NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
widget_class->activate_signal = signals[ACTIVATE];
signals[MOVE_CURSOR] = g_signal_new ("move_cursor", G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_STRUCT_OFFSET (GkrAskEntryClass, move_cursor),
+ G_STRUCT_OFFSET (EggSecureEntryClass, move_cursor),
NULL, NULL, _gtk_marshal_VOID__ENUM_INT_BOOLEAN,
G_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, G_TYPE_INT, G_TYPE_BOOLEAN);
signals[INSERT_AT_CURSOR] = g_signal_new("insert_at_cursor", G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_STRUCT_OFFSET (GkrAskEntryClass, insert_at_cursor),
+ G_STRUCT_OFFSET (EggSecureEntryClass, insert_at_cursor),
NULL, NULL, _gtk_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
signals[DELETE_FROM_CURSOR] = g_signal_new("delete_from_cursor", G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_STRUCT_OFFSET (GkrAskEntryClass, delete_from_cursor),
+ G_STRUCT_OFFSET (EggSecureEntryClass, delete_from_cursor),
NULL, NULL, _gtk_marshal_VOID__ENUM_INT, G_TYPE_NONE, 2,
GTK_TYPE_DELETE_TYPE, G_TYPE_INT);
@@ -385,57 +384,57 @@ gkr_ask_entry_class_init(GkrAskEntryClass *class)
}
static void
-gkr_ask_entry_editable_init (GtkEditableClass *iface)
+egg_secure_entry_editable_init (GtkEditableClass *iface)
{
- iface->do_insert_text = gkr_ask_entry_insert_text;
- iface->do_delete_text = gkr_ask_entry_delete_text;
- iface->insert_text = gkr_ask_entry_real_insert_text;
- iface->delete_text = gkr_ask_entry_real_delete_text;
- iface->set_selection_bounds = gkr_ask_entry_set_selection_bounds;
- iface->get_selection_bounds = gkr_ask_entry_get_selection_bounds;
- iface->set_position = gkr_ask_entry_real_set_position;
- iface->get_position = gkr_ask_entry_get_position;
+ iface->do_insert_text = egg_secure_entry_insert_text;
+ iface->do_delete_text = egg_secure_entry_delete_text;
+ iface->insert_text = egg_secure_entry_real_insert_text;
+ iface->delete_text = egg_secure_entry_real_delete_text;
+ iface->set_selection_bounds = egg_secure_entry_set_selection_bounds;
+ iface->get_selection_bounds = egg_secure_entry_get_selection_bounds;
+ iface->set_position = egg_secure_entry_real_set_position;
+ iface->get_position = egg_secure_entry_get_position;
}
static void
-gkr_ask_entry_cell_editable_init (GtkCellEditableIface * iface)
+egg_secure_entry_cell_editable_init (GtkCellEditableIface * iface)
{
- iface->start_editing = gkr_ask_entry_start_editing;
+ iface->start_editing = egg_secure_entry_start_editing;
}
static void
-gkr_ask_entry_set_property (GObject *object, guint prop_id,
+egg_secure_entry_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(object);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(object);
switch (prop_id) {
case PROP_MAX_LENGTH:
- gkr_ask_entry_set_max_length(entry, g_value_get_int(value));
+ egg_secure_entry_set_max_length(entry, g_value_get_int(value));
break;
case PROP_HAS_FRAME:
- gkr_ask_entry_set_has_frame(entry, g_value_get_boolean(value));
+ egg_secure_entry_set_has_frame(entry, g_value_get_boolean(value));
break;
case PROP_INVISIBLE_CHAR:
- gkr_ask_entry_set_invisible_char(entry, g_value_get_uint(value));
+ egg_secure_entry_set_invisible_char(entry, g_value_get_uint(value));
break;
case PROP_ACTIVATES_DEFAULT:
- gkr_ask_entry_set_activates_default(entry, g_value_get_boolean(value));
+ egg_secure_entry_set_activates_default(entry, g_value_get_boolean(value));
break;
case PROP_WIDTH_CHARS:
- gkr_ask_entry_set_width_chars(entry, g_value_get_int(value));
+ egg_secure_entry_set_width_chars(entry, g_value_get_int(value));
break;
case PROP_TEXT:
- gkr_ask_entry_set_text(entry, g_value_get_string(value));
+ egg_secure_entry_set_text(entry, g_value_get_string(value));
break;
case PROP_VISIBILITY:
- gkr_ask_entry_set_visibility (entry, g_value_get_boolean (value));
+ egg_secure_entry_set_visibility (entry, g_value_get_boolean (value));
break;
case PROP_SCROLL_OFFSET:
@@ -447,10 +446,10 @@ gkr_ask_entry_set_property (GObject *object, guint prop_id,
}
static void
-gkr_ask_entry_get_property (GObject *object, guint prop_id,
+egg_secure_entry_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(object);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(object);
switch (prop_id) {
case PROP_CURSOR_POSITION:
@@ -478,10 +477,10 @@ gkr_ask_entry_get_property (GObject *object, guint prop_id,
g_value_set_int(value, entry->scroll_offset);
break;
case PROP_TEXT:
- g_value_set_string(value, gkr_ask_entry_get_text(entry));
+ g_value_set_string(value, egg_secure_entry_get_text(entry));
break;
case PROP_VISIBILITY:
- g_value_set_boolean (value, gkr_ask_entry_get_visibility (entry));
+ g_value_set_boolean (value, egg_secure_entry_get_visibility (entry));
break;
default:
@@ -491,7 +490,7 @@ gkr_ask_entry_get_property (GObject *object, guint prop_id,
}
static void
-gkr_ask_entry_init (GkrAskEntry *entry)
+egg_secure_entry_init (EggSecureEntry *entry)
{
GtkStyle *style;
GtkWidget *tempent;
@@ -526,19 +525,19 @@ gkr_ask_entry_init (GkrAskEntry *entry)
entry->im_context = gtk_im_multicontext_new ();
g_signal_connect (entry->im_context, "commit",
- G_CALLBACK (gkr_ask_entry_commit_cb), entry);
+ G_CALLBACK (egg_secure_entry_commit_cb), entry);
g_signal_connect (entry->im_context, "preedit_changed",
- G_CALLBACK(gkr_ask_entry_preedit_changed_cb), entry);
+ G_CALLBACK(egg_secure_entry_preedit_changed_cb), entry);
g_signal_connect (entry->im_context, "retrieve_surrounding",
- G_CALLBACK(gkr_ask_entry_retrieve_surrounding_cb), entry);
+ G_CALLBACK(egg_secure_entry_retrieve_surrounding_cb), entry);
g_signal_connect (entry->im_context, "delete_surrounding",
- G_CALLBACK(gkr_ask_entry_delete_surrounding_cb), entry);
+ G_CALLBACK(egg_secure_entry_delete_surrounding_cb), entry);
}
static void
-gkr_ask_entry_finalize (GObject *object)
+egg_secure_entry_finalize (GObject *object)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (object);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (object);
if (entry->cached_layout)
g_object_unref (entry->cached_layout);
@@ -561,15 +560,15 @@ gkr_ask_entry_finalize (GObject *object)
}
static void
-gkr_ask_entry_realize (GtkWidget *widget)
+egg_secure_entry_realize (GtkWidget *widget)
{
- GkrAskEntry *entry;
+ EggSecureEntry *entry;
GtkEditable *editable;
GdkWindowAttr attributes;
gint attributes_mask;
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
- entry = GKR_ASK_ENTRY (widget);
+ entry = EGG_SECURE_ENTRY (widget);
editable = GTK_EDITABLE (widget);
attributes.window_type = GDK_WINDOW_CHILD;
@@ -615,15 +614,15 @@ gkr_ask_entry_realize (GtkWidget *widget)
gtk_im_context_set_client_window (entry->im_context, entry->text_area);
- gkr_ask_entry_adjust_scroll (entry);
+ egg_secure_entry_adjust_scroll (entry);
}
static void
-gkr_ask_entry_unrealize (GtkWidget *widget)
+egg_secure_entry_unrealize (GtkWidget *widget)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
- gkr_ask_entry_reset_layout (entry);
+ egg_secure_entry_reset_layout (entry);
gtk_im_context_set_client_window (entry->im_context, NULL);
@@ -638,7 +637,7 @@ gkr_ask_entry_unrealize (GtkWidget *widget)
}
static void
-get_borders (GkrAskEntry *entry, gint *xborder, gint *yborder)
+get_borders (EggSecureEntry *entry, gint *xborder, gint *yborder)
{
GtkWidget *widget = GTK_WIDGET (entry);
gint focus_width;
@@ -662,9 +661,9 @@ get_borders (GkrAskEntry *entry, gint *xborder, gint *yborder)
}
static void
-gkr_ask_entry_size_request (GtkWidget *widget, GtkRequisition *requisition)
+egg_secure_entry_size_request (GtkWidget *widget, GtkRequisition *requisition)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
PangoFontMetrics *metrics;
gint xborder, yborder;
PangoContext *context;
@@ -695,7 +694,7 @@ gkr_ask_entry_size_request (GtkWidget *widget, GtkRequisition *requisition)
}
static void
-get_text_area_size(GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height)
+get_text_area_size(EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height)
{
gint xborder, yborder;
GtkRequisition requisition;
@@ -719,7 +718,7 @@ get_text_area_size(GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *heig
}
static void
-get_widget_window_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint *height)
+get_widget_window_size (EggSecureEntry *entry, gint *x, gint *y, gint *width, gint *height)
{
GtkRequisition requisition;
GtkWidget *widget = GTK_WIDGET (entry);
@@ -749,9 +748,9 @@ get_widget_window_size (GkrAskEntry *entry, gint *x, gint *y, gint *width, gint
}
static void
-gkr_ask_entry_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+egg_secure_entry_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
widget->allocation = *allocation;
@@ -771,12 +770,12 @@ gkr_ask_entry_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
gdk_window_move_resize (entry->text_area, x, y, width, height);
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
}
}
static void
-gkr_ask_entry_draw_frame (GtkWidget *widget)
+egg_secure_entry_draw_frame (GtkWidget *widget)
{
gint x = 0, y = 0;
gint width, height;
@@ -810,12 +809,12 @@ gkr_ask_entry_draw_frame (GtkWidget *widget)
}
static gint
-gkr_ask_entry_expose(GtkWidget *widget, GdkEventExpose *event)
+egg_secure_entry_expose(GtkWidget *widget, GdkEventExpose *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
if (widget->window == event->window)
- gkr_ask_entry_draw_frame(widget);
+ egg_secure_entry_draw_frame(widget);
else if (entry->text_area == event->window) {
gint area_width, area_height;
@@ -826,18 +825,18 @@ gkr_ask_entry_expose(GtkWidget *widget, GdkEventExpose *event)
if ((entry->invisible_char != 0) && GTK_WIDGET_HAS_FOCUS (widget) &&
entry->selection_bound == entry->current_pos && entry->cursor_visible)
- gkr_ask_entry_draw_cursor (GKR_ASK_ENTRY (widget));
+ egg_secure_entry_draw_cursor (EGG_SECURE_ENTRY (widget));
- gkr_ask_entry_draw_text (GKR_ASK_ENTRY (widget));
+ egg_secure_entry_draw_text (EGG_SECURE_ENTRY (widget));
}
return FALSE;
}
static gint
-gkr_ask_entry_button_press(GtkWidget *widget, GdkEventButton *event)
+egg_secure_entry_button_press(GtkWidget *widget, GdkEventButton *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
gint tmp_pos;
if (event->window != entry->text_area ||
@@ -852,12 +851,12 @@ gkr_ask_entry_button_press(GtkWidget *widget, GdkEventButton *event)
entry->in_click = FALSE;
}
- tmp_pos = gkr_ask_entry_find_position (entry, event->x + entry->scroll_offset);
+ tmp_pos = egg_secure_entry_find_position (entry, event->x + entry->scroll_offset);
if (event->button == 1) {
switch (event->type) {
case GDK_BUTTON_PRESS:
- gkr_ask_entry_set_positions(entry, tmp_pos, tmp_pos);
+ egg_secure_entry_set_positions(entry, tmp_pos, tmp_pos);
break;
default:
break;
@@ -870,9 +869,9 @@ gkr_ask_entry_button_press(GtkWidget *widget, GdkEventButton *event)
}
static gint
-gkr_ask_entry_button_release(GtkWidget *widget, GdkEventButton *event)
+egg_secure_entry_button_release(GtkWidget *widget, GdkEventButton *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
if (event->window != entry->text_area || entry->button != event->button)
return FALSE;
@@ -882,9 +881,9 @@ gkr_ask_entry_button_release(GtkWidget *widget, GdkEventButton *event)
}
static gint
-gkr_ask_entry_motion_notify(GtkWidget *widget, GdkEventMotion *event)
+egg_secure_entry_motion_notify(GtkWidget *widget, GdkEventMotion *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(widget);
gint tmp_pos;
if (entry->mouse_cursor_obscured) {
@@ -912,10 +911,10 @@ gkr_ask_entry_motion_notify(GtkWidget *widget, GdkEventMotion *event)
else if (event->y >= height)
tmp_pos = entry->text_length;
else
- tmp_pos = gkr_ask_entry_find_position (entry,
+ tmp_pos = egg_secure_entry_find_position (entry,
event->x + entry->scroll_offset);
- gkr_ask_entry_set_positions (entry, tmp_pos, -1);
+ egg_secure_entry_set_positions (entry, tmp_pos, -1);
}
return TRUE;
@@ -944,7 +943,7 @@ set_invisible_cursor (GdkWindow * window)
}
static void
-gkr_ask_entry_obscure_mouse_cursor (GkrAskEntry * entry)
+egg_secure_entry_obscure_mouse_cursor (EggSecureEntry * entry)
{
if (entry->mouse_cursor_obscured)
return;
@@ -955,14 +954,14 @@ gkr_ask_entry_obscure_mouse_cursor (GkrAskEntry * entry)
}
static gint
-gkr_ask_entry_key_press (GtkWidget *widget, GdkEventKey *event)
+egg_secure_entry_key_press (GtkWidget *widget, GdkEventKey *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
- gkr_ask_entry_pend_cursor_blink (entry);
+ egg_secure_entry_pend_cursor_blink (entry);
if (gtk_im_context_filter_keypress (entry->im_context, event)) {
- gkr_ask_entry_obscure_mouse_cursor (entry);
+ egg_secure_entry_obscure_mouse_cursor (entry);
entry->need_im_reset = TRUE;
return TRUE;
}
@@ -975,9 +974,9 @@ gkr_ask_entry_key_press (GtkWidget *widget, GdkEventKey *event)
}
static gint
-gkr_ask_entry_key_release (GtkWidget *widget, GdkEventKey *event)
+egg_secure_entry_key_release (GtkWidget *widget, GdkEventKey *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
if (gtk_im_context_filter_keypress (entry->im_context, event)) {
entry->need_im_reset = TRUE;
@@ -988,9 +987,9 @@ gkr_ask_entry_key_release (GtkWidget *widget, GdkEventKey *event)
}
static gint
-gkr_ask_entry_focus_in (GtkWidget *widget, GdkEventFocus *event)
+egg_secure_entry_focus_in (GtkWidget *widget, GdkEventFocus *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
gtk_widget_queue_draw (widget);
@@ -998,35 +997,35 @@ gkr_ask_entry_focus_in (GtkWidget *widget, GdkEventFocus *event)
gtk_im_context_focus_in (entry->im_context);
g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)), "direction_changed",
- G_CALLBACK (gkr_ask_entry_keymap_direction_changed), entry);
+ G_CALLBACK (egg_secure_entry_keymap_direction_changed), entry);
- gkr_ask_entry_check_cursor_blink (entry);
+ egg_secure_entry_check_cursor_blink (entry);
return FALSE;
}
static gint
-gkr_ask_entry_focus_out (GtkWidget *widget, GdkEventFocus *event)
+egg_secure_entry_focus_out (GtkWidget *widget, GdkEventFocus *event)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
gtk_widget_queue_draw (widget);
entry->need_im_reset = TRUE;
gtk_im_context_focus_out (entry->im_context);
- gkr_ask_entry_check_cursor_blink (entry);
+ egg_secure_entry_check_cursor_blink (entry);
g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
- gkr_ask_entry_keymap_direction_changed, entry);
+ egg_secure_entry_keymap_direction_changed, entry);
return FALSE;
}
static void
-gkr_ask_entry_grab_focus (GtkWidget *widget)
+egg_secure_entry_grab_focus (GtkWidget *widget)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
GtkSettings *settings = gtk_widget_get_settings (widget);
gboolean select_on_focus = FALSE;
@@ -1043,19 +1042,19 @@ gkr_ask_entry_grab_focus (GtkWidget *widget)
}
static void
-gkr_ask_entry_direction_changed(GtkWidget *widget, GtkTextDirection previous_dir)
+egg_secure_entry_direction_changed(GtkWidget *widget, GtkTextDirection previous_dir)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
GTK_WIDGET_CLASS (parent_class)->direction_changed (widget, previous_dir);
}
static void
-gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state)
+egg_secure_entry_state_changed (GtkWidget *widget, GtkStateType previous_state)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
if (GTK_WIDGET_REALIZED (widget)) {
gdk_window_set_background (widget->window,
@@ -1074,18 +1073,18 @@ gkr_ask_entry_state_changed (GtkWidget *widget, GtkStateType previous_state)
}
static void
-gkr_ask_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen)
+egg_secure_entry_screen_changed (GtkWidget *widget, GdkScreen *old_screen)
{
- gkr_ask_entry_recompute (GKR_ASK_ENTRY (widget));
+ egg_secure_entry_recompute (EGG_SECURE_ENTRY (widget));
}
/* GtkEditable method implementations */
static void
-gkr_ask_entry_insert_text (GtkEditable *editable, const gchar *new_text,
+egg_secure_entry_insert_text (GtkEditable *editable, const gchar *new_text,
gint new_text_length, gint * position)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY(editable);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY(editable);
gchar *text;
if (*position < 0 || *position > entry->text_length)
@@ -1107,10 +1106,10 @@ gkr_ask_entry_insert_text (GtkEditable *editable, const gchar *new_text,
}
static void
-gkr_ask_entry_delete_text (GtkEditable* editable, gint start_pos,
+egg_secure_entry_delete_text (GtkEditable* editable, gint start_pos,
gint end_pos)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
if (end_pos < 0 || end_pos > entry->text_length)
end_pos = entry->text_length;
@@ -1127,7 +1126,7 @@ gkr_ask_entry_delete_text (GtkEditable* editable, gint start_pos,
}
static void
-gkr_ask_entry_set_position_internal (GkrAskEntry *entry,
+egg_secure_entry_set_position_internal (EggSecureEntry *entry,
gint position, gboolean reset_im)
{
if (position < 0 || position > entry->text_length)
@@ -1135,46 +1134,46 @@ gkr_ask_entry_set_position_internal (GkrAskEntry *entry,
if (position != entry->current_pos || position != entry->selection_bound) {
if (reset_im)
- gkr_ask_entry_reset_im_context (entry);
- gkr_ask_entry_set_positions (entry, position, position);
+ egg_secure_entry_reset_im_context (entry);
+ egg_secure_entry_set_positions (entry, position, position);
}
}
static void
-gkr_ask_entry_real_set_position (GtkEditable *editable, gint position)
+egg_secure_entry_real_set_position (GtkEditable *editable, gint position)
{
- gkr_ask_entry_set_position_internal (GKR_ASK_ENTRY (editable),
+ egg_secure_entry_set_position_internal (EGG_SECURE_ENTRY (editable),
position, TRUE);
}
static gint
-gkr_ask_entry_get_position (GtkEditable *editable)
+egg_secure_entry_get_position (GtkEditable *editable)
{
- return GKR_ASK_ENTRY (editable)->current_pos;
+ return EGG_SECURE_ENTRY (editable)->current_pos;
}
static void
-gkr_ask_entry_set_selection_bounds (GtkEditable *editable,
+egg_secure_entry_set_selection_bounds (GtkEditable *editable,
gint start, gint end)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
if (start < 0)
start = entry->text_length;
if (end < 0)
end = entry->text_length;
- gkr_ask_entry_reset_im_context (entry);
+ egg_secure_entry_reset_im_context (entry);
- gkr_ask_entry_set_positions (entry, MIN (end, entry->text_length),
+ egg_secure_entry_set_positions (entry, MIN (end, entry->text_length),
MIN (start, entry->text_length));
}
static gboolean
-gkr_ask_entry_get_selection_bounds (GtkEditable *editable,
+egg_secure_entry_get_selection_bounds (GtkEditable *editable,
gint *start, gint *end)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
*start = entry->selection_bound;
*end = entry->current_pos;
@@ -1183,11 +1182,11 @@ gkr_ask_entry_get_selection_bounds (GtkEditable *editable,
}
static void
-gkr_ask_entry_style_set (GtkWidget *widget, GtkStyle *previous_style)
+egg_secure_entry_style_set (GtkWidget *widget, GtkStyle *previous_style)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (widget);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (widget);
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
if (previous_style && GTK_WIDGET_REALIZED (widget)) {
gdk_window_set_background (widget->window,
@@ -1200,14 +1199,14 @@ gkr_ask_entry_style_set (GtkWidget *widget, GtkStyle *previous_style)
/* GtkCellEditable method implementations
*/
static void
-gtk_cell_editable_secure_entry_activated (GkrAskEntry *entry, gpointer data)
+gtk_cell_editable_secure_entry_activated (EggSecureEntry *entry, gpointer data)
{
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
}
static gboolean
-gtk_cell_editable_key_press_event (GkrAskEntry *entry, GdkEventKey *key_event,
+gtk_cell_editable_key_press_event (EggSecureEntry *entry, GdkEventKey *key_event,
gpointer data)
{
if (key_event->keyval == GDK_Escape) {
@@ -1228,10 +1227,10 @@ gtk_cell_editable_key_press_event (GkrAskEntry *entry, GdkEventKey *key_event,
}
static void
-gkr_ask_entry_start_editing (GtkCellEditable *cell_editable,
+egg_secure_entry_start_editing (GtkCellEditable *cell_editable,
GdkEvent *event)
{
- GKR_ASK_ENTRY(cell_editable)->is_cell_renderer = TRUE;
+ EGG_SECURE_ENTRY(cell_editable)->is_cell_renderer = TRUE;
g_signal_connect (cell_editable, "activate",
G_CALLBACK (gtk_cell_editable_secure_entry_activated), NULL);
@@ -1242,13 +1241,13 @@ gkr_ask_entry_start_editing (GtkCellEditable *cell_editable,
/* Default signal handlers */
static void
-gkr_ask_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
+egg_secure_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
gint new_text_length, gint *position)
{
gint _index;
gint n_chars;
- GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
if (new_text_length < 0)
new_text_length = strlen (new_text);
@@ -1303,7 +1302,7 @@ gkr_ask_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
*position += n_chars;
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
entry->changed = TRUE;
g_signal_emit_by_name (editable, "changed");
@@ -1311,10 +1310,10 @@ gkr_ask_entry_real_insert_text (GtkEditable *editable, const gchar *new_text,
}
static void
-gkr_ask_entry_real_delete_text (GtkEditable *editable, gint start_pos,
+egg_secure_entry_real_delete_text (GtkEditable *editable, gint start_pos,
gint end_pos)
{
- GkrAskEntry *entry = GKR_ASK_ENTRY (editable);
+ EggSecureEntry *entry = EGG_SECURE_ENTRY (editable);
if (start_pos < 0)
start_pos = 0;
@@ -1340,9 +1339,9 @@ gkr_ask_entry_real_delete_text (GtkEditable *editable, gint start_pos,
if (selection_bound > start_pos)
selection_bound -= MIN(selection_bound, end_pos) - start_pos;
- gkr_ask_entry_set_positions(entry, current_pos, selection_bound);
+ egg_secure_entry_set_positions(entry, current_pos, selection_bound);
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
entry->changed = TRUE;
g_signal_emit_by_name (editable, "changed");
@@ -1357,13 +1356,13 @@ gkr_ask_entry_real_delete_text (GtkEditable *editable, gint start_pos,
* right arrow key.
*/
static gint
-get_better_cursor_x (GkrAskEntry *entry, gint offset)
+get_better_cursor_x (EggSecureEntry *entry, gint offset)
{
GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET(entry)));
PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
gboolean split_cursor;
- PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+ PangoLayout *layout = egg_secure_entry_ensure_layout (entry, TRUE);
const gchar *text = pango_layout_get_text(layout);
gint _index = g_utf8_offset_to_pointer (text, offset) - text;
@@ -1383,12 +1382,12 @@ get_better_cursor_x (GkrAskEntry *entry, gint offset)
}
static void
-gkr_ask_entry_move_cursor (GkrAskEntry *entry, GtkMovementStep step,
+egg_secure_entry_move_cursor (EggSecureEntry *entry, GtkMovementStep step,
gint count, gboolean extend_selection)
{
gint new_pos = entry->current_pos;
- gkr_ask_entry_reset_im_context (entry);
+ egg_secure_entry_reset_im_context (entry);
if (entry->current_pos != entry->selection_bound && !extend_selection) {
/*
@@ -1425,10 +1424,10 @@ gkr_ask_entry_move_cursor (GkrAskEntry *entry, GtkMovementStep step,
} else {
switch (step) {
case GTK_MOVEMENT_LOGICAL_POSITIONS:
- new_pos = gkr_ask_entry_move_logically (entry, new_pos, count);
+ new_pos = egg_secure_entry_move_logically (entry, new_pos, count);
break;
case GTK_MOVEMENT_VISUAL_POSITIONS:
- new_pos = gkr_ask_entry_move_visually (entry, new_pos, count);
+ new_pos = egg_secure_entry_move_visually (entry, new_pos, count);
break;
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
case GTK_MOVEMENT_PARAGRAPH_ENDS:
@@ -1449,30 +1448,30 @@ gkr_ask_entry_move_cursor (GkrAskEntry *entry, GtkMovementStep step,
else
gtk_editable_set_position (GTK_EDITABLE (entry), new_pos);
- gkr_ask_entry_pend_cursor_blink (entry);
+ egg_secure_entry_pend_cursor_blink (entry);
}
static void
-gkr_ask_entry_insert_at_cursor(GkrAskEntry *entry, const gchar *str)
+egg_secure_entry_insert_at_cursor(EggSecureEntry *entry, const gchar *str)
{
GtkEditable *editable = GTK_EDITABLE (entry);
gint pos = entry->current_pos;
- gkr_ask_entry_reset_im_context (entry);
+ egg_secure_entry_reset_im_context (entry);
gtk_editable_insert_text (editable, str, -1, &pos);
gtk_editable_set_position (editable, pos);
}
static void
-gkr_ask_entry_delete_from_cursor (GkrAskEntry *entry, GtkDeleteType type,
+egg_secure_entry_delete_from_cursor (EggSecureEntry *entry, GtkDeleteType type,
gint count)
{
GtkEditable *editable = GTK_EDITABLE (entry);
gint start_pos = entry->current_pos;
gint end_pos = entry->current_pos;
- gkr_ask_entry_reset_im_context (entry);
+ egg_secure_entry_reset_im_context (entry);
if (entry->selection_bound != entry->current_pos) {
gtk_editable_delete_selection (editable);
@@ -1481,7 +1480,7 @@ gkr_ask_entry_delete_from_cursor (GkrAskEntry *entry, GtkDeleteType type,
switch (type) {
case GTK_DELETE_CHARS:
- end_pos = gkr_ask_entry_move_logically (entry, entry->current_pos, count);
+ end_pos = egg_secure_entry_move_logically (entry, entry->current_pos, count);
gtk_editable_delete_text (editable, MIN (start_pos, end_pos), MAX (start_pos, end_pos));
break;
case GTK_DELETE_DISPLAY_LINE_ENDS:
@@ -1499,11 +1498,11 @@ gkr_ask_entry_delete_from_cursor (GkrAskEntry *entry, GtkDeleteType type,
break;
}
- gkr_ask_entry_pend_cursor_blink (entry);
+ egg_secure_entry_pend_cursor_blink (entry);
}
static void
-gkr_ask_entry_real_activate (GkrAskEntry *entry)
+egg_secure_entry_real_activate (EggSecureEntry *entry)
{
GtkWindow *window;
GtkWidget *toplevel;
@@ -1525,22 +1524,22 @@ gkr_ask_entry_real_activate (GkrAskEntry *entry)
}
static void
-gkr_ask_entry_keymap_direction_changed (GdkKeymap *keymap, GkrAskEntry *entry)
+egg_secure_entry_keymap_direction_changed (GdkKeymap *keymap, EggSecureEntry *entry)
{
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
}
/* IM Context Callbacks */
static void
-gkr_ask_entry_commit_cb (GtkIMContext *context, const gchar *str,
- GkrAskEntry *entry)
+egg_secure_entry_commit_cb (GtkIMContext *context, const gchar *str,
+ EggSecureEntry *entry)
{
- gkr_ask_entry_enter_text (entry, str);
+ egg_secure_entry_enter_text (entry, str);
}
static void
-gkr_ask_entry_preedit_changed_cb (GtkIMContext *context, GkrAskEntry *entry)
+egg_secure_entry_preedit_changed_cb (GtkIMContext *context, EggSecureEntry *entry)
{
gchar *preedit_string;
gint cursor_pos;
@@ -1551,11 +1550,11 @@ gkr_ask_entry_preedit_changed_cb (GtkIMContext *context, GkrAskEntry *entry)
entry->preedit_cursor = cursor_pos;
g_free (preedit_string);
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
}
static gboolean
-gkr_ask_entry_retrieve_surrounding_cb (GtkIMContext *context, GkrAskEntry *entry)
+egg_secure_entry_retrieve_surrounding_cb (GtkIMContext *context, EggSecureEntry *entry)
{
gtk_im_context_set_surrounding (context, entry->text, entry->n_bytes,
g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text);
@@ -1563,8 +1562,8 @@ gkr_ask_entry_retrieve_surrounding_cb (GtkIMContext *context, GkrAskEntry *entry
}
static gboolean
-gkr_ask_entry_delete_surrounding_cb (GtkIMContext *slave, gint offset, gint n_chars,
- GkrAskEntry *entry)
+egg_secure_entry_delete_surrounding_cb (GtkIMContext *slave, gint offset, gint n_chars,
+ EggSecureEntry *entry)
{
gtk_editable_delete_text (GTK_EDITABLE (entry), entry->current_pos + offset,
entry->current_pos + offset + n_chars);
@@ -1575,7 +1574,7 @@ gkr_ask_entry_delete_surrounding_cb (GtkIMContext *slave, gint offset, gint n_ch
/* Used for im_commit_cb and inserting Unicode chars */
static void
-gkr_ask_entry_enter_text (GkrAskEntry *entry, const gchar *str)
+egg_secure_entry_enter_text (EggSecureEntry *entry, const gchar *str)
{
GtkEditable *editable = GTK_EDITABLE (entry);
gint tmp_pos;
@@ -1584,12 +1583,12 @@ gkr_ask_entry_enter_text (GkrAskEntry *entry, const gchar *str)
gtk_editable_delete_selection (editable);
else {
if (entry->overwrite_mode)
- gkr_ask_entry_delete_from_cursor (entry, GTK_DELETE_CHARS, 1);
+ egg_secure_entry_delete_from_cursor (entry, GTK_DELETE_CHARS, 1);
}
tmp_pos = entry->current_pos;
gtk_editable_insert_text (editable, str, strlen(str), &tmp_pos);
- gkr_ask_entry_set_position_internal (entry, tmp_pos, FALSE);
+ egg_secure_entry_set_position_internal (entry, tmp_pos, FALSE);
}
/*
@@ -1597,7 +1596,7 @@ gkr_ask_entry_enter_text (GkrAskEntry *entry, const gchar *str)
* should go through this function.
*/
static void
-gkr_ask_entry_set_positions (GkrAskEntry *entry, gint current_pos,
+egg_secure_entry_set_positions (EggSecureEntry *entry, gint current_pos,
gint selection_bound)
{
gboolean changed = FALSE;
@@ -1621,11 +1620,11 @@ gkr_ask_entry_set_positions (GkrAskEntry *entry, gint current_pos,
g_object_thaw_notify (G_OBJECT (entry));
if (changed)
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
}
static void
-gkr_ask_entry_reset_layout (GkrAskEntry *entry)
+egg_secure_entry_reset_layout (EggSecureEntry *entry)
{
if (entry->cached_layout) {
g_object_unref (entry->cached_layout);
@@ -1634,14 +1633,14 @@ gkr_ask_entry_reset_layout (GkrAskEntry *entry)
}
static void
-update_im_cursor_location (GkrAskEntry *entry)
+update_im_cursor_location (EggSecureEntry *entry)
{
GdkRectangle area;
gint strong_x;
gint strong_xoffset;
gint area_width, area_height;
- gkr_ask_entry_get_cursor_locations (entry, &strong_x, NULL);
+ egg_secure_entry_get_cursor_locations (entry, &strong_x, NULL);
get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
strong_xoffset = strong_x - entry->scroll_offset;
@@ -1661,17 +1660,17 @@ update_im_cursor_location (GkrAskEntry *entry)
static gboolean
recompute_idle_func (gpointer data)
{
- GkrAskEntry *entry;
+ EggSecureEntry *entry;
GDK_THREADS_ENTER ();
- entry = GKR_ASK_ENTRY (data);
+ entry = EGG_SECURE_ENTRY (data);
entry->recompute_idle = 0;
if (gtk_widget_has_screen (GTK_WIDGET (entry))) {
- gkr_ask_entry_adjust_scroll (entry);
- gkr_ask_entry_queue_draw (entry);
+ egg_secure_entry_adjust_scroll (entry);
+ egg_secure_entry_queue_draw (entry);
update_im_cursor_location (entry);
}
@@ -1682,10 +1681,10 @@ recompute_idle_func (gpointer data)
}
static void
-gkr_ask_entry_recompute (GkrAskEntry *entry)
+egg_secure_entry_recompute (EggSecureEntry *entry)
{
- gkr_ask_entry_reset_layout (entry);
- gkr_ask_entry_check_cursor_blink (entry);
+ egg_secure_entry_reset_layout (entry);
+ egg_secure_entry_check_cursor_blink (entry);
if (!entry->recompute_idle) {
entry->recompute_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 15, /* between resize and redraw */
@@ -1694,7 +1693,7 @@ gkr_ask_entry_recompute (GkrAskEntry *entry)
}
static gunichar
-build_string (GkrAskEntry *entry, GString *str, gint extra)
+build_string (EggSecureEntry *entry, GString *str, gint extra)
{
gint i, count, char_len;
gunichar invisible_char;
@@ -1722,7 +1721,7 @@ build_string (GkrAskEntry *entry, GString *str, gint extra)
}
static PangoLayout *
-gkr_ask_entry_create_layout (GkrAskEntry * entry, gboolean include_preedit)
+egg_secure_entry_create_layout (EggSecureEntry * entry, gboolean include_preedit)
{
GtkWidget *widget = GTK_WIDGET (entry);
PangoLayout *layout = gtk_widget_create_pango_layout (widget, NULL);
@@ -1810,13 +1809,13 @@ gkr_ask_entry_create_layout (GkrAskEntry * entry, gboolean include_preedit)
}
static PangoLayout *
-gkr_ask_entry_ensure_layout (GkrAskEntry *entry, gboolean include_preedit)
+egg_secure_entry_ensure_layout (EggSecureEntry *entry, gboolean include_preedit)
{
if (entry->preedit_length > 0 && !include_preedit != !entry->cache_includes_preedit)
- gkr_ask_entry_reset_layout (entry);
+ egg_secure_entry_reset_layout (entry);
if (!entry->cached_layout) {
- entry->cached_layout = gkr_ask_entry_create_layout (entry, include_preedit);
+ entry->cached_layout = egg_secure_entry_create_layout (entry, include_preedit);
entry->cache_includes_preedit = include_preedit;
}
@@ -1824,7 +1823,7 @@ gkr_ask_entry_ensure_layout (GkrAskEntry *entry, gboolean include_preedit)
}
static void
-get_layout_position (GkrAskEntry *entry, gint *x, gint *y)
+get_layout_position (EggSecureEntry *entry, gint *x, gint *y)
{
PangoLayout *layout;
PangoRectangle logical_rect;
@@ -1832,7 +1831,7 @@ get_layout_position (GkrAskEntry *entry, gint *x, gint *y)
gint y_pos;
PangoLayoutLine *line;
- layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+ layout = egg_secure_entry_ensure_layout (entry, TRUE);
get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
@@ -1863,7 +1862,7 @@ get_layout_position (GkrAskEntry *entry, gint *x, gint *y)
}
static void
-gkr_ask_entry_draw_text(GkrAskEntry *entry)
+egg_secure_entry_draw_text(EggSecureEntry *entry)
{
GtkWidget *widget;
PangoLayoutLine *line;
@@ -1872,7 +1871,7 @@ gkr_ask_entry_draw_text(GkrAskEntry *entry)
return;
if (GTK_WIDGET_DRAWABLE (entry)) {
- PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+ PangoLayout *layout = egg_secure_entry_ensure_layout (entry, TRUE);
gint x, y;
gint start_pos, end_pos;
@@ -1932,7 +1931,7 @@ gkr_ask_entry_draw_text(GkrAskEntry *entry)
}
static void
-draw_insertion_cursor (GkrAskEntry *entry, GdkRectangle *cursor_location,
+draw_insertion_cursor (EggSecureEntry *entry, GdkRectangle *cursor_location,
gboolean is_primary, PangoDirection direction, gboolean draw_arrow)
{
GtkWidget *widget = GTK_WIDGET (entry);
@@ -1948,7 +1947,7 @@ draw_insertion_cursor (GkrAskEntry *entry, GdkRectangle *cursor_location,
}
static void
-gkr_ask_entry_draw_cursor (GkrAskEntry * entry)
+egg_secure_entry_draw_cursor (EggSecureEntry * entry)
{
GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET(entry)));
PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
@@ -1968,7 +1967,7 @@ gkr_ask_entry_draw_cursor (GkrAskEntry * entry)
gdk_drawable_get_size (entry->text_area, NULL, &text_area_height);
- gkr_ask_entry_get_cursor_locations (entry, &strong_x, &weak_x);
+ egg_secure_entry_get_cursor_locations (entry, &strong_x, &weak_x);
g_object_get (gtk_widget_get_settings (widget), "gtk-split-cursor", &split_cursor, NULL);
@@ -2005,14 +2004,14 @@ gkr_ask_entry_draw_cursor (GkrAskEntry * entry)
}
static void
-gkr_ask_entry_queue_draw (GkrAskEntry *entry)
+egg_secure_entry_queue_draw (EggSecureEntry *entry)
{
if (GTK_WIDGET_REALIZED (entry))
gdk_window_invalidate_rect (entry->text_area, NULL, FALSE);
}
static void
-gkr_ask_entry_reset_im_context (GkrAskEntry *entry)
+egg_secure_entry_reset_im_context (EggSecureEntry *entry)
{
if (entry->need_im_reset) {
entry->need_im_reset = 0;
@@ -2021,7 +2020,7 @@ gkr_ask_entry_reset_im_context (GkrAskEntry *entry)
}
static gint
-gkr_ask_entry_find_position (GkrAskEntry *entry, gint x)
+egg_secure_entry_find_position (EggSecureEntry *entry, gint x)
{
PangoLayout *layout;
PangoLayoutLine *line;
@@ -2031,7 +2030,7 @@ gkr_ask_entry_find_position (GkrAskEntry *entry, gint x)
const gchar *text;
gint cursor_index;
- layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+ layout = egg_secure_entry_ensure_layout (entry, TRUE);
text = pango_layout_get_text (layout);
cursor_index = g_utf8_offset_to_pointer (text, entry->current_pos) - text;
@@ -2054,7 +2053,7 @@ gkr_ask_entry_find_position (GkrAskEntry *entry, gint x)
}
static void
-gkr_ask_entry_get_cursor_locations (GkrAskEntry *entry,
+egg_secure_entry_get_cursor_locations (EggSecureEntry *entry,
gint *strong_x, gint *weak_x)
{
if (!entry->invisible_char) {
@@ -2063,7 +2062,7 @@ gkr_ask_entry_get_cursor_locations (GkrAskEntry *entry,
if (weak_x)
*weak_x = 0;
} else {
- PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+ PangoLayout *layout = egg_secure_entry_ensure_layout (entry, TRUE);
const gchar *text = pango_layout_get_text (layout);
PangoRectangle strong_pos, weak_pos;
gint _index;
@@ -2082,7 +2081,7 @@ gkr_ask_entry_get_cursor_locations (GkrAskEntry *entry,
}
static void
-gkr_ask_entry_adjust_scroll (GkrAskEntry *entry)
+egg_secure_entry_adjust_scroll (EggSecureEntry *entry)
{
gint min_offset, max_offset;
gint text_area_width, text_width;
@@ -2098,7 +2097,7 @@ gkr_ask_entry_adjust_scroll (GkrAskEntry *entry)
gdk_drawable_get_size (entry->text_area, &text_area_width, NULL);
text_area_width -= 2 * INNER_BORDER;
- layout = gkr_ask_entry_ensure_layout (entry, TRUE);
+ layout = egg_secure_entry_ensure_layout (entry, TRUE);
line = pango_layout_get_lines (layout)->data;
pango_layout_line_get_extents (line, NULL, &logical_rect);
@@ -2132,7 +2131,7 @@ gkr_ask_entry_adjust_scroll (GkrAskEntry *entry)
* put the weak cursor on screen if possible.
*/
- gkr_ask_entry_get_cursor_locations (entry, &strong_x, &weak_x);
+ egg_secure_entry_get_cursor_locations (entry, &strong_x, &weak_x);
strong_xoffset = strong_x - entry->scroll_offset;
@@ -2157,11 +2156,11 @@ gkr_ask_entry_adjust_scroll (GkrAskEntry *entry)
}
static gint
-gkr_ask_entry_move_visually (GkrAskEntry * entry,
+egg_secure_entry_move_visually (EggSecureEntry * entry,
gint start, gint count)
{
gint _index;
- PangoLayout *layout = gkr_ask_entry_ensure_layout (entry, FALSE);
+ PangoLayout *layout = egg_secure_entry_ensure_layout (entry, FALSE);
const gchar *text;
text = pango_layout_get_text (layout);
@@ -2208,7 +2207,7 @@ gkr_ask_entry_move_visually (GkrAskEntry * entry,
}
static gint
-gkr_ask_entry_move_logically (GkrAskEntry *entry,
+egg_secure_entry_move_logically (EggSecureEntry *entry,
gint start, gint count)
{
gint new_pos = start;
@@ -2221,17 +2220,17 @@ gkr_ask_entry_move_logically (GkrAskEntry *entry,
/* Public API */
GtkWidget *
-gkr_ask_entry_new (void)
+egg_secure_entry_new (void)
{
- return g_object_new (GKR_TYPE_ASK_ENTRY, NULL);
+ return g_object_new (EGG_TYPE_SECURE_ENTRY, NULL);
}
void
-gkr_ask_entry_set_text (GkrAskEntry *entry, const gchar *text)
+egg_secure_entry_set_text (EggSecureEntry *entry, const gchar *text)
{
gint tmp_pos;
- g_return_if_fail (GKR_IS_ASK_ENTRY(entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY(entry));
g_return_if_fail (text != NULL);
/*
@@ -2248,47 +2247,47 @@ gkr_ask_entry_set_text (GkrAskEntry *entry, const gchar *text)
}
void
-gkr_ask_entry_reset_changed (GkrAskEntry *entry)
+egg_secure_entry_reset_changed (EggSecureEntry *entry)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
entry->changed = FALSE;
}
gboolean
-gkr_ask_entry_get_changed (GkrAskEntry *entry)
+egg_secure_entry_get_changed (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
return entry->changed;
}
void
-gkr_ask_entry_set_visibility (GkrAskEntry *entry, gboolean setting)
+egg_secure_entry_set_visibility (EggSecureEntry *entry, gboolean setting)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
if (setting == entry->visibility)
return;
entry->visibility = setting;
g_object_notify (G_OBJECT (entry), "visibility");
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
}
gboolean
-gkr_ask_entry_get_visibility (GkrAskEntry *entry)
+egg_secure_entry_get_visibility (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
return entry->visibility;
}
/**
- * gkr_ask_entry_set_invisible_char:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_invisible_char:
+ * @entry: a #EggSecureEntry
* @ch: a Unicode character
*
* Sets the character to use in place of the actual text when
- * gkr_ask_entry_set_visibility() has been called to set text
+ * egg_secure_entry_set_visibility() has been called to set text
* to %FALSE. i.e. this is the character used in "password mode" to
* show the user how many characters have been typed. The default
* invisible char is an asterisk ('*'). If you set the invisible char
@@ -2297,39 +2296,39 @@ gkr_ask_entry_get_visibility (GkrAskEntry *entry)
*
**/
void
-gkr_ask_entry_set_invisible_char (GkrAskEntry *entry, gunichar ch)
+egg_secure_entry_set_invisible_char (EggSecureEntry *entry, gunichar ch)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
if (ch == entry->invisible_char)
return;
entry->invisible_char = ch;
g_object_notify (G_OBJECT (entry), "invisible_char");
- gkr_ask_entry_recompute (entry);
+ egg_secure_entry_recompute (entry);
}
/**
- * gkr_ask_entry_get_invisible_char:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_invisible_char:
+ * @entry: a #EggSecureEntry
*
* Retrieves the character displayed in place of the real characters
- * for entries with visisbility set to false. See gkr_ask_entry_set_invisible_char().
+ * for entries with visisbility set to false. See egg_secure_entry_set_invisible_char().
*
* Return value: the current invisible char, or 0, if the entry does not
* show invisible text at all.
**/
gunichar
-gkr_ask_entry_get_invisible_char (GkrAskEntry * entry)
+egg_secure_entry_get_invisible_char (EggSecureEntry * entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), 0);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), 0);
return entry->invisible_char;
}
/**
- * gkr_ask_entry_get_text:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_text:
+ * @entry: a #EggSecureEntry
*
* Retrieves the contents of the entry widget.
* See also gtk_editable_get_chars().
@@ -2340,16 +2339,16 @@ gkr_ask_entry_get_invisible_char (GkrAskEntry * entry)
* stored.
**/
G_CONST_RETURN gchar*
-gkr_ask_entry_get_text (GkrAskEntry *entry)
+egg_secure_entry_get_text (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), NULL);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), NULL);
return entry->text;
}
/**
- * gkr_ask_entry_set_max_length:
- * @entry: a #GkrAskEntry.
+ * egg_secure_entry_set_max_length:
+ * @entry: a #EggSecureEntry.
* @max: the maximum length of the entry, or 0 for no maximum.
* (other than the maximum length of entries.) The value passed in will
* be clamped to the range 0-65536.
@@ -2359,9 +2358,9 @@ gkr_ask_entry_get_text (GkrAskEntry *entry)
* will be truncated to fit.
**/
void
-gkr_ask_entry_set_max_length(GkrAskEntry *entry, gint max)
+egg_secure_entry_set_max_length(EggSecureEntry *entry, gint max)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
max = CLAMP (max, 0, MAX_SIZE);
@@ -2373,25 +2372,25 @@ gkr_ask_entry_set_max_length(GkrAskEntry *entry, gint max)
}
/**
- * gkr_ask_entry_get_max_length:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_max_length:
+ * @entry: a #EggSecureEntry
*
* Retrieves the maximum allowed length of the text in
- * @entry. See gkr_ask_entry_set_max_length().
+ * @entry. See egg_secure_entry_set_max_length().
*
* Return value: the maximum allowed number of characters
- * in #GkrAskEntry, or 0 if there is no maximum.
+ * in #EggSecureEntry, or 0 if there is no maximum.
**/
gint
-gkr_ask_entry_get_max_length (GkrAskEntry *entry)
+egg_secure_entry_get_max_length (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), 0);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), 0);
return entry->text_max_length;
}
/**
- * gkr_ask_entry_set_activates_default:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_activates_default:
+ * @entry: a #EggSecureEntry
* @setting: %TRUE to activate window's default widget on Enter keypress
*
* If @setting is %TRUE, pressing Enter in the @entry will activate the default
@@ -2405,10 +2404,10 @@ gkr_ask_entry_get_max_length (GkrAskEntry *entry)
*
**/
void
-gkr_ask_entry_set_activates_default (GkrAskEntry *entry,
+egg_secure_entry_set_activates_default (EggSecureEntry *entry,
gboolean setting)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
setting = setting != FALSE;
if (setting != entry->activates_default) {
@@ -2418,23 +2417,23 @@ gkr_ask_entry_set_activates_default (GkrAskEntry *entry,
}
/**
- * gkr_ask_entry_get_activates_default:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_activates_default:
+ * @entry: a #EggSecureEntry
*
- * Retrieves the value set by gkr_ask_entry_set_activates_default().
+ * Retrieves the value set by egg_secure_entry_set_activates_default().
*
* Return value: %TRUE if the entry will activate the default widget
**/
gboolean
-gkr_ask_entry_get_activates_default (GkrAskEntry *entry)
+egg_secure_entry_get_activates_default (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
return entry->activates_default;
}
/**
- * gkr_ask_entry_set_width_chars:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_width_chars:
+ * @entry: a #EggSecureEntry
* @n_chars: width in chars
*
* Changes the size request of the entry to be about the right size
@@ -2445,9 +2444,9 @@ gkr_ask_entry_get_activates_default (GkrAskEntry *entry)
*
**/
void
-gkr_ask_entry_set_width_chars (GkrAskEntry *entry, gint n_chars)
+egg_secure_entry_set_width_chars (EggSecureEntry *entry, gint n_chars)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
if (entry->width_chars != n_chars) {
entry->width_chars = n_chars;
@@ -2457,31 +2456,31 @@ gkr_ask_entry_set_width_chars (GkrAskEntry *entry, gint n_chars)
}
/**
- * gkr_ask_entry_get_width_chars:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_width_chars:
+ * @entry: a #EggSecureEntry
*
- * Gets the value set by gkr_ask_entry_set_width_chars().
+ * Gets the value set by egg_secure_entry_set_width_chars().
*
* Return value: number of chars to request space for, or negative if unset
**/
gint
-gkr_ask_entry_get_width_chars (GkrAskEntry *entry)
+egg_secure_entry_get_width_chars (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), 0);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), 0);
return entry->width_chars;
}
/**
- * gkr_ask_entry_set_has_frame:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_set_has_frame:
+ * @entry: a #EggSecureEntry
* @setting: new value
*
* Sets whether the entry has a beveled frame around it.
**/
void
-gkr_ask_entry_set_has_frame (GkrAskEntry *entry, gboolean setting)
+egg_secure_entry_set_has_frame (EggSecureEntry *entry, gboolean setting)
{
- g_return_if_fail (GKR_IS_ASK_ENTRY (entry));
+ g_return_if_fail (EGG_IS_SECURE_ENTRY (entry));
setting = (setting != FALSE);
@@ -2494,22 +2493,22 @@ gkr_ask_entry_set_has_frame (GkrAskEntry *entry, gboolean setting)
}
/**
- * gkr_ask_entry_get_has_frame:
- * @entry: a #GkrAskEntry
+ * egg_secure_entry_get_has_frame:
+ * @entry: a #EggSecureEntry
*
- * Gets the value set by gkr_ask_entry_set_has_frame().
+ * Gets the value set by egg_secure_entry_set_has_frame().
*
* Return value: whether the entry has a beveled frame
**/
gboolean
-gkr_ask_entry_get_has_frame (GkrAskEntry *entry)
+egg_secure_entry_get_has_frame (EggSecureEntry *entry)
{
- g_return_val_if_fail (GKR_IS_ASK_ENTRY (entry), FALSE);
+ g_return_val_if_fail (EGG_IS_SECURE_ENTRY (entry), FALSE);
return entry->has_frame;
}
static gboolean
-gkr_ask_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling)
+egg_secure_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling)
{
gtk_widget_grab_focus (widget);
return TRUE;
@@ -2526,7 +2525,7 @@ gkr_ask_entry_mnemonic_activate (GtkWidget *widget, gboolean group_cycling)
#define CURSOR_PEND_MULTIPLIER 1.0
static gboolean
-cursor_blinks (GkrAskEntry *entry)
+cursor_blinks (EggSecureEntry *entry)
{
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
gboolean blink;
@@ -2540,7 +2539,7 @@ cursor_blinks (GkrAskEntry *entry)
}
static gint
-get_cursor_time (GkrAskEntry *entry)
+get_cursor_time (EggSecureEntry *entry)
{
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
gint time;
@@ -2551,7 +2550,7 @@ get_cursor_time (GkrAskEntry *entry)
}
static void
-show_cursor (GkrAskEntry *entry)
+show_cursor (EggSecureEntry *entry)
{
if (!entry->cursor_visible) {
entry->cursor_visible = TRUE;
@@ -2563,7 +2562,7 @@ show_cursor (GkrAskEntry *entry)
}
static void
-hide_cursor(GkrAskEntry * entry)
+hide_cursor(EggSecureEntry * entry)
{
if (entry->cursor_visible) {
entry->cursor_visible = FALSE;
@@ -2580,14 +2579,14 @@ hide_cursor(GkrAskEntry * entry)
static gint
blink_cb (gpointer data)
{
- GkrAskEntry *entry;
+ EggSecureEntry *entry;
GDK_THREADS_ENTER ();
- entry = GKR_ASK_ENTRY (data);
+ entry = EGG_SECURE_ENTRY (data);
if (!GTK_WIDGET_HAS_FOCUS (entry)) {
- g_warning ("GkrAskEntry - did not receive focus-out-event. If you\n"
+ g_warning ("EggSecureEntry - did not receive focus-out-event. If you\n"
"connect a handler to this signal, it must return\n"
"FALSE so the entry gets the event as well");
}
@@ -2612,7 +2611,7 @@ blink_cb (gpointer data)
}
static void
-gkr_ask_entry_check_cursor_blink (GkrAskEntry *entry)
+egg_secure_entry_check_cursor_blink (EggSecureEntry *entry)
{
if (cursor_blinks (entry)) {
if (!entry->blink_timeout) {
@@ -2632,7 +2631,7 @@ gkr_ask_entry_check_cursor_blink (GkrAskEntry *entry)
}
static void
-gkr_ask_entry_pend_cursor_blink (GkrAskEntry *entry)
+egg_secure_entry_pend_cursor_blink (EggSecureEntry *entry)
{
if (cursor_blinks (entry)) {
if (entry->blink_timeout != 0)
diff --git a/daemon/ui/gkr-ask-entry.h b/egg/egg-secure-entry.h
index 5091df8a..5e1f7cea 100644
--- a/daemon/ui/gkr-ask-entry.h
+++ b/egg/egg-secure-entry.h
@@ -41,8 +41,8 @@
* Modified for inclusion into gnome-keyring by Stef Walter
*/
-#ifndef __GKR_ASK_ENTRY_H__
-#define __GKR_ASK_ENTRY_H__
+#ifndef __EGG_SECURE_ENTRY_H__
+#define __EGG_SECURE_ENTRY_H__
#include <gtk/gtk.h>
@@ -51,17 +51,17 @@
extern "C" {
#endif
-#define GKR_TYPE_ASK_ENTRY (gkr_ask_entry_get_type ())
-#define GKR_ASK_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GKR_TYPE_ASK_ENTRY, GkrAskEntry))
-#define GKR_ASK_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GKR_TYPE_ASK_ENTRY, GkrAskEntryClass))
-#define GKR_IS_ASK_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GKR_TYPE_ASK_ENTRY))
-#define GKR_IS_ASK_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GKR_TYPE_ASK_ENTRY))
-#define GKR_ASK_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GKR_TYPE_ASK_ENTRY, GkrAskEntryClass))
+#define EGG_TYPE_SECURE_ENTRY (egg_secure_entry_get_type ())
+#define EGG_SECURE_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EGG_TYPE_SECURE_ENTRY, EggSecureEntry))
+#define EGG_SECURE_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EGG_TYPE_SECURE_ENTRY, EggSecureEntryClass))
+#define EGG_IS_SECURE_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EGG_TYPE_SECURE_ENTRY))
+#define EGG_IS_SECURE_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EGG_TYPE_SECURE_ENTRY))
+#define EGG_SECURE_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EGG_TYPE_SECURE_ENTRY, EggSecureEntryClass))
-typedef struct _GkrAskEntry GkrAskEntry;
-typedef struct _GkrAskEntryClass GkrAskEntryClass;
+typedef struct _EggSecureEntry EggSecureEntry;
+typedef struct _EggSecureEntryClass EggSecureEntryClass;
-struct _GkrAskEntry {
+struct _EggSecureEntry {
GtkWidget widget;
gchar *text;
@@ -124,15 +124,15 @@ struct _GkrAskEntry {
gboolean changed;
};
-struct _GkrAskEntryClass {
+struct _EggSecureEntryClass {
GtkWidgetClass parent_class;
/* Action signals */
- void (*activate) (GkrAskEntry *entry);
- void (*move_cursor) (GkrAskEntry *entry, GtkMovementStep step,
+ void (*activate) (EggSecureEntry *entry);
+ void (*move_cursor) (EggSecureEntry *entry, GtkMovementStep step,
gint count, gboolean extend_selection);
- void (*insert_at_cursor) (GkrAskEntry *entry, const gchar *str);
- void (*delete_from_cursor) (GkrAskEntry *entry, GtkDeleteType type, gint count);
+ void (*insert_at_cursor) (EggSecureEntry *entry, const gchar *str);
+ void (*delete_from_cursor) (EggSecureEntry *entry, GtkDeleteType type, gint count);
/* Padding for future expansion */
void (*_gtk_reserved1) (void);
@@ -141,47 +141,47 @@ struct _GkrAskEntryClass {
void (*_gtk_reserved4) (void);
};
-GType gkr_ask_entry_get_type (void) G_GNUC_CONST;
+GType egg_secure_entry_get_type (void) G_GNUC_CONST;
-GtkWidget* gkr_ask_entry_new (void);
+GtkWidget* egg_secure_entry_new (void);
-void gkr_ask_entry_reset_changed (GkrAskEntry *entry);
+void egg_secure_entry_reset_changed (EggSecureEntry *entry);
-gboolean gkr_ask_entry_get_changed (GkrAskEntry *entry);
+gboolean egg_secure_entry_get_changed (EggSecureEntry *entry);
-void gkr_ask_entry_set_visibility (GkrAskEntry *entry, gboolean setting);
+void egg_secure_entry_set_visibility (EggSecureEntry *entry, gboolean setting);
-gboolean gkr_ask_entry_get_visibility (GkrAskEntry *entry);
+gboolean egg_secure_entry_get_visibility (EggSecureEntry *entry);
-void gkr_ask_entry_set_invisible_char (GkrAskEntry *entry, gunichar ch);
+void egg_secure_entry_set_invisible_char (EggSecureEntry *entry, gunichar ch);
-gunichar gkr_ask_entry_get_invisible_char (GkrAskEntry *entry);
+gunichar egg_secure_entry_get_invisible_char (EggSecureEntry *entry);
-void gkr_ask_entry_set_has_frame (GkrAskEntry *entry, gboolean setting);
+void egg_secure_entry_set_has_frame (EggSecureEntry *entry, gboolean setting);
-gboolean gkr_ask_entry_get_has_frame (GkrAskEntry *entry);
+gboolean egg_secure_entry_get_has_frame (EggSecureEntry *entry);
/* text is truncated if needed */
-void gkr_ask_entry_set_max_length (GkrAskEntry *entry, gint max);
+void egg_secure_entry_set_max_length (EggSecureEntry *entry, gint max);
-gint gkr_ask_entry_get_max_length (GkrAskEntry *entry);
+gint egg_secure_entry_get_max_length (EggSecureEntry *entry);
-void gkr_ask_entry_set_activates_default (GkrAskEntry *entry, gboolean setting);
+void egg_secure_entry_set_activates_default (EggSecureEntry *entry, gboolean setting);
-gboolean gkr_ask_entry_get_activates_default (GkrAskEntry *entry);
+gboolean egg_secure_entry_get_activates_default (EggSecureEntry *entry);
-void gkr_ask_entry_set_width_chars (GkrAskEntry *entry, gint n_chars);
+void egg_secure_entry_set_width_chars (EggSecureEntry *entry, gint n_chars);
-gint gkr_ask_entry_get_width_chars (GkrAskEntry *entry);
+gint egg_secure_entry_get_width_chars (EggSecureEntry *entry);
/* Somewhat more convenient than the GtkEditable generic functions */
-void gkr_ask_entry_set_text (GkrAskEntry *entry, const gchar *text);
+void egg_secure_entry_set_text (EggSecureEntry *entry, const gchar *text);
/* returns a reference to the text */
-const gchar* gkr_ask_entry_get_text (GkrAskEntry *entry);
+const gchar* egg_secure_entry_get_text (EggSecureEntry *entry);
#ifdef __cplusplus
}
#endif
-#endif /*__GKR_ASK_ENTRY_H__ */
+#endif /*__EGG_SECURE_ENTRY_H__ */
diff --git a/gcr/Makefile.am b/gcr/Makefile.am
index bbc15b4e..c9de7506 100644
--- a/gcr/Makefile.am
+++ b/gcr/Makefile.am
@@ -1,12 +1,24 @@
-incdir = $(includedir)/gcr
+# ------------------------------------------------------------------
+# UI BUILDER
+#
-inc_HEADERS = \
- gcr-parser.h \
- gcr-types.h
+uidir = $(datadir)/gcr/ui/
+
+GLADE_FILES = \
+ gcr-import-dialog.glade
+
+.glade.ui:
+ gtk-builder-convert --skip-windows $< $@
+
+ui_DATA = $(GLADE_FILES:.glade=.ui)
+
+# ------------------------------------------------------------------
+# LIBRARY
INCLUDES = \
-I$(top_builddir) \
-I$(top_srcdir) \
+ $(GTK_CFLAGS) \
$(GOBJECT_CFLAGS) \
$(GLIB_CFLAGS)
@@ -16,10 +28,18 @@ BUILT_SOURCES = \
lib_LTLIBRARIES = libgcr.la
libgcr_la_SOURCES = \
- gcr-internal.c gcr-internal.h \
+ gcr-import-dialog.c gcr-import-dialog.h \
+ gcr-importer.c gcr-importer.h \
+ gcr-internal.h \
+ gcr-library.c \
gcr-parser.c gcr-parser.h \
gcr-types.h \
$(BUILT_SOURCES)
+
+libgcr_la_CFLAGS = \
+ -DPKCS11_MODULE_PATH=\""$(libdir)/gnome-keyring/gnome-keyring-pkcs11.so"\" \
+ -DGCR_API_SUBJECT_TO_CHANGE \
+ -DUIDIR=\""$(uidir)"\"
libgcr_la_LDFLAGS = \
-version-info $(GCR_LT_RELEASE) \
@@ -27,6 +47,7 @@ libgcr_la_LDFLAGS = \
libgcr_la_LIBADD = \
$(top_builddir)/egg/libegg.la \
+ $(top_builddir)/egg/libegg-secure-entry.la \
$(top_builddir)/gp11/libgp11.la \
$(GOBJECT_LIBS) \
$(GLIB_LIBS)
@@ -41,17 +62,25 @@ gcr-marshal.c: gcr-marshal.list $(GLIB_GENMARSHAL)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = gcr-$(GCR_MAJOR).pc
+gcr-$(GCR_MAJOR).pc: gcr.pc
+ cp gcr.pc gcr-$(GCR_MAJOR).pc
+
+# ----------------------------------------------------------------
+
EXTRA_DIST = \
gcr.pc.in \
gcr-marshal.list \
- gcr-import-dialog.glade
+ gcr-import-dialog.glade \
+ $(GLADE_FILES)
+CLEANFILES = \
+ $(BUILT_SOURCES) \
+ $(ui_DATA) \
+ $(pkgconfig_DATA)
+
DISTCLEANFILES = \
- gcr-$(GCR_MAJOR).pc
+ $(pkgconfig_DATA)
-gcr-$(GCR_MAJOR).pc: gcr.pc
- cp gcr.pc gcr-$(GCR_MAJOR).pc
-
if WITH_TESTS
TESTS_DIR = tests
else
@@ -60,4 +89,3 @@ endif
SUBDIRS = . \
$(TESTS_DIR)
-
diff --git a/gcr/gcr-import-dialog.c b/gcr/gcr-import-dialog.c
new file mode 100644
index 00000000..492205fc
--- /dev/null
+++ b/gcr/gcr-import-dialog.c
@@ -0,0 +1,452 @@
+/*
+ * gnome-keyring
+ *
+ * Copyright (C) 2008 Stefan Walter
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "gcr-import-dialog.h"
+#include "gcr-internal.h"
+
+#include "egg/egg-secure-entry.h"
+
+enum {
+ PROP_0,
+ PROP_SELECTED_SLOT,
+ PROP_PASSWORD,
+ PROP_PRIMARY_TEXT,
+ PROP_SECONDARY_TEXT
+};
+
+enum {
+ COLUMN_SLOT,
+ COLUMN_ICON,
+ COLUMN_LABEL,
+ N_COLUMNS
+};
+
+struct _GcrImportDialogPrivate {
+ GtkBuilder *builder;
+ EggSecureEntry *entry;
+ GtkComboBox *combo;
+ GtkListStore *slots;
+};
+
+G_DEFINE_TYPE (GcrImportDialog, _gcr_import_dialog, GTK_TYPE_DIALOG);
+
+/* -----------------------------------------------------------------------------
+ * INTERNAL
+ */
+
+static void
+populate_slots (GcrImportDialog *self)
+{
+ GList *modules, *m;
+ GList *slots, *s;
+ GtkTreeIter iter;
+ GP11TokenInfo *info;
+ gboolean added;
+
+ g_assert (GCR_IS_IMPORT_DIALOG (self));
+
+ if (self->pv->slots)
+ return;
+
+ self->pv->slots = gtk_list_store_new (N_COLUMNS, GP11_TYPE_SLOT, G_TYPE_STRING, G_TYPE_STRING);
+ gtk_combo_box_set_model (self->pv->combo, GTK_TREE_MODEL (self->pv->slots));
+
+ modules = _gcr_get_pkcs11_modules ();
+ g_return_if_fail (modules);
+
+ gtk_list_store_clear (self->pv->slots);
+
+ added = FALSE;
+ for (m = modules; m; m = g_list_next (m)) {
+
+ g_return_if_fail (GP11_IS_MODULE (m->data));
+ slots = gp11_module_get_slots (m->data, TRUE);
+
+ for (s = slots; s; s = g_list_next (s)) {
+ info = gp11_slot_get_token_info (s->data);
+ if (!(info->flags & CKF_WRITE_PROTECTED)) {
+ gtk_list_store_append (self->pv->slots, &iter);
+ gtk_list_store_set (self->pv->slots, &iter,
+ COLUMN_LABEL, info->label,
+ COLUMN_SLOT, s->data,
+ -1);
+ added = TRUE;
+ }
+ }
+
+ gp11_list_unref_free (slots);
+ }
+
+ if (added)
+ gtk_combo_box_set_active (self->pv->combo, 0);
+}
+
+/* -----------------------------------------------------------------------------
+ * OBJECT
+ */
+
+static void
+gcr_import_dialog_real_realize (GtkWidget *base)
+{
+ GcrImportDialog *self = GCR_IMPORT_DIALOG (base);
+ if (GTK_WIDGET_VISIBLE (self->pv->combo))
+ populate_slots (self);
+ GTK_WIDGET_CLASS (_gcr_import_dialog_parent_class)->realize (base);
+}
+
+static GObject*
+gcr_import_dialog_constructor (GType type, guint n_props, GObjectConstructParam *props)
+{
+ GcrImportDialog *self = GCR_IMPORT_DIALOG (G_OBJECT_CLASS (_gcr_import_dialog_parent_class)->constructor(type, n_props, props));
+ GtkCellRenderer *renderer;
+ GtkWidget *widget;
+
+ g_return_val_if_fail (self, NULL);
+
+ if (!gtk_builder_add_from_file (self->pv->builder, UIDIR "gcr-import-dialog.ui", NULL))
+ g_return_val_if_reached (NULL);
+
+ /* Fill in the dialog from builder */
+ widget = GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "import-dialog"));
+ g_return_val_if_fail (widget, FALSE);
+ gtk_container_add (GTK_CONTAINER (GTK_DIALOG (self)->vbox), widget);
+
+ /* Add a secure entry */
+ self->pv->entry = EGG_SECURE_ENTRY (egg_secure_entry_new ());
+ widget = GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-area"));
+ gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (self->pv->entry));
+ gtk_widget_show (GTK_WIDGET (self->pv->entry));
+
+ /* Initialize the combo box */
+ self->pv->combo = GTK_COMBO_BOX (gtk_builder_get_object (self->pv->builder, "slot-combo"));
+ renderer = gtk_cell_renderer_pixbuf_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->pv->combo), renderer, FALSE);
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->pv->combo), renderer, "icon-name", COLUMN_ICON);
+ g_object_set (renderer, "xpad", 3, NULL);
+ renderer = gtk_cell_renderer_text_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->pv->combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (self->pv->combo), renderer, "text", COLUMN_LABEL);
+
+ /* Add our various buttons */
+ gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
+ gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_OK, GTK_RESPONSE_OK);
+
+ return G_OBJECT (self);
+}
+
+static void
+_gcr_import_dialog_init (GcrImportDialog *self)
+{
+ self->pv = G_TYPE_INSTANCE_GET_PRIVATE (self, GCR_TYPE_IMPORT_DIALOG, GcrImportDialogPrivate);
+ self->pv->builder = gtk_builder_new ();
+}
+
+static void
+gcr_import_dialog_dispose (GObject *obj)
+{
+ G_OBJECT_CLASS (_gcr_import_dialog_parent_class)->dispose (obj);
+}
+
+static void
+gcr_import_dialog_finalize (GObject *obj)
+{
+ GcrImportDialog *self = GCR_IMPORT_DIALOG (obj);
+
+ g_object_unref (self->pv->slots);
+ self->pv->slots = NULL;
+
+ g_object_unref (self->pv->builder);
+ self->pv->builder = NULL;
+
+ G_OBJECT_CLASS (_gcr_import_dialog_parent_class)->finalize (obj);
+}
+
+static void
+gcr_import_dialog_set_property (GObject *obj, guint prop_id, const GValue *value,
+ GParamSpec *pspec)
+{
+ GcrImportDialog *self = GCR_IMPORT_DIALOG (obj);
+
+ switch (prop_id) {
+ case PROP_SELECTED_SLOT:
+ _gcr_import_dialog_set_selected_slot (self, g_value_get_object (value));
+ break;
+ case PROP_PASSWORD:
+ _gcr_import_dialog_set_password (self, g_value_get_pointer (value));
+ break;
+ case PROP_PRIMARY_TEXT:
+ _gcr_import_dialog_set_primary_text (self, g_value_get_string (value));
+ break;
+ case PROP_SECONDARY_TEXT:
+ _gcr_import_dialog_set_secondary_text (self, g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gcr_import_dialog_get_property (GObject *obj, guint prop_id, GValue *value,
+ GParamSpec *pspec)
+{
+ GcrImportDialog *self = GCR_IMPORT_DIALOG (obj);
+
+ switch (prop_id) {
+ case PROP_SELECTED_SLOT:
+ g_value_set_object (value, _gcr_import_dialog_get_selected_slot (self));
+ break;
+ case PROP_PASSWORD:
+ g_value_set_pointer (value, (gpointer)_gcr_import_dialog_get_password (self));
+ break;
+ case PROP_PRIMARY_TEXT:
+ g_value_set_string (value, _gcr_import_dialog_get_primary_text (self));
+ break;
+ case PROP_SECONDARY_TEXT:
+ g_value_set_string (value, _gcr_import_dialog_get_secondary_text (self));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+_gcr_import_dialog_class_init (GcrImportDialogClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ gobject_class->constructor = gcr_import_dialog_constructor;
+ gobject_class->dispose = gcr_import_dialog_dispose;
+ gobject_class->finalize = gcr_import_dialog_finalize;
+ gobject_class->set_property = gcr_import_dialog_set_property;
+ gobject_class->get_property = gcr_import_dialog_get_property;
+
+ widget_class->realize = gcr_import_dialog_real_realize;
+
+ g_type_class_add_private (gobject_class, sizeof (GcrImportDialogPrivate));
+
+ g_object_class_install_property (gobject_class, PROP_SELECTED_SLOT,
+ g_param_spec_object ("selected-slot", "Selected Slot", "Selected PKCS#11 slot",
+ GP11_TYPE_SLOT, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PASSWORD,
+ g_param_spec_pointer ("password", "Password", "Pointer to password",
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PRIMARY_TEXT,
+ g_param_spec_string ("primary-text", "Primary Text", "Primary dialog text",
+ NULL, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_SECONDARY_TEXT,
+ g_param_spec_string ("secondary-text", "Secondary Text", "Dialog secondary text",
+ NULL, G_PARAM_READWRITE));
+
+ _gcr_initialize ();
+}
+
+/* -----------------------------------------------------------------------------
+ * PUBLIC
+ */
+
+GcrImportDialog*
+_gcr_import_dialog_new (void)
+{
+ GcrImportDialog *dialog = g_object_new (GCR_TYPE_IMPORT_DIALOG, NULL);
+ return g_object_ref_sink (dialog);
+}
+
+gboolean
+_gcr_import_dialog_run (GcrImportDialog *self, GtkWindow *parent)
+{
+ gboolean ret;
+
+ g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), FALSE);
+
+ if (parent != NULL)
+ gtk_window_set_transient_for (GTK_WINDOW (self), parent);
+
+ ret = (gtk_dialog_run (GTK_DIALOG (self)) == GTK_RESPONSE_OK);
+
+ if (parent != NULL)
+ gtk_window_set_transient_for (GTK_WINDOW (self), NULL);
+
+ gtk_widget_hide (GTK_WIDGET (self));
+ return ret;
+}
+
+GP11Slot*
+_gcr_import_dialog_get_selected_slot (GcrImportDialog *self)
+{
+ GtkTreeIter iter;
+ GP11Slot *slot;
+
+ g_return_val_if_fail (GCR_IMPORT_DIALOG (self), NULL);
+
+ if (GTK_WIDGET_VISIBLE (self->pv->combo))
+ populate_slots (self);
+ else
+ return NULL;
+
+ if (!gtk_combo_box_get_active_iter (self->pv->combo, &iter))
+ return NULL;
+
+ gtk_tree_model_get (GTK_TREE_MODEL (self->pv->slots), &iter, COLUMN_SLOT, &slot, -1);
+
+ /* We hold the reference to this */
+ if (slot != NULL)
+ g_object_unref (slot);
+
+ return slot;
+}
+
+void
+_gcr_import_dialog_set_selected_slot (GcrImportDialog *self, GP11Slot *slot)
+{
+ GtkTreeIter iter;
+ GP11Slot *it_slot;
+ gboolean matched;
+
+ g_return_if_fail (GCR_IMPORT_DIALOG (self));
+
+ if (GTK_WIDGET_VISIBLE (self->pv->combo))
+ populate_slots (self);
+ else
+ g_return_if_reached ();
+
+ if (slot == NULL) {
+ gtk_combo_box_set_active (self->pv->combo, -1);
+ return;
+ }
+
+ g_return_if_fail (GP11_IS_SLOT (slot));
+
+ matched = FALSE;
+ if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->pv->slots), &iter)) {
+ do {
+ gtk_tree_model_get (GTK_TREE_MODEL (self->pv->slots), &iter, COLUMN_SLOT, &it_slot, -1);
+ if (gp11_slot_equal (it_slot, slot))
+ matched = TRUE;
+ g_object_unref (it_slot);
+ } while (!matched && gtk_tree_model_iter_next (GTK_TREE_MODEL (self->pv->slots), &iter));
+ }
+
+ if (matched) {
+ gtk_combo_box_set_active_iter (self->pv->combo, &iter);
+ } else {
+ gtk_combo_box_set_active (self->pv->combo, -1);
+ g_return_if_reached ();
+ }
+}
+
+void
+_gcr_import_dialog_show_selected_slot (GcrImportDialog *self)
+{
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+ gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-label")));
+ gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-area")));
+}
+
+void
+_gcr_import_dialog_hide_selected_slot (GcrImportDialog *self)
+{
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+ gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-label")));
+ gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "slot-area")));
+}
+
+const gchar*
+_gcr_import_dialog_get_password (GcrImportDialog *self)
+{
+ g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), NULL);
+ return egg_secure_entry_get_text (self->pv->entry);
+}
+
+void
+_gcr_import_dialog_set_password (GcrImportDialog *self, const gchar *password)
+{
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+ if (password == NULL)
+ password = "";
+ egg_secure_entry_set_text (self->pv->entry, password);
+}
+
+void
+_gcr_import_dialog_show_password (GcrImportDialog *self)
+{
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+ gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-label")));
+ gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-area")));
+}
+
+void
+_gcr_import_dialog_hide_password (GcrImportDialog *self)
+{
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+ gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-label")));
+ gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->pv->builder, "password-area")));
+}
+
+const gchar*
+_gcr_import_dialog_get_primary_text (GcrImportDialog *self)
+{
+ g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), NULL);
+ return gtk_label_get_text (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "primary-text")));
+}
+
+void
+_gcr_import_dialog_set_primary_text (GcrImportDialog *self, const gchar *text)
+{
+ gchar *label;
+
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+
+ if (text == NULL)
+ text = "";
+
+ label = g_markup_printf_escaped ("<span size='large' weight='bold'>%s</span>", text);
+ gtk_label_set_markup (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "primary-text")), label);
+ g_free (label);
+
+ g_object_notify (G_OBJECT (self), "primary-text");
+}
+
+const gchar*
+_gcr_import_dialog_get_secondary_text (GcrImportDialog *self)
+{
+ g_return_val_if_fail (GCR_IS_IMPORT_DIALOG (self), NULL);
+ return gtk_label_get_text (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "secondary-text")));
+}
+
+void
+_gcr_import_dialog_set_secondary_text (GcrImportDialog *self, const gchar *text)
+{
+ g_return_if_fail (GCR_IS_IMPORT_DIALOG (self));
+
+ if (text == NULL)
+ text = "";
+
+ gtk_label_set_markup (GTK_LABEL (gtk_builder_get_object (self->pv->builder, "secondary-text")), text);
+ g_object_notify (G_OBJECT (self), "primary-text");
+}
diff --git a/gcr/gcr-import-dialog.glade b/gcr/gcr-import-dialog.glade
index 7da00a14..e91c662c 100644
--- a/gcr/gcr-import-dialog.glade
+++ b/gcr/gcr-import-dialog.glade
@@ -1,164 +1,127 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE glade-interface SYSTEM "glade-2.0.dtd">
-<!--Generated with glade3 3.4.5 on Sat Jan 17 14:53:28 2009 -->
+<!--Generated with glade3 3.4.5 on Wed Jan 21 16:01:29 2009 -->
<glade-interface>
- <widget class="GtkDialog" id="dialog1">
- <property name="border_width">5</property>
- <property name="window_position">GTK_WIN_POS_CENTER_ON_PARENT</property>
- <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
- <property name="has_separator">False</property>
- <child internal-child="vbox">
- <widget class="GtkVBox" id="dialog-vbox1">
+ <widget class="GtkWindow" id="window1">
+ <child>
+ <widget class="GtkVBox" id="import-dialog">
<property name="visible">True</property>
- <property name="spacing">2</property>
+ <property name="border_width">6</property>
+ <property name="spacing">6</property>
<child>
- <widget class="GtkVBox" id="vbox1">
+ <widget class="GtkHBox" id="hbox2">
<property name="visible">True</property>
- <property name="spacing">6</property>
+ <property name="spacing">12</property>
<child>
- <widget class="GtkHBox" id="hbox2">
+ <widget class="GtkImage" id="image1">
<property name="visible">True</property>
- <property name="spacing">12</property>
- <child>
- <widget class="GtkImage" id="image1">
- <property name="visible">True</property>
- <property name="xalign">0</property>
- <property name="yalign">1</property>
- <property name="stock">gtk-dialog-authentication</property>
- <property name="icon_size">6</property>
- </widget>
- <packing>
- <property name="expand">False</property>
- <property name="fill">False</property>
- </packing>
- </child>
- <child>
- <widget class="GtkVBox" id="vbox2">
- <property name="visible">True</property>
- <property name="spacing">6</property>
- <child>
- <widget class="GtkLabel" id="primary-text">
- <property name="visible">True</property>
- <property name="xalign">0</property>
- <property name="label" translatable="yes">&lt;span size='large' weight='bold'&gt;Import Certificates and Keys&lt;/span&gt;</property>
- <property name="use_markup">True</property>
- </widget>
- </child>
- <child>
- <widget class="GtkLabel" id="secondary-text">
- <property name="visible">True</property>
- <property name="xalign">0</property>
- <property name="label" translatable="yes">Secondary prompt text</property>
- </widget>
- <packing>
- <property name="position">1</property>
- </packing>
- </child>
- </widget>
- <packing>
- <property name="position">1</property>
- </packing>
- </child>
+ <property name="xalign">0</property>
+ <property name="yalign">1</property>
+ <property name="stock">gtk-dialog-authentication</property>
+ <property name="icon_size">6</property>
</widget>
<packing>
<property name="expand">False</property>
+ <property name="fill">False</property>
</packing>
</child>
<child>
- <widget class="GtkTable" id="table1">
+ <widget class="GtkVBox" id="vbox2">
<property name="visible">True</property>
- <property name="n_rows">2</property>
- <property name="n_columns">2</property>
- <property name="column_spacing">12</property>
- <property name="row_spacing">6</property>
+ <property name="spacing">6</property>
<child>
- <widget class="GtkEntry" id="password-entry">
- <property name="visible">True</property>
- <property name="can_focus">True</property>
- </widget>
- <packing>
- <property name="left_attach">1</property>
- <property name="right_attach">2</property>
- <property name="top_attach">1</property>
- <property name="bottom_attach">2</property>
- </packing>
- </child>
- <child>
- <widget class="GtkComboBox" id="location-combo">
- <property name="visible">True</property>
- <property name="button_sensitivity">GTK_SENSITIVITY_ON</property>
- </widget>
- <packing>
- <property name="left_attach">1</property>
- <property name="right_attach">2</property>
- </packing>
- </child>
- <child>
- <widget class="GtkLabel" id="label5">
+ <widget class="GtkLabel" id="primary-text">
<property name="visible">True</property>
<property name="xalign">0</property>
- <property name="label" translatable="yes">Password:</property>
+ <property name="label" translatable="yes">&lt;span size='large' weight='bold'&gt;Import Certificates and Keys&lt;/span&gt;</property>
+ <property name="use_markup">True</property>
+ <property name="wrap">True</property>
</widget>
- <packing>
- <property name="top_attach">1</property>
- <property name="bottom_attach">2</property>
- <property name="x_options">GTK_FILL</property>
- <property name="y_options">GTK_FILL</property>
- </packing>
</child>
<child>
- <widget class="GtkLabel" id="label4">
+ <widget class="GtkLabel" id="secondary-text">
<property name="visible">True</property>
<property name="xalign">0</property>
- <property name="label" translatable="yes">Import Into:</property>
+ <property name="wrap">True</property>
</widget>
<packing>
- <property name="x_options">GTK_FILL</property>
- <property name="y_options">GTK_FILL</property>
+ <property name="position">1</property>
</packing>
</child>
</widget>
<packing>
- <property name="expand">False</property>
<property name="position">1</property>
</packing>
</child>
</widget>
<packing>
- <property name="position">1</property>
+ <property name="expand">False</property>
</packing>
</child>
- <child internal-child="action_area">
- <widget class="GtkHButtonBox" id="dialog-action_area1">
+ <child>
+ <widget class="GtkTable" id="table1">
<property name="visible">True</property>
- <property name="layout_style">GTK_BUTTONBOX_END</property>
+ <property name="n_rows">2</property>
+ <property name="n_columns">2</property>
+ <property name="column_spacing">12</property>
+ <property name="row_spacing">6</property>
+ <child>
+ <widget class="GtkAlignment" id="password-area">
+ <property name="visible">True</property>
+ <child>
+ <placeholder/>
+ </child>
+ </widget>
+ <packing>
+ <property name="left_attach">1</property>
+ <property name="right_attach">2</property>
+ <property name="top_attach">1</property>
+ <property name="bottom_attach">2</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="GtkAlignment" id="slot-area">
+ <property name="visible">True</property>
+ <child>
+ <widget class="GtkComboBox" id="slot-combo">
+ <property name="visible">True</property>
+ <property name="button_sensitivity">GTK_SENSITIVITY_ON</property>
+ </widget>
+ </child>
+ </widget>
+ <packing>
+ <property name="left_attach">1</property>
+ <property name="right_attach">2</property>
+ </packing>
+ </child>
<child>
- <widget class="GtkButton" id="button1">
+ <widget class="GtkLabel" id="password-label">
<property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="receives_default">True</property>
- <property name="label" translatable="yes">gtk-cancel</property>
- <property name="use_stock">True</property>
- <property name="response_id">0</property>
+ <property name="xalign">0</property>
+ <property name="label" translatable="yes">Password:</property>
</widget>
+ <packing>
+ <property name="top_attach">1</property>
+ <property name="bottom_attach">2</property>
+ <property name="x_options">GTK_FILL</property>
+ <property name="y_options">GTK_FILL</property>
+ </packing>
</child>
<child>
- <widget class="GtkButton" id="button2">
+ <widget class="GtkLabel" id="slot-label">
<property name="visible">True</property>
- <property name="can_focus">True</property>
- <property name="receives_default">True</property>
- <property name="label" translatable="yes">gtk-ok</property>
- <property name="use_stock">True</property>
- <property name="response_id">0</property>
+ <property name="xalign">0</property>
+ <property name="label" translatable="yes">Import Into:</property>
</widget>
<packing>
- <property name="position">1</property>
+ <property name="x_options">GTK_FILL</property>
+ <property name="y_options">GTK_FILL</property>
</packing>
</child>
</widget>
<packing>
<property name="expand">False</property>
- <property name="pack_type">GTK_PACK_END</property>
+ <property name="position">1</property>
</packing>
</child>
</widget>
diff --git a/gcr/gcr-import-dialog.h b/gcr/gcr-import-dialog.h
new file mode 100644
index 00000000..b2a665bb
--- /dev/null
+++ b/gcr/gcr-import-dialog.h
@@ -0,0 +1,86 @@
+/*
+ * gnome-keyring
+ *
+ * Copyright (C) 2008 Stefan Walter
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef __GCR_IMPORT_DIALOG_H__
+#define __GCR_IMPORT_DIALOG_H__
+
+#include "gcr.h"
+
+#include "gp11/gp11.h"
+
+#include <gtk/gtk.h>
+
+#define GCR_TYPE_IMPORT_DIALOG (_gcr_import_dialog_get_type ())
+#define GCR_IMPORT_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCR_TYPE_IMPORT_DIALOG, GcrImportDialog))
+#define GCR_IMPORT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GCR_TYPE_IMPORT_DIALOG, GcrImportDialogClass))
+#define GCR_IS_IMPORT_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GCR_TYPE_IMPORT_DIALOG))
+#define GCR_IS_IMPORT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GCR_TYPE_IMPORT_DIALOG))
+#define GCR_IMPORT_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GCR_TYPE_IMPORT_DIALOG, GcrImportDialogClass))
+
+typedef struct _GcrImportDialog GcrImportDialog;
+typedef struct _GcrImportDialogClass GcrImportDialogClass;
+typedef struct _GcrImportDialogPrivate GcrImportDialogPrivate;
+
+struct _GcrImportDialog {
+ GtkDialog parent;
+ GcrImportDialogPrivate *pv;
+};
+
+struct _GcrImportDialogClass {
+ GtkDialogClass parent_class;
+};
+
+GType _gcr_import_dialog_get_type (void);
+
+GcrImportDialog* _gcr_import_dialog_new (void);
+
+gboolean _gcr_import_dialog_run (GcrImportDialog *self,
+ GtkWindow *parent);
+
+GP11Slot* _gcr_import_dialog_get_selected_slot (GcrImportDialog *self);
+
+void _gcr_import_dialog_set_selected_slot (GcrImportDialog *self,
+ GP11Slot *slot);
+
+void _gcr_import_dialog_show_selected_slot (GcrImportDialog *self);
+
+void _gcr_import_dialog_hide_selected_slot (GcrImportDialog *self);
+
+const gchar* _gcr_import_dialog_get_password (GcrImportDialog *self);
+
+void _gcr_import_dialog_set_password (GcrImportDialog *self,
+ const gchar *password);
+
+void _gcr_import_dialog_show_password (GcrImportDialog *self);
+
+void _gcr_import_dialog_hide_password (GcrImportDialog *self);
+
+const gchar* _gcr_import_dialog_get_primary_text (GcrImportDialog *self);
+
+void _gcr_import_dialog_set_primary_text (GcrImportDialog *self,
+ const gchar *text);
+
+const gchar* _gcr_import_dialog_get_secondary_text (GcrImportDialog *self);
+
+void _gcr_import_dialog_set_secondary_text (GcrImportDialog *self,
+ const gchar *text);
+
+#endif /* __GCR_IMPORT_DIALOG_H__ */
diff --git a/gcr/gcr-importer.c b/gcr/gcr-importer.c
index 1ba00d6a..529b7cdb 100644
--- a/gcr/gcr-importer.c
+++ b/gcr/gcr-importer.c
@@ -21,38 +21,545 @@
#include "config.h"
+#include "gcr-import-dialog.h"
#include "gcr-importer.h"
+#include "gcr-internal.h"
+#include "gcr-parser.h"
+
+#include <glib/gi18n-lib.h>
enum {
PROP_0,
- PROP_IMPORTER
+ PROP_SLOT,
+ PROP_PARSER,
+ PROP_PROMPT_BEHAVIOR
};
enum {
- SIGNAL,
+ IMPORTED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE (GcrImporter, gcr_importer, G_TYPE_OBJECT);
+struct _GcrImporterPrivate {
+ GP11Slot *slot;
+ GcrParser *parser;
+ GcrImporterPromptBehavior behavior;
+
+ /* Information about last import */
+ GError *error;
+ gboolean succeeded;
+
+ /* State data during import */
+ gboolean processing;
+ GCancellable *cancel;
+ GInputStream *input;
+ gboolean prompted;
+ gboolean async;
+ GByteArray *buffer;
+ GP11Session *session;
+ GQueue queue;
+
+ /* Extra async stuff */
+ GAsyncReadyCallback callback;
+ gpointer user_data;
+};
+
+/* State forward declarations */
+static void state_cancelled (GcrImporter *self, gboolean async);
+static void state_complete (GcrImporter *self, gboolean async);
+static void state_create_object (GcrImporter *self, gboolean async);
+static void state_open_session (GcrImporter *self, gboolean async);
+static void state_parse_buffer (GcrImporter *self, gboolean async);
+static void state_read_buffer (GcrImporter *self, gboolean async);
+
+static void gcr_importer_async_result (GAsyncResultIface *iface);
+G_DEFINE_TYPE_WITH_CODE (GcrImporter, gcr_importer, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_RESULT, gcr_importer_async_result));
+
+#define BLOCK 4096
/* -----------------------------------------------------------------------------
* INTERNAL
*/
+static void
+cleanup_state_data (GcrImporter *self)
+{
+ GP11Attributes *attrs;
+
+ if (self->pv->buffer)
+ g_byte_array_free (self->pv->buffer, TRUE);
+ self->pv->buffer = NULL;
+
+ if (self->pv->session)
+ g_object_unref (self->pv->session);
+ self->pv->session = NULL;
+
+ while ((attrs = g_queue_pop_head (&self->pv->queue)) != NULL)
+ gp11_attributes_unref (attrs);
+ g_assert (g_queue_is_empty (&self->pv->queue));
+
+ if (self->pv->input)
+ g_object_unref (self->pv->input);
+ self->pv->input = NULL;
+
+ if (self->pv->cancel)
+ g_object_unref (self->pv->cancel);
+ self->pv->cancel = NULL;
+}
+
+static void
+cleanup_import_data (GcrImporter *self)
+{
+ if (self->pv->error)
+ g_clear_error (&self->pv->error);
+ self->pv->succeeded = TRUE;
+}
+
+static void
+next_state (GcrImporter *self, void (*state) (GcrImporter*, gboolean))
+{
+ g_assert (GCR_IS_IMPORTER (self));
+ g_assert (self->pv->processing);
+ g_assert (state);
+
+ if (self->pv->cancel && g_cancellable_is_cancelled (self->pv->cancel))
+ state = state_cancelled;
+
+ (state) (self, self->pv->async);
+}
+
+/* ---------------------------------------------------------------------------------
+ * COMPLETE
+ */
+
+static void
+state_complete (GcrImporter *self, gboolean async)
+{
+ if (async && self->pv->callback != NULL)
+ (self->pv->callback) (G_OBJECT (self), G_ASYNC_RESULT (self), self->pv->user_data);
+
+ cleanup_state_data (self);
+ self->pv->processing = FALSE;
+}
+
+static void
+state_failure (GcrImporter *self, gboolean async)
+{
+ self->pv->succeeded = FALSE;
+ next_state (self, state_complete);
+}
+
+static void
+state_cancelled (GcrImporter *self, gboolean async)
+{
+ if (self->pv->cancel && g_cancellable_is_cancelled (self->pv->cancel))
+ g_cancellable_cancel (self->pv->cancel);
+ if (self->pv->error)
+ g_error_free (self->pv->error);
+ self->pv->error = g_error_new_literal (GCR_DATA_ERROR, GCR_ERROR_CANCELLED, _("The operation was cancelled"));
+ next_state (self, state_failure);
+}
+
+/* ---------------------------------------------------------------------------------
+ * CREATE OBJECTS
+ */
+
+static void
+complete_create_object (GcrImporter *self, GP11Object *object, GError *error)
+{
+ if (object == NULL) {
+ g_propagate_error (&self->pv->error, error);
+ next_state (self, state_failure);
+
+ } else {
+ g_signal_emit (self, signals[IMPORTED], 0, object);
+ g_object_unref (object);
+ next_state (self, state_create_object);
+ }
+}
+
+static void
+on_create_object (GObject *obj, GAsyncResult *res, gpointer user_data)
+{
+ GError *error = NULL;
+ GP11Object *object = gp11_session_create_object_finish (GP11_SESSION (obj), res, &error);
+ complete_create_object (GCR_IMPORTER (user_data), object, error);
+}
+
+static void
+state_create_object (GcrImporter *self, gboolean async)
+{
+ GP11Attributes *attrs;
+ GP11Object *object;
+ GError *error = NULL;
+
+ /* No more objects */
+ if (g_queue_is_empty (&self->pv->queue)) {
+ next_state (self, state_complete);
+
+ } else {
+
+ /* Pop first one off the list */
+ attrs = g_queue_pop_head (&self->pv->queue);
+ g_assert (attrs);
+
+ gp11_attributes_add_ulong (attrs, CKA_TOKEN, CK_TRUE);
+
+ if (async) {
+ gp11_session_create_object_async (self->pv->session, attrs, self->pv->cancel,
+ on_create_object, self);
+ } else {
+ object = gp11_session_create_object_full (self->pv->session, attrs, self->pv->cancel, &error);
+ complete_create_object (self, object, error);
+ }
+
+ gp11_attributes_unref (attrs);
+ }
+}
+
+/* ---------------------------------------------------------------------------------
+ * OPEN SESSION
+ */
+
+static void
+complete_open_session (GcrImporter *self, GP11Session *session, GError *error)
+{
+ if (!session) {
+ g_propagate_error (&self->pv->error, error);
+ next_state (self, state_failure);
+ } else {
+ self->pv->session = session;
+ next_state (self, state_create_object);
+ }
+}
+
+static void
+on_open_session (GObject *obj, GAsyncResult *res, gpointer user_data)
+{
+ GError *error = NULL;
+ GP11Session *session = gp11_slot_open_session_finish (GP11_SLOT (obj), res, &error);
+ complete_open_session (GCR_IMPORTER (user_data), session, error);
+}
+
+static void
+state_open_session (GcrImporter *self, gboolean async)
+{
+ GP11Session *session;
+ GError *error = NULL;
+
+ if (!self->pv->slot) {
+ g_set_error (&self->pv->error, GCR_DATA_ERROR, GCR_ERROR_FAILURE, _("No location available to import to"));
+ next_state (self, state_failure);
+
+ } else {
+
+ if (async) {
+ gp11_slot_open_session_async (self->pv->slot, CKF_RW_SESSION,
+ self->pv->cancel, on_open_session, self);
+ } else {
+ session = gp11_slot_open_session_full (self->pv->slot, CKF_RW_SESSION,
+ self->pv->cancel, &error);
+ complete_open_session (self, session, error);
+ }
+ }
+}
+
+/* ---------------------------------------------------------------------------------
+ * IMPORT PROMPT
+ */
+
+static void
+complete_import_prompt (GcrImporter *self, GcrImportDialog *dialog, gint response)
+{
+ GP11Slot *slot;
+
+ gtk_widget_hide (GTK_WIDGET (dialog));
+ self->pv->prompted = TRUE;
+
+ /* No dialog or dialog completed */
+ if (response == GTK_RESPONSE_OK) {
+
+ slot = _gcr_import_dialog_get_selected_slot (dialog);
+ gcr_importer_set_slot (self, slot);
+ next_state (self, state_open_session);
+
+ /* The dialog was cancelled or closed */
+ } else {
+ next_state (self, state_cancelled);
+ }
+}
+
+static void
+on_prompt_response (GtkDialog *dialog, gint response, gpointer user_data)
+{
+ complete_import_prompt (GCR_IMPORTER (user_data), GCR_IMPORT_DIALOG (dialog), response);
+ g_object_unref (dialog);
+}
+
+static void
+state_import_prompt (GcrImporter *self, gboolean async)
+{
+ GcrImportDialog *dialog;
+ gboolean prompt;
+ gint response;
+
+ g_assert (GCR_IS_IMPORTER (self));
+
+ /* No need to prompt */
+ if (self->pv->prompted == TRUE)
+ prompt = FALSE;
+ else if (self->pv->behavior == GCR_IMPORTER_PROMPT_ALWAYS)
+ prompt = TRUE;
+ else if (self->pv->behavior == GCR_IMPORTER_PROMPT_NEVER)
+ prompt = FALSE;
+ else
+ prompt = self->pv->slot ? FALSE : TRUE;
+
+ if (prompt == FALSE) {
+ next_state (self, state_open_session);
+
+ } else {
+
+ dialog = _gcr_import_dialog_new ();
+
+ _gcr_import_dialog_set_primary_text (dialog, _("Import Certificates/Keys"));
+ _gcr_import_dialog_hide_password (dialog);
+
+ if (self->pv->slot) {
+ _gcr_import_dialog_set_selected_slot (dialog, self->pv->slot);
+ _gcr_import_dialog_hide_selected_slot (dialog);
+ } else {
+ _gcr_import_dialog_set_secondary_text (dialog, _("Choose a location to store the imported certificates/keys."));
+ }
+
+ /* Prompt without blocking main loop */
+ if (async) {
+ g_signal_connect (dialog, "response", G_CALLBACK (on_prompt_response), self);
+ gtk_widget_show (GTK_WIDGET (dialog));
+
+ /* Block mainloop */
+ } else {
+ response = gtk_dialog_run (GTK_DIALOG (dialog));
+ complete_import_prompt (self, dialog, response);
+ g_object_unref (dialog);
+ }
+ }
+}
+
+/* ---------------------------------------------------------------------------------
+ * PARSING
+ */
+
+static const gchar*
+prepare_auth_primary (CK_OBJECT_CLASS klass)
+{
+ if (klass == CKO_PRIVATE_KEY)
+ return _("Enter password to unlock the private key");
+ else if (klass == CKO_CERTIFICATE)
+ return _("Enter password to unlock the certificate");
+ else
+ return _("Enter password to unlock");
+}
+
+static gchar*
+prepare_auth_secondary (CK_OBJECT_CLASS klass, const gchar *label)
+{
+ if (label == NULL) {
+ if (klass == CKO_PRIVATE_KEY)
+ return g_strdup (_("In order to import the private key, it must be unlocked"));
+ else if (klass == CKO_CERTIFICATE)
+ return g_strdup (_("In order to import the certificate, it must be unlocked"));
+ else
+ return g_strdup (_("In order to import the data, it must be unlocked"));
+ } else {
+ if (klass == CKO_PRIVATE_KEY)
+ return g_strdup_printf (_("In order to import the private key '%s', it must be unlocked"), label);
+ else if (klass == CKO_CERTIFICATE)
+ return g_strdup_printf (_("In order to import the certificate '%s', it must be unlocked"), label);
+ else
+ return g_strdup_printf (_("In order to import '%s', it must be unlocked"), label);
+ }
+}
+
+static void
+on_parser_parsed (GcrParser *parser, GcrImporter *self)
+{
+ GP11Attributes *attrs;
+
+ g_return_if_fail (GCR_IS_PARSER (parser));
+ g_return_if_fail (GCR_IS_IMPORTER (self));
+
+ attrs = gcr_parser_get_parsed_attributes (parser);
+ g_return_if_fail (attrs);
+ g_queue_push_tail (&self->pv->queue, gp11_attributes_ref (attrs));
+}
+
+static gboolean
+on_parser_authenticate (GcrParser *parser, gint count, GcrImporter *self)
+{
+ GcrImportDialog *dialog;
+ GP11Attributes *attrs;
+ const gchar *password;
+ gchar *text, *label;
+ GP11Slot *slot;
+ gulong klass;
+
+ dialog = _gcr_import_dialog_new ();
+
+ if (self->pv->slot)
+ _gcr_import_dialog_set_selected_slot (dialog, self->pv->slot);
+
+ /* Figure out the text for the dialog */
+ attrs = gcr_parser_get_parsed_attributes (parser);
+ g_return_val_if_fail (attrs, FALSE);
+
+ if (!gp11_attributes_find_ulong (attrs, CKA_CLASS, &klass))
+ klass = (gulong)-1;
+ if (!gp11_attributes_find_string (attrs, CKA_LABEL, &label))
+ label = NULL;
+
+ text = prepare_auth_secondary (klass, label);
+ _gcr_import_dialog_set_primary_text (dialog, prepare_auth_primary (klass));
+ _gcr_import_dialog_set_secondary_text (dialog, text);
+ g_free (label);
+ g_free (text);
+
+ if (!_gcr_import_dialog_run (dialog, NULL))
+ return FALSE;
+
+ slot = _gcr_import_dialog_get_selected_slot (dialog);
+ gcr_importer_set_slot (self, slot);
+
+ password = _gcr_import_dialog_get_password (dialog);
+ gcr_parser_add_password (parser, password);
+
+ g_object_unref (dialog);
+ self->pv->prompted = TRUE;
+ return TRUE;
+}
+
+static void
+state_parse_buffer (GcrImporter *self, gboolean async)
+{
+ GError *error = NULL;
+ GcrParser *parser;
+ gulong parsed_conn;
+ gulong auth_conn;
+ gboolean ret;
+
+ g_assert (GCR_IS_IMPORTER (self));
+ g_assert (self->pv->buffer);
+
+ parser = gcr_importer_get_parser (self);
+ g_object_ref (parser);
+
+ /* Listen in to the parser */
+ parsed_conn = g_signal_connect (parser, "parsed", G_CALLBACK (on_parser_parsed), self);
+ auth_conn = g_signal_connect (parser, "authenticate", G_CALLBACK (on_parser_authenticate), self);
+
+ ret = gcr_parser_parse_data (parser, self->pv->buffer->data, self->pv->buffer->len, &error);
+
+ /* An optimization to free data early as possible */
+ g_byte_array_free (self->pv->buffer, TRUE);
+ self->pv->buffer = NULL;
+
+ g_signal_handler_disconnect (parser, parsed_conn);
+ g_signal_handler_disconnect (parser, auth_conn);
+ g_object_unref (parser);
+
+ if (ret == TRUE) {
+ next_state (self, state_import_prompt);
+ } else {
+ g_propagate_error (&self->pv->error, error);
+ next_state (self, state_failure);
+ }
+}
+
+/* ---------------------------------------------------------------------------------
+ * BUFFER READING
+ */
+
+static void
+complete_read_buffer (GcrImporter *self, gssize count, GError *error)
+{
+ g_assert (GCR_IS_IMPORTER (self));
+ g_assert (self->pv->buffer);
+
+ /* A failure */
+ if (count == -1) {
+ g_propagate_error (&self->pv->error, error);
+ next_state (self, state_failure);
+ } else {
+
+ g_return_if_fail (count >= 0 && count <= BLOCK);
+ g_byte_array_set_size (self->pv->buffer, self->pv->buffer->len - (BLOCK - count));
+
+ /* Finished reading */
+ if (count == 0) {
+
+ /* Optimization, unref input early */
+ g_object_unref (self->pv->input);
+ self->pv->input = NULL;
+
+ next_state (self, state_parse_buffer);
+
+ /* Read the next block */
+ } else {
+ next_state (self, state_read_buffer);
+ }
+ }
+
+}
+
+static void
+on_read_buffer (GObject *obj, GAsyncResult *res, gpointer user_data)
+{
+ GError *error = NULL;
+ gssize count;
+
+ count = g_input_stream_read_finish (G_INPUT_STREAM (obj), res, &error);
+ complete_read_buffer (user_data, count, error);
+}
+
+static void
+state_read_buffer (GcrImporter *self, gboolean async)
+{
+ GError *error = NULL;
+ gssize count;
+ gsize at;
+
+ g_assert (GCR_IS_IMPORTER (self));
+ g_assert (G_IS_INPUT_STREAM (self->pv->input));
+
+ if (!self->pv->buffer)
+ self->pv->buffer = g_byte_array_sized_new (BLOCK);
+
+ at = self->pv->buffer->len;
+ g_byte_array_set_size (self->pv->buffer, at + BLOCK);
+
+ if (async) {
+ g_input_stream_read_async (self->pv->input, self->pv->buffer->data + at,
+ BLOCK, G_PRIORITY_DEFAULT, self->pv->cancel,
+ on_read_buffer, self);
+ } else {
+ count = g_input_stream_read (self->pv->input, self->pv->buffer->data + at,
+ BLOCK, self->pv->cancel, &error);
+ complete_read_buffer (self, count, error);
+ }
+}
+
/* -----------------------------------------------------------------------------
* OBJECT
*/
-
static GObject*
gcr_importer_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GcrImporter *self = GCR_IMPORTER (G_OBJECT_CLASS (gcr_importer_parent_class)->constructor(type, n_props, props));
g_return_val_if_fail (self, NULL);
-
-
return G_OBJECT (self);
}
@@ -60,14 +567,27 @@ gcr_importer_constructor (GType type, guint n_props, GObjectConstructParam *prop
static void
gcr_importer_init (GcrImporter *self)
{
-
+ self->pv = G_TYPE_INSTANCE_GET_PRIVATE (self, GCR_TYPE_IMPORTER, GcrImporterPrivate);
+ self->pv->behavior = GCR_IMPORTER_PROMPT_NEEDED;
+ g_queue_init (&self->pv->queue);
}
static void
gcr_importer_dispose (GObject *obj)
{
GcrImporter *self = GCR_IMPORTER (obj);
-
+
+ cleanup_state_data (self);
+ cleanup_import_data (self);
+
+ if (self->pv->parser)
+ g_object_unref (self->pv->parser);
+ self->pv->parser = NULL;
+
+ if (self->pv->slot)
+ g_object_unref (self->pv->slot);
+ self->pv->slot = NULL;
+
G_OBJECT_CLASS (gcr_importer_parent_class)->dispose (obj);
}
@@ -75,7 +595,10 @@ static void
gcr_importer_finalize (GObject *obj)
{
GcrImporter *self = GCR_IMPORTER (obj);
-
+
+ g_assert (!self->pv->parser);
+ g_assert (!self->pv->slot);
+
G_OBJECT_CLASS (gcr_importer_parent_class)->finalize (obj);
}
@@ -86,7 +609,14 @@ gcr_importer_set_property (GObject *obj, guint prop_id, const GValue *value,
GcrImporter *self = GCR_IMPORTER (obj);
switch (prop_id) {
- case PROP_IMPORTER:
+ case PROP_PARSER:
+ gcr_importer_set_parser (self, g_value_get_object (value));
+ break;
+ case PROP_SLOT:
+ gcr_importer_set_slot (self, g_value_get_object (value));
+ break;
+ case PROP_PROMPT_BEHAVIOR:
+ gcr_importer_set_prompt_behavior (self, (GcrImporterPromptBehavior)g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
@@ -101,7 +631,14 @@ gcr_importer_get_property (GObject *obj, guint prop_id, GValue *value,
GcrImporter *self = GCR_IMPORTER (obj);
switch (prop_id) {
- case PROP_IMPORTER:
+ case PROP_PARSER:
+ g_value_set_object (value, gcr_importer_get_parser (self));
+ break;
+ case PROP_SLOT:
+ g_value_set_object (value, gcr_importer_get_slot (self));
+ break;
+ case PROP_PROMPT_BEHAVIOR:
+ g_value_set_int (value, gcr_importer_get_prompt_behavior (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
@@ -120,17 +657,49 @@ gcr_importer_class_init (GcrImporterClass *klass)
gobject_class->set_property = gcr_importer_set_property;
gobject_class->get_property = gcr_importer_get_property;
- g_object_class_install_property (gobject_class, PROP_IMPORTER,
- g_param_spec_pointer ("importer", "Importer", "Importer.", G_PARAM_READWRITE));
-
- signals[SIGNAL] = g_signal_new ("signal", GCR_TYPE_IMPORTER,
- G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GcrImporterClass, signal),
+ g_type_class_add_private (gobject_class, sizeof (GcrImporterPrivate));
+
+ g_object_class_install_property (gobject_class, PROP_PARSER,
+ g_param_spec_object ("parser", "Parser", "Parser used to parse imported data",
+ GCR_TYPE_PARSER, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PARSER,
+ g_param_spec_object ("slot", "Slot", "PKCS#11 slot to import data into",
+ GP11_TYPE_SLOT, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PROMPT_BEHAVIOR,
+ g_param_spec_int ("prompt-behavior", "Prompt Behavior", "Import Prompt Behavior",
+ 0, G_MAXINT, GCR_IMPORTER_PROMPT_NEEDED, G_PARAM_READWRITE));
+
+ signals[IMPORTED] = g_signal_new ("imported", GCR_TYPE_IMPORTER,
+ G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GcrImporterClass, imported),
NULL, NULL, g_cclosure_marshal_VOID__OBJECT,
- G_TYPE_NONE, 0);
+ G_TYPE_NONE, 1, GP11_TYPE_OBJECT);
_gcr_initialize ();
}
+static gpointer
+gcr_importer_real_get_user_data (GAsyncResult *base)
+{
+ g_return_val_if_fail (GCR_IS_IMPORTER (base), NULL);
+ return GCR_IMPORTER (base)->pv->user_data;
+}
+
+static GObject*
+gcr_importer_real_get_source_object (GAsyncResult *base)
+{
+ g_return_val_if_fail (GCR_IS_IMPORTER (base), NULL);
+ return G_OBJECT (base);
+}
+
+static void
+gcr_importer_async_result (GAsyncResultIface *iface)
+{
+ iface->get_source_object = gcr_importer_real_get_source_object;
+ iface->get_user_data = gcr_importer_real_get_user_data;
+}
+
/* -----------------------------------------------------------------------------
* PUBLIC
*/
@@ -141,73 +710,133 @@ gcr_importer_new (void)
return g_object_new (GCR_TYPE_IMPORTER, NULL);
}
-gboolean
-gcr_importer_import_data (GcrImporter *self, const guchar *data, gsize n_data,
- GError *err)
+GcrParser*
+gcr_importer_get_parser (GcrImporter *self)
{
- GckParser *parser;
- gulong parsed_conn;
- gulong auth_conn;
- gboolean ret;
+ g_return_val_if_fail (GCR_IS_IMPORTER (self), NULL);
+ if (!self->pv->parser)
+ self->pv->parser = gcr_parser_new ();
+ return self->pv->parser;
+}
+
+void
+gcr_importer_set_parser (GcrImporter *self, GcrParser *parser)
+{
+ g_return_if_fail (GCR_IS_IMPORTER (self));
+
+ if (parser)
+ g_object_ref (parser);
+ if (self->pv->parser)
+ g_object_unref (self->pv->parser);
+ self->pv->parser = parser;
+ g_object_notify (G_OBJECT (self), "parser");
+}
+
+GP11Slot*
+gcr_importer_get_slot (GcrImporter *self)
+{
+ g_return_val_if_fail (GCR_IS_IMPORTER (self), NULL);
+ return self->pv->slot;
+}
+
+void
+gcr_importer_set_slot (GcrImporter *self, GP11Slot *slot)
+{
+ g_return_if_fail (GCR_IS_IMPORTER (self));
+ if (slot)
+ g_object_ref (slot);
+ if (self->pv->slot)
+ g_object_unref (self->pv->slot);
+ self->pv->slot = slot;
+ g_object_notify (G_OBJECT (self), "slot");
+}
+
+GcrImporterPromptBehavior
+gcr_importer_get_prompt_behavior (GcrImporter *self)
+{
+ g_return_val_if_fail (GCR_IS_IMPORTER (self), GCR_IMPORTER_PROMPT_NEEDED);
+ return self->pv->behavior;
+}
+
+void
+gcr_importer_set_prompt_behavior (GcrImporter *self, GcrImporterPromptBehavior behavior)
+{
+ g_return_if_fail (GCR_IMPORTER (self));
+ self->pv->behavior = behavior;
+ g_object_notify (G_OBJECT (self), "prompt-behavior");
+}
+
+gboolean
+gcr_importer_import (GcrImporter *self, GInputStream *input,
+ GCancellable *cancel, GError **error)
+{
g_return_val_if_fail (GCR_IS_IMPORTER (self), FALSE);
- g_return_val_if_fail (data || !n_data, FALSE);
+ g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
+ g_return_val_if_fail (!self->pv->processing, FALSE);
+ cleanup_import_data (self);
- xxxx;
-
-
- /*
- * Parse to see if it's something that needs a password
- * if we can't prompt,
- * return an error
- * Possibly prompt, if password needed, with all information necessary
- *
- */
+ self->pv->input = g_object_ref (input);
+ if (cancel)
+ self->pv->cancel = g_object_ref (cancel);
+ self->pv->processing = TRUE;
+ self->pv->async = FALSE;
+ next_state (self, state_read_buffer);
- g_object_ref (self);
-
- parser = gcr_importer_get_parser (self);
-
- /* Listen in to the parser */
- g_object_ref (parser);
- parsed_conn = g_signal_connect (parser, "parsed-item", G_CALLBACK (parser_parsed_item), self);
- auth_conn = g_signal_connect (parser, "authenticate", G_CALLBACK (parser_authenticate), self);
+ g_assert (!self->pv->processing);
+ g_assert (!self->pv->input);
+ g_assert (!self->pv->cancel);
- /* Feed the parser the data */
- ret = gcr_parser_parse_data (parser, data, n_data, err);
+ if (!self->pv->succeeded) {
+ g_propagate_error (error, self->pv->error);
+ self->pv->error = NULL;
+ return FALSE;
+ }
- /* Now we should have all the data ready, check if we should prompt... */
- /* Import data one by one into module */
+ return TRUE;
+}
+
+void
+gcr_importer_import_async (GcrImporter *self, GInputStream *input, GCancellable *cancel,
+ GAsyncReadyCallback callback, gpointer user_data)
+{
+ g_return_if_fail (GCR_IS_IMPORTER (self));
+ g_return_if_fail (G_IS_INPUT_STREAM (input));
+ g_return_if_fail (!self->pv->processing);
- g_signal_handler_disconnect (parser, parsed_conn);
- g_signal_handler_disconnect (parser, auth_conn);
- g_object_unref (parser);
+ cleanup_import_data (self);
- g_object_unref (self);
+ self->pv->input = g_object_ref (input);
+ if (cancel)
+ self->pv->cancel = g_object_ref (cancel);
+ self->pv->processing = TRUE;
+ self->pv->async = TRUE;
+ self->pv->callback = callback;
+ self->pv->user_data = user_data;
- return ret;
+ next_state (self, state_read_buffer);
+ g_assert (self->pv->processing);
}
gboolean
-gcr_importer_import_file (GcrImporter *self, const gchar *filename,
- GError *err)
+gcr_importer_import_finish (GcrImporter *self, GAsyncResult *res, GError **error)
{
- gboolean ret;
- gchar *data;
- gsize n_data;
-
g_return_val_if_fail (GCR_IS_IMPORTER (self), FALSE);
- g_return_val_if_fail (filename, FALSE);
+ g_return_val_if_fail (GCR_IMPORTER (res) == self, FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
+ g_return_val_if_fail (!self->pv->processing, FALSE);
+
+ g_assert (!self->pv->input);
+ g_assert (!self->pv->cancel);
- if (!g_file_get_contents (filename, &data, &n_data, err))
+ if (!self->pv->succeeded) {
+ g_propagate_error (error, self->pv->error);
+ self->pv->error = NULL;
return FALSE;
+ }
- ret = gcr_importer_import_data (self, (const guchar*)data, n_data, error);
- g_free (data);
-
- return ret;
+ return TRUE;
}
diff --git a/gcr/gcr-importer.h b/gcr/gcr-importer.h
index 1fad27cf..065de548 100644
--- a/gcr/gcr-importer.h
+++ b/gcr/gcr-importer.h
@@ -22,8 +22,17 @@
#ifndef __GCR_IMPORTER_H__
#define __GCR_IMPORTER_H__
+#include "gcr.h"
+#include "gcr-parser.h"
+
#include <glib-object.h>
+typedef enum {
+ GCR_IMPORTER_PROMPT_NEEDED,
+ GCR_IMPORTER_PROMPT_ALWAYS,
+ GCR_IMPORTER_PROMPT_NEVER
+} GcrImporterPromptBehavior;
+
#define GCR_TYPE_IMPORTER (gcr_importer_get_type ())
#define GCR_IMPORTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCR_TYPE_IMPORTER, GcrImporter))
#define GCR_IMPORTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GCR_TYPE_IMPORTER, GcrImporterClass))
@@ -33,49 +42,53 @@
typedef struct _GcrImporter GcrImporter;
typedef struct _GcrImporterClass GcrImporterClass;
+typedef struct _GcrImporterPrivate GcrImporterPrivate;
struct _GcrImporter {
GObject parent;
+ GcrImporterPrivate *pv;
};
struct _GcrImporterClass {
GObjectClass parent_class;
-
- /* signals --------------------------------------------------------- */
-
- void (*signal) (GcrImporter *self, GkrImportedItem *item);
+
+ /* signals */
+
+ void (*imported) (GcrImporter *self, GP11Object *object);
};
-GType gcr_importer_get_type (void);
+GType gcr_importer_get_type (void);
-GcrImporter* gcr_importer_new (void);
+GcrImporter* gcr_importer_new (void);
-GcrImporter* gcr_importer_new_for_module (GP11Module *module);
+GcrParser* gcr_importer_get_parser (GcrImporter *self);
-GcrImporter* gcr_importer_new_for_module_funcs (gpointer pkcs11_funcs);
+void gcr_importer_set_parser (GcrImporter *self,
+ GcrParser *parser);
-void gcr_importer_set_slot (GcrImporter *self,
- GP11Slot *slot);
+struct _GP11Slot* gcr_importer_get_slot (GcrImporter *self);
-void gcr_importer_set_slot_id (GcrImporter *self,
- gulong slot_id);
+void gcr_importer_set_slot (GcrImporter *self,
+ struct _GP11Slot *slot);
-void gcr_importer_set_parser (GcrImporter *self,
- GcrParser *parser);
+GcrImporterPromptBehavior gcr_importer_get_prompt_behavior (GcrImporter *self);
-void gcr_importer_set_window (GcrImporter *self,
- GtkWindow *window);
+void gcr_importer_set_prompt_behavior (GcrImporter *self,
+ GcrImporterPromptBehavior behavior);
-void gcr_importer_set_prompt_behavior (GcrImporter *self,
- GcrImporterPromptBehavior behavior);
+gboolean gcr_importer_import (GcrImporter *self,
+ GInputStream *input,
+ GCancellable *cancel,
+ GError **error);
-gboolean gcr_importer_import_data (GcrImporter *self,
- const guchar *data,
- gsize n_data,
- GError *error);
+void gcr_importer_import_async (GcrImporter *self,
+ GInputStream *input,
+ GCancellable *cancel,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
-gboolean gcr_importer_import_file (GcrImporter *self,
- const gchar *filename,
- GError *error);
+gboolean gcr_importer_import_finish (GcrImporter *self,
+ GAsyncResult *res,
+ GError **error);
#endif /* __GCR_IMPORTER_H__ */
diff --git a/gcr/gcr-internal.h b/gcr/gcr-internal.h
index daad9903..a8a4651e 100644
--- a/gcr/gcr-internal.h
+++ b/gcr/gcr-internal.h
@@ -1,8 +1,14 @@
#ifndef GCR_INTERNAL_H_
#define GCR_INTERNAL_H_
+#include "gcr.h"
+
+#include "gp11/gp11.h"
+
#include <glib.h>
-void _gcr_initialize (void);
+void _gcr_initialize (void);
+
+GList* _gcr_get_pkcs11_modules (void);
#endif /* GCR_INTERNAL_H_ */
diff --git a/gcr/gcr-internal.c b/gcr/gcr-library.c
index 2996208b..12d5ca59 100644
--- a/gcr/gcr-internal.c
+++ b/gcr/gcr-library.c
@@ -21,12 +21,95 @@
#include "config.h"
+#include "gcr.h"
+#include "gcr-types.h"
#include "gcr-internal.h"
#include "egg/egg-secure-memory.h"
#include <gcrypt.h>
+static GList *all_modules = NULL;
+
+GQuark
+gcr_data_error_get_domain (void)
+{
+ static GQuark domain = 0;
+ if (domain == 0)
+ domain = g_quark_from_static_string ("gcr-parser-error");
+ return domain;
+}
+
+/* -----------------------------------------------------------------------------
+ * MEMORY
+ */
+
+static gboolean do_warning = TRUE;
+#define WARNING "couldn't allocate secure memory to keep passwords " \
+ "and or keys from being written to the disk"
+
+#define ABORTMSG "The GNOME_KEYRING_PARANOID environment variable was set. " \
+ "Exiting..."
+
+static G_LOCK_DEFINE (memory_lock);
+
+/*
+ * These are called from egg-secure-memory.c to provide appropriate
+ * locking for memory between threads
+ */
+
+void
+egg_memory_lock (void)
+{
+ G_LOCK (memory_lock);
+}
+
+void
+egg_memory_unlock (void)
+{
+ G_UNLOCK (memory_lock);
+}
+
+void*
+egg_memory_fallback (void *p, unsigned long sz)
+{
+ const gchar *env;
+
+ /* We were asked to free memory */
+ if (!sz) {
+ g_free (p);
+ return NULL;
+ }
+
+ /* We were asked to allocate */
+ if (!p) {
+ if (do_warning) {
+ g_message (WARNING);
+ do_warning = FALSE;
+ }
+
+ env = g_getenv ("GNOME_KEYRING_PARANOID");
+ if (env && *env)
+ g_error (ABORTMSG);
+
+ return g_malloc0 (sz);
+ }
+
+ /*
+ * Reallocation is a bit of a gray area, as we can be asked
+ * by external libraries (like libgcrypt) to reallocate a
+ * non-secure block into secure memory. We cannot satisfy
+ * this request (as we don't know the size of the original
+ * block) so we just try our best here.
+ */
+
+ return g_realloc (p, sz);
+}
+
+/* ------------------------------------------------------------------------------
+ * GCRYPT HOOKS
+ */
+
static void
log_handler (gpointer unused, int unknown, const gchar *msg, va_list va)
{
@@ -88,10 +171,12 @@ static struct gcry_thread_cbs glib_thread_cbs = {
void
_gcr_initialize (void)
{
- static gsize gcrypt_initialized = FALSE;
+ static volatile gsize gcr_initialized = 0;
+ GP11Module *module;
+ GError *error = NULL;
unsigned seed;
- if (g_once_init_enter (&gcrypt_initialized)) {
+ if (g_once_init_enter (&gcr_initialized)) {
/* Only initialize libgcrypt if it hasn't already been initialized */
if (!gcry_control (GCRYCTL_INITIALIZATION_FINISHED_P)) {
@@ -110,7 +195,21 @@ _gcr_initialize (void)
gcry_create_nonce (&seed, sizeof (seed));
srand (seed);
-
- g_once_init_leave (&gcrypt_initialized, 1);
+
+ /* TODO: This needs reworking for multiple modules */
+ module = gp11_module_initialize (PKCS11_MODULE_PATH, NULL, &error);
+ if (module)
+ all_modules = g_list_prepend (all_modules, module);
+ else
+ g_warning ("couldn't initialize PKCS#11 module: %s",
+ error && error->message ? error->message : "");
+
+ g_once_init_leave (&gcr_initialized, 1);
}
}
+
+GList*
+_gcr_get_pkcs11_modules (void)
+{
+ return all_modules;
+}
diff --git a/gcr/gcr-parser.c b/gcr/gcr-parser.c
index 0c58ce39..d508ec97 100644
--- a/gcr/gcr-parser.c
+++ b/gcr/gcr-parser.c
@@ -263,7 +263,7 @@ enum_next_password (GcrParser *self, PasswordState *state, const gchar **passwor
++state->ask_state;
if (!result)
- return GCR_PARSE_CANCELLED;
+ return GCR_ERROR_CANCELLED;
/* Return any passwords added */
if (state->seen < self->pv->passwords->len) {
@@ -273,7 +273,7 @@ enum_next_password (GcrParser *self, PasswordState *state, const gchar **passwor
return SUCCESS;
}
- return GCR_PARSE_LOCKED;
+ return GCR_ERROR_LOCKED;
}
static void
@@ -293,7 +293,7 @@ parsed_fire (GcrParser *self)
static gint
parse_der_private_key_rsa (GcrParser *self, const guchar *data, gsize n_data)
{
- gint res = GCR_PARSE_UNRECOGNIZED;
+ gint res = GCR_ERROR_UNRECOGNIZED;
ASN1_TYPE asn = ASN1_TYPE_EMPTY;
guint version;
@@ -303,14 +303,14 @@ parse_der_private_key_rsa (GcrParser *self, const guchar *data, gsize n_data)
parsed_clear (self, CKO_PRIVATE_KEY);
parsed_ulong (self, CKA_KEY_TYPE, CKK_RSA);
- res = GCR_PARSE_FAILURE;
+ res = GCR_ERROR_FAILURE;
if (!egg_asn1_read_uint (asn, "version", &version))
goto done;
/* We only support simple version */
if (version != 0) {
- res = GCR_PARSE_UNRECOGNIZED;
+ res = GCR_ERROR_UNRECOGNIZED;
g_message ("unsupported version of RSA key: %u", version);
goto done;
}
@@ -330,7 +330,7 @@ done:
if (asn)
asn1_delete_structure (&asn);
- if (res == GCR_PARSE_FAILURE)
+ if (res == GCR_ERROR_FAILURE)
g_message ("invalid RSA key");
return res;
@@ -343,7 +343,7 @@ done:
static gint
parse_der_private_key_dsa (GcrParser *self, const guchar *data, gsize n_data)
{
- gint ret = GCR_PARSE_UNRECOGNIZED;
+ gint ret = GCR_ERROR_UNRECOGNIZED;
int res;
ASN1_TYPE asn;
@@ -353,7 +353,7 @@ parse_der_private_key_dsa (GcrParser *self, const guchar *data, gsize n_data)
parsed_clear (self, CKO_PRIVATE_KEY);
parsed_ulong (self, CKA_KEY_TYPE, CKK_DSA);
- res = GCR_PARSE_FAILURE;
+ res = GCR_ERROR_FAILURE;
if (!parsed_asn1_attribute (self, asn, data, n_data, "p", CKA_PRIME) ||
!parsed_asn1_attribute (self, asn, data, n_data, "q", CKA_SUBPRIME) ||
@@ -368,7 +368,7 @@ done:
if (asn)
asn1_delete_structure (&asn);
- if (ret == GCR_PARSE_FAILURE)
+ if (ret == GCR_ERROR_FAILURE)
g_message ("invalid DSA key");
return ret;
@@ -378,7 +378,7 @@ static gint
parse_der_private_key_dsa_parts (GcrParser *self, const guchar *keydata, gsize n_keydata,
const guchar *params, gsize n_params)
{
- gint ret = GCR_PARSE_UNRECOGNIZED;
+ gint ret = GCR_ERROR_UNRECOGNIZED;
int res;
ASN1_TYPE asn_params = ASN1_TYPE_EMPTY;
ASN1_TYPE asn_key = ASN1_TYPE_EMPTY;
@@ -390,7 +390,7 @@ parse_der_private_key_dsa_parts (GcrParser *self, const guchar *keydata, gsize n
parsed_clear (self, CKO_PRIVATE_KEY);
parsed_ulong (self, CKA_KEY_TYPE, CKK_DSA);
- res = GCR_PARSE_FAILURE;
+ res = GCR_ERROR_FAILURE;
if (!parsed_asn1_attribute (self, asn_params, params, n_params, "p", CKA_PRIME) ||
!parsed_asn1_attribute (self, asn_params, params, n_params, "q", CKA_SUBPRIME) ||
@@ -407,7 +407,7 @@ done:
if (asn_params)
asn1_delete_structure (&asn_params);
- if (ret == GCR_PARSE_FAILURE)
+ if (ret == GCR_ERROR_FAILURE)
g_message ("invalid DSA key");
return ret;
@@ -423,7 +423,7 @@ parse_der_private_key (GcrParser *self, const guchar *data, gsize n_data)
gint res;
res = parse_der_private_key_rsa (self, data, n_data);
- if (res == GCR_PARSE_UNRECOGNIZED)
+ if (res == GCR_ERROR_UNRECOGNIZED)
res = parse_der_private_key_dsa (self, data, n_data);
return res;
@@ -445,13 +445,13 @@ parse_der_pkcs8_plain (GcrParser *self, const guchar *data, gsize n_data)
const guchar *params;
gsize n_params;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-8-PrivateKeyInfo", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
key_type = GP11_INVALID;
key_algo = egg_asn1_read_oid (asn, "privateKeyAlgorithm.algorithm");
@@ -463,7 +463,7 @@ parse_der_pkcs8_plain (GcrParser *self, const guchar *data, gsize n_data)
key_type = CKK_DSA;
if (key_type == GP11_INVALID) {
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
goto done;
}
@@ -487,17 +487,17 @@ done:
ret = parse_der_private_key_dsa (self, keydata, n_keydata);
/* Otherwise try the two part format that everyone seems to like */
- if (ret == GCR_PARSE_UNRECOGNIZED && params && n_params)
+ if (ret == GCR_ERROR_UNRECOGNIZED && params && n_params)
ret = parse_der_private_key_dsa_parts (self, keydata, n_keydata,
params, n_params);
break;
default:
g_message ("invalid or unsupported key type in PKCS#8 key");
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
break;
};
- } else if (ret == GCR_PARSE_FAILURE) {
+ } else if (ret == GCR_ERROR_FAILURE) {
g_message ("invalid PKCS#8 key");
}
@@ -521,13 +521,13 @@ parse_der_pkcs8_encrypted (GcrParser *self, const guchar *data, gsize n_data)
const gchar *password;
gint l;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-8-EncryptedPrivateKeyInfo", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
/* Figure out the type of encryption */
scheme = egg_asn1_read_oid (asn, "encryptionAlgorithm.algorithm");
@@ -576,7 +576,7 @@ parse_der_pkcs8_encrypted (GcrParser *self, const guchar *data, gsize n_data)
egg_secure_free (crypted);
crypted = NULL;
- if (r != GCR_PARSE_UNRECOGNIZED) {
+ if (r != GCR_ERROR_UNRECOGNIZED) {
ret = r;
break;
}
@@ -600,7 +600,7 @@ parse_der_pkcs8 (GcrParser *self, const guchar *data, gsize n_data)
gint ret;
ret = parse_der_pkcs8_plain (self, data, n_data);
- if (ret == GCR_PARSE_UNRECOGNIZED)
+ if (ret == GCR_ERROR_UNRECOGNIZED)
ret = parse_der_pkcs8_encrypted (self, data, n_data);
return ret;
@@ -618,7 +618,7 @@ parse_der_certificate (GcrParser *self, const guchar *data, gsize n_data)
asn = egg_asn1_decode ("PKIX1.Certificate", data, n_data);
if (asn == NULL)
- return GCR_PARSE_UNRECOGNIZED;
+ return GCR_ERROR_UNRECOGNIZED;
parsed_clear (self, CKO_CERTIFICATE);
parsed_ulong (self, CKA_CERTIFICATE_TYPE, CKC_X_509);
@@ -651,13 +651,13 @@ handle_pkcs7_signed_data (GcrParser *self, const guchar *data, gsize n_data)
gsize n_certificate;
int i;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-7-SignedData", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
for (i = 0; TRUE; ++i) {
@@ -694,13 +694,13 @@ parse_der_pkcs7 (GcrParser *self, const guchar *data, gsize n_data)
gsize n_content;
GQuark oid;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-7-ContentInfo", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
oid = egg_asn1_read_oid (asn, "contentType");
if (!oid)
@@ -736,13 +736,13 @@ handle_pkcs12_cert_bag (GcrParser *self, const guchar *data, gsize n_data)
gsize n_certificate;
gint ret;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-12-CertBag", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
certificate = egg_asn1_read_content (asn, data, n_data, "certValue", &n_certificate);
if (!certificate)
@@ -775,13 +775,13 @@ handle_pkcs12_bag (GcrParser *self, const guchar *data, gsize n_data)
const guchar *element;
gsize n_element;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-12-SafeContents", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
/* Get the number of elements in this bag */
res = asn1_number_of_elements (asn, "", &count);
@@ -822,10 +822,10 @@ handle_pkcs12_bag (GcrParser *self, const guchar *data, gsize n_data)
/* TODO: OID_PKCS12_BAG_CRL */
} else {
- r = GCR_PARSE_UNRECOGNIZED;
+ r = GCR_ERROR_UNRECOGNIZED;
}
- if (r == GCR_PARSE_FAILURE || r == GCR_PARSE_CANCELLED) {
+ if (r == GCR_ERROR_FAILURE || r == GCR_ERROR_CANCELLED) {
ret = r;
goto done;
}
@@ -855,13 +855,13 @@ handle_pkcs12_encrypted_bag (GcrParser *self, const guchar *data, gsize n_data)
gint ret, r;
gint l;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-7-EncryptedData", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
/* Check the encryption schema OID */
scheme = egg_asn1_read_oid (asn, "encryptedContentInfo.contentEncryptionAlgorithm.algorithm");
@@ -887,7 +887,7 @@ handle_pkcs12_encrypted_bag (GcrParser *self, const guchar *data, gsize n_data)
/* Parse the encryption stuff into a cipher. */
if (!egg_symkey_read_cipher (scheme, password, -1, params, n_params, &cih)) {
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
goto done;
}
@@ -915,7 +915,7 @@ handle_pkcs12_encrypted_bag (GcrParser *self, const guchar *data, gsize n_data)
egg_secure_free (crypted);
crypted = NULL;
- if (r != GCR_PARSE_UNRECOGNIZED) {
+ if (r != GCR_ERROR_UNRECOGNIZED) {
ret = r;
break;
}
@@ -944,13 +944,13 @@ handle_pkcs12_safe (GcrParser *self, const guchar *data, gsize n_data)
GQuark oid;
guint i;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-12-AuthenticatedSafe", data, n_data);
if (!asn)
goto done;
- ret = GCR_PARSE_FAILURE;
+ ret = GCR_ERROR_FAILURE;
/*
* Inside each PKCS12 safe there are multiple bags.
@@ -992,10 +992,10 @@ handle_pkcs12_safe (GcrParser *self, const guchar *data, gsize n_data)
/* Hmmmm, not sure what this is */
} else {
g_warning ("unrecognized type of safe content in pkcs12: %s", g_quark_to_string (oid));
- r = GCR_PARSE_UNRECOGNIZED;
+ r = GCR_ERROR_UNRECOGNIZED;
}
- if (r == GCR_PARSE_FAILURE || r == GCR_PARSE_CANCELLED) {
+ if (r == GCR_ERROR_FAILURE || r == GCR_ERROR_CANCELLED) {
ret = r;
goto done;
}
@@ -1019,7 +1019,7 @@ parse_der_pkcs12 (GcrParser *self, const guchar *data, gsize n_data)
gsize n_content;
GQuark oid;
- ret = GCR_PARSE_UNRECOGNIZED;
+ ret = GCR_ERROR_UNRECOGNIZED;
asn = egg_asn1_decode ("PKIX1.pkcs-12-PFX", data, n_data);
if (!asn)
@@ -1091,14 +1091,14 @@ handle_plain_pem (GcrParser *self, GQuark type, gint subformat,
format_id = GCR_FORMAT_DER_PKCS12;
else
- return GCR_PARSE_UNRECOGNIZED;
+ return GCR_ERROR_UNRECOGNIZED;
if (subformat != 0 && subformat != format_id)
- return GCR_PARSE_UNRECOGNIZED;
+ return GCR_ERROR_UNRECOGNIZED;
format = parser_format_lookup (format_id);
if (format == NULL)
- return GCR_PARSE_UNRECOGNIZED;
+ return GCR_ERROR_UNRECOGNIZED;
return (format->function) (self, data, n_data);
}
@@ -1143,7 +1143,7 @@ handle_encrypted_pem (GcrParser *self, GQuark type, gint subformat,
val = g_hash_table_lookup (headers, "DEK-Info");
if (!val) {
g_message ("missing encryption header");
- return GCR_PARSE_FAILURE;
+ return GCR_ERROR_FAILURE;
}
/* Fill in information necessary for prompting */
@@ -1162,7 +1162,7 @@ handle_encrypted_pem (GcrParser *self, GQuark type, gint subformat,
ret = egg_openssl_decrypt_block (val, password, -1, data, n_data,
&decrypted, &n_decrypted);
if (!ret)
- return GCR_PARSE_FAILURE;
+ return GCR_ERROR_FAILURE;
g_assert (decrypted);
@@ -1176,11 +1176,11 @@ handle_encrypted_pem (GcrParser *self, GQuark type, gint subformat,
egg_secure_free (decrypted);
/* Unrecognized is a bad password */
- if (res != GCR_PARSE_UNRECOGNIZED)
+ if (res != GCR_ERROR_UNRECOGNIZED)
return res;
}
- return GCR_PARSE_FAILURE;
+ return GCR_ERROR_FAILURE;
}
typedef struct {
@@ -1194,12 +1194,12 @@ handle_pem_data (GQuark type, const guchar *data, gsize n_data,
GHashTable *headers, gpointer user_data)
{
HandlePemArgs *args = (HandlePemArgs*)user_data;
- gint res = GCR_PARSE_FAILURE;
+ gint res = GCR_ERROR_FAILURE;
gboolean encrypted = FALSE;
const gchar *val;
/* Something already failed to parse */
- if (args->result == GCR_PARSE_FAILURE)
+ if (args->result == GCR_ERROR_FAILURE)
return;
/* See if it's encrypted PEM all openssl like*/
@@ -1216,8 +1216,8 @@ handle_pem_data (GQuark type, const guchar *data, gsize n_data,
res = handle_plain_pem (args->parser, type, args->subformat,
data, n_data);
- if (res != GCR_PARSE_UNRECOGNIZED) {
- if (args->result == GCR_PARSE_UNRECOGNIZED)
+ if (res != GCR_ERROR_UNRECOGNIZED) {
+ if (args->result == GCR_ERROR_UNRECOGNIZED)
args->result = res;
else if (res > args->result)
args->result = res;
@@ -1227,16 +1227,16 @@ handle_pem_data (GQuark type, const guchar *data, gsize n_data,
static gint
handle_pem_format (GcrParser *self, gint subformat, const guchar *data, gsize n_data)
{
- HandlePemArgs ctx = { self, GCR_PARSE_UNRECOGNIZED, subformat };
+ HandlePemArgs ctx = { self, GCR_ERROR_UNRECOGNIZED, subformat };
guint found;
if (n_data == 0)
- return GCR_PARSE_UNRECOGNIZED;
+ return GCR_ERROR_UNRECOGNIZED;
found = egg_openssl_pem_parse (data, n_data, handle_pem_data, &ctx);
if (found == 0)
- return GCR_PARSE_UNRECOGNIZED;
+ return GCR_ERROR_UNRECOGNIZED;
return ctx.result;
}
@@ -1375,7 +1375,7 @@ parser_format_foreach (gpointer key, gpointer value, gpointer data)
g_assert (GCR_IS_PARSER (args->parser));
result = (format->function) (args->parser, args->data, args->n_data);
- if (result != GCR_PARSE_UNRECOGNIZED) {
+ if (result != GCR_ERROR_UNRECOGNIZED) {
args->result = result;
return TRUE;
}
@@ -1534,15 +1534,6 @@ gcr_parser_new (void)
return g_object_new (GCR_TYPE_PARSER, NULL);
}
-GQuark
-gcr_parser_get_error_domain (void)
-{
- static GQuark domain = 0;
- if (domain == 0)
- domain = g_quark_from_static_string ("gcr-parser-error");
- return domain;
-}
-
void
gcr_parser_add_password (GcrParser *self, const gchar *password)
{
@@ -1554,7 +1545,7 @@ gboolean
gcr_parser_parse_data (GcrParser *self, const guchar *data,
gsize n_data, GError **err)
{
- ForeachArgs args = { self, data, n_data, GCR_PARSE_UNRECOGNIZED };
+ ForeachArgs args = { self, data, n_data, GCR_ERROR_UNRECOGNIZED };
const gchar *message;
gint i;
@@ -1578,16 +1569,16 @@ gcr_parser_parse_data (GcrParser *self, const guchar *data,
switch (args.result) {
case SUCCESS:
return TRUE;
- case GCR_PARSE_CANCELLED:
+ case GCR_ERROR_CANCELLED:
message = _("The operation was cancelled");
break;
- case GCR_PARSE_UNRECOGNIZED:
+ case GCR_ERROR_UNRECOGNIZED:
message = _("Unrecognized or unsupported data.");
break;
- case GCR_PARSE_FAILURE:
+ case GCR_ERROR_FAILURE:
message = _("Could not parse invalid or corrupted data.");
break;
- case GCR_PARSE_LOCKED:
+ case GCR_ERROR_LOCKED:
message = _("The data is locked");
break;
default:
@@ -1595,37 +1586,11 @@ gcr_parser_parse_data (GcrParser *self, const guchar *data,
break;
};
- g_set_error_literal (err, GCR_PARSER_ERROR, args.result, message);
+ g_set_error_literal (err, GCR_DATA_ERROR, args.result, message);
return FALSE;
}
gboolean
-gcr_parser_parse_file (GcrParser *self, const gchar *filename, GError **err)
-{
- GMappedFile *mapped;
- gboolean ret;
- const guchar *data;
- gsize n_data;
-
- g_return_val_if_fail (GCR_IS_PARSER (self), FALSE);
- g_return_val_if_fail (filename, FALSE);
- g_return_val_if_fail (!err || !*err, FALSE);
-
- mapped = g_mapped_file_new (filename, FALSE, err);
- if (mapped == NULL)
- return FALSE;
-
- data = (const guchar*)g_mapped_file_get_contents (mapped);
- n_data = g_mapped_file_get_length (mapped);
-
- ret = gcr_parser_parse_data (self, data, n_data, err);
-
- g_mapped_file_free (mapped);
-
- return ret;
-}
-
-gboolean
gcr_parser_format_enable (GcrParser *self, gint format_id)
{
ParserFormat *format;
diff --git a/gcr/gcr-parser.h b/gcr/gcr-parser.h
index e4c3e248..152586d9 100644
--- a/gcr/gcr-parser.h
+++ b/gcr/gcr-parser.h
@@ -22,12 +22,12 @@
#ifndef __GCR_PARSER_H__
#define __GCR_PARSER_H__
+#include "gcr.h"
+
#include <glib-object.h>
#include "gcr-types.h"
-#define GCR_PARSER_ERROR (gcr_parser_get_error_domain ())
-
#define GCR_TYPE_PARSER (gcr_parser_get_type ())
#define GCR_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GCR_TYPE_PARSER, GcrParser))
#define GCR_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GCR_TYPE_PARSER, GcrParserClass))
@@ -56,37 +56,31 @@ struct _GcrParserClass {
void (*parsed) (GcrParser *self);
};
-GType gcr_parser_get_type (void);
-
-GQuark gcr_parser_get_error_domain (void) G_GNUC_CONST;
-
-GcrParser* gcr_parser_new (void);
+GType gcr_parser_get_type (void);
-gboolean gcr_parser_format_enable (GcrParser *self,
- gint format);
+GcrParser* gcr_parser_new (void);
-gboolean gcr_parser_format_disable (GcrParser *self,
- gint format);
+gboolean gcr_parser_format_enable (GcrParser *self,
+ gint format);
-gboolean gcr_parser_format_supported (GcrParser *self,
- gint format);
+gboolean gcr_parser_format_disable (GcrParser *self,
+ gint format);
-gboolean gcr_parser_parse_data (GcrParser *self,
- const guchar *data,
- gsize n_data,
- GError **err);
+gboolean gcr_parser_format_supported (GcrParser *self,
+ gint format);
-gboolean gcr_parser_parse_file (GcrParser *self,
- const gchar *filename,
- GError **err);
+gboolean gcr_parser_parse_data (GcrParser *self,
+ const guchar *data,
+ gsize n_data,
+ GError **err);
-void gcr_parser_add_password (GcrParser *self,
- const gchar *password);
+void gcr_parser_add_password (GcrParser *self,
+ const gchar *password);
-const gchar* gcr_parser_get_parsed_label (GcrParser *self);
+const gchar* gcr_parser_get_parsed_label (GcrParser *self);
-const gchar* gcr_parser_get_parsed_description (GcrParser *self);
+const gchar* gcr_parser_get_parsed_description (GcrParser *self);
-GP11Attributes* gcr_parser_get_parsed_attributes (GcrParser *self);
+struct _GP11Attributes* gcr_parser_get_parsed_attributes (GcrParser *self);
#endif /* __GCR_PARSER_H__ */
diff --git a/gcr/gcr-types.h b/gcr/gcr-types.h
index edef49b5..8cb29566 100644
--- a/gcr/gcr-types.h
+++ b/gcr/gcr-types.h
@@ -1,11 +1,15 @@
#ifndef GCRTYPES_H_
#define GCRTYPES_H_
+#define GCR_DATA_ERROR (gcr_data_error_get_domain ())
+
+GQuark gcr_data_error_get_domain (void) G_GNUC_CONST;
+
enum {
- GCR_PARSE_FAILURE = -1,
- GCR_PARSE_UNRECOGNIZED = 1,
- GCR_PARSE_CANCELLED = 2,
- GCR_PARSE_LOCKED = 3
+ GCR_ERROR_FAILURE = -1,
+ GCR_ERROR_UNRECOGNIZED = 1,
+ GCR_ERROR_CANCELLED = 2,
+ GCR_ERROR_LOCKED = 3
};
enum {
@@ -35,11 +39,8 @@ enum {
GCR_FORMAT_PEM_PKCS12
};
-#ifndef GP11_H
-
/* Forward declare some of the GP11 objects */
-typedef struct _GP11Attributes GP11Attributes;
-
-#endif /* GP11_H */
+struct _GP11Attributes;
+struct _GP11Slot;
#endif /* GCRTYPES_H_ */
diff --git a/gcr/gcr.h b/gcr/gcr.h
new file mode 100644
index 00000000..70a4681d
--- /dev/null
+++ b/gcr/gcr.h
@@ -0,0 +1,46 @@
+/*
+ * gnome-keyring
+ *
+ * Copyright (C) 2008 Stefan Walter
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef __GCR_H__
+#define __GCR_H__
+
+#include <glib.h>
+
+#ifndef GCR_API_SUBJECT_TO_CHANGE
+#error "This API has not yet reached stability."
+#endif
+
+struct _GP11Slot;
+
+#ifdef UNIMPLEMENTED
+enum {
+ GCR_INIT_NO_MODULES = 0x01,
+};
+
+void gcr_initialize (guint flags);
+
+void gcr_modules_register_loaded (gpointer funcs);
+
+gboolean gcr_modules_register_file (const gchar *module_path,
+ GError *error);
+#endif /* UNIMPLEMENTED */
+
+#endif /* __GCR_H__ */
diff --git a/gcr/template/gcr-xxx.c b/gcr/template/gcr-xxx.c
index 91f7e6c6..053aabb5 100644
--- a/gcr/template/gcr-xxx.c
+++ b/gcr/template/gcr-xxx.c
@@ -21,6 +21,7 @@
#include "config.h"
+#include "gcr-internal.h"
#include "gcr-xxx.h"
enum {
@@ -133,6 +134,8 @@ gcr_xxx_class_init (GcrXxxClass *klass)
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GcrXxxClass, signal),
NULL, NULL, g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 0);
+
+ _gcr_initialize ();
}
/* -----------------------------------------------------------------------------
diff --git a/gcr/template/gcr-xxx.h b/gcr/template/gcr-xxx.h
index b85cd95e..3557ee7c 100644
--- a/gcr/template/gcr-xxx.h
+++ b/gcr/template/gcr-xxx.h
@@ -22,6 +22,8 @@
#ifndef __GCR_XXX_H__
#define __GCR_XXX_H__
+#include "gcr.h"
+
#include <glib-object.h>
#define GCR_TYPE_XXX (gcr_xxx_get_type ())
diff --git a/gcr/tests/Makefile.am b/gcr/tests/Makefile.am
index c746135a..4a055852 100644
--- a/gcr/tests/Makefile.am
+++ b/gcr/tests/Makefile.am
@@ -8,6 +8,10 @@ UNIT_PROMPT =
UNIT_LIBS = \
$(top_builddir)/gcr/libgcr.la \
$(top_builddir)/egg/libegg.la \
+ $(top_builddir)/egg/libegg-secure-entry.la \
$(top_builddir)/gp11/libgp11.la
+
+UNIT_FLAGS = \
+ -DGCR_API_SUBJECT_TO_CHANGE
include $(top_srcdir)/tests/gtest.make
diff --git a/gcr/tests/unit-test-parser.c b/gcr/tests/unit-test-parser.c
index 33f21596..4f175d50 100644
--- a/gcr/tests/unit-test-parser.c
+++ b/gcr/tests/unit-test-parser.c
@@ -29,6 +29,8 @@
#include "gcr/gcr-parser.h"
+#include "gp11/gp11.h"
+
#include <glib.h>
#include <gcrypt.h>
#include <libtasn1.h>
diff --git a/po/ChangeLog b/po/ChangeLog
index ccdd7800..15bc122e 100644
--- a/po/ChangeLog
+++ b/po/ChangeLog
@@ -1,3 +1,7 @@
+2009-01-21 Stef Walter <stef@memberwebs.com>
+
+ * POTFILES.in: Added gcr/gcr-importer.c
+
2009-01-20 Jorge Gonzalez <jorgegonz@svn.gnome.org>
* es.po: Updated Spanish translation.
diff --git a/po/POTFILES.skip b/po/POTFILES.skip
index 62d825e1..f7d718cd 100644
--- a/po/POTFILES.skip
+++ b/po/POTFILES.skip
@@ -1,2 +1,2 @@
daemon/gnome-keyring-daemon.desktop.in
-
+gcr/gcr-import-dialog.ui
diff --git a/tool/Makefile.am b/tool/Makefile.am
index 0d7ee535..8dd5fcbd 100644
--- a/tool/Makefile.am
+++ b/tool/Makefile.am
@@ -2,17 +2,25 @@ bin_PROGRAMS= \
gnome-keyring
INCLUDES= \
- -DPKCS11_MODULE_PATH=\""$(libdir)/gnome-keyring/gnome-keyring-pkcs11.so"\" \
- -DGNOMELOCALEDIR=\""$(datadir)/locale"\" \
- -I$(top_srcdir) \
- -I$(top_builddir) \
- $(GOBJECT_CFLAGS) \
+ -I$(top_srcdir) \
+ -I$(top_builddir) \
+ $(GTK_CFLAGS) \
+ $(GOBJECT_CFLAGS) \
$(GLIB_CFLAGS)
gnome_keyring_SOURCES = \
gkr-tool.c gkr-tool.h \
gkr-tool-import.c
+
+gnome_keyring_CFLAGS = \
+ -DGCR_API_SUBJECT_TO_CHANGE \
+ -DGNOMELOCALEDIR=\""$(datadir)/locale"\"
gnome_keyring_LDADD = \
$(top_builddir)/gp11/libgp11.la \
- $(GLIB_LIBS) $(GTHREAD_LIBS)
+ $(top_builddir)/gcr/libgcr.la \
+ $(top_builddir)/egg/libegg.la \
+ $(GTK_LIBS) \
+ $(GCRYPT_LIBS) \
+ $(LIBTASN1_LIBS) \
+ $(DAEMON_LIBS)
diff --git a/tool/gkr-tool-import.c b/tool/gkr-tool-import.c
index 685b70a5..473a90b1 100644
--- a/tool/gkr-tool-import.c
+++ b/tool/gkr-tool-import.c
@@ -27,7 +27,9 @@
#include "gp11/gp11.h"
-#include "pkcs11/pkcs11g.h"
+#include "gcr/gcr-importer.h"
+
+#include "egg/egg-hex.h"
static gchar **import_files = NULL;
@@ -37,23 +39,15 @@ static GOptionEntry import_entries[] = {
{ NULL }
};
-static const gulong ATTR_TYPES[] = {
- CKA_LABEL,
- CKA_CLASS,
- CKA_ID
-};
-
-static const char HEXC[] = "0123456789ABCDEF";
-
static void
-print_object_information (GP11Object *object)
+on_imported (GcrImporter *importer, GP11Object *object)
{
GP11Attributes *attrs;
GP11Attribute *id;
CK_OBJECT_CLASS klass;
const gchar *message;
GError *err = NULL;
- gchar *label;
+ gchar *label, *hex;
attrs = gp11_attributes_new_empty (CKA_LABEL, CKA_CLASS, CKA_ID, -1);
if (!gp11_object_get_full (object, attrs, NULL, &err)) {
@@ -91,133 +85,23 @@ print_object_information (GP11Object *object)
g_print (message, label);
if (id) {
- guchar *data = id->value;
- gsize n_data = id->length;
- gchar pair[3];
-
- g_print ("\tID: ");
-
- while(n_data > 0) {
- pair[0] = HEXC[*(data) >> 4 & 0xf];
- pair[1] = HEXC[*(data++) & 0xf];
- pair[2] = 0;
- n_data--;
- g_print ("%s", pair);
- }
-
- g_print ("\n");
+ hex = egg_hex_encode (id->value, id->length);
+ g_print ("\tID: %s\n", hex);
+ g_free (hex);
}
gp11_attributes_unref (attrs);
g_free (label);
}
-static void
-print_import_information (GP11Session *session, GP11Object *import)
-{
- CK_OBJECT_HANDLE_PTR handles;
- CK_ULONG n_handles;
- gsize length;
- GList *objects, *l;
- GP11Slot *slot;
- GError *err;
-
- handles = gp11_object_get_data (import, CKA_GNOME_IMPORT_OBJECTS, &length, &err);
- if (!handles) {
- gkr_tool_handle_error (&err, "couldn't find imported objects");
- return;
- }
-
- n_handles = length / sizeof (CK_OBJECT_HANDLE);
-
- slot = gp11_session_get_slot (session);
- g_return_if_fail (slot);
-
- objects = gp11_objects_from_handle_array (slot, handles, n_handles);
- g_free (handles);
- g_object_unref (slot);
-
- for (l = objects; l; l = g_list_next (l))
- print_object_information (GP11_OBJECT (l->data));
-
- gp11_list_unref_free (objects);
-}
-
-static int
-import_from_file (GP11Session *session, const gchar *filename)
-{
- GError *err = NULL;
- GP11Object *import;
- GP11Attributes *attrs;
- gchar *basename;
- gchar *data;
- gsize n_data;
-
- /* Read in the file data */
- if (!g_file_get_contents (filename, &data, &n_data, &err)) {
- gkr_tool_handle_error (&err, NULL);
- return 1;
- }
-
- /* Setup the attributes on the object */
- attrs = gp11_attributes_new ();
- gp11_attributes_add_data (attrs, CKA_VALUE, data, n_data);
- gp11_attributes_add_boolean (attrs, CKA_TOKEN, FALSE);
- gp11_attributes_add_ulong (attrs, CKA_CLASS, CKO_GNOME_IMPORT);
- gp11_attributes_add_boolean (attrs, CKA_GNOME_IMPORT_TOKEN, TRUE);
- basename = g_path_get_basename (filename);
- gp11_attributes_add_string (attrs, CKA_GNOME_IMPORT_LABEL, basename);
- g_free (basename);
-
- import = gp11_session_create_object_full (session, attrs, NULL, &err);
- gp11_attributes_unref (attrs);
- g_free (data);
-
- if (!import) {
- gkr_tool_handle_error (&err, "couldn't import file: %s", filename);
- return 1;
- }
-
- if (!gkr_tool_mode_quiet)
- print_import_information (session, import);
-
- g_object_unref (import);
- return 0;
-}
-
-static GP11Session*
-open_import_session (void)
-{
- GP11Module *module;
- GP11Session *session;
- GList *slots;
- GError *err = NULL;
-
- module = gp11_module_initialize (PKCS11_MODULE_PATH, NULL, &err);
- if (!module) {
- gkr_tool_handle_error (&err, NULL);
- return NULL;
- }
-
- slots = gp11_module_get_slots (module, FALSE);
- g_return_val_if_fail (slots && slots->data, NULL);
-
- session = gp11_slot_open_session(slots->data, CKF_RW_SESSION, &err);
- gp11_list_unref_free (slots);
- g_object_unref (module);
-
- if (!session) {
- gkr_tool_handle_error (&err, "couldn't connect to gnome-keyring");
- return NULL;
- }
-
- return session;
-}
-
int
gkr_tool_import (int argc, char *argv[])
{
- GP11Session *session;
+ GcrImporter *importer;
+ GError *error = NULL;
+ GInputStream *input;
+ gboolean res;
+ GFile *file;
gchar **imp;
int ret = 0;
@@ -230,17 +114,31 @@ gkr_tool_import (int argc, char *argv[])
return 2;
}
- /* Open a session */
- session = open_import_session ();
- if (!session)
- return 1;
+ importer = gcr_importer_new ();
+ gcr_importer_set_prompt_behavior (importer, GCR_IMPORTER_PROMPT_NEEDED);
+
+ if (!gkr_tool_mode_quiet)
+ g_signal_connect (importer, "imported", G_CALLBACK (on_imported), NULL);
for (imp = import_files; *imp; ++imp) {
- ret = import_from_file (session, *imp);
- if (ret != 0)
- break;
+ file = g_file_new_for_commandline_arg (*imp);
+
+ input = G_INPUT_STREAM (g_file_read (file, NULL, &error));
+ g_object_unref (file);
+ if (!input) {
+ gkr_tool_handle_error (&error, "couldn't read file: %s", *imp);
+ ret = 1;
+ }
+
+ res = gcr_importer_import (importer, input, NULL, &error);
+ g_object_unref (input);
+ if (res == FALSE) {
+ if (!error || error->code != GCR_ERROR_CANCELLED)
+ gkr_tool_handle_error (&error, "couldn't import file: %s", *imp);
+ ret = 1;
+ }
}
- g_object_unref (session);
+ g_object_unref (importer);
return ret;
}
diff --git a/tool/gkr-tool.c b/tool/gkr-tool.c
index a3184849..57343372 100644
--- a/tool/gkr-tool.c
+++ b/tool/gkr-tool.c
@@ -25,9 +25,8 @@
#include "gkr-tool.h"
-#include <glib.h>
#include <glib/gi18n.h>
-#include <glib-object.h>
+#include <gtk/gtk.h>
#include <locale.h>
#include <string.h>
@@ -127,6 +126,8 @@ main (int argc, char *argv[])
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
+ gtk_init (&argc, &argv);
+
/* The first argument is the command */
if (argc < 2) {
print_general_usage ();
View Lorry Controller Status