--- /dev/null	2006-10-05 20:08:52.821361324 -0400
+++ gdm-2.16.0/config/securitytokens.conf.in	2006-10-05 21:20:32.000000000 -0400
@@ -0,0 +1,3 @@
+[SecurityTokens]
+Enable=true
+#Driver=@libdir@/pkcs11/libcoolkeypk11.so
--- gdm-2.16.0/config/Makefile.am.security-tokens	2006-05-18 14:39:13.000000000 -0400
+++ gdm-2.16.0/config/Makefile.am	2006-10-05 21:20:32.000000000 -0400
@@ -34,9 +34,10 @@
 	XKeepsCrashing \
 	gettextfoo.h \
 	gdmprefetchlist.in \
+	securitytokens.conf.in \
 	extract-shell.sh
 
-CLEANFILES = Xsession gdm.conf default.desktop gnome.desktop CDE.desktop ssh.desktop Init PreSession PostSession gdmprefetchlist
+CLEANFILES = Xsession gdm.conf default.desktop gnome.desktop CDE.desktop ssh.desktop Init PreSession PostSession gdmprefetchlist securitytokens.conf
 
 Xsession: $(srcdir)/Xsession.in
 	sed	-e 's,[@]XSESSION_SHELL[@],$(XSESSION_SHELL),g' \
@@ -67,6 +68,31 @@
 		-e 's,[@]sbindir[@],$(sbindir),g' \
 		<$(srcdir)/gdm.conf.in >gdm.conf
 
+securitytokens.conf: $(srcdir)/securitytokens.conf.in
+	sed	-e 's,[@]GDMPREFETCHCMD[@],$(GDMPREFETCHCMD),g' \
+		-e 's,[@]GDM_USER_PATH[@],$(GDM_USER_PATH),g' \
+		-e 's,[@]HALT_COMMAND[@],$(HALT_COMMAND),g' \
+		-e 's,[@]REBOOT_COMMAND[@],$(REBOOT_COMMAND),g' \
+		-e 's,[@]SOUND_PROGRAM[@],$(SOUND_PROGRAM),g' \
+		-e 's,[@]SUSPEND_COMMAND[@],$(SUSPEND_COMMAND),g' \
+		-e 's,[@]XEVIE_OPTION[@],$(XEVIE_OPTION),g' \
+		-e 's,[@]X_CONFIG_OPTIONS[@],$(X_CONFIG_OPTIONS),g' \
+		-e 's,[@]X_SERVER[@],$(X_SERVER),g' \
+		-e 's,[@]X_XNEST_CONFIG_OPTIONS[@],$(X_XNEST_CONFIG_OPTIONS),g' \
+		-e 's,[@]X_XNEST_PATH[@],$(X_XNEST_PATH),g' \
+		-e 's,[@]authdir[@],$(authdir),g' \
+		-e 's,[@]datadir[@],$(datadir),g' \
+		-e 's,[@]dmconfdir[@],$(dmconfdir),g' \
+		-e 's,[@]gdmconfdir[@],$(gdmconfdir),g' \
+		-e 's,[@]libdir[@],$(libdir),g' \
+		-e 's,[@]libexecdir[@],$(libexecdir),g' \
+		-e 's,[@]localedir[@],$(libexecdir),g' \
+		-e 's,[@]logdir[@],$(logdir),g' \
+		-e 's,[@]pixmapdir[@],$(pixmapdir),g' \
+		-e 's,[@]sbindir[@],$(sbindir),g' \
+		<$(srcdir)/securitytokens.conf.in >securitytokens.conf
+
+
 gettextfoo.h: XKeepsCrashing Xsession.in
 	cat $^ | $(srcdir)/extract-shell.sh > gettextfoo.h
 
@@ -95,7 +121,7 @@
 	$(DESTDIR)$(predir)/Default \
 	$(DESTDIR)$(postdir)/Default
 
-install-data-hook: gdm.conf gdm.conf-custom Xsession Init PostSession PreSession $(DESKTOP_FILES) $(GDMPREFETCHLIST)
+install-data-hook: gdm.conf gdm.conf-custom Xsession Init PostSession PreSession $(DESKTOP_FILES) $(GDMPREFETCHLIST) securitytokens.conf
 	if test '!' -d $(DESTDIR)$(confdir); then \
 		$(mkinstalldirs) $(DESTDIR)$(confdir); \
 		chmod 755 $(DESTDIR)$(confdir); \
@@ -128,6 +154,7 @@
 		chmod 644 $(DESTDIR)$(GDM_CUSTOM_CONF); \
 	fi
 	$(INSTALL_DATA) gdm.conf `dirname $(DESTDIR)$(GDM_DEFAULTS_CONF)`/factory-`basename $(DESTDIR)$(GDM_DEFAULTS_CONF)`
+	$(INSTALL_DATA) securitytokens.conf $(DESTDIR)$(confdir)/securitytokens.conf
 
 	$(INSTALL_SCRIPT) $(srcdir)/XKeepsCrashing $(DESTDIR)$(confdir)/XKeepsCrashing
 	$(INSTALL_SCRIPT) Xsession $(DESTDIR)$(confdir)/Xsession
--- gdm-2.16.0/config/gdm.conf.in.security-tokens	2006-10-05 21:20:32.000000000 -0400
+++ gdm-2.16.0/config/gdm.conf.in	2006-10-05 21:20:32.000000000 -0400
@@ -199,6 +199,10 @@
 # kills it.  10 seconds should be long enough for X, but Xgl may need 20 or 25. 
 GdmXserverTimeout=10
 
+# Whether or not to listen for smart card insertion/removal events
+SecurityTokensEnable=true
+SecurityTokensDriver=
+
 [security]
 # Allow root to login.  It makes sense to turn this off for kiosk use, when
 # you want to minimize the possibility of break in.
--- gdm-2.16.0/configure.ac.security-tokens	2006-10-05 21:20:32.000000000 -0400
+++ gdm-2.16.0/configure.ac	2006-10-05 21:20:32.000000000 -0400
@@ -19,6 +19,7 @@
 LIBXML_REQUIRED=2.4.12
 LIBART_REQUIRED=2.3.11
 SCROLLKEEPER_REQUIRED=0.1.4
+NSS_REQUIRED=3.11.1
 
 dnl
 dnl Let the user configure where to look for the configuration files.
@@ -156,7 +157,7 @@
 AC_SUBST(VICIOUS_CFLAGS)
 AC_SUBST(VICIOUS_LIBS)
 
-PKG_CHECK_MODULES(DAEMON, gtk+-2.0 >= $GTK_REQUIRED)
+PKG_CHECK_MODULES(DAEMON, gtk+-2.0 >= $GTK_REQUIRED nss >= $NSS_REQUIRED)
 AC_SUBST(DAEMON_CFLAGS)
 AC_SUBST(DAEMON_LIBS)
 
--- /dev/null	2006-10-05 20:08:52.821361324 -0400
+++ gdm-2.16.0/daemon/securitytokenmonitor.c	2006-10-05 21:25:26.000000000 -0400
@@ -0,0 +1,1619 @@
+/* securitytokenmonitor.c - monitor for security token insertion and
+ *                          removal events
+ * 
+ * Copyright (C) 2006 Ray Strode <rstrode@redhat.com>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ *
+ * TODO:     - doing this per project is a bad idea i think.
+ *             We should probably make this a system service 
+ *             and use dbus.
+ */
+#include "securitytokenmonitor.h"
+
+#define SC_SECURITY_TOKEN_ENABLE_INTERNAL_API
+#include "securitytoken.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <prerror.h>
+#include <nss.h>
+#include <pk11func.h>
+#include <secmod.h>
+#include <secerr.h>
+
+#ifndef SC_SECURITY_TOKEN_MONITOR_DRIVER
+#define SC_SECURITY_TOKEN_MONITOR_DRIVER LIBDIR"/pkcs11/libcoolkeypk11.so"
+#endif
+
+#ifndef SC_SECURITY_TOKEN_MONITOR_NSS_DB
+#define SC_SECURITY_TOKEN_MONITOR_NSS_DB SYSCONFDIR"/pki/nssdb"
+#endif 
+
+#ifndef SC_MAX_OPEN_FILE_DESCRIPTORS
+#define SC_MAX_OPEN_FILE_DESCRIPTORS 1024
+#endif
+
+#ifndef SC_OPEN_FILE_DESCRIPTORS_DIR
+#define SC_OPEN_FILE_DESCRIPTORS_DIR "/proc/self/fd"
+#endif
+
+#ifndef sc_debug
+#if defined (SC_SECURITY_TOKEN_MONITOR_ENABLE_TEST)
+#define sc_debug(fmt, args...) g_printerr("[%u] " fmt " \n", getpid(), ##args)
+#else
+#define sc_debug(fmt, args...) 
+#endif
+#endif
+
+typedef enum _ScSecurityTokenMonitorState ScSecurityTokenMonitorState;
+typedef struct _ScSecurityTokenMonitorWorker ScSecurityTokenMonitorWorker;
+
+enum _ScSecurityTokenMonitorState {
+	SC_SECURITY_TOKEN_MONITOR_STATE_STOPPED = 0,
+	SC_SECURITY_TOKEN_MONITOR_STATE_STARTING,
+	SC_SECURITY_TOKEN_MONITOR_STATE_STARTED,
+	SC_SECURITY_TOKEN_MONITOR_STATE_STOPPING,
+};
+
+struct _ScSecurityTokenMonitorPrivate {
+	ScSecurityTokenMonitorState state;
+	SECMODModule *module;
+	gchar        *module_path;
+
+	GSource *security_token_event_source;
+	GPid security_token_event_watcher_pid;
+	GHashTable *security_tokens;
+
+	guint poll_timeout_id;
+
+	guint32 is_unstoppable : 1;
+	guint32 nss_is_loaded : 1;
+
+#ifndef SC_SECURITY_TOKEN_MONITOR_DRIVER_CAN_BE_RELOADED_AFTER_BEING_DESTROYED
+	GArray *fds_to_close_on_fork;
+#endif 
+};
+
+struct _ScSecurityTokenMonitorWorker {
+	SECMODModule *module;
+	GHashTable *security_tokens;
+	gint output_fd;
+
+	guint32 nss_is_loaded : 1;
+};
+
+static void sc_security_token_monitor_finalize (GObject *object);
+static void sc_security_token_monitor_class_install_signals (ScSecurityTokenMonitorClass *service_class);
+static void sc_security_token_monitor_class_install_properties (ScSecurityTokenMonitorClass *service_class);
+static void sc_security_token_monitor_set_property (GObject       *object,
+						    guint          prop_id,
+						    const GValue  *value,
+						    GParamSpec    *pspec);
+static void sc_security_token_monitor_get_property (GObject    *object,
+						    guint       prop_id,
+						    GValue     *value,
+						    GParamSpec *pspec);
+static void sc_security_token_monitor_set_module_path (ScSecurityTokenMonitor *monitor,
+						       const gchar            *module_path);
+static void sc_security_token_monitor_token_removed_handler (ScSecurityTokenMonitor *monitor,
+							     ScSecurityToken        *token);
+static void sc_security_token_monitor_token_inserted_handler (ScSecurityTokenMonitor *monitor_class,
+							      ScSecurityToken        *token);
+static gboolean sc_security_token_monitor_stop_now (ScSecurityTokenMonitor *monitor);
+static void sc_security_token_monitor_queue_stop (ScSecurityTokenMonitor *monitor);
+
+static gboolean sc_security_token_monitor_create_worker (ScSecurityTokenMonitor *monitor,
+							 gint *worker_fd, GPid *worker_pid);
+
+static ScSecurityTokenMonitorWorker * sc_security_token_monitor_worker_new (gint output_fd);
+static void sc_security_token_monitor_worker_free (ScSecurityTokenMonitorWorker *worker);
+
+static gboolean sc_open_pipe (gint *input_fd, gint *output_fd);
+static gboolean sc_read_bytes (gint fd, gpointer bytes, gsize num_bytes);
+static gboolean sc_write_bytes (gint fd, gconstpointer bytes, gsize num_bytes);
+static ScSecurityToken *sc_read_security_token (gint fd, SECMODModule *module);
+static gboolean sc_write_security_token (gint fd, ScSecurityToken *token);
+
+enum {
+	PROP_0 = 0,
+	PROP_MODULE_PATH,
+	NUMBER_OF_PROPERTIES
+};
+
+enum {
+	SECURITY_TOKEN_INSERTED = 0,
+	SECURITY_TOKEN_REMOVED,
+	ERROR,
+	NUMBER_OF_SIGNALS
+};
+
+static guint sc_security_token_monitor_signals[NUMBER_OF_SIGNALS];
+
+G_DEFINE_TYPE (ScSecurityTokenMonitor, 
+	       sc_security_token_monitor, 
+	       G_TYPE_OBJECT);
+
+static void
+sc_security_token_monitor_class_init (ScSecurityTokenMonitorClass *monitor_class)
+{
+    GObjectClass *gobject_class;
+
+    gobject_class = G_OBJECT_CLASS (monitor_class);
+
+    gobject_class->finalize = sc_security_token_monitor_finalize;
+
+    sc_security_token_monitor_class_install_signals (monitor_class);
+    sc_security_token_monitor_class_install_properties (monitor_class);
+
+    g_type_class_add_private (monitor_class,
+			      sizeof (ScSecurityTokenMonitorPrivate));
+}
+
+static void
+sc_security_token_monitor_class_install_properties (ScSecurityTokenMonitorClass *token_class)
+{
+    GObjectClass *object_class;
+    GParamSpec *param_spec;
+
+    object_class = G_OBJECT_CLASS (token_class);
+    object_class->set_property = sc_security_token_monitor_set_property;
+    object_class->get_property = sc_security_token_monitor_get_property;
+
+    param_spec = g_param_spec_string ("module-path", _("Module Path"),
+				      _("path to security token PKCS #11 driver"),
+				      NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+    g_object_class_install_property (object_class, PROP_MODULE_PATH, param_spec);
+}
+
+static void 
+sc_security_token_monitor_set_property (GObject       *object,
+					guint          prop_id,
+					const GValue  *value,
+					GParamSpec    *pspec)
+{
+    ScSecurityTokenMonitor *monitor = SC_SECURITY_TOKEN_MONITOR (object);
+
+    switch (prop_id)
+    {
+	    case PROP_MODULE_PATH:
+		    sc_security_token_monitor_set_module_path (monitor, 
+							       g_value_get_string (value));
+		    break;
+
+	    default:
+		    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		    break;
+    }
+}
+
+static void 
+sc_security_token_monitor_get_property (GObject    *object,
+					guint       prop_id,
+					GValue     *value,
+					GParamSpec *pspec)
+{
+    ScSecurityTokenMonitor *monitor = SC_SECURITY_TOKEN_MONITOR (object);
+    gchar *module_path;
+
+    switch (prop_id)
+    {
+	    case PROP_MODULE_PATH:
+		    module_path = sc_security_token_monitor_get_module_path (monitor);
+		    g_value_set_string (value, module_path);
+		    g_free (module_path);
+		    break;
+
+	    default:
+		    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		    break;
+    }
+}
+
+gchar *
+sc_security_token_monitor_get_module_path (ScSecurityTokenMonitor *monitor)
+{
+    return monitor->priv->module_path;
+}
+
+static void
+sc_security_token_monitor_set_module_path (ScSecurityTokenMonitor *monitor,
+					   const gchar            *module_path)
+{
+    /* For now we hardcode coolkey. Later we'll remove these lines
+     */
+    if (module_path == NULL) {
+	    if (g_file_test (SC_SECURITY_TOKEN_MONITOR_DRIVER,
+			     G_FILE_TEST_IS_REGULAR))
+		    module_path = SC_SECURITY_TOKEN_MONITOR_DRIVER;
+    }
+
+    if ((monitor->priv->module_path == NULL) && (module_path == NULL))
+	    return;
+
+    if (((monitor->priv->module_path == NULL) ||
+	 (module_path == NULL) ||
+	 (strcmp (monitor->priv->module_path, module_path) != 0))) {
+	    g_free (monitor->priv->module_path);
+	    monitor->priv->module_path = g_strdup (module_path);
+	    g_object_notify (G_OBJECT (monitor), "module-path");
+    }
+}
+
+static void
+sc_security_token_monitor_token_removed_handler (ScSecurityTokenMonitor *monitor,
+						 ScSecurityToken        *token)
+{
+    sc_debug ("informing security token of its removal");
+    _sc_security_token_set_state (token, SC_SECURITY_TOKEN_STATE_REMOVED);
+    sc_debug ("done");
+}
+
+static void
+sc_security_token_monitor_token_inserted_handler (ScSecurityTokenMonitor *monitor,
+						  ScSecurityToken        *token)
+{
+    sc_debug ("informing security token of its insertion");
+
+    _sc_security_token_set_state (token, SC_SECURITY_TOKEN_STATE_INSERTED);
+    sc_debug ("done");
+
+}
+
+static void
+sc_security_token_monitor_class_install_signals (ScSecurityTokenMonitorClass *monitor_class)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (monitor_class);
+
+    sc_security_token_monitor_signals[SECURITY_TOKEN_INSERTED] =
+	    g_signal_new ("security-token-inserted",
+			  G_OBJECT_CLASS_TYPE (object_class),
+			  G_SIGNAL_RUN_FIRST,
+			  G_STRUCT_OFFSET (ScSecurityTokenMonitorClass,
+					   security_token_inserted), 
+			  NULL, NULL, g_cclosure_marshal_VOID__POINTER, 
+			  G_TYPE_NONE, 1, G_TYPE_POINTER);
+    monitor_class->security_token_inserted = sc_security_token_monitor_token_inserted_handler;
+
+    sc_security_token_monitor_signals[SECURITY_TOKEN_REMOVED] =
+	    g_signal_new ("security-token-removed",
+			  G_OBJECT_CLASS_TYPE (object_class),
+			  G_SIGNAL_RUN_FIRST,
+			  G_STRUCT_OFFSET (ScSecurityTokenMonitorClass,
+					   security_token_removed), 
+			  NULL, NULL, g_cclosure_marshal_VOID__POINTER, 
+			  G_TYPE_NONE, 1, G_TYPE_POINTER);
+    monitor_class->security_token_removed = sc_security_token_monitor_token_removed_handler;
+
+    sc_security_token_monitor_signals[ERROR] =
+	    g_signal_new ("error",
+			  G_OBJECT_CLASS_TYPE (object_class),
+			  G_SIGNAL_RUN_LAST,
+			  G_STRUCT_OFFSET (ScSecurityTokenMonitorClass, error),
+			  NULL, NULL, g_cclosure_marshal_VOID__POINTER,
+			  G_TYPE_NONE, 1, G_TYPE_POINTER);
+    monitor_class->error = NULL;
+}
+
+static gboolean
+sc_slot_id_equal (CK_SLOT_ID *slot_id_1, 
+		  CK_SLOT_ID *slot_id_2)
+{
+    g_assert (slot_id_1 != NULL);
+    g_assert (slot_id_2 != NULL);
+
+    return *slot_id_1 == *slot_id_2;
+}
+
+static gboolean
+sc_slot_id_hash (CK_SLOT_ID *slot_id) 
+{
+    guint32 upper_bits, lower_bits;
+    gint temp;
+
+    if (sizeof (CK_SLOT_ID) == sizeof (gint))
+	    return g_int_hash (slot_id);
+
+    upper_bits = ((*slot_id) >> 31) - 1;
+    lower_bits = (*slot_id) & 0xffffffff;
+
+    /* The upper bits are almost certainly always zero,
+     * so let's degenerate to g_int_hash for the 
+     * (very) common case
+     */
+    temp = lower_bits + upper_bits;
+    return upper_bits + g_int_hash (&temp);
+}
+
+static void
+sc_security_token_monitor_init (ScSecurityTokenMonitor *monitor)
+{
+    sc_debug ("initializing security token monitor");
+
+    monitor->priv = G_TYPE_INSTANCE_GET_PRIVATE (monitor,
+						 SC_TYPE_SECURITY_TOKEN_MONITOR,
+						 ScSecurityTokenMonitorPrivate);
+    monitor->priv->poll_timeout_id = 0;
+    monitor->priv->is_unstoppable = FALSE;
+    monitor->priv->module = NULL;
+
+    monitor->priv->security_tokens = 
+	    g_hash_table_new_full (g_str_hash, 
+				   g_str_equal,
+				   (GDestroyNotify) g_free, 
+				   (GDestroyNotify) g_object_unref);
+
+#ifndef SC_SECURITY_TOKEN_MONITOR_DRIVER_CAN_BE_RELOADED_AFTER_BEING_DESTROYED
+    monitor->priv->fds_to_close_on_fork = g_array_new (FALSE, FALSE, sizeof (gint));
+#endif
+
+}
+
+static void 
+sc_security_token_monitor_finalize (GObject *object)
+{
+    ScSecurityTokenMonitor *monitor;
+    GObjectClass *gobject_class;
+
+    monitor = SC_SECURITY_TOKEN_MONITOR (object);
+    gobject_class =
+	    G_OBJECT_CLASS (sc_security_token_monitor_parent_class);
+
+    sc_security_token_monitor_stop_now (monitor);
+
+    g_hash_table_destroy (monitor->priv->security_tokens);
+    monitor->priv->security_tokens = NULL;
+
+#ifndef SC_SECURITY_TOKEN_MONITOR_DRIVER_CAN_BE_RELOADED_AFTER_BEING_DESTROYED
+    g_array_free (monitor->priv->fds_to_close_on_fork, TRUE);
+#endif 
+
+    gobject_class->finalize (object);
+}
+
+GQuark 
+sc_security_token_monitor_error_quark (void)
+{
+    static GQuark error_quark = 0;
+
+    if (error_quark == 0)
+	    error_quark = g_quark_from_static_string ("sc-security-token-monitor-error-quark");
+
+    return error_quark;
+}
+
+ScSecurityTokenMonitor *
+sc_security_token_monitor_new (const gchar *module_path)
+{
+    ScSecurityTokenMonitor *instance;
+
+    instance = SC_SECURITY_TOKEN_MONITOR (g_object_new (SC_TYPE_SECURITY_TOKEN_MONITOR, 
+							"module-path", module_path,
+							NULL));
+
+    return instance;
+}
+
+static void 
+sc_security_token_monitor_emit_error (ScSecurityTokenMonitor *monitor,
+				      GError                 *error)
+{
+    monitor->priv->is_unstoppable = TRUE;
+    g_signal_emit (monitor, sc_security_token_monitor_signals[ERROR], 0,
+		   error);
+    monitor->priv->is_unstoppable = FALSE;
+}
+
+static void 
+sc_security_token_monitor_emit_security_token_inserted (ScSecurityTokenMonitor *monitor,
+							ScSecurityToken        *token)
+{
+    monitor->priv->is_unstoppable = TRUE;
+    g_signal_emit (monitor, sc_security_token_monitor_signals[SECURITY_TOKEN_INSERTED], 0,
+		   token);
+    monitor->priv->is_unstoppable = FALSE;
+}
+
+static void 
+sc_security_token_monitor_emit_security_token_removed (ScSecurityTokenMonitor *monitor,
+							ScSecurityToken        *token)
+{
+    ScSecurityTokenMonitorState old_state;
+
+    old_state = monitor->priv->state;
+    monitor->priv->is_unstoppable = TRUE;
+    g_signal_emit (monitor, sc_security_token_monitor_signals[SECURITY_TOKEN_REMOVED], 0,
+		   token);
+    monitor->priv->is_unstoppable = FALSE;
+}
+
+static gboolean
+sc_security_token_monitor_check_for_and_process_events (GIOChannel *io_channel,
+							GIOCondition condition,
+							ScSecurityTokenMonitor *monitor)
+{
+    ScSecurityToken *token;
+    gboolean should_stop;
+    guchar event_type;
+    gchar *token_name;
+    gint fd;
+
+    token = NULL;
+    should_stop = (condition & G_IO_HUP) || (condition & G_IO_ERR);
+
+    if (should_stop)
+	    sc_debug ("received %s on event socket, stopping "
+		      "monitor...", 
+		      (condition & G_IO_HUP) && (condition & G_IO_ERR)? 
+		      "error and hangup" : 
+		      (condition & G_IO_HUP)? 
+		      "hangup" : "error");
+
+    if (!(condition & G_IO_IN))
+	    goto out;
+
+    fd = g_io_channel_unix_get_fd (io_channel);
+
+    event_type = '\0';
+    if (!sc_read_bytes (fd, &event_type, 1)) {
+	    should_stop = TRUE;
+	    goto out;
+    }
+
+    token = sc_read_security_token (fd, monitor->priv->module);
+
+    if (token == NULL) {
+	    should_stop = TRUE;
+	    goto out;
+    }
+
+    token_name = sc_security_token_get_name (token);
+
+    switch (event_type) {
+	    case 'I':
+		    g_hash_table_replace (monitor->priv->security_tokens,
+					  token_name, token);
+		    token_name = NULL;
+
+		    sc_security_token_monitor_emit_security_token_inserted (monitor, token);
+		    token = NULL;
+		    break;
+
+	    case 'R':
+		    sc_security_token_monitor_emit_security_token_removed (monitor, token);
+		    if (!g_hash_table_remove (monitor->priv->security_tokens, token_name))
+			    sc_debug ("got removal event of unknown token!");
+		    g_free (token_name);
+		    token_name = NULL;
+		    token = NULL;
+		    break;
+
+	    default: 
+		    g_free (token_name);
+		    token_name = NULL;
+		    g_object_unref (token);
+
+		    should_stop = TRUE;
+		    break;
+    }
+
+out:
+    if (should_stop) {
+	    GError *error;
+
+	    error = g_error_new (SC_SECURITY_TOKEN_MONITOR_ERROR,
+				 SC_SECURITY_TOKEN_MONITOR_ERROR_WATCHING_FOR_EVENTS,
+				 "%s", (condition & G_IO_IN) ? g_strerror (errno) : _("received error or hang up from event source"));
+
+	    sc_security_token_monitor_emit_error (monitor, error);
+	    g_error_free (error);
+	    sc_security_token_monitor_stop_now (monitor);
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void
+sc_security_token_monitor_event_processing_stopped_handler (ScSecurityTokenMonitor *monitor)
+{
+    monitor->priv->security_token_event_source = NULL;
+    sc_security_token_monitor_stop_now (monitor);
+}
+
+/* sorta complex function that is nothing more than fork() without having
+ * to worry about reaping the child later with waitpid
+ */
+static GPid
+sc_fork_and_disown (void)
+{
+    pid_t child_pid;
+    GPid grandchild_pid;
+    gint input_fd, output_fd;
+    gint saved_errno;
+
+    input_fd = -1;
+    output_fd = -1;
+    if (!sc_open_pipe (&input_fd, &output_fd))
+	    return (GPid) -1;
+
+    child_pid = fork ();
+
+    if (child_pid < 0) {
+	    close (input_fd);
+	    close (output_fd);
+	    return (GPid) child_pid;
+    }
+
+    if (child_pid == 0) {
+
+	    /* close the end of the pipe we're not going to use
+	     */
+	    close (output_fd);
+
+	    /* fork again 
+	     */
+	    child_pid = fork ();
+
+	    /* in the event of error, write out negative errno
+	     */
+	    if (child_pid < 0) {
+		    child_pid = -1 * errno;
+
+		    sc_write_bytes (input_fd, &child_pid, sizeof (child_pid));
+		    close (input_fd);
+		    _exit (1);
+	    }
+
+	    /* otherwise write out the pid of the child and exit
+	     */
+	    if (child_pid != 0) {
+
+		    signal (SIGPIPE, SIG_IGN);
+
+		    if (!sc_write_bytes (input_fd, &child_pid, sizeof (child_pid))) {
+			    kill (SIGKILL, child_pid);
+			    _exit (2);
+		    }
+		    close (input_fd);
+		    _exit (0);
+	    }
+	    close (input_fd);
+
+	    /* we're done, we've forked without having to worry about
+	     * reaping the child later
+	     */
+	    g_assert (child_pid == 0);
+	    return (GPid) 0;
+    }
+
+    /* close the end of the pipe we're not going to use
+     */
+    close (input_fd);
+
+    grandchild_pid = -1;
+    if (!sc_read_bytes (output_fd, &grandchild_pid, sizeof (grandchild_pid))) {
+	    grandchild_pid = -1;
+    }
+
+    saved_errno = errno;
+
+    /* close the other end of the pipe since we're done with it
+     */
+    close (output_fd);
+
+    /* wait for child to die (and emancipate the grandchild)
+     */
+    waitpid (child_pid, NULL, 0);
+    
+    errno = saved_errno;
+    return (GPid) grandchild_pid;
+}
+
+static gboolean
+sc_open_pipe (gint *input_fd,
+	      gint *output_fd)
+{
+    gint pipe_fds[2] = { -1, -1 };
+
+    g_assert (input_fd != NULL);
+    g_assert (output_fd != NULL);
+
+    if (pipe (pipe_fds) < 0)
+	    return FALSE;
+
+    if (fcntl (pipe_fds[0], F_SETFD, FD_CLOEXEC) < 0) {
+	    close (pipe_fds[0]);
+	    close (pipe_fds[1]);
+	    return FALSE;
+    }
+
+    if (fcntl (pipe_fds[1], F_SETFD, FD_CLOEXEC) < 0) {
+	    close (pipe_fds[0]);
+	    close (pipe_fds[1]);
+	    return FALSE;
+    }
+
+    *output_fd = pipe_fds[0];
+    *input_fd = pipe_fds[1];
+ 
+    return TRUE;
+}
+
+static void
+sc_security_token_monitor_stop_watching_for_events (ScSecurityTokenMonitor  *monitor)
+{
+    if (monitor->priv->security_token_event_source != NULL) {
+	    g_source_destroy (monitor->priv->security_token_event_source);
+	    monitor->priv->security_token_event_source = NULL;
+    }
+
+    if (monitor->priv->security_token_event_watcher_pid > 0) {
+	    kill (monitor->priv->security_token_event_watcher_pid, SIGKILL);
+	    monitor->priv->security_token_event_watcher_pid = 0;
+    }
+}
+
+static gboolean
+sc_load_nss (GError **error)
+{
+    SECStatus status = SECSuccess;
+    static const guint32 flags = 
+	NSS_INIT_READONLY| NSS_INIT_NOCERTDB | NSS_INIT_NOMODDB | 
+	NSS_INIT_FORCEOPEN | NSS_INIT_NOROOTINIT | 
+	NSS_INIT_OPTIMIZESPACE | NSS_INIT_PK11RELOAD;
+
+    sc_debug ("attempting to load NSS database '%s'",
+	      SC_SECURITY_TOKEN_MONITOR_NSS_DB);
+
+    status = NSS_Initialize (SC_SECURITY_TOKEN_MONITOR_NSS_DB,
+			     "", "", SECMOD_DB, flags);
+
+    if (status != SECSuccess) {
+	    gsize error_message_size;
+	    gchar *error_message;
+
+	    error_message_size = PR_GetErrorTextLength ();
+
+	    if (error_message_size == 0) {
+		    sc_debug ("NSS security system could not be initialized");
+		    g_set_error (error,
+				 SC_SECURITY_TOKEN_MONITOR_ERROR,
+				 SC_SECURITY_TOKEN_MONITOR_ERROR_WITH_NSS,
+				 _("NSS security system could not be initialized"));
+		    goto out;
+	    }
+
+	    error_message = g_slice_alloc0 (error_message_size);
+	    PR_GetErrorText (error_message);
+
+	    g_set_error (error,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR_WITH_NSS,
+			 "%s", error_message);
+	    sc_debug ("NSS security system could not be initialized - %s",
+		      error_message);
+
+	    g_slice_free1 (error_message_size, error_message);
+
+	    goto out;
+    }
+
+    sc_debug ("NSS database sucessfully loaded");
+    return TRUE;
+
+out:
+    sc_debug ("NSS database couldn't be sucessfully loaded");
+    return FALSE;
+}
+
+static SECMODModule *
+sc_load_driver (gchar   *module_path,
+		GError **error)
+{
+    SECMODModule *module;
+    gchar *module_spec;
+    gboolean module_explicitly_specified;
+
+    sc_debug ("attempting to load driver...");
+
+    module = NULL;
+    module_explicitly_specified = module_path != NULL;
+    if (module_explicitly_specified) {
+	    module_spec = g_strdup_printf ("library=\"%s\"", module_path);
+	    sc_debug ("loading security token driver using spec '%s'",
+		      module_spec);
+
+	    module = SECMOD_LoadUserModule (module_spec, 
+					    NULL /* parent */, 
+					    FALSE /* recurse */);
+	    g_free (module_spec);
+
+    } else {
+	    SECMODModuleList *modules, *tmp;
+
+	    modules = SECMOD_GetDefaultModuleList ();
+
+	    for (tmp = modules; tmp != NULL; tmp = tmp->next) {
+		    if (!SECMOD_HasRemovableSlots (tmp->module) ||
+			!tmp->module->loaded)
+			    continue;
+
+		    module = SECMOD_ReferenceModule (tmp->module);
+		    break;
+	    }
+    }
+
+    if (!module_explicitly_specified && module == NULL) {
+	    g_set_error (error,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR_LOADING_DRIVER,
+			 _("no suitable security token driver could be found"));
+    } else if (module == NULL || !module->loaded) {
+
+	    gsize error_message_size;
+	    gchar *error_message;
+            
+	    if (module != NULL && !module->loaded) {
+		    sc_debug ("module found but not loaded?!");
+		    SECMOD_DestroyModule (module);
+		    module = NULL;
+	    }
+
+	    error_message_size = PR_GetErrorTextLength ();
+
+	    if (error_message_size == 0) {
+		    sc_debug ("security token driver '%s' could not be loaded",
+			      module_path);
+		    g_set_error (error,
+				 SC_SECURITY_TOKEN_MONITOR_ERROR,
+				 SC_SECURITY_TOKEN_MONITOR_ERROR_LOADING_DRIVER,
+				 _("security token driver '%s' could not be "
+				   "loaded"), module_path);
+		    goto out;
+	    }
+
+	    error_message = g_slice_alloc0 (error_message_size);
+	    PR_GetErrorText (error_message);
+
+	    g_set_error (error,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR_LOADING_DRIVER,
+			 "%s", error_message);
+
+	    sc_debug ("security token driver '%s' could not be loaded - %s",
+		      module_path, error_message);
+	    g_slice_free1 (error_message_size, error_message);
+    }
+
+out:
+    return module;
+}
+
+gboolean
+sc_security_token_monitor_start (ScSecurityTokenMonitor  *monitor,
+				 GError                 **error)
+{
+    GError *watching_error;
+    gint worker_fd;
+    GPid worker_pid;
+    GIOChannel *io_channel;
+    GSource *source;
+    GIOFlags channel_flags;
+    GError *nss_error;
+
+    if (monitor->priv->state == SC_SECURITY_TOKEN_MONITOR_STATE_STARTED) {
+	    sc_debug ("security token monitor already started");
+	    return TRUE;
+    }
+
+    monitor->priv->state = SC_SECURITY_TOKEN_MONITOR_STATE_STARTING;
+
+    worker_fd = -1;
+    worker_pid = 0;
+
+    nss_error = NULL;
+    if (!monitor->priv->nss_is_loaded && !sc_load_nss (&nss_error)) {
+	    g_propagate_error (error, nss_error);
+	    goto out;
+    }
+    monitor->priv->nss_is_loaded = TRUE;
+
+    if (monitor->priv->module == NULL)
+	    monitor->priv->module = sc_load_driver (monitor->priv->module_path, &nss_error);
+
+    if (monitor->priv->module == NULL) {
+	    g_propagate_error (error, nss_error);
+	    goto out;
+    }
+
+    if (!sc_security_token_monitor_create_worker (monitor, &worker_fd, &worker_pid)) {
+
+	    g_set_error (error,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR_WATCHING_FOR_EVENTS,
+			 _("could not watch for incoming token events - %s"),
+			 g_strerror (errno));
+
+	    goto out;
+    }
+
+    monitor->priv->security_token_event_watcher_pid = worker_pid;
+
+    io_channel = g_io_channel_unix_new (worker_fd);
+
+    channel_flags = g_io_channel_get_flags (io_channel);
+    watching_error = NULL;
+
+    source = g_io_create_watch (io_channel, G_IO_IN | G_IO_HUP);
+    g_io_channel_unref (io_channel);
+    io_channel = NULL;
+
+    monitor->priv->security_token_event_source = source;
+
+    g_source_set_callback (monitor->priv->security_token_event_source,
+			   (GSourceFunc) (GIOFunc)
+			   sc_security_token_monitor_check_for_and_process_events,
+			   monitor,
+			   (GDestroyNotify)
+			   sc_security_token_monitor_event_processing_stopped_handler);
+    g_source_attach (monitor->priv->security_token_event_source, NULL);
+    g_source_unref (monitor->priv->security_token_event_source);
+
+    monitor->priv->state = SC_SECURITY_TOKEN_MONITOR_STATE_STARTED;
+
+out:
+    /* don't leave it in a half started state
+     */
+    if (monitor->priv->state != SC_SECURITY_TOKEN_MONITOR_STATE_STARTED) {
+	    sc_debug ("security token monitor could not be completely started");
+	    sc_security_token_monitor_stop (monitor);
+    } else
+	    sc_debug ("security token monitor started");
+
+    return monitor->priv->state == SC_SECURITY_TOKEN_MONITOR_STATE_STARTED;
+}
+
+static gboolean
+sc_security_token_monitor_stop_now (ScSecurityTokenMonitor *monitor)
+{
+    if (monitor->priv->state == SC_SECURITY_TOKEN_MONITOR_STATE_STOPPED)
+	    return FALSE;
+
+    monitor->priv->state = SC_SECURITY_TOKEN_MONITOR_STATE_STOPPED;
+    sc_security_token_monitor_stop_watching_for_events (monitor);
+#ifdef SC_SECURITY_TOKEN_MONITOR_DRIVER_CAN_BE_RELOADED_AFTER_BEING_DESTROYED
+    if (monitor->priv->module != NULL) {
+	    SECMOD_DestroyModule (monitor->priv->module);
+	    monitor->priv->module = NULL;
+    }
+
+    if (monitor->priv->nss_is_loaded) {
+	    NSS_Shutdown ();
+	    monitor->priv->nss_is_loaded = FALSE;
+    }
+#endif
+    sc_debug ("security token monitor stopped");
+    
+    return FALSE;
+}
+
+static void
+sc_security_token_monitor_queue_stop (ScSecurityTokenMonitor *monitor)
+{
+
+    monitor->priv->state = SC_SECURITY_TOKEN_MONITOR_STATE_STOPPING;
+
+    g_idle_add ((GSourceFunc) sc_security_token_monitor_stop_now, monitor);
+}
+
+void 
+sc_security_token_monitor_stop (ScSecurityTokenMonitor *monitor)
+{
+    if (monitor->priv->state == SC_SECURITY_TOKEN_MONITOR_STATE_STOPPED)
+	    return;
+
+    if (monitor->priv->is_unstoppable) {
+	    sc_security_token_monitor_queue_stop (monitor);
+	    return;
+    } 
+
+    sc_security_token_monitor_stop_now (monitor);
+}
+
+static void
+sc_security_token_monitor_check_for_login_token (CK_SLOT_ID       slot_id,
+						 ScSecurityToken *token,
+						 gboolean        *is_inserted)
+{
+    g_assert (is_inserted != NULL);
+
+    if (sc_security_token_is_login_token (token))
+	    *is_inserted = TRUE;
+
+}
+
+gboolean 
+sc_security_token_monitor_login_token_is_inserted (ScSecurityTokenMonitor *monitor) 
+
+{
+    gboolean is_inserted;
+
+    is_inserted = FALSE;
+    g_hash_table_foreach (monitor->priv->security_tokens, 
+			  (GHFunc)
+			  sc_security_token_monitor_check_for_login_token,
+			  &is_inserted);
+    return is_inserted;
+}
+
+static gint
+sc_get_max_open_fds (void)
+{
+  struct rlimit open_fd_limit;
+  const gint fallback_limit = SC_MAX_OPEN_FILE_DESCRIPTORS;
+
+  if (getrlimit (RLIMIT_NOFILE, &open_fd_limit) < 0) {
+	  sc_debug ("could not get file descriptor limit: %s",
+		    g_strerror (errno));
+	  sc_debug ("returning fallback file descriptor limit of %d",
+		    fallback_limit);
+	  return fallback_limit;
+  }
+
+  if (open_fd_limit.rlim_cur == RLIM_INFINITY) {
+	  sc_debug ("currently no file descriptor limit, returning fallback limit of %d",
+		    fallback_limit);
+	  return fallback_limit;
+  }
+
+  return (gint) open_fd_limit.rlim_cur;
+}
+
+static void
+sc_close_all_fds (int *fds_to_keep_open)
+{
+    int max_open_fds, fd;
+
+    sc_debug ("closing all file descriptors");
+    max_open_fds = sc_get_max_open_fds ();
+
+    for (fd = 0; fd < max_open_fds; fd++) {
+	    int i;
+	    gboolean should_close_fd;
+
+	    should_close_fd = TRUE;
+
+	    if (fds_to_keep_open != NULL) {
+		    for (i = 0; fds_to_keep_open[i] >= 0; i++) {
+			    if (fd == fds_to_keep_open[i]) {
+				    should_close_fd = FALSE;
+				    break;
+			    }
+		    }
+	    } 
+
+	    if (should_close_fd) {
+		    sc_debug ("closing file descriptor '%d'", fd);
+		    close (fd);
+	    }
+    }
+}
+
+static void
+sc_close_open_fds (int *fds_to_keep_open)
+{
+    /* using DIR instead of GDir because we need access to dirfd so
+     * that we can iterate through the fds and close them in one sweep.
+     * (if we just closed all of them then we would close the one we're using
+     * for reading the directory!)
+     */
+    DIR *dir;
+    struct dirent *entry;
+    gint fd, opendir_fd;
+    gboolean should_use_fallback;
+
+    should_use_fallback = FALSE;
+    opendir_fd = -1;
+
+    dir = opendir (SC_OPEN_FILE_DESCRIPTORS_DIR);
+
+    if (dir != NULL)
+	    opendir_fd = dirfd (dir);
+
+    if ((dir == NULL) || (opendir_fd < 0)) {
+	    sc_debug ("could not open "SC_OPEN_FILE_DESCRIPTORS_DIR": %s", g_strerror (errno));
+	    should_use_fallback = TRUE;
+    } else {
+	    sc_debug ("reading files in '"SC_OPEN_FILE_DESCRIPTORS_DIR"'");
+	    while ((entry = readdir (dir)) != NULL) {
+		    gint i;
+		    glong filename_as_number;
+		    gchar *byte_after_number;
+		    gboolean should_close_fd;
+
+		    errno = 0;
+		    if (entry->d_name[0] == '.')
+			    continue;
+
+		    sc_debug ("scanning filename '%s' for file descriptor number",
+			       entry->d_name);
+		    fd = -1;
+		    filename_as_number = strtol (entry->d_name, &byte_after_number, 10);
+
+		    g_assert (byte_after_number != NULL);
+
+		    if ((*byte_after_number != '\0') ||
+			(filename_as_number < 0) ||
+			(filename_as_number >= G_MAXINT)) {
+			    sc_debug ("filename '%s' does not appear to represent a "
+				       "file descriptor: %s",
+				       entry->d_name, strerror (errno));
+			    should_use_fallback = TRUE;
+		    } else {
+			    fd = (gint) filename_as_number;
+			    sc_debug ("filename '%s' represents file descriptor '%d'",
+				       entry->d_name, fd);
+			    should_use_fallback = FALSE;
+		    }
+
+		    if (fd == opendir_fd) {
+			    should_close_fd = FALSE;
+		    } else {
+			    should_close_fd = TRUE;
+			    if (fds_to_keep_open != NULL)
+				    for (i = 0; fds_to_keep_open[i] >= 0; i++) {
+					    if (fd == fds_to_keep_open[i]) {
+						    should_close_fd = FALSE;
+						    break;
+					    }
+				    }
+		    }
+
+		    if (should_close_fd) {
+			    sc_debug ("closing file descriptor '%d'", fd);
+			    close (fd);
+		    } else {
+			    sc_debug ("will not close file descriptor '%d' because it "
+				      "is still needed", fd);
+		    }
+	    }
+	    
+	    if (entry != NULL)
+		    should_use_fallback = TRUE;
+
+	    sc_debug ("closing directory '"SC_OPEN_FILE_DESCRIPTORS_DIR"'");
+	    closedir (dir);
+    }
+
+    /* if /proc isn't mounted or something else is screwy,
+     * fall back to closing everything
+     */
+    if (should_use_fallback)
+	    sc_close_all_fds (fds_to_keep_open);
+}
+
+static void
+sc_close_fds (gint *fds, 
+	      gint  num_fds)
+{
+    gint i;
+
+    for (i = 0; i < num_fds; i++)
+	    close (fds[i]);
+}
+
+static ScSecurityTokenMonitorWorker *
+sc_security_token_monitor_worker_new (gint output_fd)
+{
+    ScSecurityTokenMonitorWorker *worker;
+
+    worker = g_slice_new0 (ScSecurityTokenMonitorWorker);
+    worker->output_fd = output_fd;
+    worker->module = NULL;
+
+    worker->security_tokens =
+	    g_hash_table_new_full ((GHashFunc) sc_slot_id_hash, 
+				   (GEqualFunc) sc_slot_id_equal, 
+				   (GDestroyNotify) g_free, 
+				   (GDestroyNotify) g_object_unref);
+
+    return worker;
+}
+
+static void 
+sc_security_token_monitor_worker_free (ScSecurityTokenMonitorWorker *worker)
+{
+    if (worker->security_tokens != NULL) {
+	    g_hash_table_destroy (worker->security_tokens);
+	    worker->security_tokens = NULL;
+    }
+
+    g_slice_free (ScSecurityTokenMonitorWorker, worker);
+}
+
+static gboolean
+sc_read_bytes (gint fd, gpointer bytes, gsize num_bytes)
+{
+    size_t bytes_left;
+    size_t total_bytes_read;
+    ssize_t bytes_read;
+
+    bytes_left = (size_t) num_bytes;
+    total_bytes_read = 0;
+
+    do {
+	    bytes_read = read (fd, bytes + total_bytes_read, bytes_left);
+	    g_assert (bytes_read <= (ssize_t) bytes_left);
+
+	    if (bytes_read <= 0) {
+		    if ((bytes_read < 0) && (errno == EINTR || errno == EAGAIN))
+			    continue;
+
+		    bytes_left = 0;
+	    } else {
+		    bytes_left -= bytes_read;
+		    total_bytes_read += bytes_read;
+	    }
+    } while (bytes_left > 0);
+
+    if (total_bytes_read <  (size_t) num_bytes)
+	    return FALSE;
+
+    return TRUE;
+}
+
+static gboolean
+sc_write_bytes (gint fd, gconstpointer bytes, gsize num_bytes)
+{
+    size_t bytes_left;
+    size_t total_bytes_written;
+    ssize_t bytes_written;
+
+    bytes_left = (size_t) num_bytes;
+    total_bytes_written = 0;
+
+    do {
+	    bytes_written = write (fd, bytes + total_bytes_written, bytes_left);
+	    g_assert (bytes_written <= (ssize_t) bytes_left);
+
+	    if (bytes_written <= 0) {
+		    if ((bytes_written < 0) && (errno == EINTR || errno == EAGAIN))
+			    continue;
+
+		    bytes_left = 0;
+	    } else {
+		    bytes_left -= bytes_written;
+		    total_bytes_written += bytes_written;
+	    }
+    } while (bytes_left > 0);
+
+    if (total_bytes_written <  (size_t) num_bytes)
+	    return FALSE;
+
+    return TRUE;
+}
+
+static ScSecurityToken *
+sc_read_security_token (gint fd, SECMODModule *module)
+{
+    ScSecurityToken *token;
+    gchar *token_name;
+    gsize token_name_size;
+
+    token_name_size = 0;
+    if (!sc_read_bytes (fd, &token_name_size, sizeof (token_name_size)))
+	return NULL;
+
+    token_name = g_slice_alloc0 (token_name_size);
+    if (!sc_read_bytes (fd, token_name, token_name_size)) {
+	    g_slice_free1 (token_name_size, token_name);
+	    return NULL;
+    }
+    token = _sc_security_token_new_from_name (module, token_name);
+    g_slice_free1 (token_name_size, token_name);
+
+    return token;
+}
+
+static gboolean
+sc_write_security_token (gint             fd, 
+			 ScSecurityToken *token)
+{
+    gsize token_name_size;
+    gchar *token_name;
+
+    token_name = sc_security_token_get_name (token);
+    token_name_size = strlen (token_name) + 1;
+
+    if (!sc_write_bytes (fd, &token_name_size, sizeof (token_name_size))) {
+	g_free (token_name);
+	return FALSE;
+    }
+
+    if (!sc_write_bytes (fd, token_name, token_name_size)) {
+	g_free (token_name);
+	return FALSE;
+    }
+    g_free (token_name);
+
+    return TRUE;
+}
+
+static gboolean
+sc_security_token_monitor_worker_emit_security_token_removed (ScSecurityTokenMonitorWorker  *worker, 
+							      ScSecurityToken               *token, 
+							      GError                       **error)
+{
+    sc_debug ("token '%s' removed!", sc_security_token_get_name (token));
+
+    if (!sc_write_bytes (worker->output_fd, "R", 1)) 
+	    goto error_out;
+
+    if (!sc_write_security_token (worker->output_fd, token))
+	    goto error_out;
+
+    return TRUE;
+
+error_out:
+    g_set_error (error, SC_SECURITY_TOKEN_MONITOR_ERROR,
+		 SC_SECURITY_TOKEN_MONITOR_ERROR_REPORTING_EVENTS, 
+		 "%s", g_strerror (errno));
+    return FALSE;
+}
+
+static gboolean
+sc_security_token_monitor_worker_emit_security_token_inserted (ScSecurityTokenMonitorWorker  *worker, 
+							       ScSecurityToken               *token,
+							       GError                       **error)
+{
+    GError *write_error;
+
+    write_error = NULL;
+    sc_debug ("token '%s' inserted!", sc_security_token_get_name (token));
+    if (!sc_write_bytes (worker->output_fd, "I", 1)) 
+	    goto error_out;
+
+    if (!sc_write_security_token (worker->output_fd, token))
+	    goto error_out;
+
+    return TRUE;
+
+error_out:
+    g_set_error (error, SC_SECURITY_TOKEN_MONITOR_ERROR,
+		 SC_SECURITY_TOKEN_MONITOR_ERROR_REPORTING_EVENTS, 
+		 "%s", g_strerror (errno));
+    return FALSE;
+}
+
+static gboolean
+sc_security_token_monitor_worker_watch_for_and_process_event (ScSecurityTokenMonitorWorker *worker,
+							      GError                      **error)
+{
+    PK11SlotInfo *slot;
+    CK_SLOT_ID slot_id, *key;
+    gint slot_series, token_slot_series;
+    ScSecurityToken *token;
+    GError *processing_error;
+
+    sc_debug ("waiting for token event");
+
+    /* FIXME: we return FALSE quite a bit in this function without cleaning up
+     * resources.  By returning FALSE we're going to ultimately exit anyway, but
+     * we should still be tidier about things.
+     */
+
+    slot = SECMOD_WaitForAnyTokenEvent (worker->module, 0, PR_SecondsToInterval (1)); 
+    processing_error = NULL;
+
+    if (slot == NULL) {
+	    int error_code;
+
+	    error_code = PORT_GetError ();
+	    if ((error_code == 0) || (error_code == SEC_ERROR_NO_EVENT)) {
+		    sc_debug ("spurrious event occurred");
+		    return TRUE;
+	    }
+
+	    /* FIXME: is there a function to convert from a PORT error
+	     * code to a translated string?
+	     */
+	    g_set_error (error, SC_SECURITY_TOKEN_MONITOR_ERROR,
+			 SC_SECURITY_TOKEN_MONITOR_ERROR_WITH_NSS,
+			 _("encountered unexpected error while "
+			   "waiting for security token events"));
+	    return FALSE;
+    }
+
+    /* the slot id and series together uniquely identify a token.
+     * You can never have two tokens with the same slot id at the
+     * same time, however (I think), so we can key off of it.
+     */
+    slot_id = PK11_GetSlotID (slot);
+    slot_series = PK11_GetSlotSeries (slot);
+
+    /* First check to see if there is a token that we're currently
+     * tracking in the slot.
+     */
+    key = g_new (CK_SLOT_ID, 1);
+    *key = slot_id;
+    token = g_hash_table_lookup (worker->security_tokens, key);
+
+    if (token != NULL)
+	    token_slot_series = sc_security_token_get_slot_series (token);
+
+    if (PK11_IsPresent (slot)) {
+	    /* Now, check to see if their is a new token in the slot.
+	     * If there was a different token in the slot now than
+	     * there was before, then we need to emit a removed signal
+	     * for the old token (we don't want unpaired insertion events).
+	     */
+	    if ((token != NULL) && 
+		token_slot_series != slot_series) {
+		    if (!sc_security_token_monitor_worker_emit_security_token_removed (worker, token, &processing_error)) {
+			    g_propagate_error (error, processing_error);
+			    return FALSE;
+		    }
+	    }
+
+	    token = _sc_security_token_new (worker->module, 
+					    slot_id, slot_series);
+
+	    g_hash_table_replace (worker->security_tokens,
+				  key, token);
+	    key = NULL;
+
+	    if (!sc_security_token_monitor_worker_emit_security_token_inserted (worker, token, &processing_error)) {
+		    g_propagate_error (error, processing_error);
+		    return FALSE;
+	    }
+    } else {
+	    /* if we aren't tracking the token, just discard the event.
+	     * We don't want unpaired remove events.  Note on startup
+	     * NSS will generate an "insertion" event if a token is
+	     * already inserted in the slot.
+	     */
+	    if ((token != NULL)) {
+		    /* FIXME: i'm not sure about this code.  Maybe we
+		     * shouldn't do this at all, or maybe we should do it
+		     * n times (where n = slot_series - token_slot_series + 1)
+		     * 
+		     * Right now, i'm just doing it once.  
+		     */
+		    if ((slot_series - token_slot_series) > 1) {
+
+			    if (!sc_security_token_monitor_worker_emit_security_token_removed (worker, token, &processing_error)) {
+				    g_propagate_error (error, processing_error);
+				    return FALSE;
+			    }
+			    g_hash_table_remove (worker->security_tokens, key);
+
+			    token = _sc_security_token_new (worker->module, 
+							    slot_id, slot_series);
+			    g_hash_table_replace (worker->security_tokens,
+						  key, token);
+			    key = NULL;
+			    if (!sc_security_token_monitor_worker_emit_security_token_inserted (worker, token, &processing_error)) {
+				    g_propagate_error (error, processing_error);
+				    return FALSE;
+			    }
+		    }
+
+		    if (!sc_security_token_monitor_worker_emit_security_token_removed (worker, token, &processing_error)) {
+			    g_propagate_error (error, processing_error);
+			    return FALSE;
+		    }
+
+		    g_hash_table_remove (worker->security_tokens, key);
+		    token = NULL;
+	    } else {
+		    sc_debug ("got spurious remove event");
+	    }
+    }
+
+    g_free (key);
+    PK11_FreeSlot (slot);
+
+    return TRUE;
+}
+
+static gboolean
+sc_security_token_monitor_create_worker (ScSecurityTokenMonitor *monitor,
+					 gint *worker_fd, GPid *worker_pid)
+{
+    GPid child_pid;
+    gint input_fd, output_fd;
+
+    input_fd = -1;
+    output_fd = -1;
+    if (!sc_open_pipe (&input_fd, &output_fd))
+	    return FALSE;
+
+    child_pid = sc_fork_and_disown ();
+
+    if (child_pid < 0)
+	    return FALSE;
+
+    if (child_pid == 0) {
+	    GError *error;
+	    ScSecurityTokenMonitorWorker *worker;
+
+/* FIXME: Gotta figure out why this isn't working
+*/
+#ifdef SC_SECURITY_TOKEN_MONITOR_DRIVER_CAN_BE_RELOADED_AFTER_BEING_DESTROYED
+	    gint fds_to_keep_open[] = { -1, STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO, -1 };
+
+	    SECMOD_DestroyModule (monitor->priv->module);
+	    monitor->priv->module = NULL;
+
+	    NSS_Shutdown ();
+
+	    fds_to_keep_open[0] = input_fd;
+	    sc_close_open_fds (fds_to_keep_open);
+	    output_fd = -1;
+
+	    if (!sc_load_nss (&error)) {
+		    sc_debug ("could not load nss - %s", error->message);
+		    g_error_free (error);
+		    _exit (1);
+	    }
+#else
+	    /* Junky workaround to keep from leaking fds
+	     */
+	    sc_close_fds ((gint *) monitor->priv->fds_to_close_on_fork->data,
+			  monitor->priv->fds_to_close_on_fork->len);
+#endif
+	    error = NULL;
+
+	    worker = sc_security_token_monitor_worker_new (input_fd);
+
+	    worker->module = sc_load_driver (monitor->priv->module_path, &error);
+
+	    if (worker->module == NULL) {
+		    sc_debug ("could not load nss driver - %s", error->message);
+		    g_error_free (error);
+		    _exit (2);
+	    }
+
+	    while (sc_security_token_monitor_worker_watch_for_and_process_event (worker, &error));
+
+	    sc_debug ("could not process token event - %s", error->message);
+	    sc_security_token_monitor_worker_free (worker);
+
+	    _exit (0);
+    }
+    close (input_fd);
+
+#ifndef SC_SECURITY_TOKEN_MONITOR_DRIVER_CAN_BE_RELOADED_AFTER_BEING_DESTROYED
+    g_array_append_val (monitor->priv->fds_to_close_on_fork, output_fd);
+#endif
+
+    if (worker_pid)
+	    *worker_pid = child_pid;
+
+    if (worker_fd)
+	    *worker_fd = output_fd;
+
+    return TRUE;
+}
+
+#ifdef SC_SECURITY_TOKEN_MONITOR_ENABLE_TEST
+#include <glib.h>
+
+static GMainLoop *event_loop;
+static gboolean should_exit_on_next_remove = FALSE;
+
+static gboolean on_timeout (ScSecurityTokenMonitor *monitor)
+{
+    GError *error;
+    g_print ("Re-enabling monitor.\n");
+
+    if (!sc_security_token_monitor_start (monitor, &error)) {
+	    g_warning ("could not start security token monitor - %s",
+		       error->message);
+	    g_error_free (error);
+	    return 1;
+    }
+    g_print ("Please re-insert security token\n");
+
+    should_exit_on_next_remove = TRUE;
+
+    return FALSE;
+}
+
+static void
+on_device_inserted (ScSecurityTokenMonitor * monitor,
+		    ScSecurityToken *token)
+{
+    g_print ("security token inserted!\n");
+    g_print ("Please remove it.\n");
+}
+
+static void
+on_device_removed (ScSecurityTokenMonitor * monitor,
+		   ScSecurityToken *token)
+{
+    g_print ("security token removed!\n");
+
+    if (should_exit_on_next_remove)
+	    g_main_loop_quit (event_loop);
+    else {
+	    g_print ("disabling monitor for 2 seconds\n");
+	    sc_security_token_monitor_stop (monitor);
+	    g_timeout_add (2000, (GSourceFunc) on_timeout, monitor);
+    }
+}
+
+int 
+main (int   argc, 
+      char *argv[])
+{
+    ScSecurityTokenMonitor *monitor;
+    GError *error;
+
+    g_log_set_always_fatal (G_LOG_LEVEL_ERROR
+			    | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
+
+    g_type_init ();
+
+    g_message ("creating instance of 'security token monitor' object...");
+    monitor = sc_security_token_monitor_new (NULL);
+    g_message ("'security token monitor' object created successfully");
+
+    g_signal_connect (monitor, "security-token-inserted",
+		      G_CALLBACK (on_device_inserted), NULL);
+
+    g_signal_connect (monitor, "security-token-removed",
+		      G_CALLBACK (on_device_removed), NULL);
+
+    g_message ("starting listener...");
+
+    error = NULL;
+    if (!sc_security_token_monitor_start (monitor, &error)) {
+	    g_warning ("could not start security token monitor - %s",
+		       error->message);
+	    g_error_free (error);
+	    return 1;
+    }
+
+    event_loop = g_main_loop_new (NULL, FALSE);
+    g_main_loop_run (event_loop);
+    g_main_loop_unref (event_loop);
+    event_loop = NULL;
+
+    g_message ("destroying previously created 'security token monitor' object...");
+    g_object_unref (monitor);
+    monitor = NULL;
+    g_message ("'security token monitor' object destroyed successfully");
+
+    return 0;
+}
+#endif
--- /dev/null	2006-10-05 20:08:52.821361324 -0400
+++ gdm-2.16.0/daemon/securitytoken.h	2006-10-05 21:25:26.000000000 -0400
@@ -0,0 +1,94 @@
+/* securitytoken.h - api for reading and writing data to a security token 
+ *
+ * Copyright (C) 2006 Ray Strode
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ */
+#ifndef SC_SECURITY_TOKEN_H
+#define SC_SECURITY_TOKEN_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <secmod.h>
+
+G_BEGIN_DECLS
+#define SC_TYPE_SECURITY_TOKEN            (sc_security_token_get_type ())
+#define SC_SECURITY_TOKEN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SC_TYPE_SECURITY_TOKEN, ScSecurityToken))
+#define SC_SECURITY_TOKEN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SC_TYPE_SECURITY_TOKEN, ScSecurityTokenClass))
+#define SC_IS_SECURITY_TOKEN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SC_TYPE_SECURITY_TOKEN))
+#define SC_IS_SECURITY_TOKEN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SC_TYPE_SECURITY_TOKEN))
+#define SC_SECURITY_TOKEN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), SC_TYPE_SECURITY_TOKEN, ScSecurityTokenClass))
+#define SC_SECURITY_TOKEN_ERROR           (sc_security_token_error_quark ())
+typedef struct _ScSecurityTokenClass ScSecurityTokenClass;
+typedef struct _ScSecurityToken ScSecurityToken;
+typedef struct _ScSecurityTokenPrivate ScSecurityTokenPrivate;
+typedef enum _ScSecurityTokenError ScSecurityTokenError;
+typedef enum _ScSecurityTokenState ScSecurityTokenState;
+
+typedef struct _ScSecurityTokenRequest ScSecurityTokenRequest;
+
+struct _ScSecurityToken {
+    GObject parent;
+
+    /*< private > */
+    ScSecurityTokenPrivate *priv;
+};
+
+struct _ScSecurityTokenClass {
+    GObjectClass parent_class;
+
+    void (* inserted) (ScSecurityToken *token);
+    void (* removed) (ScSecurityToken *token);
+};
+
+enum _ScSecurityTokenError {
+    SC_SECURITY_TOKEN_ERROR_GENERIC = 0,
+};
+
+enum _ScSecurityTokenState {
+    SC_SECURITY_TOKEN_STATE_INSERTED = 0,
+    SC_SECURITY_TOKEN_STATE_REMOVED,
+};
+
+GType sc_security_token_get_type (void) G_GNUC_CONST;
+GQuark sc_security_token_error_quark (void) G_GNUC_CONST;
+
+CK_SLOT_ID sc_security_token_get_slot_id (ScSecurityToken *token);
+gint sc_security_token_get_slot_series (ScSecurityToken *token);
+ScSecurityTokenState sc_security_token_get_state (ScSecurityToken *token);
+
+gchar *sc_security_token_get_name (ScSecurityToken *token);
+gboolean sc_security_token_is_login_token (ScSecurityToken *token);
+
+gboolean sc_security_token_unlock (ScSecurityToken *token,
+				   const gchar     *password);
+
+/* don't under any circumstances call these functions */
+#ifdef SC_SECURITY_TOKEN_ENABLE_INTERNAL_API
+
+ScSecurityToken *_sc_security_token_new (SECMODModule *module,
+					 CK_SLOT_ID slot_id, 
+					 gint slot_series);
+ScSecurityToken *_sc_security_token_new_from_name (SECMODModule *module,
+						   const gchar *name);
+
+void _sc_security_token_set_state (ScSecurityToken      *token,
+				   ScSecurityTokenState  state);
+#endif 
+
+G_END_DECLS
+#endif				/* SC_SECURITY_TOKEN_H */
--- /dev/null	2006-10-05 20:08:52.821361324 -0400
+++ gdm-2.16.0/daemon/securitytoken.c	2006-10-05 21:25:26.000000000 -0400
@@ -0,0 +1,680 @@
+/* securitytoken.c - security token
+ * 
+ * Copyright (C) 2006 Ray Strode <rstrode@redhat.com>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ *
+ * TODO:     - doing this per project is a bad idea i think.
+ *             We should probably make this a system service 
+ *             and use dbus.
+ *
+ *           - We hardcode a driver right now.  We should probably
+ *             look up the default list and go from there. 
+ */
+#define SC_SECURITY_TOKEN_ENABLE_INTERNAL_API
+#include "securitytoken.h"
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <cert.h>
+#include <nss.h>
+#include <pk11func.h>
+#include <prerror.h>
+#include <secmod.h>
+#include <secerr.h>
+
+#if defined (SC_SECURITY_TOKEN_ENABLE_TEST) || defined (SC_SECURITY_TOKEN_MONITOR_ENABLE_TEST)
+#define sc_debug(format, args...) g_printerr (format "\n", ##args)
+#define sc_warning(format, args...) g_printerr (format "\n", ##args)
+#else
+#define sc_debug(format, args...) 
+#define sc_warning(format, args...) 
+#endif
+
+struct _ScSecurityTokenPrivate {
+	SECMODModule *module;
+	ScSecurityTokenState state;
+
+	CK_SLOT_ID slot_id;
+	gint slot_series;
+
+	PK11SlotInfo *slot;
+	gchar *name;
+
+	CERTCertificate *signing_certificate;
+	CERTCertificate *encryption_certificate;
+};
+
+static void sc_security_token_finalize (GObject *object);
+static void sc_security_token_class_install_signals (ScSecurityTokenClass *token_class);
+static void sc_security_token_class_install_properties (ScSecurityTokenClass *token_class);
+static void sc_security_token_set_property (GObject       *object,
+					    guint          prop_id,
+					    const GValue  *value,
+					    GParamSpec    *pspec);
+static void sc_security_token_get_property (GObject     *object,
+					    guint        prop_id,
+					    GValue      *value,
+					    GParamSpec  *pspec);
+static void sc_security_token_set_name (ScSecurityToken *token, const gchar *name);
+static void sc_security_token_set_slot_id (ScSecurityToken *token, 
+					   gint             slot_id);
+static void sc_security_token_set_slot_series (ScSecurityToken *token, 
+					       gint             slot_series);
+static void sc_security_token_set_module (ScSecurityToken *token,
+					  SECMODModule    *module);
+
+static PK11SlotInfo *sc_security_token_find_slot_from_id (ScSecurityToken *token,
+							  gint slot_id);
+
+static PK11SlotInfo *sc_security_token_find_slot_from_token_name (ScSecurityToken *token,
+								  const gchar     *token_name);
+static gboolean sc_security_token_fetch_certificates (ScSecurityToken *token);
+
+
+#ifndef SC_SECURITY_TOKEN_DEFAULT_SLOT_ID 
+#define SC_SECURITY_TOKEN_DEFAULT_SLOT_ID ((gulong) -1)
+#endif
+
+#ifndef SC_SECURITY_TOKEN_DEFAULT_SLOT_SERIES
+#define SC_SECURITY_TOKEN_DEFAULT_SLOT_SERIES -1
+#endif
+
+enum {
+	PROP_0 = 0,
+	PROP_NAME,
+	PROP_SLOT_ID,
+	PROP_SLOT_SERIES,
+	PROP_MODULE,
+	NUMBER_OF_PROPERTIES
+};
+
+enum {
+	INSERTED,
+	REMOVED,
+	NUMBER_OF_SIGNALS
+};
+
+static guint sc_security_token_signals[NUMBER_OF_SIGNALS];
+
+G_DEFINE_TYPE (ScSecurityToken, sc_security_token, G_TYPE_OBJECT);
+
+static void
+sc_security_token_class_init (ScSecurityTokenClass *token_class)
+{
+    GObjectClass *gobject_class;
+
+    gobject_class = G_OBJECT_CLASS (token_class);
+
+    gobject_class->finalize = sc_security_token_finalize;
+
+    sc_security_token_class_install_signals (token_class);
+    sc_security_token_class_install_properties (token_class);
+
+    g_type_class_add_private (token_class,
+			      sizeof (ScSecurityTokenPrivate));
+}
+
+static void
+sc_security_token_class_install_signals (ScSecurityTokenClass *token_class)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (token_class);
+
+    sc_security_token_signals[INSERTED] =
+	    g_signal_new ("inserted",
+			  G_OBJECT_CLASS_TYPE (object_class),
+			  G_SIGNAL_RUN_LAST,
+			  G_STRUCT_OFFSET (ScSecurityTokenClass,
+					   inserted), 
+			  NULL, NULL, g_cclosure_marshal_VOID__VOID, 
+			  G_TYPE_NONE, 0);
+    token_class->inserted = NULL;
+
+    sc_security_token_signals[REMOVED] =
+	    g_signal_new ("removed",
+			  G_OBJECT_CLASS_TYPE (object_class),
+			  G_SIGNAL_RUN_LAST,
+			  G_STRUCT_OFFSET (ScSecurityTokenClass,
+					   removed), 
+			  NULL, NULL, g_cclosure_marshal_VOID__VOID, 
+			  G_TYPE_NONE, 0);
+    token_class->removed = NULL;
+}
+
+static void
+sc_security_token_class_install_properties (ScSecurityTokenClass *token_class)
+{
+    GObjectClass *object_class;
+    GParamSpec *param_spec;
+
+    object_class = G_OBJECT_CLASS (token_class);
+    object_class->set_property = sc_security_token_set_property;
+    object_class->get_property = sc_security_token_get_property;
+
+    param_spec = g_param_spec_ulong ("slot-id", _("Slot ID"),
+				   _("The slot the token is in"),
+				   1, G_MAXULONG,
+				   SC_SECURITY_TOKEN_DEFAULT_SLOT_ID,
+				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+    g_object_class_install_property (object_class, PROP_SLOT_ID, param_spec);
+
+    param_spec = g_param_spec_int ("slot-series", _("Slot Series"),
+				   _("per-slot token identifier"),
+				   -1, G_MAXINT,
+				   SC_SECURITY_TOKEN_DEFAULT_SLOT_SERIES,
+				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+    g_object_class_install_property (object_class, PROP_SLOT_SERIES, param_spec);
+
+    param_spec = g_param_spec_string ("name", _("name"),
+				      _("name"), NULL,
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+    g_object_class_install_property (object_class, PROP_NAME, param_spec);
+
+    param_spec = g_param_spec_pointer ("module", _("Module"),
+				       _("security token driver"),
+				       G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
+    g_object_class_install_property (object_class, PROP_MODULE, param_spec);
+}
+
+static void 
+sc_security_token_set_property (GObject       *object,
+				guint          prop_id,
+				const GValue  *value,
+				GParamSpec    *pspec)
+{
+    ScSecurityToken *token = SC_SECURITY_TOKEN (object);
+
+    switch (prop_id)
+    {
+	    case PROP_NAME:
+		    sc_security_token_set_name (token, g_value_get_string (value));
+		    break;
+
+	    case PROP_SLOT_ID:
+		    sc_security_token_set_slot_id (token, 
+						   g_value_get_ulong (value));
+		    break;
+
+	    case PROP_SLOT_SERIES:
+		    sc_security_token_set_slot_series (token, 
+						       g_value_get_int (value));
+		    break;
+
+	    case PROP_MODULE:
+		    sc_security_token_set_module (token, 
+						  (SECMODModule *)
+						  g_value_get_pointer (value));
+		    break;
+
+	    default:
+		    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+CK_SLOT_ID
+sc_security_token_get_slot_id (ScSecurityToken *token)
+{
+    return token->priv->slot_id;
+}
+
+ScSecurityTokenState 
+sc_security_token_get_state (ScSecurityToken *token)
+{
+    return token->priv->state;
+}
+
+gchar *
+sc_security_token_get_name (ScSecurityToken *token)
+{
+    return g_strdup (token->priv->name);
+}
+
+gboolean
+sc_security_token_is_login_token (ScSecurityToken *token)
+{
+    const gchar *login_token_name;
+    login_token_name = g_getenv ("PKCS11_LOGIN_TOKEN_NAME");
+
+    if ((login_token_name == NULL) || (token->priv->name == NULL))
+	    return FALSE;
+
+    if (strcmp (token->priv->name, login_token_name) == 0)
+	    return TRUE;
+
+    return FALSE;
+}
+
+static void 
+sc_security_token_get_property (GObject    *object,
+				guint        prop_id,
+				GValue      *value,
+				GParamSpec  *pspec)
+{
+    ScSecurityToken *token = SC_SECURITY_TOKEN (object);
+
+    switch (prop_id)
+    {
+	    case PROP_NAME:
+		    g_value_take_string (value, 
+					 sc_security_token_get_name (token));
+		    break;
+
+	    case PROP_SLOT_ID:
+		    g_value_set_ulong (value, 
+				       (gulong) sc_security_token_get_slot_id (token));
+		    break;
+
+	    case PROP_SLOT_SERIES:
+		    g_value_set_int (value, 
+				     sc_security_token_get_slot_series (token));
+		    break;
+
+	    default:
+		    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+    }
+}
+
+static void
+sc_security_token_set_name (ScSecurityToken *token,
+			    const gchar     *name)
+{
+    if (name == NULL)
+	    return;
+
+    if ((token->priv->name == NULL) ||
+	(strcmp (token->priv->name, name) != 0)) {
+	    g_free (token->priv->name);
+	    token->priv->name = g_strdup (name);
+
+	    if (token->priv->slot == NULL) {
+		    token->priv->slot = sc_security_token_find_slot_from_token_name (token,
+										     token->priv->name);
+
+		    if (token->priv->slot != NULL) {
+			    gint slot_id, slot_series;
+
+			    slot_id = PK11_GetSlotID (token->priv->slot);
+			    if (slot_id != token->priv->slot_id)
+				    sc_security_token_set_slot_id (token, slot_id);
+
+			    slot_series = PK11_GetSlotSeries (token->priv->slot);
+			    if (slot_series != token->priv->slot_series)
+				    sc_security_token_set_slot_series (token, slot_series);
+
+			    _sc_security_token_set_state (token, SC_SECURITY_TOKEN_STATE_INSERTED);
+		    } else {
+			    _sc_security_token_set_state (token, SC_SECURITY_TOKEN_STATE_REMOVED);
+		    }
+	    }
+
+
+	    g_object_notify (G_OBJECT (token), "name");
+    }
+}
+
+static void
+sc_security_token_set_slot_id (ScSecurityToken *token,
+			       gint             slot_id)
+{
+    if (token->priv->slot_id != slot_id)
+    {
+	    token->priv->slot_id = slot_id;
+
+	    if (token->priv->slot == NULL) {
+		    token->priv->slot = sc_security_token_find_slot_from_id (token,
+									     token->priv->slot_id);
+
+		    if (token->priv->slot != NULL) {
+			    const gchar *token_name;
+
+			    token_name = PK11_GetTokenName (token->priv->slot);
+			    if ((token->priv->name == NULL) || 
+				((token_name != NULL) &&
+				(strcmp (token_name, token->priv->name) != 0)))
+				    sc_security_token_set_name (token, token_name);
+
+			    _sc_security_token_set_state (token, SC_SECURITY_TOKEN_STATE_INSERTED);
+		    } else {
+			    _sc_security_token_set_state (token, SC_SECURITY_TOKEN_STATE_REMOVED);
+		    }
+	    }
+
+	    g_object_notify (G_OBJECT (token), "slot-id");
+    }
+}
+
+static void
+sc_security_token_set_slot_series (ScSecurityToken *token,
+				   gint             slot_series)
+{
+    if (token->priv->slot_series != slot_series)
+    {
+	    token->priv->slot_series = slot_series;
+	    g_object_notify (G_OBJECT (token), "slot-series");
+    }
+}
+
+static void
+sc_security_token_set_module (ScSecurityToken *token,
+			      SECMODModule    *module)
+{
+    gboolean should_notify;
+
+    if (token->priv->module != module)
+	    should_notify = TRUE;
+    else
+	    should_notify = FALSE;
+
+    if (token->priv->module != NULL) {
+	    SECMOD_DestroyModule (token->priv->module);
+	    token->priv->module = NULL;
+    }
+
+    if (module != NULL)
+	    token->priv->module = SECMOD_ReferenceModule (module);
+
+    if (should_notify)
+	    g_object_notify (G_OBJECT (token), "module");
+}
+
+gint 
+sc_security_token_get_slot_series (ScSecurityToken *token)
+{
+    return token->priv->slot_series;
+}
+
+static void
+sc_security_token_init (ScSecurityToken *token)
+{
+
+    sc_debug ("initializing security token ");
+
+    token->priv = G_TYPE_INSTANCE_GET_PRIVATE (token,
+					       SC_TYPE_SECURITY_TOKEN,
+					       ScSecurityTokenPrivate);
+
+    if (token->priv->slot != NULL)
+	    token->priv->name = g_strdup (PK11_GetTokenName (token->priv->slot));
+}
+
+static void sc_security_token_finalize (GObject *object)
+{
+    ScSecurityToken *token;
+    GObjectClass *gobject_class;
+
+    token = SC_SECURITY_TOKEN (object);
+
+    g_free (token->priv->name);
+
+    sc_security_token_set_module (token, NULL);
+
+    gobject_class =
+	    G_OBJECT_CLASS (sc_security_token_parent_class);
+
+    gobject_class->finalize (object);
+}
+
+GQuark sc_security_token_error_quark (void)
+{
+    static GQuark error_quark = 0;
+
+    if (error_quark == 0)
+	    error_quark = g_quark_from_static_string ("sc-security-token-error-quark");
+
+    return error_quark;
+}
+
+ScSecurityToken *
+_sc_security_token_new (SECMODModule *module,
+			CK_SLOT_ID    slot_id,
+			gint          slot_series)
+{
+    ScSecurityToken *token;
+
+    g_return_val_if_fail (module != NULL, NULL);
+    g_return_val_if_fail (slot_id >= 1, NULL);
+    g_return_val_if_fail (slot_series > 0, NULL);
+    g_return_val_if_fail (sizeof (gulong) == sizeof (slot_id), NULL);
+
+    token = SC_SECURITY_TOKEN (g_object_new (SC_TYPE_SECURITY_TOKEN,
+					     "module", module,
+					     "slot-id", (gulong) slot_id,
+					     "slot-series", slot_series,
+					     NULL));
+    return token;
+}
+
+ScSecurityToken *
+_sc_security_token_new_from_name (SECMODModule *module,
+				  const gchar  *name)
+{
+    ScSecurityToken *token;
+
+    g_return_val_if_fail (module != NULL, NULL);
+    g_return_val_if_fail (name != NULL, NULL);
+
+    token = SC_SECURITY_TOKEN (g_object_new (SC_TYPE_SECURITY_TOKEN,
+					     "module", module,
+					     "name", name,
+					     NULL));
+    return token;
+}
+
+void 
+_sc_security_token_set_state (ScSecurityToken      *token,
+			      ScSecurityTokenState  state)
+{
+    /* sc_security_token_fetch_certificates (token); */
+    if (token->priv->state != state)
+    {
+	    token->priv->state = state;
+
+	    if (state == SC_SECURITY_TOKEN_STATE_INSERTED) {
+		    g_signal_emit (token, sc_security_token_signals[INSERTED], 0);
+	    } else if (state == SC_SECURITY_TOKEN_STATE_REMOVED)
+		    g_signal_emit (token, sc_security_token_signals[REMOVED], 0);
+	    else
+		    g_assert_not_reached ();
+    }
+}
+
+/* So we could conceivably make the closure data a pointer to the token
+ * or something similiar and then emit signals when we want passwords,
+ * but it's probably easier to just get the password up front and use
+ * it.  So we just take the passed in g_malloc'd (well probably, who knows)
+ * and strdup it using NSPR's memory allocation routines.
+ */
+static char *
+sc_security_token_password_handler (PK11SlotInfo *slot, 
+				    PRBool        is_retrying, 
+				    const gchar  *password)
+{
+    if (is_retrying)
+	    return NULL;
+
+    return password != NULL? PL_strdup (password): NULL;
+}
+
+gboolean
+sc_security_token_unlock (ScSecurityToken *token,
+			  const gchar     *password)
+{   
+    SECStatus status;
+
+    PK11_SetPasswordFunc ((PK11PasswordFunc) sc_security_token_password_handler);
+
+    /* we pass PR_TRUE to load certificates
+     */
+    status = PK11_Authenticate (token->priv->slot, PR_TRUE, (gpointer) password);
+
+    if (status != SECSuccess) {
+	    sc_debug ("could not unlock token - %d", status);
+	    return FALSE;
+    }
+    return TRUE;
+}
+
+static PK11SlotInfo *
+sc_security_token_find_slot_from_token_name (ScSecurityToken *token,
+					     const gchar     *token_name)
+{
+    int i;
+
+    for (i = 0; i < token->priv->module->slotCount; i++) {
+	    const gchar *slot_token_name;
+
+	    slot_token_name = PK11_GetTokenName (token->priv->module->slots[i]);
+
+	    if ((slot_token_name != NULL) &&
+		(strcmp (slot_token_name, token_name) == 0))
+		    return token->priv->module->slots[i];
+    }
+
+    return NULL;
+}
+
+static PK11SlotInfo *
+sc_security_token_find_slot_from_id (ScSecurityToken *token,
+                                     gint slot_id)
+{
+    int i;
+
+    for (i = 0; i < token->priv->module->slotCount; i++)
+	    if (PK11_GetSlotID (token->priv->module->slots[i]) == slot_id)
+		    return token->priv->module->slots[i];
+
+    return NULL;
+}
+
+static gboolean
+sc_security_token_fetch_certificates (ScSecurityToken *token)
+{
+    PK11SlotInfo *slot;
+    CERTCertList *certificates;
+    CERTCertListNode *node;
+    SECStatus status;
+    int i;
+
+    sc_security_token_unlock (token, "0000");
+
+    sc_debug ("fetching certificates for token in slot %lu",
+	      token->priv->slot_id);
+
+    slot = sc_security_token_find_slot_from_id (token,
+						token->priv->slot_id);
+
+    g_assert (PK11_GetSlotID (slot) == token->priv->slot_id);
+
+    if (i == token->priv->module->slotCount) {
+	    sc_debug ("could not find slot %lu", token->priv->slot_id);
+	    return FALSE;
+    }
+
+    certificates = PK11_ListCertsInSlot (slot);
+
+    sc_debug ("filtering out non-user certificates");
+    if (CERT_FilterCertListForUserCerts (certificates) != SECSuccess) {
+	    CERT_DestroyCertList (certificates);
+	    sc_debug ("could not filter out non-user certificates");
+	    return FALSE;
+    }
+
+    for (node = CERT_LIST_HEAD (certificates); 
+	 !CERT_LIST_END (node, certificates);
+	 node = CERT_LIST_NEXT(node)) {
+
+	    SECCertificateUsage cert_usages;
+
+	    sc_debug ("verifying certificate for use");
+	    status = CERT_VerifyCertificateNow (NULL, node->cert, TRUE, 
+						0, NULL, &cert_usages);
+
+	    if (status != SECSuccess) {
+		    sc_debug ("could not be verified, skipping...");
+		    continue;
+	    }
+
+	    sc_debug ("got cert with usages 0x%lx", (gulong) cert_usages);
+
+	    if (token->priv->encryption_certificate == NULL) {
+
+		    sc_debug ("checking if certificate can be used for data "
+			      "encryption");
+		    status = CERT_CheckCertUsage (node->cert, 
+						  KU_DATA_ENCIPHERMENT);
+
+		    if (status == SECSuccess) {
+			    token->priv->encryption_certificate = 
+				    CERT_DupCertificate (node->cert);
+		    } else {
+			    sc_debug ("certificate can not be used for encryption");
+		    }
+	    }
+
+	    if (token->priv->signing_certificate == NULL) {
+
+		    sc_debug ("checking if certificate can be used for data "
+			      "signing");
+		    status = CERT_CheckCertUsage (node->cert, 
+						  KU_DIGITAL_SIGNATURE);
+
+		    if (status == SECSuccess) {
+			    token->priv->signing_certificate = 
+				    CERT_DupCertificate (node->cert);
+		    } else {
+			    sc_debug ("certificate can not be used for signing things");
+		    }
+	    }
+    }
+    return TRUE;
+}
+
+#ifdef SC_SECURITY_TOKEN_ENABLE_TEST
+#include <glib.h>
+
+static GMainLoop *event_loop;
+
+int 
+main (int   argc, 
+      char *argv[])
+{
+    ScSecurityToken *token;
+    GError *error;
+
+    g_log_set_always_fatal (G_LOG_LEVEL_ERROR
+			    | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
+
+    g_type_init ();
+
+    g_message ("creating instance of 'security token' object...");
+    token = _sc_security_token_new (NULL, 1, 1);
+    g_message ("'security token' object created successfully");
+
+    g_message ("destroying previously created 'security token' object...");
+    g_object_unref (token);
+    token = NULL;
+    g_message ("'security token' object destroyed successfully");
+
+    return 0;
+}
+#endif
--- gdm-2.16.0/daemon/Makefile.am.security-tokens	2006-03-28 18:43:21.000000000 -0500
+++ gdm-2.16.0/daemon/Makefile.am	2006-10-05 21:20:32.000000000 -0400
@@ -9,6 +9,7 @@
 	-DAUTHDIR=\"$(authdir)\"			\
 	-DBINDIR=\"$(bindir)\"				\
 	-DDATADIR=\"$(datadir)\"			\
+	-DSYSCONFDIR=\"$(sysconfdir)\"			\
 	-DDMCONFDIR=\"$(dmconfdir)\"			\
 	-DGDMCONFDIR=\"$(gdmconfdir)\"			\
 	-DGDMLOCALEDIR=\"$(gdmlocaledir)\"		\
@@ -71,7 +72,11 @@
 	gdm-net.c \
 	gdm-net.h \
 	getvt.c \
-	getvt.h
+	getvt.h \
+	securitytoken.c \
+	securitytoken.h \
+	securitytokenmonitor.c \
+	securitytokenmonitor.h
 
 EXTRA_gdm_binary_SOURCES = verify-pam.c verify-crypt.c verify-shadow.c
 
--- gdm-2.16.0/daemon/gdm.c.security-tokens	2006-10-05 21:20:32.000000000 -0400
+++ gdm-2.16.0/daemon/gdm.c	2006-10-05 21:20:32.000000000 -0400
@@ -63,6 +63,8 @@
 #include "cookie.h"
 #include "filecheck.h"
 #include "gdmconfig.h"
+#include "securitytokenmonitor.h"
+#include "securitytoken.h"
 
 #define DYNAMIC_ADD     0
 #define DYNAMIC_RELEASE 1
@@ -72,6 +74,7 @@
 #include <libdevinfo.h>
 #endif  /* HAVE_LOGINDEVPERM */
 
+
 extern GSList *displays;
 
 /* Local functions */
@@ -81,6 +84,10 @@
 static void gdm_handle_user_message (GdmConnection *conn,
 				     const gchar *msg,
 				     gpointer data);
+
+static void gdm_reset_local_displays (void);
+static void gdm_watch_for_security_tokens (void);
+
 static void gdm_daemonify (void);
 static void gdm_safe_restart (void);
 static void gdm_try_logout_action (GdmDisplay *disp);
@@ -151,7 +158,6 @@
 
 static gboolean monte_carlo_sqrt2 = FALSE;
 
-
 /*
  * lookup display number if the display number is
  * exists then clear the remove flag and return TRUE
@@ -1440,6 +1446,8 @@
     /* Initialize runtime environment */
     umask (022);
 
+    g_type_init ();
+
     ctx = g_option_context_new (_("- The GNOME login manager"));
     g_option_context_add_main_entries (ctx, options, _("main options"));
 
@@ -1682,6 +1690,8 @@
 	gdm_xdmcp_run ();
     }
 
+    gdm_watch_for_security_tokens ();
+
     /* We always exit via exit (), and sadly we need to g_main_quit ()
      * at times not knowing if it's this main or a recursive one we're
      * quitting.
@@ -3472,4 +3482,85 @@
 	}
 }
 
+static void
+gdm_reset_local_displays (void)
+{
+    GSList *li;
+
+    for (li = displays; li != NULL; li = li->next) {
+	    GdmDisplay *d = li->data;
+
+	    if (d->attached)
+		    send_slave_command (d, GDM_NOTIFY_RESET);
+    }
+}
+
+
+
+
+
+
+
+#ifndef GDM_SECURITY_TOKENS_CONF
+#define GDM_SECURITY_TOKENS_CONF GDMCONFDIR "/securitytokens.conf"
+#endif
+
+#ifndef GDM_SECURITY_TOKENS_KEY_ENABLED
+#define GDM_SECURITY_TOKENS_KEY_ENABLED "SecurityTokens/Enabled=true"
+#endif
+
+#ifndef GDM_SECURITY_TOKENS_KEY_DRIVER
+#define GDM_SECURITY_TOKENS_KEY_DRIVER "SecurityTokens/Driver"
+#endif
+
+static void
+gdm_watch_for_security_tokens (void)
+{
+    GError *error;
+    ScSecurityTokenMonitor *monitor;
+    gchar *driver;
+    VeConfig *cfg;
+
+    cfg = ve_config_new (GDM_SECURITY_TOKENS_CONF);
+
+    if (!ve_config_get_bool (cfg, GDM_SECURITY_TOKENS_KEY_ENABLED)) {
+	    gdm_debug ("security token support is not enabled");
+	    goto out;
+    }
+
+    gdm_debug ("watching for security token insertion and removal events");
+
+    driver = ve_config_get_string (cfg, GDM_SECURITY_TOKENS_KEY_DRIVER);
+    gdm_debug ("security tokens driver is set to '%s'", 
+	       ve_string_empty (driver)? "<automatic>" : driver);
+    monitor = sc_security_token_monitor_new (driver);
+    g_free (driver);
+    
+    g_signal_connect (monitor,
+		      "security-token-inserted",
+		      G_CALLBACK (gdm_reset_local_displays), 
+		      NULL);
+
+    g_signal_connect (monitor,
+		      "security-token-removed",
+		      G_CALLBACK (gdm_reset_local_displays), 
+		      NULL);
+
+    error = NULL;
+    if (!sc_security_token_monitor_start (monitor, &error)) {
+	    g_object_unref (monitor);
+	    monitor = NULL;
+
+	    if (error != NULL) {
+		    syslog (LOG_ERR, "%s", error->message);
+		    g_error_free (error);
+	    } else {
+		    syslog (LOG_ERR, "could not start security token monitor");
+
+	    }
+	    goto out;
+    }
+out:
+    ve_config_destroy (cfg);
+}
 /* EOF */
--- /dev/null	2006-10-05 20:08:52.821361324 -0400
+++ gdm-2.16.0/daemon/securitytokenmonitor.h	2006-10-05 21:25:27.000000000 -0400
@@ -0,0 +1,84 @@
+/* securitytokenmonitor.h - monitor for security token insertion and
+ *                          removal events
+ *
+ * Copyright (C) 2006 Ray Strode
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.  
+ */
+#ifndef SC_SECURITY_TOKEN_MONITOR_H
+#define SC_SECURITY_TOKEN_MONITOR_H
+
+#define SC_SECURITY_TOKEN_ENABLE_INTERNAL_API
+#include "securitytoken.h"
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+#define SC_TYPE_SECURITY_TOKEN_MONITOR            (sc_security_token_monitor_get_type ())
+#define SC_SECURITY_TOKEN_MONITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SC_TYPE_SECURITY_TOKEN_MONITOR, ScSecurityTokenMonitor))
+#define SC_SECURITY_TOKEN_MONITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SC_TYPE_SECURITY_TOKEN_MONITOR, ScSecurityTokenMonitorClass))
+#define SC_IS_SECURITY_TOKEN_MONITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SC_TYPE_SECURITY_TOKEN_MONITOR))
+#define SC_IS_SECURITY_TOKEN_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SC_TYPE_SECURITY_TOKEN_MONITOR))
+#define SC_SECURITY_TOKEN_MONITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), SC_TYPE_SECURITY_TOKEN_MONITOR, ScSecurityTokenMonitorClass))
+#define SC_SECURITY_TOKEN_MONITOR_ERROR           (sc_security_token_monitor_error_quark ())
+typedef struct _ScSecurityTokenMonitor ScSecurityTokenMonitor;
+typedef struct _ScSecurityTokenMonitorClass ScSecurityTokenMonitorClass;
+typedef struct _ScSecurityTokenMonitorPrivate ScSecurityTokenMonitorPrivate;
+typedef enum _ScSecurityTokenMonitorError ScSecurityTokenMonitorError;
+
+struct _ScSecurityTokenMonitor {
+    GObject parent;
+
+    /*< private > */
+    ScSecurityTokenMonitorPrivate *priv;
+};
+
+struct _ScSecurityTokenMonitorClass {
+    GObjectClass parent_class;
+
+    /* Signals */
+    void (*security_token_inserted) (ScSecurityTokenMonitor *monitor,
+				     ScSecurityToken *token);
+    void (*security_token_removed) (ScSecurityTokenMonitor *monitor,
+				    ScSecurityToken *token);
+    void (*error) (ScSecurityTokenMonitor *monitor, 
+		   GError                 *error);
+};
+
+enum _ScSecurityTokenMonitorError {
+    SC_SECURITY_TOKEN_MONITOR_ERROR_GENERIC = 0,
+    SC_SECURITY_TOKEN_MONITOR_ERROR_WITH_NSS,
+    SC_SECURITY_TOKEN_MONITOR_ERROR_LOADING_DRIVER,
+    SC_SECURITY_TOKEN_MONITOR_ERROR_WATCHING_FOR_EVENTS,
+    SC_SECURITY_TOKEN_MONITOR_ERROR_REPORTING_EVENTS
+};
+
+GType sc_security_token_monitor_get_type (void) G_GNUC_CONST;
+GQuark sc_security_token_monitor_error_quark (void) G_GNUC_CONST;
+
+ScSecurityTokenMonitor *sc_security_token_monitor_new (const gchar *module);
+
+gboolean sc_security_token_monitor_start (ScSecurityTokenMonitor  *monitor, 
+				 	  GError                 **error);
+
+void sc_security_token_monitor_stop (ScSecurityTokenMonitor *monitor);
+
+gchar *sc_security_token_monitor_get_module_path (ScSecurityTokenMonitor *monitor);
+gboolean sc_security_token_monitor_login_token_is_inserted (ScSecurityTokenMonitor *monitor);
+
+G_END_DECLS
+#endif				/* SC_SECURITY_TOKEN_MONITOR_H */
