[gnome-online-accounts/wip/kerberos: 4/5] daemon: Add kerberos renewal service
- From: Ray Strode <halfline src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-online-accounts/wip/kerberos: 4/5] daemon: Add kerberos renewal service
- Date: Tue, 14 Aug 2012 02:01:10 +0000 (UTC)
commit bc293b8d6e9eddcc805d5311064ba9a5d2a5873d
Author: Ray Strode <rstrode redhat com>
Date: Fri Jul 27 16:17:28 2012 -0400
daemon: Add kerberos renewal service
This commit adds an identity service whose purpose is
to automatically renew expiring kerberos credentials,
and to expose a mechanism over the bus to "kinit".
This on top of the commit that adds a kerberos provider
backend gives us what we need for kerberos integration.
configure.ac | 52 +
src/Makefile.am | 2 +-
src/daemon/Makefile.am | 14 +-
src/daemon/goadaemon.c | 14 +
src/goaidentity/Makefile.am | 112 ++
src/goaidentity/goaalarm.c | 602 ++++++++++
src/goaidentity/goaalarm.h | 64 +
src/goaidentity/goaidentity.c | 83 ++
src/goaidentity/goaidentity.h | 71 ++
src/goaidentity/goaidentityenumtypes.c.in | 42 +
src/goaidentity/goaidentityenumtypes.h.in | 24 +
src/goaidentity/goaidentityinquiry.c | 144 +++
src/goaidentity/goaidentityinquiry.h | 110 ++
src/goaidentity/goaidentityinquiryprivate.h | 34 +
src/goaidentity/goaidentitylibrary.c | 1032 +++++++++++++++++
src/goaidentity/goaidentitylibrary.h | 59 +
src/goaidentity/goaidentitymanager.c | 310 +++++
src/goaidentity/goaidentitymanager.h | 175 +++
src/goaidentity/goaidentitymanagerprivate.h | 49 +
src/goaidentity/goaidentityutils.c | 191 +++
src/goaidentity/goaidentityutils.h | 38 +
src/goaidentity/goakerberosidentity.c | 1483 ++++++++++++++++++++++++
src/goaidentity/goakerberosidentity.h | 87 ++
src/goaidentity/goakerberosidentityinquiry.c | 375 ++++++
src/goaidentity/goakerberosidentityinquiry.h | 73 ++
src/goaidentity/goakerberosidentitymanager.c | 1592 ++++++++++++++++++++++++++
src/goaidentity/goakerberosidentitymanager.h | 61 +
src/goaidentity/org.gnome.Identity.xml | 73 ++
28 files changed, 6964 insertions(+), 2 deletions(-)
---
diff --git a/configure.ac b/configure.ac
index 1fc7b89..010b9fd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -235,6 +235,57 @@ if test "$enable_windows_live" != "no"; then
AC_DEFINE(GOA_WINDOWS_LIVE_ENABLED, 1, [Enable Windows Live data provider])
fi
+# Optional timerfd support
+AC_MSG_CHECKING([for timerfd support])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
+#include <sys/timerfd.h>
+#include <unistd.h>
+],[
+int
+main (void)
+{
+ struct itimerspec timer_spec = { 0 };
+ timerfd_settime (timerfd_create (CLOCK_MONOTONIC, TFD_CLOEXEC),
+ TFD_TIMER_ABSTIME,
+ &timer_spec,
+ NULL);
+
+ return 0;
+}
+])],
+[have_timerfd=yes],
+[have_timerfd=no])
+AC_MSG_RESULT($have_timerfd)
+if test x"$have_timerfd" = x"yes"; then
+ AC_DEFINE(HAVE_TIMERFD, 1, [have timerfd support])
+
+ dnl libc headers tend to trail kernel support
+ dnl so compensate if necessary
+ AC_MSG_CHECKING([for timerfd cancel-on-set support])
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
+ #include <sys/timerfd.h>
+ #include <unistd.h>
+ ],[
+ int
+ main (void)
+ {
+ struct itimerspec timer_spec = { 0 };
+ timerfd_settime (timerfd_create (CLOCK_MONOTONIC, TFD_CLOEXEC),
+ TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET,
+ &timer_spec,
+ NULL);
+
+ return 0;
+ }
+ ])],
+ [have_tfd_timer_cancel_on_set=yes],
+ [have_tfd_timer_cancel_on_set=no])
+ AC_MSG_RESULT($have_tfd_timer_cancel_on_set)
+ if test x"$have_tfd_timer_cancel_on_set" = x"no"; then
+ AC_DEFINE(TFD_TIMER_CANCEL_ON_SET, [(1 << 1)], [have timerfd support])
+ fi
+fi
+
# Internationalization
#
@@ -262,6 +313,7 @@ src/goa/Makefile
src/goa/goa-1.0.pc
src/goabackend/Makefile
src/goabackend/goa-backend-1.0.pc
+src/goaidentity/Makefile
src/daemon/Makefile
src/examples/Makefile
po/Makefile.in
diff --git a/src/Makefile.am b/src/Makefile.am
index bda8d46..21cf4e5 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,6 +1,6 @@
NULL =
-SUBDIRS = goa goabackend daemon examples
+SUBDIRS = goa goabackend goaidentity daemon examples
-include $(top_srcdir)/git.mk
diff --git a/src/daemon/Makefile.am b/src/daemon/Makefile.am
index 236502b..fb62f71 100644
--- a/src/daemon/Makefile.am
+++ b/src/daemon/Makefile.am
@@ -1,8 +1,9 @@
-
NULL =
INCLUDES = \
-I$(top_builddir)/src -I$(top_srcdir)/src \
+ -I$(top_builddir)/goaidentity \
+ -I$(top_srcdir)/goaidentity \
-DPACKAGE_LIBEXEC_DIR=\""$(libexecdir)"\" \
-DPACKAGE_SYSCONF_DIR=\""$(sysconfdir)"\" \
-DPACKAGE_DATA_DIR=\""$(datadir)"\" \
@@ -16,6 +17,9 @@ INCLUDES = \
$(WARN_CFLAGS) \
$(NULL)
+BUILT_SOURCES = $(NULL)
+EXTRA_DIST = $(NULL)
+
libexec_PROGRAMS = goa-daemon
goa_daemon_SOURCES = \
@@ -46,6 +50,14 @@ goa_daemon_LDADD = \
$(REST_LIBS) \
$(NULL)
+if BUILD_KERBEROS
+goa_daemon_LDADD += \
+ $(top_builddir)/src/goaidentity/libgoaidentity.la \
+ $(KRB5_LIBS) \
+ $(GCR_LIBS) \
+ $(NULL)
+endif
+
clean-local :
rm -f *~
diff --git a/src/daemon/goadaemon.c b/src/daemon/goadaemon.c
index 097b080..daf1a2e 100644
--- a/src/daemon/goadaemon.c
+++ b/src/daemon/goadaemon.c
@@ -30,6 +30,7 @@
#include "goadaemon.h"
#include "goabackend/goabackend.h"
#include "goabackend/goautils.h"
+#include "goaidentity/goaidentitylibrary.h"
struct _GoaDaemon
{
@@ -45,6 +46,7 @@ struct _GoaDaemon
GoaManager *manager;
+ GoaIdentityLibrary *identity_library;
NotifyNotification *notification;
guint config_timeout_id;
@@ -130,6 +132,8 @@ goa_daemon_finalize (GObject *object)
g_object_unref (daemon->object_manager);
g_object_unref (daemon->connection);
+ g_clear_object (&daemon->identity_library);
+
G_OBJECT_CLASS (goa_daemon_parent_class)->finalize (object);
}
@@ -193,6 +197,7 @@ goa_daemon_init (GoaDaemon *daemon)
static volatile GQuark goa_error_domain = 0;
GoaObjectSkeleton *object;
gchar *path;
+ GError *error = NULL;
/* this will force associating errors in the GOA_ERROR error domain
* with org.freedesktop.Goa.Error.* errors via g_dbus_error_register_error_domain().
@@ -239,6 +244,15 @@ goa_daemon_init (GoaDaemon *daemon)
/* Export objects */
g_dbus_object_manager_server_set_connection (daemon->object_manager, daemon->connection);
+
+ daemon->identity_library = goa_identity_library_new ();
+ if (!goa_identity_library_activate (daemon->identity_library,
+ &error))
+ {
+ goa_warning ("Error activating identity service: %s", error->message);
+ g_error_free (error);
+ g_clear_object (&daemon->identity_library);
+ }
}
static void
diff --git a/src/goaidentity/Makefile.am b/src/goaidentity/Makefile.am
new file mode 100644
index 0000000..3306571
--- /dev/null
+++ b/src/goaidentity/Makefile.am
@@ -0,0 +1,112 @@
+NULL =
+BUILT_SOURCES = $(NULL)
+EXTRA_DIST = $(NULL)
+CLEANFILES= $(NULL)
+
+INCLUDES = \
+ -I$(top_builddir)/src -I$(top_srcdir)/src \
+ -I$(top_srcdir)/src/goabackend \
+ -DPACKAGE_LIBEXEC_DIR=\""$(libexecdir)"\" \
+ -DPACKAGE_SYSCONF_DIR=\""$(sysconfdir)"\" \
+ -DPACKAGE_DATA_DIR=\""$(datadir)"\" \
+ -DPACKAGE_BIN_DIR=\""$(bindir)"\" \
+ -DPACKAGE_LOCALSTATE_DIR=\""$(localstatedir)"\" \
+ -DPACKAGE_LOCALE_DIR=\""$(localedir)"\" \
+ -DPACKAGE_LIB_DIR=\""$(libdir)"\" \
+ -D_POSIX_PTHREAD_SEMANTICS -D_REENTRANT \
+ -DGOA_API_IS_SUBJECT_TO_CHANGE \
+ -DGOA_BACKEND_API_IS_SUBJECT_TO_CHANGE \
+ $(WARN_CFLAGS) \
+ $(NULL)
+
+identity_headers = \
+ goaalarm.h \
+ goaidentity.h \
+ goaidentityinquiry.h \
+ goaidentitylibrary.h \
+ goaidentitymanagerprivate.h \
+ goaidentitymanager.h \
+ goaidentityutils.h \
+ goakerberosidentity.h \
+ goakerberosidentityinquiry.h \
+ goakerberosidentitymanager.h \
+ $(NULL)
+
+identity_sources = \
+ $(identity_headers) \
+ goaalarm.c \
+ goaidentity.c \
+ goaidentityinquiry.c \
+ goaidentitylibrary.c \
+ goaidentitymanager.c \
+ goaidentityutils.c \
+ goakerberosidentity.c \
+ goakerberosidentityinquiry.c \
+ goakerberosidentitymanager.c \
+ $(NULL)
+
+identity_dbus_built_sources = \
+ org.gnome.Identity.c org.gnome.Identity.h \
+ $(NULL)
+
+$(identity_dbus_built_sources) : Makefile.am org.gnome.Identity.xml
+ gdbus-codegen \
+ --interface-prefix org.gnome.Identity. \
+ --c-namespace GoaIdentityService \
+ --c-generate-object-manager \
+ --generate-c-code org.gnome.Identity \
+ org.gnome.Identity.xml \
+ $(NULL)
+BUILT_SOURCES += $(identity_dbus_built_sources)
+EXTRA_DIST += org.gnome.Identity.xml
+
+goaidentityenumtypes.h: goaidentityenumtypes.h.in $(identity_headers)
+ $(AM_V_GEN) glib-mkenums --template $^ > $@
+EXTRA_DIST += goaidentityenumtypes.h.in
+BUILT_SOURCES += goaidentityenumtypes.h
+
+goaidentityenumtypes.c: goaidentityenumtypes.c.in $(identity_headers)
+ $(AM_V_GEN) glib-mkenums --template $^ > $@
+EXTRA_DIST += goaidentityenumtypes.c.in
+BUILT_SOURCES += goaidentityenumtypes.c
+
+if BUILD_KERBEROS
+noinst_LTLIBRARIES = libgoaidentity.la
+
+libgoaidentity_la_SOURCES = \
+ goaidentityenumtypes.h goaidentityenumtypes.c \
+ $(identity_dbus_built_sources) \
+ $(identity_sources) \
+ $(NULL)
+
+libgoaidentity_la_CPPFLAGS = \
+ -DG_LOG_DOMAIN=\"libgoaidentity\" \
+ -DGOA_BACKEND_COMPILATION \
+ $(NULL)
+
+libgoaidentity_la_CFLAGS = \
+ $(GLIB_CFLAGS) \
+ $(GTK_CFLAGS) \
+ $(LIBNOTIFY_CFLAGS) \
+ $(KRB5_CFLAGS) \
+ $(GCR_CFLAGS) \
+ $(NULL)
+
+libgoaidentity_la_LIBADD = \
+ $(GLIB_LIBS) \
+ $(GTK_LIBS) \
+ $(LIBNOTIFY_LIBS) \
+ $(KRB5_LIBS) \
+ $(GCR_LIBS) \
+ $(NULL)
+
+else
+EXTRA_DIST += $(identity_sources)
+endif
+
+CLEANFILES += $(BUILT_SOURCES)
+
+clean-local :
+ rm -f *~
+
+-include $(top_srcdir)/git.mk
diff --git a/src/goaidentity/goaalarm.c b/src/goaidentity/goaalarm.c
new file mode 100644
index 0000000..545a5ec
--- /dev/null
+++ b/src/goaidentity/goaalarm.c
@@ -0,0 +1,602 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ *
+ * Author: Ray Strode
+ * Based on work by Colin Walters
+ */
+
+#include "config.h"
+
+#include "goaalarm.h"
+
+#ifdef HAVE_TIMERFD
+#include <sys/timerfd.h>
+#endif
+
+#include <unistd.h>
+#include <string.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <gio/gunixinputstream.h>
+
+#include "goalogging.h"
+
+typedef struct
+{
+ GSource *source;
+ GInputStream *stream;
+} Timer;
+
+typedef struct
+{
+ GSource *source;
+} Timeout;
+
+#define MAX_TIMEOUT_INTERVAL (10 *1000)
+
+typedef enum
+{
+ GOA_ALARM_TYPE_UNSCHEDULED,
+ GOA_ALARM_TYPE_TIMER,
+ GOA_ALARM_TYPE_TIMEOUT,
+} GoaAlarmType;
+
+struct _GoaAlarmPrivate
+{
+ GCancellable *cancellable;
+ gulong cancelled_id;
+ GDateTime *time;
+ GDateTime *previous_wakeup_time;
+ GMainContext *context;
+ GSource *immediate_wakeup_source;
+ GRecMutex lock;
+
+ GoaAlarmType type;
+ union
+ {
+ Timer timer;
+ Timeout timeout;
+ };
+};
+
+enum
+{
+ FIRED,
+ REARMED,
+ NUMBER_OF_SIGNALS,
+};
+
+enum
+{
+ PROP_0,
+ PROP_TIME
+};
+
+static void schedule_wakeups (GoaAlarm *self);
+static void schedule_wakeups_with_timeout_source (GoaAlarm *self);
+static guint signals[NUMBER_OF_SIGNALS] = { 0 };
+
+G_DEFINE_TYPE (GoaAlarm, goa_alarm, G_TYPE_OBJECT);
+
+static void
+clear_scheduled_immediate_wakeup (GoaAlarm *self)
+{
+ g_clear_pointer (&self->priv->immediate_wakeup_source,
+ (GDestroyNotify) g_source_destroy);
+}
+
+static void
+clear_scheduled_timer_wakeups (GoaAlarm *self)
+{
+#ifdef HAVE_TIMERFD
+ GError *error;
+ gboolean is_closed;
+
+ g_clear_pointer (&self->priv->timer.source, (GDestroyNotify) g_source_destroy);
+
+ error = NULL;
+ is_closed = g_input_stream_close (self->priv->timer.stream, NULL, &error);
+
+ if (!is_closed)
+ {
+ goa_warning ("GoaAlarm: could not close timer stream: %s", error->message);
+ g_error_free (error);
+ }
+
+ g_clear_object (&self->priv->timer.stream);
+#endif
+}
+
+static void
+clear_scheduled_timeout_wakeups (GoaAlarm *self)
+{
+ g_clear_pointer (&self->priv->timeout.source, (GDestroyNotify) g_source_destroy);
+}
+
+static void
+clear_scheduled_wakeups (GoaAlarm *self)
+{
+ g_rec_mutex_lock (&self->priv->lock);
+ clear_scheduled_immediate_wakeup (self);
+
+ switch (self->priv->type)
+ {
+ case GOA_ALARM_TYPE_TIMER:
+ clear_scheduled_timer_wakeups (self);
+ break;
+
+ case GOA_ALARM_TYPE_TIMEOUT:
+ clear_scheduled_timeout_wakeups (self);
+ break;
+
+ default:
+ break;
+ }
+
+ g_clear_object (&self->priv->cancellable);
+
+ g_clear_pointer (&self->priv->context, (GDestroyNotify) g_main_context_unref);
+
+ g_clear_pointer (&self->priv->previous_wakeup_time,
+ (GDestroyNotify) g_date_time_unref);
+
+ g_clear_pointer (&self->priv->time, (GDestroyNotify) g_date_time_unref);
+
+ g_assert (self->priv->timeout.source == NULL);
+
+ self->priv->type = GOA_ALARM_TYPE_UNSCHEDULED;
+ g_rec_mutex_unlock (&self->priv->lock);
+}
+
+static void
+goa_alarm_finalize (GObject *object)
+{
+ GoaAlarm *self = GOA_ALARM (object);
+
+ clear_scheduled_wakeups (self);
+
+ G_OBJECT_CLASS (goa_alarm_parent_class)->finalize (object);
+}
+
+static void
+goa_alarm_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *param_spec)
+{
+ GoaAlarm *self = GOA_ALARM (object);
+ GDateTime *time;
+
+ switch (property_id)
+ {
+ case PROP_TIME:
+ time = (GDateTime *) g_value_get_boxed (value);
+ goa_alarm_set_time (self, time, self->priv->cancellable);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, param_spec);
+ break;
+ }
+}
+
+static void
+goa_alarm_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *param_spec)
+{
+ GoaAlarm *self = GOA_ALARM (object);
+
+ switch (property_id)
+ {
+ case PROP_TIME:
+ g_value_set_boxed (value, self->priv->time);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, param_spec);
+ break;
+ }
+}
+
+static void
+goa_alarm_class_init (GoaAlarmClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = goa_alarm_finalize;
+ object_class->get_property = goa_alarm_get_property;
+ object_class->set_property = goa_alarm_set_property;
+
+ g_type_class_add_private (klass, sizeof (GoaAlarmPrivate));
+
+ signals[FIRED] = g_signal_new ("fired",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+ signals[REARMED] = g_signal_new ("rearmed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+ g_object_class_install_property (object_class,
+ PROP_TIME,
+ g_param_spec_boxed ("time",
+ _("Time"),
+ _("Time to fire"),
+ G_TYPE_DATE_TIME,
+ G_PARAM_READWRITE));
+}
+
+static void
+goa_alarm_init (GoaAlarm *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GOA_TYPE_ALARM, GoaAlarmPrivate);
+ self->priv->type = GOA_ALARM_TYPE_UNSCHEDULED;
+ g_rec_mutex_init (&self->priv->lock);
+}
+
+static void
+on_cancelled (GCancellable *cancellable, gpointer user_data)
+{
+ GoaAlarm *self = GOA_ALARM (user_data);
+
+ clear_scheduled_wakeups (self);
+}
+
+static void
+fire_alarm (GoaAlarm *self)
+{
+ g_signal_emit (G_OBJECT (self), signals[FIRED], 0);
+}
+
+static void
+rearm_alarm (GoaAlarm *self)
+{
+ g_signal_emit (G_OBJECT (self), signals[REARMED], 0);
+}
+
+static void
+fire_or_rearm_alarm (GoaAlarm *self)
+{
+ GTimeSpan time_until_fire;
+ GTimeSpan previous_time_until_fire;
+ GDateTime *now;
+
+ now = g_date_time_new_now_local ();
+ time_until_fire = g_date_time_difference (self->priv->time, now);
+
+ if (self->priv->previous_wakeup_time == NULL)
+ {
+ self->priv->previous_wakeup_time = now;
+
+ /* If, according to the time, we're past when we should have fired,
+ * then fire the alarm.
+ */
+ if (time_until_fire <= 0)
+ fire_alarm (self);
+ }
+ else
+ {
+ previous_time_until_fire =
+ g_date_time_difference (self->priv->time,
+ self->priv->previous_wakeup_time);
+
+ g_date_time_unref (self->priv->previous_wakeup_time);
+ self->priv->previous_wakeup_time = now;
+
+ /* If, according to the time, we're past when we should have fired,
+ * and this is the first wakeup where that's been true then fire
+ * the alarm. The first check makes sure we don't fire prematurely,
+ * and the second check makes sure we don't fire more than once
+ */
+ if (time_until_fire <= 0 && previous_time_until_fire > 0)
+ {
+ fire_alarm (self);
+
+ /* If, according to the time, we're before when we should fire,
+ * and we previously fired the alarm, then we've jumped back in
+ * time and need to rearm the alarm.
+ */
+ }
+ else if (time_until_fire > 0 && previous_time_until_fire <= 0)
+ {
+ rearm_alarm (self);
+ }
+ }
+}
+
+static gboolean
+on_immediate_wakeup_source_ready (GoaAlarm *self)
+{
+ g_return_val_if_fail (self->priv->type != GOA_ALARM_TYPE_UNSCHEDULED, FALSE);
+
+ g_rec_mutex_lock (&self->priv->lock);
+ if (g_cancellable_is_cancelled (self->priv->cancellable))
+ goto out;
+
+ fire_or_rearm_alarm (self);
+
+out:
+ g_rec_mutex_unlock (&self->priv->lock);
+ return FALSE;
+}
+
+#ifdef HAVE_TIMERFD
+static gboolean
+on_timer_source_ready (GObject *stream, GoaAlarm *self)
+{
+ gint64 number_of_fires;
+ gssize bytes_read;
+ gboolean run_again = FALSE;
+
+ g_return_val_if_fail (GOA_IS_ALARM (self), FALSE);
+ g_return_val_if_fail (self->priv->type == GOA_ALARM_TYPE_TIMER, FALSE);
+
+ g_rec_mutex_lock (&self->priv->lock);
+ if (g_cancellable_is_cancelled (self->priv->cancellable))
+ goto out;
+
+ bytes_read =
+ g_pollable_input_stream_read_nonblocking (G_POLLABLE_INPUT_STREAM (stream),
+ &number_of_fires, sizeof (gint64),
+ NULL, NULL);
+
+ if (bytes_read == sizeof (gint64))
+ {
+ if (number_of_fires < 0 || number_of_fires > 1)
+ {
+ goa_warning ("GoaAlarm: expected timerfd to report firing once,"
+ "but it reported firing %ld times\n", (long) number_of_fires);
+ }
+ }
+
+ fire_or_rearm_alarm (self);
+ run_again = TRUE;
+out:
+ g_rec_mutex_unlock (&self->priv->lock);
+ return run_again;
+}
+
+static void
+clear_timer_source_pointer (GoaAlarm *self)
+{
+ self->priv->timer.source = NULL;
+}
+#endif
+
+static gboolean
+schedule_wakeups_with_timerfd (GoaAlarm *self)
+{
+#ifdef HAVE_TIMERFD
+ struct itimerspec timer_spec;
+ int fd;
+ int result;
+ static gboolean seen_before = FALSE;
+
+ if (!seen_before)
+ {
+ goa_debug ("GoaAlarm: trying to use kernel timer");
+ seen_before = TRUE;
+ }
+
+ fd = timerfd_create (CLOCK_REALTIME, TFD_CLOEXEC | TFD_NONBLOCK);
+
+ if (fd < 0)
+ {
+ goa_debug ("GoaAlarm: could not create timer fd: %m");
+ return FALSE;
+ }
+
+ memset (&timer_spec, 0, sizeof (timer_spec));
+ timer_spec.it_value.tv_sec = g_date_time_to_unix (self->priv->time) + 1;
+
+ result = timerfd_settime (fd,
+ TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET,
+ &timer_spec, NULL);
+
+ if (result < 0)
+ {
+ goa_debug ("GoaAlarm: could not set timer: %m");
+ return FALSE;
+ }
+
+ self->priv->type = GOA_ALARM_TYPE_TIMER;
+ self->priv->timer.stream = g_unix_input_stream_new (fd, TRUE);
+
+ self->priv->timer.source =
+ g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM
+ (self->priv->timer.stream),
+ self->priv->cancellable);
+ g_source_set_callback (self->priv->timer.source,
+ (GSourceFunc) on_timer_source_ready, self,
+ (GDestroyNotify) clear_timer_source_pointer);
+ g_source_attach (self->priv->timer.source, self->priv->context);
+ g_source_unref (self->priv->timer.source);
+
+ return TRUE;
+
+#endif /*HAVE_TIMERFD */
+
+ return FALSE;
+}
+
+static gboolean
+on_timeout_source_ready (GoaAlarm *self)
+{
+ g_return_val_if_fail (GOA_IS_ALARM (self), FALSE);
+
+ g_rec_mutex_lock (&self->priv->lock);
+
+ if (g_cancellable_is_cancelled (self->priv->cancellable) ||
+ self->priv->type == GOA_ALARM_TYPE_UNSCHEDULED)
+ goto out;
+
+ fire_or_rearm_alarm (self);
+
+ if (g_cancellable_is_cancelled (self->priv->cancellable))
+ goto out;
+
+ schedule_wakeups_with_timeout_source (self);
+
+out:
+ g_rec_mutex_unlock (&self->priv->lock);
+ return FALSE;
+}
+
+static void
+clear_timeout_source_pointer (GoaAlarm *self)
+{
+ self->priv->timeout.source = NULL;
+}
+
+static void
+schedule_wakeups_with_timeout_source (GoaAlarm *self)
+{
+ GDateTime *now;
+ GTimeSpan time_span;
+ guint interval;
+
+ self->priv->type = GOA_ALARM_TYPE_TIMEOUT;
+
+ now = g_date_time_new_now_local ();
+ time_span = g_date_time_difference (self->priv->time, now);
+ g_date_time_unref (now);
+
+ time_span =
+ CLAMP (time_span, 1000 *G_TIME_SPAN_MILLISECOND,
+ G_MAXUINT *G_TIME_SPAN_MILLISECOND);
+ interval = (guint) time_span / G_TIME_SPAN_MILLISECOND;
+
+ /* We poll every 10 seconds or so because we want to catch time skew
+ */
+ interval = MIN (interval, MAX_TIMEOUT_INTERVAL);
+
+ self->priv->timeout.source = g_timeout_source_new (interval);
+ g_source_set_callback (self->priv->timeout.source,
+ (GSourceFunc)
+ on_timeout_source_ready,
+ self, (GDestroyNotify) clear_timeout_source_pointer);
+
+ g_source_attach (self->priv->timeout.source, self->priv->context);
+ g_source_unref (self->priv->timeout.source);
+}
+
+static void
+schedule_wakeups (GoaAlarm *self)
+{
+ gboolean wakeup_scheduled;
+
+ wakeup_scheduled = schedule_wakeups_with_timerfd (self);
+
+ if (!wakeup_scheduled)
+ {
+ static gboolean seen_before = FALSE;
+
+ if (!seen_before)
+ {
+ goa_debug ("GoaAlarm: falling back to polling timeout");
+ seen_before = TRUE;
+ }
+ schedule_wakeups_with_timeout_source (self);
+ }
+}
+
+static void
+clear_immediate_wakeup_source_pointer (GoaAlarm *self)
+{
+ self->priv->immediate_wakeup_source = NULL;
+}
+
+static void
+schedule_immediate_wakeup (GoaAlarm *self)
+{
+ self->priv->immediate_wakeup_source = g_idle_source_new ();
+
+ g_source_set_callback (self->priv->immediate_wakeup_source,
+ (GSourceFunc)
+ on_immediate_wakeup_source_ready,
+ self,
+ (GDestroyNotify) clear_immediate_wakeup_source_pointer);
+ g_source_attach (self->priv->immediate_wakeup_source, self->priv->context);
+ g_source_unref (self->priv->immediate_wakeup_source);
+}
+
+void
+goa_alarm_set_time (GoaAlarm *self, GDateTime *time, GCancellable *cancellable)
+{
+ if (g_cancellable_is_cancelled (cancellable))
+ return;
+
+ if (self->priv->cancellable != NULL && self->priv->cancellable != cancellable)
+ g_cancellable_cancel (self->priv->cancellable);
+
+ if (cancellable != NULL)
+ g_object_ref (cancellable);
+
+ if (self->priv->cancelled_id != 0)
+ g_cancellable_disconnect (self->priv->cancellable, self->priv->cancelled_id);
+
+ g_clear_object (&self->priv->cancellable);
+
+ if (cancellable != NULL)
+ self->priv->cancellable = cancellable;
+ else
+ self->priv->cancellable = g_cancellable_new ();
+
+ self->priv->cancelled_id = g_cancellable_connect (self->priv->cancellable,
+ G_CALLBACK (on_cancelled),
+ self, NULL);
+
+ g_date_time_ref (time);
+
+ if (self->priv->time != NULL)
+ g_date_time_unref (self->priv->time);
+
+ self->priv->time = time;
+
+ self->priv->context = g_main_context_ref (g_main_context_default ());
+
+ g_object_notify (G_OBJECT (self), "time");
+
+ schedule_wakeups (self);
+
+ /* Wake up right away, in case it's already expired leaving the gate */
+ schedule_immediate_wakeup (self);
+}
+
+GDateTime *
+goa_alarm_get_time (GoaAlarm *self)
+{
+ return self->priv->time;
+}
+
+GoaAlarm *
+goa_alarm_new (void)
+{
+ GoaAlarm *self;
+
+ self = GOA_ALARM (g_object_new (GOA_TYPE_ALARM, NULL));
+
+ return GOA_ALARM (self);
+}
diff --git a/src/goaidentity/goaalarm.h b/src/goaidentity/goaalarm.h
new file mode 100644
index 0000000..a93991d
--- /dev/null
+++ b/src/goaidentity/goaalarm.h
@@ -0,0 +1,64 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_ALARM_H__
+#define __GOA_ALARM_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+#define GOA_TYPE_ALARM (goa_alarm_get_type ())
+#define GOA_ALARM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOA_TYPE_ALARM, GoaAlarm))
+#define GOA_ALARM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GOA_TYPE_ALARM, GoaAlarmClass))
+#define GOA_IS_ALARM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOA_TYPE_ALARM))
+#define GOA_IS_ALARM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOA_TYPE_ALARM))
+#define GOA_ALARM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GOA_TYPE_ALARM, GoaAlarmClass))
+typedef struct _GoaAlarm GoaAlarm;
+typedef struct _GoaAlarmClass GoaAlarmClass;
+typedef struct _GoaAlarmPrivate GoaAlarmPrivate;
+
+struct _GoaAlarm
+{
+ GObject parent;
+
+ GoaAlarmPrivate *priv;
+};
+
+struct _GoaAlarmClass
+{
+ GObjectClass parent_class;
+
+ void (* fired) (GoaAlarm *alarm);
+ void (* rearmed) (GoaAlarm *alarm);
+};
+
+GType goa_alarm_get_type (void);
+
+GoaAlarm *goa_alarm_new (void);
+void goa_alarm_set_time (GoaAlarm *alarm,
+ GDateTime *time,
+ GCancellable *cancellable);
+GDateTime *goa_alarm_get_time (GoaAlarm *alarm);
+G_END_DECLS
+#endif /* __GOA_ALARM_H__ */
diff --git a/src/goaidentity/goaidentity.c b/src/goaidentity/goaidentity.c
new file mode 100644
index 0000000..03894e9
--- /dev/null
+++ b/src/goaidentity/goaidentity.c
@@ -0,0 +1,83 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include <glib-object.h>
+#include <glib/gi18n.h>
+
+#include "goaidentity.h"
+#include "goalogging.h"
+
+G_DEFINE_INTERFACE (GoaIdentity, goa_identity, G_TYPE_OBJECT);
+
+static void
+goa_identity_default_init (GoaIdentityInterface *interface)
+{
+ g_object_interface_install_property (interface,
+ g_param_spec_string ("identifier",
+ "identifier",
+ "identifier",
+ NULL, G_PARAM_READABLE));
+ g_object_interface_install_property (interface,
+ g_param_spec_boolean ("is-signed-in",
+ "Is signed in",
+ "Whether or not identity is currently signed in",
+ FALSE,
+ G_PARAM_READABLE));
+ g_object_interface_install_property (interface,
+ g_param_spec_int64 ("expiration-timestamp",
+ "Expiration Timestamp",
+ "A timestamp of when the identities credentials expire",
+ -1,
+ G_MAXINT64,
+ -1, G_PARAM_READABLE));
+}
+
+GQuark
+goa_identity_error_quark (void)
+{
+ static GQuark error_quark = 0;
+
+ if (error_quark == 0)
+ {
+ error_quark = g_quark_from_static_string ("goa-identity-error");
+ }
+
+ return error_quark;
+}
+
+char **
+goa_identity_get_identifier_components (GoaIdentity *self)
+{
+ return GOA_IDENTITY_GET_IFACE (self)->get_identifier_components (self);
+}
+
+const char *
+goa_identity_get_identifier (GoaIdentity *self)
+{
+ return GOA_IDENTITY_GET_IFACE (self)->get_identifier (self);
+}
+
+gboolean
+goa_identity_is_signed_in (GoaIdentity *self)
+{
+ return GOA_IDENTITY_GET_IFACE (self)->is_signed_in (self);
+}
diff --git a/src/goaidentity/goaidentity.h b/src/goaidentity/goaidentity.h
new file mode 100644
index 0000000..f715489
--- /dev/null
+++ b/src/goaidentity/goaidentity.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode <rstrode redhat com>
+ */
+
+#ifndef __GOA_IDENTITY_H__
+#define __GOA_IDENTITY_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+#define GOA_TYPE_IDENTITY (goa_identity_get_type ())
+#define GOA_IDENTITY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOA_TYPE_IDENTITY, GoaIdentity))
+#define GOA_IDENTITY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GOA_TYPE_IDENTITY, GoaIdentityInterface))
+#define GOA_IS_IDENTITY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOA_TYPE_IDENTITY))
+#define GOA_IDENTITY_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE((obj), GOA_TYPE_IDENTITY, GoaIdentityInterface))
+#define GOA_IDENTITY_ERROR (goa_identity_error_quark ())
+typedef struct _GoaIdentity GoaIdentity;
+typedef struct _GoaIdentityInterface GoaIdentityInterface;
+
+struct _GoaIdentityInterface
+{
+ GTypeInterface base_interface;
+
+ const char * (* get_identifier) (GoaIdentity *identity);
+ char ** (* get_identifier_components) (GoaIdentity *identity);
+ gboolean (* is_signed_in) (GoaIdentity *identity);
+};
+
+typedef enum
+{
+ GOA_IDENTITY_ERROR_NOT_FOUND,
+ GOA_IDENTITY_ERROR_VERIFYING,
+ GOA_IDENTITY_ERROR_RENEWING,
+ GOA_IDENTITY_ERROR_CREDENTIALS_UNAVAILABLE,
+ GOA_IDENTITY_ERROR_ENUMERATING_CREDENTIALS,
+ GOA_IDENTITY_ERROR_ALLOCATING_CREDENTIALS,
+ GOA_IDENTITY_ERROR_AUTHENTICATION_FAILED,
+ GOA_IDENTITY_ERROR_SAVING_CREDENTIALS,
+ GOA_IDENTITY_ERROR_REMOVING_CREDENTIALS,
+ GOA_IDENTITY_ERROR_PARSING_IDENTIFIER,
+} GoaIdentityError;
+
+GType goa_identity_get_type (void);
+GQuark goa_identity_error_quark (void);
+
+const char *goa_identity_get_identifier (GoaIdentity *identity);
+char **goa_identity_get_identifier_components (GoaIdentity *identity);
+gboolean goa_identity_is_signed_in (GoaIdentity *identity);
+
+
+G_END_DECLS
+#endif /* __GOA_IDENTITY_H__ */
diff --git a/src/goaidentity/goaidentityenumtypes.c.in b/src/goaidentity/goaidentityenumtypes.c.in
new file mode 100644
index 0000000..c028690
--- /dev/null
+++ b/src/goaidentity/goaidentityenumtypes.c.in
@@ -0,0 +1,42 @@
+/*** BEGIN file-header ***/
+
+#include <glib-object.h>
+
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+#include "@filename@"
+/* enumerations from "@filename@" */
+/*** END file-production ***/
+
+/*** BEGIN value-header ***/
+GType @enum_name _get_type (void) G_GNUC_CONST;
+
+GType
+ enum_name@_get_type (void)
+{
+ static GType etype = 0;
+
+ if (G_UNLIKELY(etype == 0)) {
+ static const G Type@Value values[] = {
+/*** END value-header ***/
+
+/*** BEGIN value-production ***/
+ { @VALUENAME@, "@VALUENAME@", "@valuenick@" },
+/*** END value-production ***/
+
+/*** BEGIN value-tail ***/
+ { 0, NULL, NULL }
+ };
+
+ etype = g_ type@_register_static (g_intern_static_string ("@EnumName@"), values);
+ }
+
+ return etype;
+}
+
+/*** END value-tail ***/
+
+/*** BEGIN file-tail ***/
+ /**/
+/*** END file-tail ***/
diff --git a/src/goaidentity/goaidentityenumtypes.h.in b/src/goaidentity/goaidentityenumtypes.h.in
new file mode 100644
index 0000000..35d4d5c
--- /dev/null
+++ b/src/goaidentity/goaidentityenumtypes.h.in
@@ -0,0 +1,24 @@
+/*** BEGIN file-header ***/
+#ifndef GOA_IDENTITY_ENUM_TYPES_H
+#define GOA_IDENTITY_ENUM_TYPES_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+
+/* enumerations from "@filename@" */
+/*** END file-production ***/
+
+/*** BEGIN value-header ***/
+GType @enum_name _get_type (void) G_GNUC_CONST;
+#define @ENUMPREFIX _TYPE_@ENUMSHORT@ (@enum_name _get_type ())
+/*** END value-header ***/
+
+/*** BEGIN file-tail ***/
+G_END_DECLS
+
+#endif /* GOA_IDENTITY_ENUM_TYPES_H */
+/*** END file-tail ***/
diff --git a/src/goaidentity/goaidentityinquiry.c b/src/goaidentity/goaidentityinquiry.c
new file mode 100644
index 0000000..db68541
--- /dev/null
+++ b/src/goaidentity/goaidentityinquiry.c
@@ -0,0 +1,144 @@
+/* -*- Mode: C; tab-width: 8; ident-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ *
+ * Author: Ray Strode
+ */
+
+#include "config.h"
+
+#include "goaidentityinquiry.h"
+#include "goaidentityinquiryprivate.h"
+#include "goalogging.h"
+
+#include <string.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
+enum
+{
+ COMPLETE,
+ NUMBER_OF_SIGNALS,
+};
+
+static guint signals[NUMBER_OF_SIGNALS] = { 0 };
+
+G_DEFINE_INTERFACE (GoaIdentityInquiry, goa_identity_inquiry, G_TYPE_OBJECT);
+
+static void
+goa_identity_inquiry_default_init (GoaIdentityInquiryInterface *interface)
+{
+ signals[COMPLETE] = g_signal_new ("complete",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+void
+_goa_identity_inquiry_emit_complete (GoaIdentityInquiry *self)
+{
+ g_signal_emit (G_OBJECT (self), signals[COMPLETE], 0);
+}
+
+char *
+goa_identity_inquiry_get_name (GoaIdentityInquiry *self)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self), NULL);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->get_name (self);
+}
+
+char *
+goa_identity_inquiry_get_banner (GoaIdentityInquiry *self)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self), NULL);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->get_banner (self);
+}
+
+gboolean
+goa_identity_inquiry_is_complete (GoaIdentityInquiry *self)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self), TRUE);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->is_complete (self);
+}
+
+void
+goa_identity_inquiry_iter_init (GoaIdentityInquiryIter *iter,
+ GoaIdentityInquiry *inquiry)
+{
+ g_return_if_fail (GOA_IS_IDENTITY_INQUIRY (inquiry));
+
+ GOA_IDENTITY_INQUIRY_GET_IFACE (inquiry)->iter_init (iter, inquiry);
+}
+
+GoaIdentityQuery *
+goa_identity_inquiry_iter_next (GoaIdentityInquiryIter *iter,
+ GoaIdentityInquiry *inquiry)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (inquiry), NULL);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (inquiry)->iter_next (iter, inquiry);
+}
+
+GoaIdentity *
+goa_identity_inquiry_get_identity (GoaIdentityInquiry *self)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self), NULL);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->get_identity (self);
+}
+
+GoaIdentityQueryMode
+goa_identity_query_get_mode (GoaIdentityInquiry *self,
+ GoaIdentityQuery *query)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self),
+ GOA_IDENTITY_QUERY_MODE_INVISIBLE);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->get_mode (self, query);
+}
+
+char *
+goa_identity_query_get_prompt (GoaIdentityInquiry *self,
+ GoaIdentityQuery *query)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self), NULL);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->get_prompt (self, query);
+}
+
+void
+goa_identity_inquiry_answer_query (GoaIdentityInquiry *self,
+ GoaIdentityQuery *query,
+ const char *answer)
+{
+ g_return_if_fail (GOA_IS_IDENTITY_INQUIRY (self));
+
+ GOA_IDENTITY_INQUIRY_GET_IFACE (self)->answer_query (self, query, answer);
+}
+
+gboolean
+goa_identity_query_is_answered (GoaIdentityInquiry *self,
+ GoaIdentityQuery *query)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_INQUIRY (self), FALSE);
+
+ return GOA_IDENTITY_INQUIRY_GET_IFACE (self)->is_answered (self, query);
+}
diff --git a/src/goaidentity/goaidentityinquiry.h b/src/goaidentity/goaidentityinquiry.h
new file mode 100644
index 0000000..a62d1f9
--- /dev/null
+++ b/src/goaidentity/goaidentityinquiry.h
@@ -0,0 +1,110 @@
+/* -*- Mode: C; tab-width: 8; ident-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_IDENTITY_INQUIRY_H__
+#define __GOA_IDENTITY_INQUIRY_H__
+
+#include <stdint.h>
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "goaidentity.h"
+
+G_BEGIN_DECLS
+#define GOA_TYPE_IDENTITY_INQUIRY (goa_identity_inquiry_get_type ())
+#define GOA_IDENTITY_INQUIRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOA_TYPE_IDENTITY_INQUIRY, GoaIdentityInquiry))
+#define GOA_IDENTITY_INQUIRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GOA_TYPE_IDENTITY_INQUIRY, GoaIdentityInquiryClass))
+#define GOA_IS_IDENTITY_INQUIRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOA_TYPE_IDENTITY_INQUIRY))
+#define GOA_IDENTITY_INQUIRY_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE((obj), GOA_TYPE_IDENTITY_INQUIRY, GoaIdentityInquiryInterface))
+typedef struct _GoaIdentityInquiry GoaIdentityInquiry;
+typedef struct _GoaIdentityInquiryInterface GoaIdentityInquiryInterface;
+typedef struct _GoaIdentityInquiryIter GoaIdentityInquiryIter;
+
+typedef struct _GoaIdentityQuery GoaIdentityQuery;
+
+typedef void (* GoaIdentityInquiryFunc) (GoaIdentityInquiry *inquiry,
+ GCancellable *cancellable,
+ gpointer user_data);
+
+typedef enum
+{
+ GOA_IDENTITY_QUERY_MODE_INVISIBLE,
+ GOA_IDENTITY_QUERY_MODE_VISIBLE
+} GoaIdentityQueryMode;
+
+struct _GoaIdentityInquiryIter
+{
+ gpointer data;
+};
+
+struct _GoaIdentityInquiryInterface
+{
+ GTypeInterface base_interface;
+
+ GoaIdentity * (* get_identity) (GoaIdentityInquiry *inquiry);
+ char * (* get_name) (GoaIdentityInquiry *inquiry);
+ char * (* get_banner) (GoaIdentityInquiry *inquiry);
+
+ gboolean (* is_complete) (GoaIdentityInquiry *inquiry);
+ void (* answer_query) (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query,
+ const char *answer);
+
+ void (* iter_init) (GoaIdentityInquiryIter *iter,
+ GoaIdentityInquiry *inquiry);
+
+ GoaIdentityQuery * (* iter_next) (GoaIdentityInquiryIter *iter,
+ GoaIdentityInquiry *inquiry);
+
+ GoaIdentityQueryMode (* get_mode) (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query);
+ char * (* get_prompt) (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query);
+ gboolean (* is_answered) (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query);
+};
+
+GType goa_identity_inquiry_get_type (void);
+
+GoaIdentity *goa_identity_inquiry_get_identity (GoaIdentityInquiry *inquiry);
+char *goa_identity_inquiry_get_name (GoaIdentityInquiry *inquiry);
+char *goa_identity_inquiry_get_banner (GoaIdentityInquiry *inquiry);
+gboolean goa_identity_inquiry_is_complete (GoaIdentityInquiry *inquiry);
+void goa_identity_inquiry_answer_query (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query,
+ const char *answer);
+
+void goa_identity_inquiry_iter_init (GoaIdentityInquiryIter *iter,
+ GoaIdentityInquiry *inquiry);
+GoaIdentityQuery *goa_identity_inquiry_iter_next (GoaIdentityInquiryIter *iter,
+ GoaIdentityInquiry *inquiry);
+
+GoaIdentityQueryMode goa_identity_query_get_mode (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query);
+char * goa_identity_query_get_prompt (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query);
+gboolean goa_identity_query_is_answered (GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query);
+
+#endif /* __GOA_IDENTITY_INQUIRY_H__ */
diff --git a/src/goaidentity/goaidentityinquiryprivate.h b/src/goaidentity/goaidentityinquiryprivate.h
new file mode 100644
index 0000000..12c628e
--- /dev/null
+++ b/src/goaidentity/goaidentityinquiryprivate.h
@@ -0,0 +1,34 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_IDENTITY_INQUIRY_PRIVATE_H__
+#define __GOA_IDENTITY_INQUIRY_PRIVATE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "goaidentityinquiry.h"
+
+G_BEGIN_DECLS
+void _goa_identity_inquiry_emit_complete (GoaIdentityInquiry *inquiry);
+G_END_DECLS
+#endif /* __GOA_IDENTITY_INQUIRY_PRIVATE_H__ */
diff --git a/src/goaidentity/goaidentitylibrary.c b/src/goaidentity/goaidentitylibrary.c
new file mode 100644
index 0000000..4777b40
--- /dev/null
+++ b/src/goaidentity/goaidentitylibrary.c
@@ -0,0 +1,1032 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ *
+ */
+
+#include "config.h"
+#include "goaidentitylibrary.h"
+
+#include <glib/gi18n-lib.h>
+#include <gmodule.h>
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include <libnotify/notify.h>
+#include <gcr/gcr.h>
+
+#include "goakerberosprovider.h"
+
+#include "goakerberosidentitymanager.h"
+#include "goalogging.h"
+
+struct _GoaIdentityLibraryPrivate
+{
+ GoaIdentityManager *identity_manager;
+ GDBusConnection *connection;
+
+ GoaClient *client;
+ GoaManager *accounts_manager;
+ GDBusObjectManager *object_manager;
+ guint bus_id;
+};
+
+G_DEFINE_TYPE (GoaIdentityLibrary, goa_identity_library, G_TYPE_OBJECT);
+
+static void
+goa_identity_library_init (GoaIdentityLibrary *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ GOA_TYPE_IDENTITY_LIBRARY,
+ GoaIdentityLibraryPrivate);
+
+ goa_debug ("GoaIdentityLibrary: initializing");
+}
+
+static void
+goa_identity_library_finalize (GObject *object)
+{
+ GoaIdentityLibrary *self;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GOA_IS_IDENTITY_LIBRARY (object));
+
+ goa_debug ("GoaIdentityLibrary: finalizing");
+
+ self = GOA_IDENTITY_LIBRARY (object);
+
+ goa_identity_library_deactivate (self);
+
+ g_clear_object (&self->priv->identity_manager);
+
+ G_OBJECT_CLASS (goa_identity_library_parent_class)->finalize (object);
+}
+
+static void
+on_identity_renewed (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ GError *error;
+
+ error = NULL;
+ goa_identity_manager_renew_identity_finish (manager, result, &error);
+
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: could not renew identity: %s",
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ goa_debug ("GoaIdentityLibrary: identity renewed");
+}
+
+static void
+on_identity_needs_renewal (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GoaIdentityLibrary *self)
+{
+ const char *principal;
+
+ principal = goa_identity_get_identifier (identity);
+
+ goa_debug ("GoaIdentityLibrary: identity %s needs renewal", principal);
+
+ object = find_object_with_principal (self, principal);
+
+ if (object != NULL)
+ {
+ GoaAccount *account;
+
+ account = goa_object_peek_account (object);
+
+ }
+
+ goa_identity_manager_renew_identity (GOA_IDENTITY_MANAGER
+ (self->priv->identity_manager),
+ identity,
+ NULL,
+ (GAsyncReadyCallback)
+ on_identity_renewed,
+ self);
+}
+
+static void
+on_identity_signed_in (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ GError *error;
+
+ error = NULL;
+ goa_identity_manager_sign_identity_in_finish (manager, result, &error);
+
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: could not sign in identity: %s",
+ error->message);
+ g_error_free (error);
+ return;
+ }
+
+ goa_debug ("GoaIdentityLibrary: identity signed in");
+}
+
+static GoaObject *
+find_object_with_principal (GoaIdentityLibrary *self,
+ const char *principal)
+{
+ GList *objects;
+ GList *node;
+ GoaObject *found_object;
+
+ objects = g_dbus_object_manager_get_objects (self->priv->object_manager);
+
+ found_object = NULL;
+ for (node = objects; node != NULL; node = node->next)
+ {
+ GoaObject *object = GOA_OBJECT (node->data);
+ GoaAccount *account;
+ const char *provider_type;
+ const char *account_identity;
+
+ account = goa_object_peek_account (object);
+
+ if (account == NULL)
+ continue;
+
+ provider_type = goa_account_get_provider_type (account);
+
+ if (g_strcmp0 (provider_type, "kerberos") != 0)
+ continue;
+
+ account_identity = goa_account_get_identity (account);
+
+ if (g_strcmp0 (account_identity, principal) == 0)
+ {
+ found_object = g_object_ref (object);
+ break;
+ }
+ }
+ g_list_free_full (objects, (GDestroyNotify) g_object_unref);
+
+ return found_object;
+}
+
+static void
+on_account_created_for_identity (GoaManager *manager,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ char *object_path;
+ GError *error;
+
+ object_path = NULL;
+ error = NULL;
+
+ if (!goa_manager_call_add_account_finish (manager,
+ &object_path,
+ result,
+ &error))
+ {
+ goa_debug ("Could not create account for identity: %s", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ if (object_path != NULL)
+ {
+ goa_debug ("Created account for identity with object path %s", object_path);
+ g_free (object_path);
+ }
+}
+
+static void
+add_temporary_account_if_necessary (GoaIdentityLibrary *self,
+ GoaIdentity *identity)
+{
+ char *realm;
+ const char *principal;
+ const char *principal_for_display;
+ GoaObject *object;
+ GVariantBuilder credentials;
+ GVariantBuilder details;
+
+ principal = goa_identity_get_identifier (identity);
+ object = find_object_with_principal (self, principal);
+
+ if (object != NULL)
+ {
+ g_object_unref (object);
+ return;
+ }
+
+ goa_debug ("GoaIdentityLibrary: adding temporary identity %s", principal);
+
+ /* If there's no account for this identity then create a temporary one.
+ */
+ principal_for_display = goa_identity_manager_name_identity (self->priv->identity_manager,
+ identity);
+
+ realm = goa_kerberos_identity_get_realm_name (GOA_KERBEROS_IDENTITY (identity));
+
+ g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT);
+
+ g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}"));
+ g_variant_builder_add (&details, "{ss}", "Realm", realm);
+ g_variant_builder_add (&details, "{ss}", "IsPermanent", "false");
+
+ goa_manager_call_add_account (self->priv->accounts_manager,
+ "kerberos",
+ principal,
+ principal_for_display,
+ g_variant_builder_end (&credentials),
+ g_variant_builder_end (&details),
+ NULL,
+ (GAsyncReadyCallback)
+ on_account_created_for_identity,
+ self);
+ g_free (realm);
+}
+
+static void
+on_identity_added (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GoaIdentityLibrary *self)
+{
+ add_temporary_account_if_necessary (self, identity);
+}
+
+static void
+on_identity_refreshed (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GoaIdentityLibrary *self)
+{
+ add_temporary_account_if_necessary (self, identity);
+}
+
+typedef struct
+{
+ GoaIdentityLibrary *library;
+ GoaIdentity *identity;
+ NotifyNotification *notification;
+ GCancellable *cancellable;
+ gulong refreshed_signal_id;
+} SignInRequest;
+
+static SignInRequest *
+sign_in_request_new (GoaIdentityLibrary *library,
+ GoaIdentity *identity,
+ NotifyNotification *notification,
+ GCancellable *cancellable)
+{
+ SignInRequest *request;
+
+ request = g_slice_new0 (SignInRequest);
+
+ request->library = library;
+ request->identity = g_object_ref (identity);
+ request->notification = notification;
+ request->cancellable = g_object_ref (cancellable);
+
+ return request;
+}
+
+static void
+sign_in_request_free (SignInRequest *data)
+{
+ GoaIdentityLibrary *library = data->library;
+
+ g_signal_handler_disconnect (library->priv->identity_manager,
+ data->refreshed_signal_id);
+ g_object_set_data (G_OBJECT (data->identity),
+ "sign-in-request",
+ NULL);
+ g_clear_object (&data->identity);
+ g_clear_object (&data->cancellable);
+ g_slice_free (SignInRequest, data);
+}
+
+typedef struct
+{
+ GoaIdentityLibrary *library;
+ GoaIdentity *identity;
+ GoaIdentityInquiry *inquiry;
+ GoaIdentityQuery *query;
+ GcrSystemPrompt *prompt;
+ GCancellable *cancellable;
+} SystemPromptRequest;
+
+static SystemPromptRequest *
+system_prompt_request_new (GoaIdentityLibrary *library,
+ GcrSystemPrompt *prompt,
+ GoaIdentity *identity,
+ GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query,
+ GCancellable *cancellable)
+{
+ SystemPromptRequest *data;
+
+ data = g_slice_new0 (SystemPromptRequest);
+
+ data->library = library;
+ data->prompt = prompt;
+ data->identity = g_object_ref (identity);
+ data->inquiry = g_object_ref (inquiry);
+ data->query = query;
+ data->cancellable = g_object_ref (cancellable);
+
+ return data;
+}
+
+static void
+system_prompt_request_free (SystemPromptRequest *data)
+{
+ g_clear_object (&data->identity);
+ g_clear_object (&data->inquiry);
+ g_clear_object (&data->cancellable);
+ g_slice_free (SystemPromptRequest, data);
+}
+
+static void
+close_system_prompt (GoaIdentityManager *manager,
+ GoaIdentity *identity,
+ SystemPromptRequest *data)
+{
+ GError *error;
+
+ /* Only close the prompt if the identity we're
+ * waiting on got refreshed
+ */
+ if (data->identity != identity)
+ return;
+
+ g_signal_handlers_disconnect_by_func (G_OBJECT (manager),
+ G_CALLBACK (close_system_prompt),
+ data);
+ error = NULL;
+ if (!gcr_system_prompt_close (data->prompt, NULL, &error))
+ {
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: could not close system prompt: %s",
+ error->message);
+ g_error_free (error);
+ }
+ }
+}
+
+static void
+on_password_system_prompt_answered (GcrPrompt *prompt,
+ GAsyncResult *result,
+ SystemPromptRequest *request)
+{
+ GoaIdentityLibrary *self = request->library;
+ GoaIdentityInquiry *inquiry = request->inquiry;
+ GoaIdentity *identity = request->identity;
+ GoaIdentityQuery *query = request->query;
+ GCancellable *cancellable = request->cancellable;
+ GError *error;
+ const char *password;
+
+ error = NULL;
+ password = gcr_prompt_password_finish (prompt, result, &error);
+
+ if (password == NULL)
+ {
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: could not get password from user: %s",
+ error->message);
+ g_error_free (error);
+ }
+ else
+ {
+ g_cancellable_cancel (cancellable);
+ }
+ }
+ else if (!g_cancellable_is_cancelled (cancellable))
+ {
+ goa_identity_inquiry_answer_query (inquiry, query, password);
+ }
+
+ close_system_prompt (self->priv->identity_manager, identity, request);
+ system_prompt_request_free (request);
+}
+
+static void
+query_user (GoaIdentityLibrary *self,
+ GoaIdentity *identity,
+ GoaIdentityInquiry *inquiry,
+ GoaIdentityQuery *query,
+ GcrPrompt *prompt,
+ GCancellable *cancellable)
+{
+ SystemPromptRequest *request;
+ char *prompt_text;
+ GoaIdentityQueryMode query_mode;
+ char *description;
+ char *name;
+
+ g_assert (GOA_IS_KERBEROS_IDENTITY (identity));
+
+ gcr_prompt_set_title (prompt, _("Sign In to Realm"));
+
+ name = goa_identity_manager_name_identity (self->priv->identity_manager, identity);
+
+ description =
+ g_strdup_printf (_
+ ("The network realm %s needs some information to sign you in."),
+ name);
+ g_free (name);
+
+ gcr_prompt_set_description (prompt, description);
+ g_free (description);
+
+ prompt_text = goa_identity_query_get_prompt (inquiry, query);
+ gcr_prompt_set_message (prompt, prompt_text);
+ g_free (prompt_text);
+
+ request = system_prompt_request_new (self,
+ GCR_SYSTEM_PROMPT (prompt),
+ identity,
+ inquiry,
+ query,
+ cancellable);
+
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-refreshed",
+ G_CALLBACK (close_system_prompt),
+ request);
+
+ query_mode = goa_identity_query_get_mode (inquiry, query);
+
+ switch (query_mode)
+ {
+ case GOA_IDENTITY_QUERY_MODE_INVISIBLE:
+ gcr_prompt_password_async (prompt,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_password_system_prompt_answered,
+ request);
+ break;
+ case GOA_IDENTITY_QUERY_MODE_VISIBLE:
+ gcr_prompt_password_async (prompt,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_password_system_prompt_answered,
+ request);
+ break;
+ }
+}
+
+typedef struct
+{
+ GoaIdentityLibrary *library;
+ GoaIdentityInquiry *inquiry;
+ GCancellable *cancellable;
+} SystemPromptOpenRequest;
+
+static SystemPromptOpenRequest *
+system_prompt_open_request_new (GoaIdentityLibrary *library,
+ GoaIdentityInquiry *inquiry,
+ GCancellable *cancellable)
+{
+ SystemPromptOpenRequest *data;
+
+ data = g_slice_new0 (SystemPromptOpenRequest);
+
+ data->library = library;
+ data->inquiry = g_object_ref (inquiry);
+ data->cancellable = g_object_ref (cancellable);
+
+ return data;
+}
+
+static void
+system_prompt_open_request_free (SystemPromptOpenRequest *data)
+{
+ g_clear_object (&data->inquiry);
+ g_clear_object (&data->cancellable);
+ g_slice_free (SystemPromptOpenRequest, data);
+}
+
+static void
+on_system_prompt_open (GcrSystemPrompt *system_prompt,
+ GAsyncResult *result,
+ SystemPromptOpenRequest *request)
+{
+ GoaIdentityLibrary *self = request->library;
+ GoaIdentityInquiry *inquiry = request->inquiry;
+ GCancellable *cancellable = request->cancellable;
+ GoaIdentity *identity;
+ GoaIdentityQuery *query;
+ GcrPrompt *prompt;
+ GError *error;
+ GoaIdentityInquiryIter iter;
+
+ error = NULL;
+ prompt = gcr_system_prompt_open_finish (result, &error);
+
+ if (prompt == NULL)
+ {
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: could not open system prompt: %s",
+ error->message);
+ g_error_free (error);
+ }
+ return;
+ }
+
+ identity = goa_identity_inquiry_get_identity (inquiry);
+ goa_identity_inquiry_iter_init (&iter, inquiry);
+ while ((query = goa_identity_inquiry_iter_next (&iter, inquiry)) != NULL)
+ query_user (self, identity, inquiry, query, prompt, cancellable);
+
+ system_prompt_open_request_free (request);
+}
+
+static void
+on_identity_inquiry (GoaIdentityInquiry *inquiry,
+ GCancellable *cancellable,
+ GoaIdentityLibrary *self)
+{
+ SystemPromptOpenRequest *request;
+
+ request = system_prompt_open_request_new (self, inquiry, cancellable);
+ gcr_system_prompt_open_async (-1,
+ cancellable,
+ (GAsyncReadyCallback)
+ on_system_prompt_open, request);
+}
+
+static void
+on_sign_in_clicked (NotifyNotification *notification,
+ const char *action_id,
+ SignInRequest *request)
+{
+ GoaIdentityLibrary *self = request->library;
+ GoaIdentity *identity = request->identity;
+ const char *identifier;
+
+ identifier = goa_identity_get_identifier (identity);
+ goa_identity_manager_sign_identity_in (self->priv->identity_manager,
+ identifier,
+ (GoaIdentityInquiryFunc)
+ on_identity_inquiry,
+ self,
+ request->cancellable,
+ (GAsyncReadyCallback)
+ on_identity_signed_in, self);
+}
+
+static void
+close_notification (GCancellable *cancellable,
+ NotifyNotification *notification)
+{
+ notify_notification_close (notification, NULL);
+}
+
+static void
+cancel_sign_in (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ SignInRequest *data)
+{
+ g_cancellable_cancel (data->cancellable);
+ g_clear_object (&data->cancellable);
+}
+
+static void
+ask_to_sign_in (GoaIdentityLibrary *self,
+ GoaIdentity *identity)
+{
+ NotifyNotification *notification;
+ char *name;
+ char *description;
+ SignInRequest *request;
+ GCancellable *cancellable;
+
+ request = g_object_get_data (G_OBJECT (identity), "sign-in-request");
+
+ if (request != NULL)
+ g_cancellable_cancel (request->cancellable);
+
+ goa_debug ("GoaIdentityLibrary: asking to sign back in");
+
+ name = goa_identity_manager_name_identity (self->priv->identity_manager, identity);
+ if (goa_identity_is_signed_in (identity))
+ {
+ description =
+ g_strdup_printf (_("The network realm %s will soon be inaccessible."),
+ name);
+ }
+ else
+ {
+ description = g_strdup_printf (_("The network realm %s is now inaccessible."),
+ name);
+ }
+ g_free (name);
+
+ notification = notify_notification_new (_("Realm Access"),
+ description,
+ "dialog-password-symbolic");
+ g_free (description);
+ notify_notification_set_app_name (notification, _("Network Realm"));
+
+ cancellable = g_cancellable_new ();
+
+ request = sign_in_request_new (self, identity, notification, cancellable);
+
+ g_object_set_data (G_OBJECT (identity),
+ "sign-in-request",
+ request);
+
+ g_cancellable_connect (cancellable,
+ G_CALLBACK (close_notification),
+ notification,
+ NULL);
+ g_signal_connect_swapped (G_OBJECT (notification),
+ "closed",
+ G_CALLBACK (sign_in_request_free),
+ request);
+
+ request->refreshed_signal_id =
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-refreshed",
+ G_CALLBACK (cancel_sign_in),
+ request);
+
+ notify_notification_add_action (notification,
+ "sign-in",
+ _("Sign In"),
+ (NotifyActionCallback)
+ on_sign_in_clicked,
+ request,
+ NULL);
+
+ notify_notification_show (notification, NULL);
+}
+
+static void
+on_identity_expiring (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GoaIdentityLibrary *self)
+{
+ goa_debug ("GoaIdentityLibrary: identity expiring");
+ ask_to_sign_in (self, identity);
+}
+
+static void
+on_identity_expired (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GoaIdentityLibrary *self)
+{
+ goa_debug ("GoaIdentityLibrary: identity expired");
+ ask_to_sign_in (self, identity);
+}
+
+static void
+on_identity_signed_in_for_service (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GSimpleAsyncResult *service_result)
+{
+ GError *error;
+ GoaIdentity *identity;
+
+ error = NULL;
+ identity = goa_identity_manager_sign_identity_in_finish (manager,
+ result,
+ &error);
+
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: Identity could not be signed in: %s",
+ error->message);
+ g_simple_async_result_take_error (service_result, error);
+
+ }
+ else
+ {
+ goa_debug ("GoaIdentityLibrary: Identity %s signed in",
+ goa_identity_get_identifier (identity));
+ g_simple_async_result_set_op_res_gpointer (service_result,
+ g_object_ref (identity),
+ (GDestroyNotify)
+ g_object_unref);
+ }
+ g_simple_async_result_complete (service_result);
+
+}
+
+static void
+on_got_identity_for_service (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GSimpleAsyncResult *service_result)
+{
+ GError *error;
+ GoaIdentity *identity;
+
+ error = NULL;
+ identity = goa_identity_manager_get_identity_finish (manager, result, &error);
+
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: Identity could not be signed in: %s",
+ error->message);
+ g_simple_async_result_take_error (service_result, error);
+ g_simple_async_result_complete (service_result);
+ return;
+ }
+
+ goa_identity_manager_sign_identity_out (manager,
+ identity,
+ NULL,
+ (GAsyncReadyCallback)
+ on_identity_signed_out_for_service,
+ service_result);
+}
+
+static void
+on_identity_signed_out_for_removal (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ GError *error;
+
+ error = NULL;
+ goa_identity_manager_sign_identity_out_finish (manager, result, &error);
+
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: Identity could not be signed out: %s",
+ error->message);
+ }
+}
+
+static void
+on_got_identity_for_removal (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ GError *error;
+ GoaIdentity *identity;
+
+ error = NULL;
+ identity = goa_identity_manager_get_identity_finish (manager, result, &error);
+
+ if (error != NULL)
+ {
+ goa_debug ("GoaIdentityLibrary: Identity could not be signed out: %s",
+ error->message);
+ return;
+ }
+
+ goa_identity_manager_sign_identity_out (manager,
+ identity,
+ NULL,
+ (GAsyncReadyCallback)
+ on_identity_signed_out_for_removal,
+ self);
+}
+
+static void
+on_account_object_removed (GoaManager *manager,
+ GoaObject *object,
+ GoaIdentityLibrary *self)
+{
+ GoaAccount *account;
+ const char *provider_type;
+ const char *account_identity;
+
+ goa_debug ("Object removed");
+
+ account = goa_object_peek_account (object);
+
+ if (account == NULL)
+ return;
+
+ goa_debug ("Object has account");
+
+ provider_type = goa_account_get_provider_type (account);
+
+ if (g_strcmp0 (provider_type, "kerberos") != 0)
+ return;
+
+ goa_debug ("Object is kerberos object");
+
+ account_identity = goa_account_get_identity (account);
+
+ goa_identity_manager_get_identity (self->priv->identity_manager,
+ account_identity,
+ NULL,
+ (GAsyncReadyCallback)
+ on_got_identity_for_removal,
+ self);
+}
+
+static void
+on_identities_listed (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ GError *error = NULL;
+ GList *identities, *node;
+
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-added",
+ G_CALLBACK (on_identity_added),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-refreshed",
+ G_CALLBACK (on_identity_refreshed),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-needs-renewal",
+ G_CALLBACK (on_identity_needs_renewal),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-expiring",
+ G_CALLBACK (on_identity_expiring),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->identity_manager),
+ "identity-expired",
+ G_CALLBACK (on_identity_expired),
+ self);
+
+ identities = goa_identity_manager_list_identities_finish (manager, result, &error);
+
+ if (identities == NULL)
+ {
+ if (error != NULL)
+ {
+ goa_warning ("Could not list identities: %s", error->message);
+ g_error_free (error);
+ }
+ return;
+ }
+
+ for (node = identities; node != NULL; node = node->next)
+ {
+ GoaIdentity *identity = node->data;
+
+ add_temporary_account_if_necessary (self, identity);
+ }
+
+ g_signal_connect (G_OBJECT (self->priv->object_manager),
+ "interface-removed",
+ G_CALLBACK (on_account_object_removed),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->object_manager),
+ "object-removed",
+ G_CALLBACK (on_account_object_removed),
+ self);
+}
+
+static void
+on_got_client (GoaClient *client,
+ GAsyncResult *result,
+ GoaIdentityLibrary *self)
+{
+ GError *error;
+
+ error = NULL;
+
+ self->priv->client = goa_client_new_finish (result, &error);
+
+ if (self->priv->client == NULL)
+ {
+ goa_warning ("Could not create client: %s", error->message);
+ return;
+ }
+
+ self->priv->object_manager = goa_client_get_object_manager (client);
+ self->priv->accounts_manager = goa_client_get_manager (client);
+
+ self->priv->identity_manager = goa_kerberos_identity_manager_new (NULL, &error);
+
+ if (self->priv->identity_manager == NULL)
+ {
+ goa_warning ("Could not create identity manager: %s", error->message);
+ return;
+ }
+
+ goa_identity_manager_list_identities (self->priv->identity_manager,
+ NULL,
+ (GAsyncReadyCallback)
+ on_identities_listed,
+ self);
+}
+
+static void
+on_bus_acquired (GDBusConnection *connection,
+ const char *unique_name,
+ GoaIdentityLibrary *self)
+{
+ goa_debug ("GoaIdentityLibrary: Connected to session bus");
+
+ if (self->priv->connection == NULL)
+ {
+ self->priv->connection = g_object_ref (connection);
+
+ goa_client_new (NULL,
+ (GAsyncReadyCallback)
+ on_got_client,
+ self);
+ }
+}
+
+static void
+on_name_acquired (GDBusConnection *connection,
+ const char *name,
+ GoaIdentityLibrary *self)
+{
+ if (g_strcmp0 (name, "org.gnome.Identity") == 0)
+ goa_debug ("GoaIdentityLibrary: Acquired name org.gnome.Identity");
+}
+
+static void
+on_name_lost (GDBusConnection *connection,
+ const char *name,
+ GoaIdentityLibrary *self)
+{
+ if (g_strcmp0 (name, "org.gnome.Identity") == 0)
+ goa_debug ("GoaIdentityLibrary: Lost name org.gnome.Identity");
+}
+
+gboolean
+goa_identity_library_activate (GoaIdentityLibrary *self,
+ GError **error)
+{
+ g_return_val_if_fail (GOA_IS_IDENTITY_LIBRARY (self), FALSE);
+
+ goa_debug ("GoaIdentityLibrary: Activating identity library");
+
+ self->priv->bus_id = g_bus_own_name (G_BUS_TYPE_SESSION,
+ "org.gnome.Identity",
+ G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
+ G_BUS_NAME_OWNER_FLAGS_REPLACE,
+ (GBusAcquiredCallback) on_bus_acquired,
+ (GBusNameAcquiredCallback) on_name_acquired,
+ (GBusNameAcquiredCallback) on_name_lost,
+ self,
+ NULL);
+
+ return TRUE;
+}
+
+void
+goa_identity_library_deactivate (GoaIdentityLibrary *self)
+{
+ goa_debug ("GoaIdentityLibrary: Deactivating identity library");
+
+ if (self->priv->identity_manager != NULL)
+ {
+ g_signal_handlers_disconnect_by_func (self, on_identity_needs_renewal, self);
+ g_signal_handlers_disconnect_by_func (self, on_identity_expiring, self);
+ g_signal_handlers_disconnect_by_func (self, on_identity_expired, self);
+ g_clear_object (&self->priv->identity_manager);
+ }
+
+ g_clear_object (&self->priv->connection);
+ g_clear_object (&self->priv->client);
+}
+
+static void
+goa_identity_library_class_init (GoaIdentityLibraryClass *library_class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (library_class);
+
+ object_class->finalize = goa_identity_library_finalize;
+
+ g_type_class_add_private (library_class, sizeof (GoaIdentityLibraryPrivate));
+}
+
+GoaIdentityLibrary *
+goa_identity_library_new (void)
+{
+ GObject *object;
+
+ object = g_object_new (GOA_TYPE_IDENTITY_LIBRARY,
+ NULL);
+
+ return GOA_IDENTITY_LIBRARY (object);
+}
diff --git a/src/goaidentity/goaidentitylibrary.h b/src/goaidentity/goaidentitylibrary.h
new file mode 100644
index 0000000..193d41c
--- /dev/null
+++ b/src/goaidentity/goaidentitylibrary.h
@@ -0,0 +1,59 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_IDENTITY_LIBRARY_H__
+#define __GOA_IDENTITY_LIBRARY_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+#define GOA_TYPE_IDENTITY_LIBRARY (goa_identity_library_get_type ())
+#define GOA_IDENTITY_LIBRARY(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GOA_TYPE_IDENTITY_LIBRARY, GoaIdentityLibrary))
+#define GOA_IDENTITY_LIBRARY_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GOA_TYPE_IDENTITY_LIBRARY, GoaIdentityLibraryClass))
+#define GOA_IS_IDENTITY_LIBRARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GOA_TYPE_IDENTITY_LIBRARY))
+#define GOA_IS_IDENTITY_LIBRARY_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GOA_TYPE_IDENTITY_LIBRARY))
+#define GOA_IDENTITY_LIBRARY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GOA_TYPE_IDENTITY_LIBRARY, GoaIdentityLibraryClass))
+typedef struct _GoaIdentityLibrary GoaIdentityLibrary;
+typedef struct _GoaIdentityLibraryClass GoaIdentityLibraryClass;
+typedef struct _GoaIdentityLibraryPrivate GoaIdentityLibraryPrivate;
+
+struct _GoaIdentityLibrary
+{
+ GObject parent_instance;
+ GoaIdentityLibraryPrivate *priv;
+};
+
+struct _GoaIdentityLibraryClass
+{
+ GObjectClass parent_class;
+};
+
+GType goa_identity_library_get_type (void);
+GoaIdentityLibrary *goa_identity_library_new (void);
+gboolean goa_identity_library_activate (GoaIdentityLibrary *library,
+ GError **error);
+void goa_identity_library_deactivate (GoaIdentityLibrary *library);
+
+G_END_DECLS
+#endif /* __GOA_IDENTITY_LIBRARY_H__ */
diff --git a/src/goaidentity/goaidentitymanager.c b/src/goaidentity/goaidentitymanager.c
new file mode 100644
index 0000000..b8e2a21
--- /dev/null
+++ b/src/goaidentity/goaidentitymanager.c
@@ -0,0 +1,310 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include <glib-object.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
+#include "goaidentitymanager.h"
+#include "goaidentitymanagerprivate.h"
+#include "goalogging.h"
+
+enum
+{
+ IDENTITY_ADDED,
+ IDENTITY_REMOVED,
+ IDENTITY_RENAMED,
+ IDENTITY_REFRESHED,
+ IDENTITY_NEEDS_RENEWAL,
+ IDENTITY_EXPIRING,
+ IDENTITY_EXPIRED,
+ NUMBER_OF_SIGNALS,
+};
+
+static guint signals[NUMBER_OF_SIGNALS] = { 0 };
+
+G_DEFINE_INTERFACE (GoaIdentityManager, goa_identity_manager, G_TYPE_OBJECT);
+
+static void
+goa_identity_manager_default_init (GoaIdentityManagerInterface *interface)
+{
+ signals[IDENTITY_ADDED] = g_signal_new ("identity-added",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET
+ (GoaIdentityManagerInterface,
+ identity_added), NULL, NULL, NULL,
+ G_TYPE_NONE, 1, GOA_TYPE_IDENTITY);
+ signals[IDENTITY_REMOVED] = g_signal_new ("identity-removed",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GoaIdentityManagerInterface,
+ identity_removed),
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GOA_TYPE_IDENTITY);
+ signals[IDENTITY_REFRESHED] = g_signal_new ("identity-refreshed",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GoaIdentityManagerInterface,
+ identity_refreshed),
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GOA_TYPE_IDENTITY);
+ signals[IDENTITY_RENAMED] = g_signal_new ("identity-renamed",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GoaIdentityManagerInterface,
+ identity_renamed),
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GOA_TYPE_IDENTITY);
+ signals[IDENTITY_NEEDS_RENEWAL] = g_signal_new ("identity-needs-renewal",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GoaIdentityManagerInterface,
+ identity_needs_renewal),
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GOA_TYPE_IDENTITY);
+ signals[IDENTITY_EXPIRING] = g_signal_new ("identity-expiring",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GoaIdentityManagerInterface,
+ identity_expiring),
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GOA_TYPE_IDENTITY);
+ signals[IDENTITY_EXPIRED] = g_signal_new ("identity-expired",
+ G_TYPE_FROM_INTERFACE (interface),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GoaIdentityManagerInterface,
+ identity_expired),
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 1,
+ GOA_TYPE_IDENTITY);
+}
+
+GQuark
+goa_identity_manager_error_quark (void)
+{
+ static GQuark error_quark = 0;
+
+ if (error_quark == 0)
+ error_quark = g_quark_from_static_string ("goa-identity-manager-error");
+
+ return error_quark;
+}
+
+void
+goa_identity_manager_get_identity (GoaIdentityManager *self,
+ const char *identifier,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->get_identity (self,
+ identifier,
+ cancellable,
+ callback,
+ user_data);
+}
+
+GoaIdentity *
+goa_identity_manager_get_identity_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ return GOA_IDENTITY_MANAGER_GET_IFACE (self)->get_identity_finish (self,
+ result,
+ error);
+}
+
+void
+goa_identity_manager_list_identities (GoaIdentityManager *self,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->list_identities (self,
+ cancellable,
+ callback,
+ user_data);
+}
+
+GList *
+goa_identity_manager_list_identities_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ return GOA_IDENTITY_MANAGER_GET_IFACE (self)->list_identities_finish (self,
+ result,
+ error);
+}
+
+void
+goa_identity_manager_renew_identity (GoaIdentityManager *self,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->renew_identity (self,
+ identity,
+ cancellable,
+ callback,
+ user_data);
+}
+
+void
+goa_identity_manager_renew_identity_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->renew_identity_finish (self, result, error);
+}
+
+void
+goa_identity_manager_sign_identity_in (GoaIdentityManager *self,
+ const char *identifier,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->sign_identity_in (self,
+ identifier,
+ inquiry_func,
+ inquiry_data,
+ cancellable,
+ callback,
+ user_data);
+}
+
+GoaIdentity *
+goa_identity_manager_sign_identity_in_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ return GOA_IDENTITY_MANAGER_GET_IFACE (self)->sign_identity_in_finish (self,
+ result,
+ error);
+}
+
+void
+goa_identity_manager_sign_identity_out (GoaIdentityManager *self,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->sign_identity_out (self,
+ identity,
+ cancellable,
+ callback,
+ user_data);
+}
+
+void
+goa_identity_manager_sign_identity_out_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ GOA_IDENTITY_MANAGER_GET_IFACE (self)->sign_identity_out_finish (self,
+ result,
+ error);
+}
+
+char *
+goa_identity_manager_name_identity (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ return GOA_IDENTITY_MANAGER_GET_IFACE (self)->name_identity (self, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_added (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_ADDED], 0, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_removed (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_REMOVED], 0, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_renamed (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_RENAMED], 0, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_refreshed (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_REFRESHED], 0, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_needs_renewal (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_NEEDS_RENEWAL], 0, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_expiring (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_EXPIRING], 0, identity);
+}
+
+void
+_goa_identity_manager_emit_identity_expired (GoaIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_emit (G_OBJECT (self), signals[IDENTITY_EXPIRED], 0, identity);
+}
diff --git a/src/goaidentity/goaidentitymanager.h b/src/goaidentity/goaidentitymanager.h
new file mode 100644
index 0000000..fb15860
--- /dev/null
+++ b/src/goaidentity/goaidentitymanager.h
@@ -0,0 +1,175 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_IDENTITY_MANAGER_H__
+#define __GOA_IDENTITY_MANAGER_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "goaidentity.h"
+#include "goaidentityinquiry.h"
+
+G_BEGIN_DECLS
+#define GOA_TYPE_IDENTITY_MANAGER (goa_identity_manager_get_type ())
+#define GOA_IDENTITY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOA_TYPE_IDENTITY_MANAGER, GoaIdentityManager))
+#define GOA_IDENTITY_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GOA_TYPE_IDENTITY_MANAGER, GoaIdentityManagerInterface))
+#define GOA_IS_IDENTITY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOA_TYPE_IDENTITY_MANAGER))
+#define GOA_IDENTITY_MANAGER_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE((obj), GOA_TYPE_IDENTITY_MANAGER, GoaIdentityManagerInterface))
+#define GOA_IDENTITY_MANAGER_ERROR (goa_identity_manager_error_quark ())
+typedef struct _GoaIdentityManager GoaIdentityManager;
+typedef struct _GoaIdentityManagerInterface GoaIdentityManagerInterface;
+
+struct _GoaIdentityManagerInterface
+{
+ GTypeInterface base_interface;
+
+ /* Signals */
+ void (* identity_added) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+
+ void (* identity_removed) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+ void (* identity_renamed) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+ void (* identity_refreshed) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+ void (* identity_needs_renewal) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+ void (* identity_expiring) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+ void (* identity_expired) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+
+ /* Virtual Functions */
+ void (* get_identity) (GoaIdentityManager *identity_manager,
+ const char *identifier,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+ GoaIdentity * (* get_identity_finish) (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+ void (* list_identities) (GoaIdentityManager *identity_manager,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+ GList * (* list_identities_finish) (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+ void (* sign_identity_in) (GoaIdentityManager *identity_manager,
+ const char *identifier,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+ GoaIdentity * (* sign_identity_in_finish) (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+ void (* sign_identity_out) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+ void (* sign_identity_out_finish) (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+ void (* renew_identity) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+ void (* renew_identity_finish) (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+ char * (* name_identity) (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+};
+
+typedef enum
+{
+ GOA_IDENTITY_MANAGER_ERROR_INITIALIZING,
+ GOA_IDENTITY_MANAGER_ERROR_IDENTITY_NOT_FOUND,
+ GOA_IDENTITY_MANAGER_ERROR_CREATING_IDENTITY,
+ GOA_IDENTITY_MANAGER_ERROR_ACCESSING_CREDENTIALS,
+ GOA_IDENTITY_MANAGER_ERROR_UNSUPPORTED_CREDENTIALS
+} GoaIdentityManagerError;
+
+GType goa_identity_manager_get_type (void);
+GQuark goa_identity_manager_error_quark (void);
+
+void goa_identity_manager_get_identity (GoaIdentityManager *identity_manager,
+ const char *identifier,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GoaIdentity *goa_identity_manager_get_identity_finish (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+void goa_identity_manager_list_identities (GoaIdentityManager *identity_manager,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GList *goa_identity_manager_list_identities_finish (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+void goa_identity_manager_sign_identity_in (GoaIdentityManager *identity_manager,
+ const char *identifier,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+GoaIdentity *goa_identity_manager_sign_identity_in_finish (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+void goa_identity_manager_sign_identity_out (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+void goa_identity_manager_sign_identity_out_finish (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+void goa_identity_manager_renew_identity (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+void goa_identity_manager_renew_identity_finish (GoaIdentityManager *identity_manager,
+ GAsyncResult *result,
+ GError **error);
+
+char *goa_identity_manager_name_identity (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+
+G_END_DECLS
+#endif /* __GOA_IDENTITY_MANAGER_H__ */
diff --git a/src/goaidentity/goaidentitymanagerprivate.h b/src/goaidentity/goaidentitymanagerprivate.h
new file mode 100644
index 0000000..1f613b6
--- /dev/null
+++ b/src/goaidentity/goaidentitymanagerprivate.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_IDENTITY_MANAGER_PRIVATE_H__
+#define __GOA_IDENTITY_MANAGER_PRIVATE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "goaidentitymanager.h"
+
+G_BEGIN_DECLS
+void _goa_identity_manager_emit_identity_added (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+void _goa_identity_manager_emit_identity_removed (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+void _goa_identity_manager_emit_identity_refreshed (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+void _goa_identity_manager_emit_identity_renamed (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+
+void _goa_identity_manager_emit_identity_expiring (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+
+void _goa_identity_manager_emit_identity_needs_renewal (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+void _goa_identity_manager_emit_identity_expired (GoaIdentityManager *identity_manager,
+ GoaIdentity *identity);
+G_END_DECLS
+#endif /* __GOA_IDENTITY_MANAGER_PRIVATE_H__ */
diff --git a/src/goaidentity/goaidentityutils.c b/src/goaidentity/goaidentityutils.c
new file mode 100644
index 0000000..9cb8838
--- /dev/null
+++ b/src/goaidentity/goaidentityutils.c
@@ -0,0 +1,191 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#include "config.h"
+
+#include "goaidentityutils.h"
+#include "goalogging.h"
+
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+
+char *
+goa_identity_utils_escape_object_path_component (const char *data,
+ gsize length)
+{
+ const char *p;
+ char *object_path;
+ GString *string;
+
+ g_return_val_if_fail (data != NULL, NULL);
+
+ string = g_string_sized_new ((length + 1) * 6);
+
+ for (p = data; *p != '\0'; p++)
+ {
+ guchar character;
+
+ character = (guchar) * p;
+
+ if (((character >= ((guchar) 'a')) &&
+ (character <= ((guchar) 'z'))) ||
+ ((character >= ((guchar) 'A')) &&
+ (character <= ((guchar) 'Z'))) ||
+ ((character >= ((guchar) '0')) && (character <= ((guchar) '9'))))
+ {
+ g_string_append_c (string, (char) character);
+ continue;
+ }
+
+ g_string_append_printf (string, "_%x_", character);
+ }
+
+ object_path = string->str;
+
+ g_string_free (string, FALSE);
+
+ return object_path;
+}
+
+static char *
+dashed_string_to_studly_caps (const char *dashed_string)
+{
+ char *studly_string;;
+ size_t studly_string_length;
+ size_t i;
+
+ i = 0;
+
+ studly_string = g_strdup (dashed_string);
+ studly_string_length = strlen (studly_string);
+
+ studly_string[i] = g_ascii_toupper (studly_string[i]);
+ i++;
+
+ while (i < studly_string_length)
+ {
+ if (studly_string[i] == '-' || studly_string[i] == '_')
+ {
+ g_memmove (studly_string + i,
+ studly_string + i + 1,
+ studly_string_length - i - 1);
+ studly_string_length--;
+ if (g_ascii_isalpha (studly_string[i]))
+ studly_string[i] = g_ascii_toupper (studly_string[i]);
+ }
+ i++;
+ }
+ studly_string[studly_string_length] = '\0';
+
+ return studly_string;
+}
+
+static char *
+dashed_string_to_dbus_error_string (const char *dashed_string,
+ const char *old_prefix,
+ const char *new_prefix,
+ const char *suffix)
+{
+ char *studly_suffix;
+ char *dbus_error_string;
+ size_t dbus_error_string_length;
+ size_t i;
+
+ i = 0;
+
+ if (g_str_has_prefix (dashed_string, old_prefix) &&
+ (dashed_string[strlen (old_prefix)] == '-' ||
+ dashed_string[strlen (old_prefix)] == '_'))
+ dashed_string += strlen (old_prefix) + 1;
+
+ studly_suffix = dashed_string_to_studly_caps (suffix);
+ dbus_error_string =
+ g_strdup_printf ("%s.%s.%s", new_prefix, dashed_string, studly_suffix);
+ g_free (studly_suffix);
+ i += strlen (new_prefix) + 1;
+
+ dbus_error_string_length = strlen (dbus_error_string);
+
+ dbus_error_string[i] = g_ascii_toupper (dbus_error_string[i]);
+ i++;
+
+ while (i < dbus_error_string_length)
+ {
+ if (dbus_error_string[i] == '_' || dbus_error_string[i] == '-')
+ {
+ dbus_error_string[i] = '.';
+
+ if (g_ascii_isalpha (dbus_error_string[i + 1]))
+ dbus_error_string[i + 1] = g_ascii_toupper (dbus_error_string[i + 1]);
+ }
+
+ i++;
+ }
+
+ return dbus_error_string;
+}
+
+void
+goa_identity_utils_register_error_domain (GQuark error_domain,
+ GType error_enum)
+{
+ const char *error_domain_string;
+ char *type_name;
+ GType type;
+ GTypeClass *type_class;
+ GEnumClass *enum_class;
+ guint i;
+
+ error_domain_string = g_quark_to_string (error_domain);
+ type_name = dashed_string_to_studly_caps (error_domain_string);
+ type = g_type_from_name (type_name);
+ type_class = g_type_class_ref (type);
+
+ if (type_class == NULL)
+ {
+ goa_warning ("GoaIdentityUtils: Could not identity type %s", type_name);
+ return;
+ }
+
+ enum_class = G_ENUM_CLASS (type_class);
+
+ for (i = 0; i < enum_class->n_values; i++)
+ {
+ char *dbus_error_string;
+
+ dbus_error_string = dashed_string_to_dbus_error_string (error_domain_string,
+ "goa",
+ "org.gnome",
+ enum_class->values[i].
+ value_nick);
+
+ goa_debug ("GoaIdentityUtils: Registering dbus error %s", dbus_error_string);
+ g_dbus_error_register_error (error_domain,
+ enum_class->values[i].value, dbus_error_string);
+ g_free (dbus_error_string);
+ }
+
+ g_type_class_unref (type_class);
+}
diff --git a/src/goaidentity/goaidentityutils.h b/src/goaidentity/goaidentityutils.h
new file mode 100644
index 0000000..9c4cd25
--- /dev/null
+++ b/src/goaidentity/goaidentityutils.h
@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_IDENTITY_UTILS_H__
+#define __GOA_IDENTITY_UTILS_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+char *goa_identity_utils_escape_object_path_component (const char *data,
+ gsize length);
+void goa_identity_utils_register_error_domain (GQuark error_domain,
+ GType error_enum);
+
+G_END_DECLS
+#endif /* __GOA_IDENTITY_UTILS_H__ */
diff --git a/src/goaidentity/goakerberosidentity.c b/src/goaidentity/goakerberosidentity.c
new file mode 100644
index 0000000..46c38fb
--- /dev/null
+++ b/src/goaidentity/goakerberosidentity.c
@@ -0,0 +1,1483 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ *
+ * Author: Ray Strode
+ */
+
+#include "config.h"
+
+#include "goaidentity.h"
+#include "goakerberosidentity.h"
+#include "goaalarm.h"
+#include "goalogging.h"
+
+#include <string.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
+typedef enum
+{
+ VERIFICATION_LEVEL_UNVERIFIED,
+ VERIFICATION_LEVEL_ERROR,
+ VERIFICATION_LEVEL_EXISTS,
+ VERIFICATION_LEVEL_SIGNED_IN
+} VerificationLevel;
+
+struct _GoaKerberosIdentityPrivate
+{
+ krb5_context kerberos_context;
+ krb5_ccache credentials_cache;
+
+ char *identifier;
+ guint identifier_idle_id;
+
+ char **identifier_components;
+
+ krb5_timestamp expiration_time;
+ guint expiration_time_idle_id;
+
+ GoaAlarm *expiration_alarm;
+ GCancellable *expiration_alarm_cancellable;
+
+ GoaAlarm *expiring_alarm;
+ GCancellable *expiring_alarm_cancellable;
+
+ GoaAlarm *renewal_alarm;
+ GCancellable *renewal_alarm_cancellable;
+
+ VerificationLevel cached_verification_level;
+ guint is_signed_in_idle_id;
+};
+
+enum
+{
+ EXPIRING,
+ EXPIRED,
+ UNEXPIRED,
+ NEEDS_RENEWAL,
+ NEEDS_REFRESH,
+ NUMBER_OF_SIGNALS,
+};
+
+enum
+{
+ PROP_0,
+ PROP_IDENTIFIER,
+ PROP_IS_SIGNED_IN,
+ PROP_EXPIRATION_TIMESTAMP
+};
+
+static guint signals[NUMBER_OF_SIGNALS] = { 0 };
+
+static void identity_interface_init (GoaIdentityInterface *interface);
+static void initable_interface_init (GInitableIface *interface);
+static void reset_alarms (GoaKerberosIdentity *self);
+static void clear_alarms (GoaKerberosIdentity *self);
+static gboolean goa_kerberos_identity_is_signed_in (GoaIdentity *identity);
+static void set_error_from_krb5_error_code (GoaKerberosIdentity *self,
+ GError **error,
+ gint code,
+ krb5_error_code error_code,
+ const char *format,
+ ...);
+
+G_LOCK_DEFINE_STATIC (identity_lock);
+
+G_DEFINE_TYPE_WITH_CODE (GoaKerberosIdentity,
+ goa_kerberos_identity,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+ initable_interface_init)
+ G_IMPLEMENT_INTERFACE (GOA_TYPE_IDENTITY,
+ identity_interface_init));
+static void
+goa_kerberos_identity_dispose (GObject *object)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (object);
+
+ G_LOCK (identity_lock);
+ clear_alarms (self);
+
+ g_clear_object (&self->priv->renewal_alarm);
+ g_clear_object (&self->priv->expiring_alarm);
+ g_clear_object (&self->priv->expiration_alarm);
+ G_UNLOCK (identity_lock);
+
+ if (self->priv->expiration_time_idle_id != 0)
+ g_source_remove (self->priv->expiration_time_idle_id);
+
+ G_OBJECT_CLASS (goa_kerberos_identity_parent_class)->dispose (object);
+
+}
+
+static void
+goa_kerberos_identity_finalize (GObject *object)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (object);
+
+ g_free (self->priv->identifier);
+
+ if (self->priv->credentials_cache != NULL)
+ krb5_cc_close (self->priv->kerberos_context, self->priv->credentials_cache);
+
+ G_OBJECT_CLASS (goa_kerberos_identity_parent_class)->finalize (object);
+}
+
+static void
+goa_kerberos_identity_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *param_spec)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (object);
+
+ switch (property_id)
+ {
+ case PROP_IDENTIFIER:
+ G_LOCK (identity_lock);
+ g_value_set_string (value, self->priv->identifier);
+ G_UNLOCK (identity_lock);
+ break;
+ case PROP_IS_SIGNED_IN:
+ g_value_set_boolean (value,
+ goa_kerberos_identity_is_signed_in (GOA_IDENTITY (self)));
+ break;
+ case PROP_EXPIRATION_TIMESTAMP:
+ G_LOCK (identity_lock);
+ g_value_set_int64 (value, (gint64) self->priv->expiration_time);
+ G_UNLOCK (identity_lock);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, param_spec);
+ break;
+ }
+}
+
+static void
+goa_kerberos_identity_class_init (GoaKerberosIdentityClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+
+ object_class->dispose = goa_kerberos_identity_dispose;
+ object_class->finalize = goa_kerberos_identity_finalize;
+ object_class->get_property = goa_kerberos_identity_get_property;
+
+ g_type_class_add_private (klass, sizeof (GoaKerberosIdentityPrivate));
+
+ signals[EXPIRING] = g_signal_new ("expiring",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 0);
+ signals[EXPIRED] = g_signal_new ("expired",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 0);
+ signals[UNEXPIRED] = g_signal_new ("unexpired",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 0);
+ signals[NEEDS_RENEWAL] = g_signal_new ("needs-renewal",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 0);
+ signals[NEEDS_REFRESH] = g_signal_new ("needs-refresh",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ 0,
+ NULL,
+ NULL,
+ NULL,
+ G_TYPE_NONE,
+ 0);
+
+ g_object_class_override_property (object_class, PROP_IDENTIFIER, "identifier");
+ g_object_class_override_property (object_class, PROP_IS_SIGNED_IN, "is-signed-in");
+ g_object_class_override_property (object_class,
+ PROP_EXPIRATION_TIMESTAMP,
+ "expiration-timestamp");
+
+}
+
+static char *
+get_identifier (GoaKerberosIdentity *self,
+ GError **error)
+{
+ krb5_principal principal;
+ krb5_error_code error_code;
+ char *unparsed_name;
+ char *identifier;
+
+ if (self->priv->credentials_cache == NULL)
+ return NULL;
+
+ error_code = krb5_cc_get_principal (self->priv->kerberos_context,
+ self->priv->credentials_cache, &principal);
+
+ if (error_code != 0)
+ {
+ if (error_code == KRB5_CC_END)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_CREDENTIALS_UNAVAILABLE,
+ error_code,
+ _
+ ("Could not find identity in credential cache: %k"));
+ }
+ else
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_ENUMERATING_CREDENTIALS,
+ error_code,
+ _
+ ("Could not find identity in credential cache: %k"));
+ }
+ return NULL;
+ }
+
+ error_code = krb5_unparse_name_flags (self->priv->kerberos_context,
+ principal,
+ 0,
+ &unparsed_name);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug ("GoaKerberosIdentity: Error parsing principal identity name: %s",
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ return NULL;
+ }
+
+ identifier = g_strdup (unparsed_name);
+ krb5_free_unparsed_name (self->priv->kerberos_context, unparsed_name);
+
+ return identifier;
+}
+
+static char **
+get_identifier_components (GoaKerberosIdentity *self)
+{
+ krb5_principal principal;
+ krb5_error_code error_code;
+ int size, i;
+ GPtrArray *array;
+
+ if (self->priv->identifier == NULL)
+ return g_new0 (char *, 1);
+
+ error_code = krb5_parse_name (self->priv->kerberos_context,
+ self->priv->identifier,
+ &principal);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+
+ goa_debug ("GoaKerberosIdentity: Error looking up principal "
+ "identity in credential cache: %s",
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ return g_new0 (char *, 1);
+ }
+
+ array = g_ptr_array_new ();
+
+ g_ptr_array_add (array,
+ g_strndup (principal->realm.data, principal->realm.length));
+
+ size = krb5_princ_size (self->priv->kerberos_context, principal);
+
+ for (i = 0; i < size; i++)
+ {
+ krb5_data *component;
+ char *component_string;
+
+ component = krb5_princ_component (self->priv->kerberos_context, principal, i);
+
+ component_string = g_strndup (component->data, component->length);
+ g_ptr_array_add (array, component_string);
+
+ }
+ g_ptr_array_add (array, NULL);
+
+ return (char **) g_ptr_array_free (array, FALSE);
+}
+
+static void
+goa_kerberos_identity_init (GoaKerberosIdentity *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ GOA_TYPE_KERBEROS_IDENTITY,
+ GoaKerberosIdentityPrivate);
+ self->priv->expiration_alarm = goa_alarm_new ();
+ self->priv->expiring_alarm = goa_alarm_new ();
+ self->priv->renewal_alarm = goa_alarm_new ();
+}
+
+static void
+set_error_from_krb5_error_code (GoaKerberosIdentity *self,
+ GError **error,
+ gint code,
+ krb5_error_code error_code,
+ const char *format,
+ ...)
+{
+ const char *error_message;
+ char *literal_message;
+ char *expanded_format;
+ va_list args;
+ char **chunks;
+
+ error_message = krb5_get_error_message (self->priv->kerberos_context, error_code);
+ chunks = g_strsplit (format, "%k", -1);
+ expanded_format = g_strjoinv (error_message, chunks);
+ g_strfreev (chunks);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+
+ va_start (args, format);
+ literal_message = g_strdup_vprintf (expanded_format, args);
+ va_end (args);
+
+ g_set_error_literal (error, GOA_IDENTITY_ERROR, code, literal_message);
+ g_free (literal_message);
+}
+
+char *
+goa_kerberos_identity_get_principal_name (GoaKerberosIdentity *self)
+{
+ krb5_principal principal;
+ krb5_error_code error_code;
+ char *unparsed_name;
+ char *principal_name;
+ int flags;
+
+ if (self->priv->identifier == NULL)
+ return NULL;
+
+ error_code = krb5_parse_name (self->priv->kerberos_context,
+ self->priv->identifier,
+ &principal);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug
+ ("GoaKerberosIdentity: Error parsing identity %s into kerberos principal: %s",
+ self->priv->identifier, error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ return NULL;
+ }
+
+ flags = KRB5_PRINCIPAL_UNPARSE_DISPLAY;
+ error_code = krb5_unparse_name_flags (self->priv->kerberos_context,
+ principal, flags, &unparsed_name);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug ("GoaKerberosIdentity: Error parsing principal identity name: %s",
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ return NULL;
+ }
+
+ principal_name = g_strdup (unparsed_name);
+ krb5_free_unparsed_name (self->priv->kerberos_context, unparsed_name);
+
+ return principal_name;
+}
+
+char *
+goa_kerberos_identity_get_realm_name (GoaKerberosIdentity *self)
+{
+ krb5_principal principal;
+ krb5_error_code error_code;
+ krb5_data *realm;
+ char *realm_name;
+
+ if (self->priv->identifier == NULL)
+ return NULL;
+
+ error_code = krb5_parse_name (self->priv->kerberos_context,
+ self->priv->identifier, &principal);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug
+ ("GoaKerberosIdentity: Error parsing identity %s into kerberos principal: %s",
+ self->priv->identifier, error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ return NULL;
+ }
+
+ realm = krb5_princ_realm (self->priv->kerberos_context, principal);
+ realm_name = g_strndup (realm->data, realm->length);
+ krb5_free_principal (self->priv->kerberos_context, principal);
+
+ return realm_name;
+}
+
+static const char *
+goa_kerberos_identity_get_identifier (GoaIdentity *identity)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (identity);
+
+ return self->priv->identifier;
+}
+
+static char **
+goa_kerberos_identity_get_identifier_components (GoaIdentity *identity)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (identity);
+
+ return g_strdupv (self->priv->identifier_components);
+}
+
+static gboolean
+credentials_validate_existence (GoaKerberosIdentity *self,
+ krb5_principal principal, krb5_creds * credentials)
+{
+ /* Checks if default principal associated with the cache has a valid
+ * ticket granting ticket in the passed in credentials
+ */
+
+ if (krb5_is_config_principal (self->priv->kerberos_context, credentials->server))
+ return FALSE;
+
+ /* looking for the krbtgt / REALM pair, so it should be exactly 2 items */
+ if (krb5_princ_size (self->priv->kerberos_context, credentials->server) != 2)
+ return FALSE;
+
+ if (!krb5_realm_compare (self->priv->kerberos_context,
+ credentials->server, principal))
+ {
+ /* credentials are from some other realm */
+ return FALSE;
+ }
+
+ if (strncmp (credentials->server->data[0].data,
+ KRB5_TGS_NAME, credentials->server->data[0].length) != 0)
+ {
+ /* credentials aren't for ticket granting */
+ return FALSE;
+ }
+
+ if (credentials->server->data[1].length != principal->realm.length ||
+ memcmp (credentials->server->data[1].data,
+ principal->realm.data, principal->realm.length) != 0)
+ {
+ /* credentials are for some other realm */
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static krb5_timestamp
+get_current_time (GoaKerberosIdentity *self)
+{
+ krb5_timestamp current_time;
+ krb5_error_code error_code;
+
+ error_code = krb5_timeofday (self->priv->kerberos_context, ¤t_time);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug ("GoaKerberosIdentity: Error getting current time: %s", error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ return 0;
+ }
+
+ return current_time;
+}
+
+typedef struct
+{
+ GoaKerberosIdentity *self;
+ guint *idle_id;
+ const char *property_name;
+} NotifyRequest;
+
+static void
+clear_idle_id (NotifyRequest *request)
+{
+ *request->idle_id = 0;
+ g_slice_free (NotifyRequest, request);
+}
+
+static gboolean
+on_notify_queued (NotifyRequest *request)
+{
+ g_object_notify (G_OBJECT (request->self), request->property_name);
+
+ return FALSE;
+}
+
+static void
+queue_notify (GoaKerberosIdentity *self,
+ guint *idle_id,
+ const char *property_name)
+{
+ NotifyRequest *request;
+
+ if (*idle_id != 0)
+ {
+ return;
+ }
+
+ request = g_slice_new0 (NotifyRequest);
+ request->self = self;
+ request->idle_id = idle_id;
+ request->property_name = property_name;
+
+ *idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
+ (GSourceFunc)
+ on_notify_queued,
+ request,
+ (GDestroyNotify)
+ clear_idle_id);
+}
+
+static void
+set_expiration_time (GoaKerberosIdentity *self,
+ krb5_timestamp expiration_time)
+{
+ if (self->priv->expiration_time != expiration_time)
+ {
+ self->priv->expiration_time = expiration_time;
+ queue_notify (self,
+ &self->priv->expiration_time_idle_id,
+ "expiration-timestamp");
+ }
+}
+
+static gboolean
+credentials_are_expired (GoaKerberosIdentity *self,
+ krb5_creds *credentials)
+{
+ krb5_timestamp current_time;
+
+ current_time = get_current_time (self);
+
+ set_expiration_time (self, MAX (credentials->times.endtime,
+ self->priv->expiration_time));
+
+ if (credentials->times.endtime <= current_time)
+ {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static VerificationLevel
+verify_identity (GoaKerberosIdentity *self,
+ GError **error)
+{
+ krb5_principal principal;
+ krb5_cc_cursor cursor;
+ krb5_creds credentials;
+ krb5_error_code error_code;
+ VerificationLevel verification_level;
+
+ set_expiration_time (self, 0);
+
+ if (self->priv->credentials_cache == NULL)
+ return VERIFICATION_LEVEL_UNVERIFIED;
+
+ error_code = krb5_cc_get_principal (self->priv->kerberos_context,
+ self->priv->credentials_cache,
+ &principal);
+
+ if (error_code != 0)
+ {
+ if (error_code == KRB5_CC_END)
+ return VERIFICATION_LEVEL_UNVERIFIED;
+
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_NOT_FOUND,
+ error_code,
+ _("Could not find identity in "
+ "credential cache: %k"));
+ return VERIFICATION_LEVEL_ERROR;
+ }
+
+ error_code = krb5_cc_start_seq_get (self->priv->kerberos_context,
+ self->priv->credentials_cache, &cursor);
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_CREDENTIALS_UNAVAILABLE,
+ error_code,
+ _("Could not find identity "
+ "credentials in cache: %k"));
+
+ verification_level = VERIFICATION_LEVEL_ERROR;
+ goto out;
+ }
+
+ verification_level = VERIFICATION_LEVEL_UNVERIFIED;
+
+ error_code = krb5_cc_next_cred (self->priv->kerberos_context,
+ self->priv->credentials_cache,
+ &cursor,
+ &credentials);
+
+ while (error_code == 0)
+ {
+ if (credentials_validate_existence (self, principal, &credentials))
+ {
+ if (!credentials_are_expired (self, &credentials))
+ verification_level = VERIFICATION_LEVEL_SIGNED_IN;
+ else
+ verification_level = VERIFICATION_LEVEL_EXISTS;
+ }
+
+ error_code = krb5_cc_next_cred (self->priv->kerberos_context,
+ self->priv->credentials_cache,
+ &cursor,
+ &credentials);
+ }
+
+ if (error_code != KRB5_CC_END)
+ {
+ verification_level = VERIFICATION_LEVEL_ERROR;
+
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_ENUMERATING_CREDENTIALS,
+ error_code,
+ _("Could not sift through identity "
+ "credentials in cache: %k"));
+ goto out;
+ }
+
+ error_code = krb5_cc_end_seq_get (self->priv->kerberos_context,
+ self->priv->credentials_cache,
+ &cursor);
+
+ if (error_code != 0)
+ {
+ verification_level = VERIFICATION_LEVEL_ERROR;
+
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_ENUMERATING_CREDENTIALS,
+ error_code,
+ _("Could not finish up sifting through "
+ "identity credentials in cache: %k"));
+ goto out;
+ }
+out:
+ krb5_free_principal (self->priv->kerberos_context, principal);
+ return verification_level;
+}
+
+static gboolean
+goa_kerberos_identity_is_signed_in (GoaIdentity *identity)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (identity);
+ gboolean is_signed_in = FALSE;
+
+ G_LOCK (identity_lock);
+ if (self->priv->cached_verification_level == VERIFICATION_LEVEL_SIGNED_IN)
+ is_signed_in = TRUE;
+ G_UNLOCK (identity_lock);
+
+ return is_signed_in;
+}
+
+static void
+identity_interface_init (GoaIdentityInterface *interface)
+{
+ interface->get_identifier = goa_kerberos_identity_get_identifier;
+ interface->get_identifier_components = goa_kerberos_identity_get_identifier_components;
+ interface->is_signed_in = goa_kerberos_identity_is_signed_in;
+}
+
+static void
+on_expiration_alarm_fired (GoaAlarm *alarm,
+ GoaKerberosIdentity *self)
+{
+ g_return_if_fail (GOA_IS_ALARM (alarm));
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY (self));
+
+ goa_debug ("GoaKerberosIdentity: expiration alarm fired for identity %s",
+ goa_identity_get_identifier (GOA_IDENTITY (self)));
+ g_signal_emit (G_OBJECT (self), signals[NEEDS_REFRESH], 0);
+}
+
+static void
+on_expiration_alarm_rearmed (GoaAlarm *alarm,
+ GoaKerberosIdentity *self)
+{
+ g_return_if_fail (GOA_IS_ALARM (alarm));
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY (self));
+
+ goa_debug ("GoaKerberosIdentity: expiration alarm rearmed");
+ g_signal_emit (G_OBJECT (self), signals[NEEDS_REFRESH], 0);
+}
+
+static void
+on_renewal_alarm_rearmed (GoaAlarm *alarm,
+ GoaKerberosIdentity *self)
+{
+ g_return_if_fail (GOA_IS_ALARM (alarm));
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY (self));
+
+ goa_debug ("GoaKerberosIdentity: renewal alarm rearmed");
+}
+
+static void
+on_renewal_alarm_fired (GoaAlarm *alarm,
+ GoaKerberosIdentity *self)
+{
+ g_return_if_fail (GOA_IS_ALARM (alarm));
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY (self));
+
+ g_clear_object (&self->priv->renewal_alarm_cancellable);
+
+ if (self->priv->cached_verification_level == VERIFICATION_LEVEL_SIGNED_IN)
+ {
+ goa_debug ("GoaKerberosIdentity: renewal alarm fired for signed-in identity");
+ g_signal_emit (G_OBJECT (self), signals[NEEDS_RENEWAL], 0);
+ }
+}
+
+static void
+on_expiring_alarm_rearmed (GoaAlarm *alarm,
+ GoaKerberosIdentity *self)
+{
+ g_return_if_fail (GOA_IS_ALARM (alarm));
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY (self));
+
+ goa_debug ("GoaKerberosIdentity: expiring alarm rearmed");
+}
+
+static void
+on_expiring_alarm_fired (GoaAlarm *alarm,
+ GoaKerberosIdentity *self)
+{
+ g_return_if_fail (GOA_IS_ALARM (alarm));
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY (self));
+
+ g_clear_object (&self->priv->expiring_alarm_cancellable);
+
+ if (self->priv->cached_verification_level == VERIFICATION_LEVEL_SIGNED_IN)
+ {
+ goa_debug ("GoaKerberosIdentity: expiring alarm fired for signed-in identity");
+ g_signal_emit (G_OBJECT (self), signals[EXPIRING], 0);
+ }
+}
+
+static void
+set_alarm (GoaKerberosIdentity *self,
+ GoaAlarm *alarm,
+ GDateTime *alarm_time,
+ GCancellable **cancellable)
+{
+ GDateTime *old_alarm_time;
+
+ G_LOCK (identity_lock);
+ old_alarm_time = goa_alarm_get_time (alarm);
+ if (old_alarm_time == NULL || !g_date_time_equal (alarm_time, old_alarm_time))
+ {
+ GCancellable *new_cancellable;
+
+ new_cancellable = g_cancellable_new ();
+ goa_alarm_set_time (alarm, alarm_time, new_cancellable);
+ g_date_time_unref (alarm_time);
+
+ g_clear_object (cancellable);
+ *cancellable = new_cancellable;
+ }
+ G_UNLOCK (identity_lock);
+
+}
+
+static void
+disconnect_alarm_signals (GoaKerberosIdentity *self)
+{
+ g_signal_handlers_disconnect_by_func (G_OBJECT (self->priv->renewal_alarm),
+ G_CALLBACK (on_renewal_alarm_fired),
+ self);
+ g_signal_handlers_disconnect_by_func (G_OBJECT (self->priv->renewal_alarm),
+ G_CALLBACK (on_renewal_alarm_rearmed),
+ self);
+ g_signal_handlers_disconnect_by_func (G_OBJECT (self->priv->expiring_alarm),
+ G_CALLBACK (on_expiring_alarm_fired),
+ self);
+ g_signal_handlers_disconnect_by_func (G_OBJECT (self->priv->expiration_alarm),
+ G_CALLBACK (on_expiration_alarm_rearmed),
+ self);
+ g_signal_handlers_disconnect_by_func (G_OBJECT (self->priv->expiration_alarm),
+ G_CALLBACK (on_expiration_alarm_fired),
+ self);
+ g_signal_handlers_disconnect_by_func (G_OBJECT (self->priv->expiring_alarm),
+ G_CALLBACK (on_expiring_alarm_rearmed),
+ self);
+}
+
+static void
+connect_alarm_signals (GoaKerberosIdentity *self)
+{
+ g_signal_connect (G_OBJECT (self->priv->renewal_alarm),
+ "fired",
+ G_CALLBACK (on_renewal_alarm_fired),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->renewal_alarm),
+ "rearmed",
+ G_CALLBACK (on_renewal_alarm_rearmed),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->expiring_alarm),
+ "fired",
+ G_CALLBACK (on_expiring_alarm_fired),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->expiring_alarm),
+ "rearmed",
+ G_CALLBACK (on_expiring_alarm_rearmed),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->expiration_alarm),
+ "fired",
+ G_CALLBACK (on_expiration_alarm_fired),
+ self);
+ g_signal_connect (G_OBJECT (self->priv->expiration_alarm),
+ "rearmed",
+ G_CALLBACK (on_expiration_alarm_rearmed),
+ self);
+}
+
+static void
+reset_alarms (GoaKerberosIdentity *self)
+{
+ GDateTime *now;
+ GDateTime *expiration_time;
+ GDateTime *expiring_time;
+ GDateTime *renewal_time;
+ GTimeSpan time_span_until_expiration;
+
+ now = g_date_time_new_now_local ();
+ expiration_time = g_date_time_new_from_unix_local (self->priv->expiration_time);
+ time_span_until_expiration = g_date_time_difference (expiration_time, now);
+
+ /* Let the user reauthenticate 10 min before expiration */
+ expiring_time = g_date_time_add_minutes (expiration_time, -10);
+
+ /* Try to quietly auto-renew halfway through so in ideal configurations
+ * the ticket is never more than halfway to expired
+ */
+ renewal_time = g_date_time_add (expiration_time,
+ -(time_span_until_expiration / 2));
+
+ disconnect_alarm_signals (self);
+
+ set_alarm (self,
+ self->priv->renewal_alarm,
+ renewal_time, &self->priv->renewal_alarm_cancellable);
+ set_alarm (self,
+ self->priv->expiring_alarm,
+ expiring_time, &self->priv->expiring_alarm_cancellable);
+ set_alarm (self,
+ self->priv->expiration_alarm,
+ expiration_time, &self->priv->expiration_alarm_cancellable);
+
+ connect_alarm_signals (self);
+}
+
+static void
+cancel_and_clear_cancellable (GCancellable **cancellable)
+{
+ if (cancellable == NULL)
+ return;
+
+ if (!g_cancellable_is_cancelled (*cancellable))
+ g_cancellable_cancel (*cancellable);
+
+ g_clear_object (cancellable);
+}
+
+static void
+clear_alarms (GoaKerberosIdentity *self)
+{
+ cancel_and_clear_cancellable (&self->priv->renewal_alarm_cancellable);
+ cancel_and_clear_cancellable (&self->priv->expiring_alarm_cancellable);
+ cancel_and_clear_cancellable (&self->priv->expiration_alarm_cancellable);
+}
+
+static gboolean
+goa_kerberos_identity_initable_init (GInitable *initable,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GoaKerberosIdentity *self = GOA_KERBEROS_IDENTITY (initable);
+ GError *verification_error;
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return FALSE;
+
+ if (self->priv->identifier == NULL)
+ {
+ self->priv->identifier = get_identifier (self, error);
+
+ if (self->priv->identifier != NULL)
+ queue_notify (self, &self->priv->identifier_idle_id, "identifier");
+ }
+
+ if (self->priv->identifier_components == NULL)
+ self->priv->identifier_components = get_identifier_components (self);
+
+ verification_error = NULL;
+ self->priv->cached_verification_level =
+ verify_identity (self, &verification_error);
+
+ switch (self->priv->cached_verification_level)
+ {
+ case VERIFICATION_LEVEL_EXISTS:
+ case VERIFICATION_LEVEL_SIGNED_IN:
+ reset_alarms (self);
+
+ queue_notify (self, &self->priv->is_signed_in_idle_id, "is-signed-in");
+ return TRUE;
+
+ case VERIFICATION_LEVEL_UNVERIFIED:
+ return TRUE;
+
+ case VERIFICATION_LEVEL_ERROR:
+ if (verification_error != NULL)
+ {
+ g_propagate_error (error, verification_error);
+ return FALSE;
+ }
+ default:
+ g_set_error (error,
+ GOA_IDENTITY_ERROR,
+ GOA_IDENTITY_ERROR_VERIFYING,
+ _("No associated identification found"));
+ return FALSE;
+
+ }
+}
+
+static void
+initable_interface_init (GInitableIface *interface)
+{
+ interface->init = goa_kerberos_identity_initable_init;
+}
+
+typedef struct
+{
+ GoaKerberosIdentity *identity;
+ GoaIdentityInquiryFunc inquiry_func;
+ gpointer inquiry_data;
+ GDestroyNotify destroy_notify;
+ GCancellable *cancellable;
+} SignInOperation;
+
+static krb5_error_code
+on_kerberos_inquiry (krb5_context kerberos_context,
+ SignInOperation *operation,
+ const char *name,
+ const char *banner,
+ int number_of_prompts,
+ krb5_prompt prompts[])
+{
+ GoaIdentityInquiry *inquiry;
+ krb5_error_code error_code;
+
+ inquiry = goa_kerberos_identity_inquiry_new (operation->identity,
+ name,
+ banner,
+ prompts,
+ number_of_prompts);
+
+ operation->inquiry_func (inquiry,
+ operation->cancellable,
+ operation->inquiry_data);
+
+ if (g_cancellable_is_cancelled (operation->cancellable))
+ error_code = KRB5_LIBOS_PWDINTR;
+ else if (!goa_identity_inquiry_is_complete (inquiry))
+ error_code = KRB5_LIBOS_PWDINTR;
+ else
+ error_code = 0;
+
+ g_object_unref (inquiry);
+
+ return error_code;
+}
+
+static gboolean
+goa_kerberos_identity_update_credentials (GoaKerberosIdentity *self,
+ krb5_principal principal,
+ krb5_creds *new_credentials,
+ GError **error)
+{
+ krb5_error_code error_code;
+
+ error_code = krb5_cc_initialize (self->priv->kerberos_context,
+ self->priv->credentials_cache,
+ principal);
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_ALLOCATING_CREDENTIALS,
+ error_code,
+ _("Could not initialize credentials "
+ "cache: %k"));
+
+ krb5_free_cred_contents (self->priv->kerberos_context, new_credentials);
+ goto out;
+ }
+
+ error_code = krb5_cc_store_cred (self->priv->kerberos_context,
+ self->priv->credentials_cache,
+ new_credentials);
+
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_SAVING_CREDENTIALS,
+ error_code,
+ _("Could not store new credentials in "
+ "credentials cache: %k"));
+
+ krb5_free_cred_contents (self->priv->kerberos_context, new_credentials);
+ goto out;
+ }
+ krb5_free_cred_contents (self->priv->kerberos_context, new_credentials);
+
+ return TRUE;
+out:
+ return FALSE;
+}
+
+static SignInOperation *
+sign_in_operation_new (GoaKerberosIdentity *identity,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GDestroyNotify destroy_notify, GCancellable *cancellable)
+{
+ SignInOperation *operation;
+
+ operation = g_slice_new0 (SignInOperation);
+ operation->identity = g_object_ref (identity);
+ operation->inquiry_func = inquiry_func;
+ operation->inquiry_data = inquiry_data;
+ operation->destroy_notify = destroy_notify;
+
+ if (cancellable == NULL)
+ {
+ operation->cancellable = g_cancellable_new ();
+ }
+ else
+ {
+ operation->cancellable = g_object_ref (cancellable);
+ }
+
+ return operation;
+}
+
+static void
+sign_in_operation_free (SignInOperation *operation)
+{
+ g_object_unref (operation->identity);
+ g_object_unref (operation->cancellable);
+
+ g_slice_free (SignInOperation, operation);
+}
+
+gboolean
+goa_kerberos_identity_sign_in (GoaKerberosIdentity *self,
+ const char *principal_name,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GDestroyNotify destroy_notify,
+ GCancellable *cancellable, GError **error)
+{
+ SignInOperation *operation;
+ krb5_principal principal;
+ krb5_error_code error_code;
+ krb5_creds new_credentials;
+ krb5_get_init_creds_opt *options;
+ krb5_deltat start_time;
+ char *service_name;
+ char *password;
+ gboolean signed_in;
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ {
+ return FALSE;
+ }
+
+ error_code = krb5_get_init_creds_opt_alloc (self->priv->kerberos_context,
+ &options);
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_ALLOCATING_CREDENTIALS,
+ error_code, "%k");
+ if (destroy_notify)
+ {
+ destroy_notify (inquiry_data);
+ }
+ return FALSE;
+ }
+
+ signed_in = FALSE;
+
+ operation = sign_in_operation_new (self,
+ inquiry_func,
+ inquiry_data, destroy_notify, cancellable);
+
+ if (g_strcmp0 (self->priv->identifier, principal_name) != 0)
+ {
+ g_free (self->priv->identifier);
+ self->priv->identifier = g_strdup (principal_name);
+ }
+
+ error_code = krb5_parse_name (self->priv->kerberos_context,
+ principal_name, &principal);
+
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_PARSING_IDENTIFIER,
+ error_code, "%k");
+ if (destroy_notify)
+ {
+ destroy_notify (inquiry_data);
+ }
+ return FALSE;
+ }
+
+ /* FIXME: get from keyring if so configured */
+ password = NULL;
+
+ krb5_get_init_creds_opt_set_forwardable (options, TRUE);
+ krb5_get_init_creds_opt_set_proxiable (options, TRUE);
+ krb5_get_init_creds_opt_set_renew_life (options, G_MAXINT);
+
+ start_time = 0;
+ service_name = NULL;
+ error_code = krb5_get_init_creds_password (self->priv->kerberos_context,
+ &new_credentials,
+ principal,
+ password,
+ (krb5_prompter_fct)
+ on_kerberos_inquiry,
+ operation,
+ start_time, service_name, options);
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_AUTHENTICATION_FAILED,
+ error_code, "%k");
+ if (destroy_notify)
+ {
+ destroy_notify (inquiry_data);
+ }
+ sign_in_operation_free (operation);
+
+ krb5_free_principal (self->priv->kerberos_context, principal);
+ goto done;
+ }
+
+ if (destroy_notify)
+ {
+ destroy_notify (inquiry_data);
+ }
+ sign_in_operation_free (operation);
+
+ if (!goa_kerberos_identity_update_credentials (self,
+ principal, &new_credentials, error))
+ {
+ krb5_free_principal (self->priv->kerberos_context, principal);
+ goto done;
+ }
+ krb5_free_principal (self->priv->kerberos_context, principal);
+
+ goa_debug ("GoaKerberosIdentity: identity signed in");
+ signed_in = TRUE;
+done:
+
+ return signed_in;
+}
+
+static void
+update_identifier (GoaKerberosIdentity *self, GoaKerberosIdentity *new_identity)
+{
+ char *new_identifier;
+
+ new_identifier = get_identifier (self, NULL);
+ if (g_strcmp0 (self->priv->identifier, new_identifier) != 0)
+ {
+ g_free (self->priv->identifier);
+ self->priv->identifier = new_identifier;
+ queue_notify (self, &self->priv->identifier_idle_id, "identifier");
+ }
+ else
+ {
+ g_free (new_identifier);
+ }
+}
+
+static void
+update_identifier_components (GoaKerberosIdentity *self,
+ GoaKerberosIdentity *new_identity)
+{
+ char **new_components;
+
+ new_components = get_identifier_components (self);
+
+ if (g_strv_length (self->priv->identifier_components) ==
+ g_strv_length (new_components))
+ {
+ int i;
+
+ for (i = 0; new_components[i] != NULL; i++)
+ {
+ if (g_strcmp0 (self->priv->identifier_components[i],
+ new_components[i]) != 0)
+ {
+ break;
+ }
+ else
+ {
+ g_strfreev (new_components);
+ return;
+ }
+ }
+ }
+
+ g_strfreev (self->priv->identifier_components);
+ self->priv->identifier_components = new_components;
+}
+
+void
+goa_kerberos_identity_update (GoaKerberosIdentity *self,
+ GoaKerberosIdentity *new_identity)
+{
+ VerificationLevel verification_level;
+
+ if (self->priv->credentials_cache != NULL)
+ {
+ krb5_cc_close (self->priv->kerberos_context, self->priv->credentials_cache);
+ }
+
+ krb5_cc_dup (new_identity->priv->kerberos_context,
+ new_identity->priv->credentials_cache,
+ &self->priv->credentials_cache);
+
+ G_LOCK (identity_lock);
+ update_identifier (self, new_identity);
+ update_identifier_components (self, new_identity);
+ G_UNLOCK (identity_lock);
+
+ verification_level = verify_identity (self, NULL);
+
+ if (verification_level == VERIFICATION_LEVEL_SIGNED_IN)
+ {
+ reset_alarms (self);
+ }
+ else
+ {
+ clear_alarms (self);
+ }
+
+ if (verification_level != self->priv->cached_verification_level)
+ {
+ if (self->priv->cached_verification_level == VERIFICATION_LEVEL_SIGNED_IN &&
+ verification_level == VERIFICATION_LEVEL_EXISTS)
+ {
+
+ G_LOCK (identity_lock);
+ self->priv->cached_verification_level = verification_level;
+ G_UNLOCK (identity_lock);
+
+ g_signal_emit (G_OBJECT (self), signals[EXPIRED], 0);
+ }
+ if (self->priv->cached_verification_level == VERIFICATION_LEVEL_EXISTS &&
+ verification_level == VERIFICATION_LEVEL_SIGNED_IN)
+ {
+
+ G_LOCK (identity_lock);
+ self->priv->cached_verification_level = verification_level;
+ G_UNLOCK (identity_lock);
+
+ g_signal_emit (G_OBJECT (self), signals[UNEXPIRED], 0);
+ }
+ queue_notify (self, &self->priv->is_signed_in_idle_id, "is-signed-in");
+ }
+}
+
+gboolean
+goa_kerberos_identity_renew (GoaKerberosIdentity *self, GError **error)
+{
+ krb5_error_code error_code = 0;
+ krb5_principal principal;
+ krb5_creds new_credentials;
+ gboolean renewed = FALSE;
+ char *name = NULL;
+
+ if (self->priv->credentials_cache == NULL)
+ {
+ g_set_error (error,
+ GOA_IDENTITY_ERROR,
+ GOA_IDENTITY_ERROR_CREDENTIALS_UNAVAILABLE,
+ _("Could not renew identitys: Not signed in"));
+ goto out;
+ }
+
+ error_code = krb5_cc_get_principal (self->priv->kerberos_context,
+ self->priv->credentials_cache, &principal);
+
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_CREDENTIALS_UNAVAILABLE,
+ error_code, _("Could not renew identity: %k"));
+ goto out;
+ }
+
+ name = goa_kerberos_identity_get_principal_name (self);
+
+ error_code = krb5_get_renewed_creds (self->priv->kerberos_context,
+ &new_credentials,
+ principal,
+ self->priv->credentials_cache, NULL);
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_RENEWING,
+ error_code,
+ _
+ ("Could not get new credentials to renew identity %s: %k"),
+ name);
+ krb5_free_principal (self->priv->kerberos_context, principal);
+ goto out;
+ }
+
+ if (!goa_kerberos_identity_update_credentials (self,
+ principal, &new_credentials, error))
+ {
+ krb5_free_principal (self->priv->kerberos_context, principal);
+ goto out;
+ }
+
+ goa_debug ("GoaKerberosIdentity: identity %s renewed", name);
+ renewed = TRUE;
+out:
+ g_free (name);
+
+ return renewed;
+}
+
+gboolean
+goa_kerberos_identity_erase (GoaKerberosIdentity *self, GError **error)
+{
+ krb5_error_code error_code = 0;
+
+ if (self->priv->credentials_cache != NULL)
+ {
+ error_code = krb5_cc_destroy (self->priv->kerberos_context,
+ self->priv->credentials_cache);
+ self->priv->credentials_cache = NULL;
+ }
+
+ if (error_code != 0)
+ {
+ set_error_from_krb5_error_code (self,
+ error,
+ GOA_IDENTITY_ERROR_REMOVING_CREDENTIALS,
+ error_code, _("Could not erase identity: %k"));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+GoaIdentity *
+goa_kerberos_identity_new (krb5_context context, krb5_ccache cache, GError **error)
+{
+ GoaKerberosIdentity *self;
+
+ self = GOA_KERBEROS_IDENTITY (g_object_new (GOA_TYPE_KERBEROS_IDENTITY, NULL));
+
+ krb5_cc_dup (context, cache, &self->priv->credentials_cache);
+ self->priv->kerberos_context = context;
+
+ error = NULL;
+ if (!g_initable_init (G_INITABLE (self), NULL, error))
+ {
+ g_object_unref (self);
+ return NULL;
+ }
+
+ return GOA_IDENTITY (self);
+}
diff --git a/src/goaidentity/goakerberosidentity.h b/src/goaidentity/goakerberosidentity.h
new file mode 100644
index 0000000..cf1305a
--- /dev/null
+++ b/src/goaidentity/goakerberosidentity.h
@@ -0,0 +1,87 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_KERBEROS_IDENTITY_H__
+#define __GOA_KERBEROS_IDENTITY_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <krb5.h>
+#include "goakerberosidentityinquiry.h"
+
+G_BEGIN_DECLS
+#define GOA_TYPE_KERBEROS_IDENTITY (goa_kerberos_identity_get_type ())
+#define GOA_KERBEROS_IDENTITY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOA_TYPE_KERBEROS_IDENTITY, GoaKerberosIdentity))
+#define GOA_KERBEROS_IDENTITY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GOA_TYPE_KERBEROS_IDENTITY, GoaKerberosIdentityClass))
+#define GOA_IS_KERBEROS_IDENTITY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOA_TYPE_KERBEROS_IDENTITY))
+#define GOA_IS_KERBEROS_IDENTITY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOA_TYPE_KERBEROS_IDENTITY))
+#define GOA_KERBEROS_IDENTITY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GOA_TYPE_KERBEROS_IDENTITY, GoaKerberosIdentityClass))
+typedef struct _GoaKerberosIdentity GoaKerberosIdentity;
+typedef struct _GoaKerberosIdentityClass GoaKerberosIdentityClass;
+typedef struct _GoaKerberosIdentityPrivate GoaKerberosIdentityPrivate;
+typedef enum _GoaKerberosIdentityDescriptionLevel
+ GoaKerberosIdentityDescriptionLevel;
+
+enum _GoaKerberosIdentityDescriptionLevel
+{
+ GOA_KERBEROS_IDENTITY_DESCRIPTION_REALM,
+ GOA_KERBEROS_IDENTITY_DESCRIPTION_USERNAME_AND_REALM,
+ GOA_KERBEROS_IDENTITY_DESCRIPTION_USERNAME_ROLE_AND_REALM
+};
+
+struct _GoaKerberosIdentity
+{
+ GObject parent;
+
+ GoaKerberosIdentityPrivate *priv;
+};
+
+struct _GoaKerberosIdentityClass
+{
+ GObjectClass parent_class;
+};
+
+GType goa_kerberos_identity_get_type (void);
+
+GoaIdentity *goa_kerberos_identity_new (krb5_context kerberos_context,
+ krb5_ccache cache,
+ GError **error);
+
+gboolean goa_kerberos_identity_sign_in (GoaKerberosIdentity *self,
+ const char *principal_name,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GDestroyNotify destroy_notify,
+ GCancellable *cancellable,
+ GError **error);
+void goa_kerberos_identity_update (GoaKerberosIdentity *identity,
+ GoaKerberosIdentity *new_identity);
+gboolean goa_kerberos_identity_renew (GoaKerberosIdentity *self,
+ GError **error);
+gboolean goa_kerberos_identity_erase (GoaKerberosIdentity *self,
+ GError **error);
+
+char *goa_kerberos_identity_get_principal_name (GoaKerberosIdentity *self);
+char *goa_kerberos_identity_get_realm_name (GoaKerberosIdentity *self);
+G_END_DECLS
+#endif /* __GOA_KERBEROS_IDENTITY_H__ */
diff --git a/src/goaidentity/goakerberosidentityinquiry.c b/src/goaidentity/goakerberosidentityinquiry.c
new file mode 100644
index 0000000..323a0c3
--- /dev/null
+++ b/src/goaidentity/goakerberosidentityinquiry.c
@@ -0,0 +1,375 @@
+/* -*- Mode: C; tab-width: 8; ident-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * 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.
+ *
+ * Author: Ray Strode
+ */
+
+#include "config.h"
+
+#include "goakerberosidentityinquiry.h"
+#include "goaidentityinquiryprivate.h"
+#include "goalogging.h"
+
+#include <string.h>
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
+struct _GoaKerberosIdentityInquiryPrivate
+{
+ GoaIdentity *identity;
+ char *name;
+ char *banner;
+ GList *queries;
+ int number_of_queries;
+ int number_of_unanswered_queries;
+};
+
+typedef struct
+{
+ GoaIdentityInquiry *inquiry;
+ krb5_prompt *kerberos_prompt;
+ gboolean is_answered;
+} GoaKerberosIdentityQuery;
+
+static void identity_inquiry_interface_init (GoaIdentityInquiryInterface *
+ interface);
+static void initable_interface_init (GInitableIface *interface);
+
+G_DEFINE_TYPE_WITH_CODE (GoaKerberosIdentityInquiry,
+ goa_kerberos_identity_inquiry,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+ initable_interface_init)
+ G_IMPLEMENT_INTERFACE (GOA_TYPE_IDENTITY_INQUIRY,
+ identity_inquiry_interface_init));
+
+static gboolean
+goa_kerberos_identity_inquiry_initable_init (GInitable * initable,
+ GCancellable *cancellable,
+ GError ** error)
+{
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+initable_interface_init (GInitableIface *interface)
+{
+ interface->init = goa_kerberos_identity_inquiry_initable_init;
+}
+
+static GoaKerberosIdentityQuery *
+goa_kerberos_identity_query_new (GoaIdentityInquiry * inquiry,
+ krb5_prompt * kerberos_prompt)
+{
+ GoaKerberosIdentityQuery *query;
+
+ query = g_slice_new (GoaKerberosIdentityQuery);
+ query->inquiry = inquiry;
+ query->kerberos_prompt = kerberos_prompt;
+ query->is_answered = FALSE;
+
+ return query;
+}
+
+static void
+goa_kerberos_identity_query_free (GoaKerberosIdentityQuery *query)
+{
+ g_slice_free (GoaKerberosIdentityQuery, query);
+}
+
+static void
+goa_kerberos_identity_inquiry_dispose (GObject *object)
+{
+ GoaKerberosIdentityInquiry *self = GOA_KERBEROS_IDENTITY_INQUIRY (object);
+
+ g_clear_object (&self->priv->identity);
+ g_clear_pointer (&self->priv->name, (GDestroyNotify) g_free);
+ g_clear_pointer (&self->priv->banner, (GDestroyNotify) g_free);
+
+ g_list_foreach (self->priv->queries,
+ (GFunc) goa_kerberos_identity_query_free, NULL);
+ g_clear_pointer (&self->priv->queries, (GDestroyNotify) g_list_free);
+}
+
+static void
+goa_kerberos_identity_inquiry_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (goa_kerberos_identity_inquiry_parent_class)->finalize (object);
+}
+
+static void
+goa_kerberos_identity_inquiry_class_init (GoaKerberosIdentityInquiryClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+
+ object_class->dispose = goa_kerberos_identity_inquiry_dispose;
+ object_class->finalize = goa_kerberos_identity_inquiry_finalize;
+
+ g_type_class_add_private (klass, sizeof (GoaKerberosIdentityInquiryPrivate));
+}
+
+static void
+goa_kerberos_identity_inquiry_init (GoaKerberosIdentityInquiry *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ GOA_TYPE_KERBEROS_IDENTITY_INQUIRY,
+ GoaKerberosIdentityInquiryPrivate);
+}
+
+GoaIdentityInquiry *
+goa_kerberos_identity_inquiry_new (GoaKerberosIdentity * identity,
+ const char *name,
+ const char *banner,
+ krb5_prompt prompts[], int number_of_prompts)
+{
+ GObject *object;
+ GoaIdentityInquiry *inquiry;
+ GoaKerberosIdentityInquiry *self;
+ GError *error;
+ int i;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY (identity), NULL);
+ g_return_val_if_fail (number_of_prompts > 0, NULL);
+
+ object = g_object_new (GOA_TYPE_KERBEROS_IDENTITY_INQUIRY, NULL);
+
+ inquiry = GOA_IDENTITY_INQUIRY (object);
+ self = GOA_KERBEROS_IDENTITY_INQUIRY (object);
+
+ /* FIXME: make these construct properties */
+ self->priv->identity = g_object_ref (identity);
+ self->priv->name = g_strdup (name);
+ self->priv->banner = g_strdup (banner);
+
+ self->priv->number_of_queries = 0;
+ for (i = 0; i < number_of_prompts; i++)
+ {
+ GoaKerberosIdentityQuery *query;
+
+ query = goa_kerberos_identity_query_new (inquiry, &prompts[i]);
+
+ self->priv->queries = g_list_prepend (self->priv->queries, query);
+ self->priv->number_of_queries++;
+ }
+ self->priv->queries = g_list_reverse (self->priv->queries);
+
+ self->priv->number_of_unanswered_queries = self->priv->number_of_queries;
+
+ error = NULL;
+ if (!g_initable_init (G_INITABLE (self), NULL, &error))
+ {
+ goa_debug ("%s", error->message);
+ g_error_free (error);
+ g_object_unref (self);
+ return NULL;
+ }
+
+ return inquiry;
+}
+
+static GoaIdentity *
+goa_kerberos_identity_inquiry_get_identity (GoaIdentityInquiry *inquiry)
+{
+ GoaKerberosIdentityInquiry *self;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry), NULL);
+
+ self = GOA_KERBEROS_IDENTITY_INQUIRY (inquiry);
+
+ return self->priv->identity;
+}
+
+static char *
+goa_kerberos_identity_inquiry_get_name (GoaIdentityInquiry *inquiry)
+{
+ GoaKerberosIdentityInquiry *self;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry), NULL);
+
+ self = GOA_KERBEROS_IDENTITY_INQUIRY (inquiry);
+
+ return g_strdup (self->priv->name);
+}
+
+static char *
+goa_kerberos_identity_inquiry_get_banner (GoaIdentityInquiry *inquiry)
+{
+ GoaKerberosIdentityInquiry *self;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry), NULL);
+
+ self = GOA_KERBEROS_IDENTITY_INQUIRY (inquiry);
+
+ return g_strdup (self->priv->banner);
+}
+
+static gboolean
+goa_kerberos_identity_inquiry_is_complete (GoaIdentityInquiry *inquiry)
+{
+ GoaKerberosIdentityInquiry *self;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry), FALSE);
+
+ self = GOA_KERBEROS_IDENTITY_INQUIRY (inquiry);
+
+ return self->priv->number_of_unanswered_queries == 0;
+}
+
+static void
+goa_kerberos_identity_inquiry_mark_query_answered (GoaKerberosIdentityInquiry * self,
+ GoaKerberosIdentityQuery * query)
+{
+ if (query->is_answered)
+ {
+ return;
+ }
+
+ query->is_answered = TRUE;
+ self->priv->number_of_unanswered_queries--;
+
+ if (self->priv->number_of_unanswered_queries == 0)
+ {
+ _goa_identity_inquiry_emit_complete (GOA_IDENTITY_INQUIRY (self));
+ }
+}
+
+static void
+goa_kerberos_identity_inquiry_answer_query (GoaIdentityInquiry * inquiry,
+ GoaIdentityQuery *query,
+ const char *answer)
+{
+ GoaKerberosIdentityInquiry *self;
+ GoaKerberosIdentityQuery *kerberos_query = (GoaKerberosIdentityQuery *) query;
+
+ g_return_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry));
+ g_return_if_fail (inquiry == kerberos_query->inquiry);
+ g_return_if_fail (!goa_kerberos_identity_inquiry_is_complete (inquiry));
+
+ self = GOA_KERBEROS_IDENTITY_INQUIRY (inquiry);
+
+ inquiry = kerberos_query->inquiry;
+
+ strncpy (kerberos_query->kerberos_prompt->reply->data,
+ answer, kerberos_query->kerberos_prompt->reply->length);
+ kerberos_query->kerberos_prompt->reply->length =
+ (unsigned int) strlen (kerberos_query->kerberos_prompt->reply->data);
+
+ goa_kerberos_identity_inquiry_mark_query_answered (self, kerberos_query);
+}
+
+static void
+goa_kerberos_identity_inquiry_iter_init (GoaIdentityInquiryIter * iter,
+ GoaIdentityInquiry * inquiry)
+{
+ GoaKerberosIdentityInquiry *self = GOA_KERBEROS_IDENTITY_INQUIRY (inquiry);
+
+ iter->data = self->priv->queries;
+}
+
+static GoaIdentityQuery *
+goa_kerberos_identity_inquiry_iter_next (GoaIdentityInquiryIter * iter,
+ GoaIdentityInquiry * inquiry)
+{
+ GoaIdentityQuery *query;
+ GList *node;
+
+ node = iter->data;
+
+ if (node == NULL)
+ {
+ return NULL;
+ }
+
+ query = (GoaIdentityQuery *) node->data;
+
+ node = node->next;
+
+ iter->data = node;
+
+ return query;
+}
+
+static GoaIdentityQueryMode
+goa_kerberos_identity_query_get_mode (GoaIdentityInquiry * inquiry,
+ GoaIdentityQuery * query)
+{
+ GoaKerberosIdentityQuery *kerberos_query = (GoaKerberosIdentityQuery *) query;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry),
+ GOA_KERBEROS_IDENTITY_QUERY_MODE_INVISIBLE);
+ g_return_val_if_fail (inquiry == kerberos_query->inquiry,
+ GOA_KERBEROS_IDENTITY_QUERY_MODE_INVISIBLE);
+
+ if (kerberos_query->kerberos_prompt->hidden)
+ {
+ return GOA_KERBEROS_IDENTITY_QUERY_MODE_INVISIBLE;
+ }
+ else
+ {
+ return GOA_KERBEROS_IDENTITY_QUERY_MODE_VISIBLE;
+ }
+}
+
+static char *
+goa_kerberos_identity_query_get_prompt (GoaIdentityInquiry * inquiry,
+ GoaIdentityQuery * query)
+{
+ GoaKerberosIdentityQuery *kerberos_query = (GoaKerberosIdentityQuery *) query;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry),
+ GOA_KERBEROS_IDENTITY_QUERY_MODE_INVISIBLE);
+ g_return_val_if_fail (inquiry == kerberos_query->inquiry, NULL);
+
+ return g_strdup (kerberos_query->kerberos_prompt->prompt);
+}
+
+static gboolean
+goa_kerberos_identity_query_is_answered (GoaIdentityInquiry * inquiry,
+ GoaIdentityQuery * query)
+{
+ GoaKerberosIdentityQuery *kerberos_query = (GoaKerberosIdentityQuery *) query;
+
+ g_return_val_if_fail (GOA_IS_KERBEROS_IDENTITY_INQUIRY (inquiry),
+ GOA_KERBEROS_IDENTITY_QUERY_MODE_INVISIBLE);
+ g_return_val_if_fail (inquiry == kerberos_query->inquiry, FALSE);
+
+ return kerberos_query->is_answered;
+}
+
+static void
+identity_inquiry_interface_init (GoaIdentityInquiryInterface *interface)
+{
+ interface->get_identity = goa_kerberos_identity_inquiry_get_identity;
+ interface->get_name = goa_kerberos_identity_inquiry_get_name;
+ interface->get_banner = goa_kerberos_identity_inquiry_get_banner;
+ interface->is_complete = goa_kerberos_identity_inquiry_is_complete;
+ interface->answer_query = goa_kerberos_identity_inquiry_answer_query;
+ interface->iter_init = goa_kerberos_identity_inquiry_iter_init;
+ interface->iter_next = goa_kerberos_identity_inquiry_iter_next;
+ interface->get_mode = goa_kerberos_identity_query_get_mode;
+ interface->get_prompt = goa_kerberos_identity_query_get_prompt;
+ interface->is_answered = goa_kerberos_identity_query_is_answered;
+}
diff --git a/src/goaidentity/goakerberosidentityinquiry.h b/src/goaidentity/goakerberosidentityinquiry.h
new file mode 100644
index 0000000..d6c7d7c
--- /dev/null
+++ b/src/goaidentity/goakerberosidentityinquiry.h
@@ -0,0 +1,73 @@
+/* -*- Mode: C; tab-width: 8; ident-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_KERBEROS_IDENTITY_INQUIRY_H__
+#define __GOA_KERBEROS_IDENTITY_INQUIRY_H__
+
+#include <stdint.h>
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "goaidentityinquiry.h"
+#include "goakerberosidentity.h"
+
+G_BEGIN_DECLS
+#define GOA_TYPE_KERBEROS_IDENTITY_INQUIRY (goa_kerberos_identity_inquiry_get_type ())
+#define GOA_KERBEROS_IDENTITY_INQUIRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOA_TYPE_KERBEROS_IDENTITY_INQUIRY, GoaKerberosIdentityInquiry))
+#define GOA_KERBEROS_IDENTITY_INQUIRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GOA_TYPE_KERBEROS_IDENTITY_INQUIRY, GoaKerberosIdentityInquiryClass))
+#define GOA_IS_KERBEROS_IDENTITY_INQUIRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOA_TYPE_KERBEROS_IDENTITY_INQUIRY))
+#define GOA_IS_KERBEROS_IDENTITY_INQUIRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOA_TYPE_KERBEROS_IDENTITY_INQUIRY))
+#define GOA_KERBEROS_IDENTITY_INQUIRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GOA_TYPE_KERBEROS_IDENTITY_INQUIRY, GoaKerberosIdentityInquiryClass))
+typedef struct _GoaKerberosIdentity GoaKerberosIdentity;
+typedef struct _GoaKerberosIdentityInquiry GoaKerberosIdentityInquiry;
+typedef struct _GoaKerberosIdentityInquiryClass GoaKerberosIdentityInquiryClass;
+typedef struct _GoaKerberosIdentityInquiryPrivate GoaKerberosIdentityInquiryPrivate;
+typedef struct _GoaKerberosIdentityInquiryIter GoaKerberosIdentityInquiryIter;
+
+typedef enum
+{
+ GOA_KERBEROS_IDENTITY_QUERY_MODE_INVISIBLE,
+ GOA_KERBEROS_IDENTITY_QUERY_MODE_VISIBLE
+} GoaKerberosIdentityQueryMode;
+
+struct _GoaKerberosIdentityInquiry
+{
+ GObject parent;
+
+ GoaKerberosIdentityInquiryPrivate *priv;
+};
+
+struct _GoaKerberosIdentityInquiryClass
+{
+ GObjectClass parent_class;
+};
+
+GType goa_kerberos_identity_inquiry_get_type (void);
+
+GoaIdentityInquiry *goa_kerberos_identity_inquiry_new (GoaKerberosIdentity *identity,
+ const char *name,
+ const char *banner,
+ krb5_prompt prompts[],
+ int number_of_prompts);
+
+#endif /* __GOA_KERBEROS_IDENTITY_INQUIRY_H__ */
diff --git a/src/goaidentity/goakerberosidentitymanager.c b/src/goaidentity/goakerberosidentitymanager.c
new file mode 100644
index 0000000..10425c3
--- /dev/null
+++ b/src/goaidentity/goakerberosidentitymanager.c
@@ -0,0 +1,1592 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#include "config.h"
+
+#include "goakerberosidentitymanager.h"
+#include "goaidentitymanager.h"
+#include "goaidentitymanagerprivate.h"
+#include "goakerberosidentity.h"
+#include "goalogging.h"
+
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+
+#include <krb5.h>
+
+struct _GoaKerberosIdentityManagerPrivate
+{
+ GHashTable *identities;
+ GHashTable *expired_identities;
+ GHashTable *identities_by_realm;
+ GAsyncQueue *pending_operations;
+ GCancellable *scheduler_cancellable;
+
+ krb5_context kerberos_context;
+ GFileMonitor *credentials_cache_monitor;
+ gulong credentials_cache_changed_signal_id;
+ char *credentials_cache_type;
+
+ GMutex scheduler_job_lock;
+ GCond scheduler_job_unblocked;
+ gboolean is_blocking_scheduler_job;
+
+ volatile int pending_refresh_count;
+};
+
+typedef enum
+{
+ OPERATION_TYPE_REFRESH,
+ OPERATION_TYPE_GET_IDENTITY,
+ OPERATION_TYPE_LIST,
+ OPERATION_TYPE_RENEW,
+ OPERATION_TYPE_SIGN_IN,
+ OPERATION_TYPE_SIGN_OUT,
+ OPERATION_TYPE_STOP_JOB
+} OperationType;
+
+typedef struct
+{
+ GCancellable *cancellable;
+ GoaKerberosIdentityManager *manager;
+ OperationType type;
+ GSimpleAsyncResult *result;
+ GIOSchedulerJob *job;
+ union
+ {
+ GoaIdentity *identity;
+ struct
+ {
+ const char *identifier;
+ GoaIdentityInquiry *inquiry;
+ GoaIdentityInquiryFunc inquiry_func;
+ gpointer inquiry_data;
+ GMutex inquiry_lock;
+ GCond inquiry_finished_condition;
+ volatile gboolean is_inquiring;
+ };
+ };
+} Operation;
+
+typedef struct
+{
+ GoaKerberosIdentityManager *manager;
+ GoaIdentity *identity;
+} IdentitySignalWork;
+
+static GoaIdentityManager *goa_kerberos_identity_manager_singleton;
+
+static void identity_manager_interface_init (GoaIdentityManagerInterface *
+ interface);
+static void initable_interface_init (GInitableIface *interface);
+
+static void on_identity_expired (GoaIdentity *identity,
+ GoaKerberosIdentityManager *self);
+
+G_DEFINE_TYPE_WITH_CODE (GoaKerberosIdentityManager,
+ goa_kerberos_identity_manager,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GOA_TYPE_IDENTITY_MANAGER,
+ identity_manager_interface_init)
+ G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
+ initable_interface_init));
+
+static Operation *
+operation_new (GoaKerberosIdentityManager *self,
+ GCancellable *cancellable,
+ OperationType type,
+ GSimpleAsyncResult *result)
+{
+ Operation *operation;
+
+ operation = g_slice_new (Operation);
+
+ operation->manager = self;
+ operation->type = type;
+
+ if (cancellable == NULL)
+ cancellable = g_cancellable_new ();
+ else
+ g_object_ref (cancellable);
+ operation->cancellable = cancellable;
+
+ if (result != NULL)
+ g_object_ref (result);
+ operation->result = result;
+
+ operation->identity = NULL;
+
+ return operation;
+}
+
+static void
+operation_free (Operation *operation)
+{
+ g_clear_object (&operation->cancellable);
+
+ if (operation->type != OPERATION_TYPE_SIGN_IN &&
+ operation->type != OPERATION_TYPE_GET_IDENTITY)
+ g_clear_object (&operation->identity);
+ else
+ g_clear_pointer (&operation->identifier, g_free);
+
+ g_clear_object (&operation->result);
+
+ g_slice_free (Operation, operation);
+}
+
+static void
+schedule_refresh (GoaKerberosIdentityManager *self)
+{
+ Operation *operation;
+
+ g_atomic_int_inc (&self->priv->pending_refresh_count);
+
+ operation = operation_new (self, NULL, OPERATION_TYPE_REFRESH, NULL);
+ g_async_queue_push (self->priv->pending_operations, operation);
+}
+
+static IdentitySignalWork *
+identity_signal_work_new (GoaKerberosIdentityManager *self,
+ GoaIdentity *identity)
+{
+ IdentitySignalWork *work;
+
+ work = g_slice_new (IdentitySignalWork);
+ work->manager = self;
+ work->identity = g_object_ref (identity);
+
+ return work;
+}
+
+static void
+identity_signal_work_free (IdentitySignalWork *work)
+{
+ g_object_unref (work->identity);
+ g_slice_free (IdentitySignalWork, work);
+}
+
+static void
+on_identity_expired (GoaIdentity *identity,
+ GoaKerberosIdentityManager *self)
+{
+ _goa_identity_manager_emit_identity_expired (GOA_IDENTITY_MANAGER (self),
+ identity);
+}
+
+static void
+on_identity_unexpired (GoaIdentity *identity,
+ GoaKerberosIdentityManager *self)
+{
+ goa_debug ("GoaKerberosIdentityManager: identity unexpired");
+ /* If an identity is now unexpired, that means some sort of weird
+ * clock skew happened and we should just do a full refresh, since it's
+ * probably affected more than one identity
+ */
+ schedule_refresh (self);
+}
+
+static void
+on_identity_expiring (GoaIdentity *identity,
+ GoaKerberosIdentityManager *self)
+{
+ goa_debug ("GoaKerberosIdentityManager: identity about to expire");
+ _goa_identity_manager_emit_identity_expiring (GOA_IDENTITY_MANAGER (self),
+ identity);
+}
+
+static void
+on_identity_needs_renewal (GoaIdentity *identity,
+ GoaKerberosIdentityManager *self)
+{
+ goa_debug ("GoaKerberosIdentityManager: identity needs renewal");
+ _goa_identity_manager_emit_identity_needs_renewal (GOA_IDENTITY_MANAGER (self),
+ identity);
+}
+
+static void
+on_identity_needs_refresh (GoaIdentity *identity,
+ GoaKerberosIdentityManager *self)
+{
+ goa_debug ("GoaKerberosIdentityManager: needs refresh");
+ schedule_refresh (self);
+}
+
+static void
+watch_for_identity_expiration (GoaKerberosIdentityManager *self,
+ GoaIdentity *identity)
+{
+ g_signal_handlers_disconnect_by_func (G_OBJECT (identity),
+ G_CALLBACK (on_identity_expired),
+ self);
+ g_signal_connect (G_OBJECT (identity),
+ "expired",
+ G_CALLBACK (on_identity_expired),
+ self);
+
+ g_signal_handlers_disconnect_by_func (G_OBJECT (identity),
+ G_CALLBACK (on_identity_unexpired),
+ self);
+ g_signal_connect (G_OBJECT (identity),
+ "unexpired",
+ G_CALLBACK (on_identity_unexpired),
+ self);
+
+ g_signal_handlers_disconnect_by_func (G_OBJECT (identity),
+ G_CALLBACK (on_identity_expiring),
+ self);
+ g_signal_connect (G_OBJECT (identity),
+ "expiring",
+ G_CALLBACK (on_identity_expiring),
+ self);
+
+ g_signal_handlers_disconnect_by_func (G_OBJECT (identity),
+ G_CALLBACK (on_identity_needs_renewal),
+ self);
+ g_signal_connect (G_OBJECT (identity),
+ "needs-renewal",
+ G_CALLBACK (on_identity_needs_renewal),
+ self);
+
+ g_signal_handlers_disconnect_by_func (G_OBJECT (identity),
+ G_CALLBACK (on_identity_needs_refresh),
+ self);
+ g_signal_connect (G_OBJECT (identity),
+ "needs-refresh",
+ G_CALLBACK (on_identity_needs_refresh),
+ self);
+}
+
+static void
+do_identity_signal_added_work (IdentitySignalWork *work)
+{
+ GoaKerberosIdentityManager *self = work->manager;
+ GoaIdentity *identity = work->identity;
+
+ watch_for_identity_expiration (self, identity);
+ _goa_identity_manager_emit_identity_added (GOA_IDENTITY_MANAGER (self), identity);
+}
+
+static void
+do_identity_signal_removed_work (IdentitySignalWork *work)
+{
+ GoaKerberosIdentityManager *self = work->manager;
+ GoaIdentity *identity = work->identity;
+
+ _goa_identity_manager_emit_identity_removed (GOA_IDENTITY_MANAGER (self),
+ identity);
+}
+
+static void
+do_identity_signal_renamed_work (IdentitySignalWork *work)
+{
+ GoaKerberosIdentityManager *self = work->manager;
+ GoaIdentity *identity = work->identity;
+
+ _goa_identity_manager_emit_identity_renamed (GOA_IDENTITY_MANAGER (self),
+ identity);
+}
+
+static void
+do_identity_signal_refreshed_work (IdentitySignalWork *work)
+{
+ GoaKerberosIdentityManager *self = work->manager;
+ GoaIdentity *identity = work->identity;
+
+ watch_for_identity_expiration (self, identity);
+ _goa_identity_manager_emit_identity_refreshed (GOA_IDENTITY_MANAGER (self),
+ identity);
+}
+
+static void
+remove_identity (GoaKerberosIdentityManager *self,
+ Operation *operation,
+ GoaIdentity *identity)
+{
+
+ IdentitySignalWork *work;
+ const char *identifier;
+ char *name;
+ GList *other_identities = NULL;
+
+ identifier = goa_identity_get_identifier (identity);
+ name = goa_kerberos_identity_get_realm_name (GOA_KERBEROS_IDENTITY (identity));
+
+ if (name != NULL)
+ {
+ other_identities = g_hash_table_lookup (self->priv->identities_by_realm, name);
+ g_hash_table_remove (self->priv->identities_by_realm, name);
+
+ other_identities = g_list_remove (other_identities, identity);
+ }
+
+
+ if (other_identities != NULL)
+ {
+ g_hash_table_replace (self->priv->identities_by_realm,
+ g_strdup (name), other_identities);
+ }
+ g_free (name);
+
+ work = identity_signal_work_new (self, identity);
+ g_hash_table_remove (self->priv->expired_identities, identifier);
+ g_hash_table_remove (self->priv->identities, identifier);
+
+ g_io_scheduler_job_send_to_mainloop (operation->job,
+ (GSourceFunc)
+ do_identity_signal_removed_work,
+ work,
+ (GDestroyNotify) identity_signal_work_free);
+ /* If there's only one identity for this realm now, then we can
+ * rename that identity to just the realm name
+ */
+ if (other_identities != NULL && other_identities->next == NULL)
+ {
+ GoaIdentity *other_identity = other_identities->data;
+
+ work = identity_signal_work_new (self, other_identity);
+
+ g_io_scheduler_job_send_to_mainloop (operation->job,
+ (GSourceFunc)
+ do_identity_signal_renamed_work,
+ work,
+ (GDestroyNotify)
+ identity_signal_work_free);
+ }
+}
+
+static void
+drop_stale_identities (GoaKerberosIdentityManager *self,
+ Operation *operation,
+ GHashTable *known_identities)
+{
+ GList *stale_identity_ids;
+ GList *node;
+
+ stale_identity_ids = g_hash_table_get_keys (self->priv->identities);
+
+ node = stale_identity_ids;
+ while (node != NULL)
+ {
+ GoaIdentity *identity;
+ const char *identifier = node->data;
+
+ identity = g_hash_table_lookup (known_identities, identifier);
+ if (identity == NULL)
+ {
+ identity = g_hash_table_lookup (self->priv->identities, identifier);
+
+ if (identity != NULL)
+ {
+ remove_identity (self, operation, identity);
+ }
+ }
+ node = node->next;
+ }
+ g_list_free (stale_identity_ids);
+}
+
+static void
+update_identity (GoaKerberosIdentityManager *self,
+ Operation *operation,
+ GoaIdentity *identity,
+ GoaIdentity *new_identity)
+{
+
+ goa_kerberos_identity_update (GOA_KERBEROS_IDENTITY (identity),
+ GOA_KERBEROS_IDENTITY (new_identity));
+
+ if (goa_identity_is_signed_in (identity))
+ {
+ IdentitySignalWork *work;
+
+ /* if it's not expired, send out a refresh signal */
+ goa_debug ("GoaKerberosIdentityManager: identity '%s' refreshed",
+ goa_identity_get_identifier (identity));
+
+ work = identity_signal_work_new (self, identity);
+ g_io_scheduler_job_send_to_mainloop (operation->job,
+ (GSourceFunc)
+ do_identity_signal_refreshed_work,
+ work,
+ (GDestroyNotify)
+ identity_signal_work_free);
+ }
+}
+
+static void
+add_identity (GoaKerberosIdentityManager *self,
+ Operation *operation,
+ GoaIdentity *identity,
+ const char *identifier)
+{
+ IdentitySignalWork *work;
+
+ g_hash_table_replace (self->priv->identities,
+ g_strdup (identifier), g_object_ref (identity));
+
+ if (!goa_identity_is_signed_in (identity))
+ {
+ g_hash_table_replace (self->priv->expired_identities,
+ g_strdup (identifier), identity);
+ }
+
+ work = identity_signal_work_new (self, identity);
+ g_io_scheduler_job_send_to_mainloop (operation->job,
+ (GSourceFunc)
+ do_identity_signal_added_work,
+ work,
+ (GDestroyNotify) identity_signal_work_free);
+}
+
+static void
+refresh_identity (GoaKerberosIdentityManager *self,
+ Operation *operation,
+ GHashTable *refreshed_identities,
+ GoaIdentity *identity)
+{
+ const char *identifier;
+ GoaIdentity *old_identity;
+
+ identifier = goa_identity_get_identifier (identity);
+
+ if (identifier == NULL)
+ {
+ return;
+ }
+ old_identity = g_hash_table_lookup (self->priv->identities, identifier);
+
+ if (old_identity != NULL)
+ {
+ goa_debug ("GoaKerberosIdentityManager: refreshing identity '%s'", identifier);
+ update_identity (self, operation, old_identity, identity);
+
+ /* Reuse the old identity, so any object data set up on it doesn't
+ * disappear spurriously
+ */
+ identifier = goa_identity_get_identifier (old_identity);
+ identity = old_identity;
+ }
+ else
+ {
+ goa_debug ("GoaKerberosIdentityManager: adding new identity '%s'", identifier);
+ add_identity (self, operation, identity, identifier);
+ }
+
+ /* Track refreshed identities so we can emit removals when we're done fully
+ * enumerating the collection of credential caches
+ */
+ g_hash_table_replace (refreshed_identities,
+ g_strdup (identifier),
+ g_object_ref (identity));
+}
+
+static gboolean
+refresh_identities (GoaKerberosIdentityManager *self,
+ Operation *operation)
+{
+ krb5_error_code error_code;
+ krb5_ccache cache;
+ krb5_cccol_cursor cursor;
+ const char *error_message;
+ GHashTable *refreshed_identities;
+
+ /* If we have more refreshes queued up, don't bother doing this one
+ */
+ if (!g_atomic_int_dec_and_test (&self->priv->pending_refresh_count))
+ {
+ return FALSE;
+ }
+
+ goa_debug ("GoaKerberosIdentityManager: Refreshing identities");
+ refreshed_identities = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ (GDestroyNotify)
+ g_free,
+ (GDestroyNotify) g_object_unref);
+ error_code = krb5_cccol_cursor_new (self->priv->kerberos_context, &cursor);
+
+ if (error_code != 0)
+ {
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug ("GoaKerberosIdentityManager: Error looking up available credential caches: %s",
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ goto done;
+ }
+
+ error_code = krb5_cccol_cursor_next (self->priv->kerberos_context, cursor, &cache);
+
+ while (error_code == 0 && cache != NULL)
+ {
+ GoaIdentity *identity;
+
+ identity = goa_kerberos_identity_new (self->priv->kerberos_context,
+ cache, NULL);
+
+ if (identity != NULL)
+ {
+ refresh_identity (self, operation, refreshed_identities, identity);
+ }
+
+ krb5_cc_close (self->priv->kerberos_context, cache);
+ error_code = krb5_cccol_cursor_next (self->priv->kerberos_context,
+ cursor, &cache);
+ }
+
+ if (error_code != 0)
+ {
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug ("GoaKerberosIdentityManager: Error iterating over available credential caches: %s",
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+ }
+
+ krb5_cccol_cursor_free (self->priv->kerberos_context, &cursor);
+done:
+ drop_stale_identities (self, operation, refreshed_identities);
+ g_hash_table_unref (refreshed_identities);
+
+ return TRUE;
+}
+
+static int
+identity_sort_func (GoaIdentity *a,
+ GoaIdentity *b)
+{
+ return g_strcmp0 (goa_identity_get_identifier (a),
+ goa_identity_get_identifier (b));
+}
+
+static void
+free_identity_list (GList *list)
+{
+ g_list_foreach (list, (GFunc) g_object_unref, NULL);
+ g_list_free (list);
+}
+
+static void
+list_identities (GoaKerberosIdentityManager *self,
+ Operation *operation)
+{
+ GList *identities;
+
+ goa_debug ("GoaKerberosIdentityManager: Listing identities");
+ identities = g_hash_table_get_values (self->priv->identities);
+
+ identities = g_list_sort (identities, (GCompareFunc) identity_sort_func);
+
+ g_list_foreach (identities, (GFunc) g_object_ref, NULL);
+ g_simple_async_result_set_op_res_gpointer (operation->result,
+ identities,
+ (GDestroyNotify) free_identity_list);
+}
+
+static void
+renew_identity (GoaKerberosIdentityManager *self,
+ Operation *operation)
+{
+ GError *error;
+ gboolean was_renewed;
+ char *identity_name;
+
+ identity_name =
+ goa_kerberos_identity_get_principal_name (GOA_KERBEROS_IDENTITY
+ (operation->identity));
+ goa_debug ("GoaKerberosIdentityManager: renewing identity %s", identity_name);
+ g_free (identity_name);
+
+ error = NULL;
+ was_renewed =
+ goa_kerberos_identity_renew (GOA_KERBEROS_IDENTITY (operation->identity),
+ &error);
+
+ if (!was_renewed)
+ {
+ goa_debug ("GoaKerberosIdentityManager: could not renew identity: %s",
+ error->message);
+
+ g_simple_async_result_set_from_error (operation->result, error);
+ }
+
+ g_simple_async_result_set_op_res_gboolean (operation->result, was_renewed);
+}
+
+static void
+do_identity_inquiry (Operation *operation)
+{
+ if (operation->inquiry_func == NULL)
+ {
+ return;
+ }
+
+ operation->inquiry_func (operation->inquiry,
+ operation->cancellable,
+ operation->inquiry_data);
+}
+
+static void
+stop_waiting_on_inquiry (Operation *operation)
+{
+ g_mutex_lock (&operation->inquiry_lock);
+ if (operation->is_inquiring)
+ {
+ operation->is_inquiring = FALSE;
+ g_cond_signal (&operation->inquiry_finished_condition);
+ }
+ g_mutex_unlock (&operation->inquiry_lock);
+}
+
+static void
+on_kerberos_identity_inquiry_complete (GoaIdentityInquiry *inquiry,
+ Operation *operation)
+{
+ stop_waiting_on_inquiry (operation);
+}
+
+static void
+start_inquiry (Operation *operation,
+ GoaIdentityInquiry *inquiry)
+{
+ operation->is_inquiring = TRUE;
+
+ g_signal_connect (G_OBJECT (inquiry),
+ "complete",
+ G_CALLBACK (on_kerberos_identity_inquiry_complete),
+ operation);
+
+ operation->inquiry = inquiry;
+ g_io_scheduler_job_send_to_mainloop (operation->job,
+ (GSourceFunc)
+ do_identity_inquiry,
+ operation, (GDestroyNotify) NULL);
+}
+
+static void
+wait_for_inquiry_to_complete (Operation *operation,
+ GoaKerberosIdentityInquiry *inquiry)
+{
+ g_mutex_lock (&operation->inquiry_lock);
+ while (operation->is_inquiring)
+ g_cond_wait (&operation->inquiry_finished_condition,
+ &operation->inquiry_lock);
+ g_mutex_unlock (&operation->inquiry_lock);
+}
+
+static void
+on_sign_in_operation_cancelled (GCancellable *cancellable,
+ Operation *operation)
+{
+ stop_waiting_on_inquiry (operation);
+}
+
+static void
+on_kerberos_identity_inquiry (GoaKerberosIdentityInquiry *inquiry,
+ GCancellable *cancellable,
+ Operation *operation)
+{
+ gulong handler_id;
+
+ start_inquiry (operation, GOA_IDENTITY_INQUIRY (inquiry));
+
+ handler_id = g_cancellable_connect (cancellable,
+ G_CALLBACK (on_sign_in_operation_cancelled),
+ operation, NULL);
+
+ if ((operation->cancellable == NULL) ||
+ !g_cancellable_is_cancelled (operation->cancellable))
+ wait_for_inquiry_to_complete (operation, inquiry);
+
+ g_cancellable_disconnect (cancellable, handler_id);
+}
+
+static void
+get_identity (GoaKerberosIdentityManager *self,
+ Operation *operation)
+{
+ GoaIdentity *identity;
+
+ goa_debug ("GoaKerberosIdentityManager: get identity %s", operation->identifier);
+ identity = g_hash_table_lookup (self->priv->identities, operation->identifier);
+
+ if (identity == NULL)
+ {
+ g_simple_async_result_set_error (operation->result,
+ GOA_IDENTITY_MANAGER_ERROR,
+ GOA_IDENTITY_MANAGER_ERROR_IDENTITY_NOT_FOUND,
+ _("Could not find identity"));
+ g_simple_async_result_set_op_res_gpointer (operation->result, NULL, NULL);
+
+ return;
+ }
+
+ g_simple_async_result_set_op_res_gpointer (operation->result,
+ g_object_ref (identity),
+ (GDestroyNotify) g_object_unref);
+}
+
+static void
+sign_in_identity (GoaKerberosIdentityManager *self,
+ Operation *operation)
+{
+ GoaIdentity *identity;
+ GError *error;
+ krb5_error_code error_code;
+
+ goa_debug ("GoaKerberosIdentityManager: signing in identity %s",
+ operation->identifier);
+ error = NULL;
+ identity = g_hash_table_lookup (self->priv->identities, operation->identifier);
+ if (identity == NULL)
+ {
+ krb5_ccache credentials_cache;
+ error_code = krb5_cc_new_unique (self->priv->kerberos_context,
+ self->priv->credentials_cache_type,
+ NULL,
+ &credentials_cache);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+ goa_debug ("GoaKerberosIdentityManager: Error creating new cache for identity credentials: %s",
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+
+ g_simple_async_result_set_error (operation->result,
+ GOA_IDENTITY_MANAGER_ERROR,
+ GOA_IDENTITY_MANAGER_ERROR_CREATING_IDENTITY,
+ _("Could not create credential cache for identity"));
+ g_simple_async_result_set_op_res_gpointer (operation->result, NULL, NULL);
+
+ }
+ else
+ {
+ identity = goa_kerberos_identity_new (self->priv->kerberos_context,
+ credentials_cache,
+ &error);
+ if (identity == NULL)
+ {
+ krb5_cc_close (self->priv->kerberos_context, credentials_cache);
+ g_simple_async_result_take_error (operation->result, error);
+ g_simple_async_result_set_op_res_gpointer (operation->result,
+ NULL,
+ NULL);
+ return;
+ }
+ }
+ }
+
+ g_hash_table_replace (self->priv->identities,
+ g_strdup (operation->identifier),
+ g_object_ref (identity));
+
+ if (!goa_kerberos_identity_sign_in (GOA_KERBEROS_IDENTITY (identity),
+ operation->identifier,
+ (GoaIdentityInquiryFunc)
+ on_kerberos_identity_inquiry,
+ operation,
+ NULL,
+ operation->cancellable,
+ &error))
+ {
+ g_simple_async_result_set_from_error (operation->result, error);
+ g_simple_async_result_set_op_res_gpointer (operation->result,
+ NULL,
+ NULL);
+
+ }
+ else
+ {
+ g_simple_async_result_set_op_res_gpointer (operation->result,
+ g_object_ref (identity),
+ (GDestroyNotify)
+ g_object_unref);
+ }
+}
+
+static void
+sign_out_identity (GoaKerberosIdentityManager *self,
+ Operation *operation)
+{
+ GError *error;
+ gboolean was_signed_out;
+ char *identity_name;
+
+ identity_name =
+ goa_kerberos_identity_get_principal_name (GOA_KERBEROS_IDENTITY
+ (operation->identity));
+ goa_debug ("GoaKerberosIdentityManager: signing out identity %s", identity_name);
+ g_free (identity_name);
+
+ error = NULL;
+ was_signed_out =
+ goa_kerberos_identity_erase (GOA_KERBEROS_IDENTITY (operation->identity),
+ &error);
+
+ if (!was_signed_out)
+ {
+ goa_debug ("GoaKerberosIdentityManager: could not sign out identity: %s",
+ error->message);
+ g_error_free (error);
+ }
+}
+
+static void
+block_scheduler_job (GoaKerberosIdentityManager *self)
+{
+ g_mutex_lock (&self->priv->scheduler_job_lock);
+ while (self->priv->is_blocking_scheduler_job)
+ g_cond_wait (&self->priv->scheduler_job_unblocked,
+ &self->priv->scheduler_job_lock);
+ self->priv->is_blocking_scheduler_job = TRUE;
+ g_mutex_unlock (&self->priv->scheduler_job_lock);
+}
+
+static void
+stop_blocking_scheduler_job (GoaKerberosIdentityManager *self)
+{
+ g_mutex_lock (&self->priv->scheduler_job_lock);
+ self->priv->is_blocking_scheduler_job = FALSE;
+ g_cond_signal (&self->priv->scheduler_job_unblocked);
+ g_mutex_unlock (&self->priv->scheduler_job_lock);
+}
+
+static void
+wait_for_scheduler_job_to_become_unblocked (GoaKerberosIdentityManager *self)
+{
+ g_mutex_lock (&self->priv->scheduler_job_lock);
+ while (self->priv->is_blocking_scheduler_job)
+ g_cond_wait (&self->priv->scheduler_job_unblocked,
+ &self->priv->scheduler_job_lock);
+ g_mutex_unlock (&self->priv->scheduler_job_lock);
+}
+
+static void
+on_job_cancelled (GCancellable *cancellable,
+ GoaKerberosIdentityManager *self)
+{
+ Operation *operation;
+ operation = operation_new (self, cancellable, OPERATION_TYPE_STOP_JOB, NULL);
+ g_async_queue_push (self->priv->pending_operations, operation);
+
+ stop_blocking_scheduler_job (self);
+}
+
+static gboolean
+on_job_scheduled (GIOSchedulerJob *job,
+ GCancellable *cancellable,
+ GoaKerberosIdentityManager *self)
+{
+ GAsyncQueue *pending_operations;
+
+ g_assert (cancellable != NULL);
+
+ g_cancellable_connect (cancellable, G_CALLBACK (on_job_cancelled), self, NULL);
+
+ /* Take ownership of queue, since we may out live the identity manager */
+ pending_operations = g_async_queue_ref (self->priv->pending_operations);
+ while (!g_cancellable_is_cancelled (cancellable))
+ {
+ Operation *operation;
+ gboolean processed_operation;
+ GError *error = NULL;
+
+ operation = g_async_queue_pop (pending_operations);
+
+ if (operation->result != NULL &&
+ g_cancellable_set_error_if_cancelled (operation->cancellable,
+ &error))
+ {
+ g_simple_async_result_take_error (operation->result, error);
+ g_simple_async_result_complete_in_idle (operation->result);
+ g_object_unref (operation->result);
+ operation->result = NULL;
+ continue;
+ }
+
+ operation->job = job;
+
+ switch (operation->type)
+ {
+ case OPERATION_TYPE_STOP_JOB:
+ /* do nothing, loop will exit next iteration since cancellable
+ * is cancelled
+ */
+ g_assert (g_cancellable_is_cancelled (cancellable));
+ operation_free (operation);
+ continue;
+ case OPERATION_TYPE_REFRESH:
+ processed_operation = refresh_identities (operation->manager, operation);
+ break;
+ case OPERATION_TYPE_GET_IDENTITY:
+ get_identity (operation->manager, operation);
+ processed_operation = TRUE;
+ break;
+ case OPERATION_TYPE_LIST:
+ list_identities (operation->manager, operation);
+ processed_operation = TRUE;
+
+ /* We want to block refreshes (and their associated "added"
+ * and "removed" signals) until the caller has had
+ * a chance to look at the batch of
+ * results we already processed
+ */
+ g_assert (operation->result != NULL);
+
+ goa_debug
+ ("GoaKerberosIdentityManager: Blocking until identities list processed");
+ block_scheduler_job (self);
+ g_object_weak_ref (G_OBJECT (operation->result),
+ (GWeakNotify) stop_blocking_scheduler_job, self);
+ goa_debug ("GoaKerberosIdentityManager: Continuing");
+ break;
+ case OPERATION_TYPE_SIGN_IN:
+ sign_in_identity (operation->manager, operation);
+ processed_operation = TRUE;
+ break;
+ case OPERATION_TYPE_SIGN_OUT:
+ sign_out_identity (operation->manager, operation);
+ processed_operation = TRUE;
+ break;
+ case OPERATION_TYPE_RENEW:
+ renew_identity (operation->manager, operation);
+ processed_operation = TRUE;
+ break;
+ }
+
+ operation->job = NULL;
+
+ if (operation->result != NULL)
+ {
+ g_simple_async_result_complete_in_idle (operation->result);
+ g_object_unref (operation->result);
+ operation->result = NULL;
+ }
+ operation_free (operation);
+
+ wait_for_scheduler_job_to_become_unblocked (self);
+
+ /* Don't bother saying "Waiting for next operation" if this operation
+ * was a no-op, since the debug spew probably already says the message
+ */
+ if (processed_operation)
+ goa_debug ("GoaKerberosIdentityManager: Waiting for next operation");
+ }
+
+ g_async_queue_unref (pending_operations);
+
+ return FALSE;
+}
+
+static void
+goa_kerberos_identity_manager_get_identity (GoaIdentityManager *manager,
+ const char *identifier,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (manager);
+ GSimpleAsyncResult *result;
+ Operation *operation;
+
+ result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ goa_kerberos_identity_manager_get_identity);
+ operation = operation_new (self, cancellable, OPERATION_TYPE_GET_IDENTITY, result);
+ g_object_unref (result);
+
+ operation->identifier = g_strdup (identifier);
+
+ g_async_queue_push (self->priv->pending_operations, operation);
+}
+
+static GoaIdentity *
+goa_kerberos_identity_manager_get_identity_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ GoaIdentity *identity;
+
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error))
+ return NULL;
+
+ identity =
+ g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ return identity;
+}
+
+static void
+goa_kerberos_identity_manager_list_identities (GoaIdentityManager *manager,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (manager);
+ GSimpleAsyncResult *result;
+ Operation *operation;
+
+ result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ goa_kerberos_identity_manager_list_identities);
+
+ operation = operation_new (self, cancellable, OPERATION_TYPE_LIST, result);
+ g_object_unref (result);
+
+ g_async_queue_push (self->priv->pending_operations, operation);
+}
+
+static GList *
+goa_kerberos_identity_manager_list_identities_finish (GoaIdentityManager *manager,
+ GAsyncResult *result,
+ GError **error)
+{
+ GList *identities;
+
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error))
+ return NULL;
+
+ identities =
+ g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ return identities;
+
+}
+
+static void
+goa_kerberos_identity_manager_renew_identity (GoaIdentityManager *manager,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (manager);
+ GSimpleAsyncResult *result;
+ Operation *operation;
+
+ result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ goa_kerberos_identity_manager_renew_identity);
+ operation = operation_new (self, cancellable, OPERATION_TYPE_RENEW, result);
+ g_object_unref (result);
+
+ operation->identity = g_object_ref (identity);
+
+ g_async_queue_push (self->priv->pending_operations, operation);
+}
+
+static void
+goa_kerberos_identity_manager_renew_identity_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
+ error))
+ return;
+}
+
+static void
+goa_kerberos_identity_manager_sign_identity_in (GoaIdentityManager *manager,
+ const char *identifier,
+ GoaIdentityInquiryFunc inquiry_func,
+ gpointer inquiry_data,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (manager);
+ GSimpleAsyncResult *result;
+ Operation *operation;
+
+ result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ goa_kerberos_identity_manager_sign_identity_in);
+ operation = operation_new (self, cancellable, OPERATION_TYPE_SIGN_IN, result);
+ g_object_unref (result);
+
+ operation->identifier = g_strdup (identifier);
+ operation->inquiry_func = inquiry_func;
+ operation->inquiry_data = inquiry_data;
+ g_mutex_init (&operation->inquiry_lock);
+ g_cond_init (&operation->inquiry_finished_condition);
+ operation->is_inquiring = FALSE;
+
+ g_async_queue_push (self->priv->pending_operations, operation);
+}
+
+static GoaIdentity *
+goa_kerberos_identity_manager_sign_identity_in_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ GoaIdentity *identity;
+
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+ return NULL;
+
+ identity =
+ g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
+
+ return identity;
+}
+
+static void
+goa_kerberos_identity_manager_sign_identity_out (GoaIdentityManager *manager,
+ GoaIdentity *identity,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (manager);
+ GSimpleAsyncResult *result;
+ Operation *operation;
+
+ result = g_simple_async_result_new (G_OBJECT (self),
+ callback,
+ user_data,
+ goa_kerberos_identity_manager_sign_identity_out);
+ operation = operation_new (self, cancellable, OPERATION_TYPE_SIGN_OUT, result);
+ g_object_unref (result);
+
+ operation->identity = g_object_ref (identity);
+
+ g_async_queue_push (self->priv->pending_operations, operation);
+}
+
+static void
+goa_kerberos_identity_manager_sign_identity_out_finish (GoaIdentityManager *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+ return;
+
+ return;
+}
+
+static char *
+goa_kerberos_identity_manager_name_identity (GoaIdentityManager *manager,
+ GoaIdentity *identity)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (manager);
+ char *name;
+ GList *other_identities;
+ gboolean other_identity_needs_rename;
+
+ name = goa_kerberos_identity_get_realm_name (GOA_KERBEROS_IDENTITY (identity));
+
+ if (name == NULL)
+ return NULL;
+
+ other_identities = g_hash_table_lookup (self->priv->identities_by_realm, name);
+
+ /* If there was already exactly one identity for this realm before,
+ * then it was going by just the realm name, so we need to rename it
+ * to use the full principle name
+ */
+ if (other_identities != NULL &&
+ other_identities->next == NULL && other_identities->data != identity)
+ other_identity_needs_rename = TRUE;
+
+ other_identities = g_list_remove (other_identities, identity);
+ other_identities = g_list_prepend (other_identities, identity);
+
+ g_hash_table_replace (self->priv->identities_by_realm,
+ g_strdup (name),
+ other_identities);
+
+ if (other_identities->next != NULL)
+ {
+ g_free (name);
+ name = goa_kerberos_identity_get_principal_name (GOA_KERBEROS_IDENTITY (identity));
+
+ if (other_identity_needs_rename)
+ {
+ GoaIdentity *other_identity = other_identities->next->data;
+
+ _goa_identity_manager_emit_identity_renamed (GOA_IDENTITY_MANAGER (self),
+ other_identity);
+ }
+ }
+
+ return name;
+}
+
+static void
+identity_manager_interface_init (GoaIdentityManagerInterface *interface)
+{
+ interface->get_identity = goa_kerberos_identity_manager_get_identity;
+ interface->get_identity_finish = goa_kerberos_identity_manager_get_identity_finish;
+ interface->list_identities = goa_kerberos_identity_manager_list_identities;
+ interface->list_identities_finish = goa_kerberos_identity_manager_list_identities_finish;
+ interface->sign_identity_in = goa_kerberos_identity_manager_sign_identity_in;
+ interface->sign_identity_in_finish = goa_kerberos_identity_manager_sign_identity_in_finish;
+ interface->sign_identity_out = goa_kerberos_identity_manager_sign_identity_out;
+ interface->sign_identity_out_finish = goa_kerberos_identity_manager_sign_identity_out_finish;
+ interface->renew_identity = goa_kerberos_identity_manager_renew_identity;
+ interface->renew_identity_finish = goa_kerberos_identity_manager_renew_identity_finish;
+ interface->name_identity = goa_kerberos_identity_manager_name_identity;
+}
+
+static void
+on_credentials_cache_changed (GFileMonitor *monitor,
+ GFile *file,
+ GFile *other_file,
+ GFileMonitorEvent *event_type,
+ GoaKerberosIdentityManager *self)
+{
+ schedule_refresh (self);
+}
+
+static gboolean
+monitor_credentials_cache (GoaKerberosIdentityManager *self,
+ GError **error)
+{
+ krb5_ccache default_cache;
+ const char *cache_type;
+ const char *cache_path;
+ GFile *file;
+ GFileMonitor *monitor;
+ krb5_error_code error_code;
+ GError *monitoring_error;
+
+ error_code = krb5_cc_default (self->priv->kerberos_context, &default_cache);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+
+ g_set_error_literal (error,
+ GOA_IDENTITY_MANAGER_ERROR,
+ GOA_IDENTITY_MANAGER_ERROR_ACCESSING_CREDENTIALS,
+ error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+
+ return FALSE;
+ }
+
+ cache_type = krb5_cc_get_type (self->priv->kerberos_context, default_cache);
+ g_assert (cache_type != NULL);
+
+ if (strcmp (cache_type, "FILE") != 0 && strcmp (cache_type, "DIR") != 0)
+ {
+ g_set_error (error,
+ GOA_IDENTITY_MANAGER_ERROR,
+ GOA_IDENTITY_MANAGER_ERROR_UNSUPPORTED_CREDENTIALS,
+ "Only 'FILE' and 'DIR' credential cache types are really supported, not '%s'",
+ cache_type);
+ return FALSE;
+ }
+
+ g_free (self->priv->credentials_cache_type);
+ self->priv->credentials_cache_type = g_strdup (cache_type);
+
+ /* If we're using a FILE type credential cache, then the
+ * default cache file is the only cache we care about,
+ * and its path is what we want to monitor.
+ *
+ * If we're using a DIR type credential cache, then the default
+ * cache file is one of many possible cache files, all in the
+ * same directory. We want to monitor that directory.
+ */
+ cache_path = krb5_cc_get_name (self->priv->kerberos_context, default_cache);
+
+ /* The cache name might have a : in front of it.
+ * FIXME: figure out if that behavior is by design, or some
+ * odd bug.
+ */
+ if (cache_path[0] == ':')
+ cache_path++;
+
+ file = g_file_new_for_path (cache_path);
+
+ monitoring_error = NULL;
+ if (strcmp (cache_type, "FILE") == 0)
+ {
+ monitor = g_file_monitor_file (file,
+ G_FILE_MONITOR_NONE,
+ NULL,
+ &monitoring_error);
+ }
+ else if (strcmp (cache_type, "DIR") == 0)
+ {
+ GFile *directory;
+
+ directory = g_file_get_parent (file);
+ monitor = g_file_monitor_directory (directory,
+ G_FILE_MONITOR_NONE,
+ NULL,
+ &monitoring_error);
+ g_object_unref (directory);
+
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+ g_object_unref (file);
+
+ if (monitor == NULL)
+ {
+ g_propagate_error (error, monitoring_error);
+ return FALSE;
+ }
+
+ self->priv->credentials_cache_changed_signal_id =
+ g_signal_connect (G_OBJECT (monitor), "changed",
+ G_CALLBACK (on_credentials_cache_changed), self);
+ self->priv->credentials_cache_monitor = monitor;
+
+ return TRUE;
+}
+
+static void
+stop_watching_credentials_cache (GoaKerberosIdentityManager *self)
+{
+ if (!g_file_monitor_is_cancelled (self->priv->credentials_cache_monitor))
+ g_file_monitor_cancel (self->priv->credentials_cache_monitor);
+
+ g_object_unref (self->priv->credentials_cache_monitor);
+ self->priv->credentials_cache_monitor = NULL;
+}
+
+static gboolean
+goa_kerberos_identity_manager_initable_init (GInitable *initable,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (initable);
+ krb5_error_code error_code;
+ GError *monitoring_error;
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return FALSE;
+
+ error_code = krb5_init_context (&self->priv->kerberos_context);
+
+ if (error_code != 0)
+ {
+ const char *error_message;
+ error_message =
+ krb5_get_error_message (self->priv->kerberos_context, error_code);
+
+ g_set_error_literal (error,
+ GOA_IDENTITY_MANAGER_ERROR,
+ GOA_IDENTITY_MANAGER_ERROR_INITIALIZING, error_message);
+ krb5_free_error_message (self->priv->kerberos_context, error_message);
+
+ return FALSE;
+ }
+
+ monitoring_error = NULL;
+ if (!monitor_credentials_cache (self, &monitoring_error))
+ {
+ goa_warning ("GoaKerberosIdentityManager: Could not monitor credentials: %s",
+ monitoring_error->message);
+ g_error_free (monitoring_error);
+ }
+
+ schedule_refresh (self);
+
+ return TRUE;
+}
+
+static void
+initable_interface_init (GInitableIface *interface)
+{
+ interface->init = goa_kerberos_identity_manager_initable_init;
+}
+
+static void
+goa_kerberos_identity_manager_init (GoaKerberosIdentityManager *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ GOA_TYPE_KERBEROS_IDENTITY_MANAGER,
+ GoaKerberosIdentityManagerPrivate);
+ self->priv->identities = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ (GDestroyNotify)
+ g_free,
+ (GDestroyNotify) g_object_unref);
+ self->priv->expired_identities = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ (GDestroyNotify)
+ g_free, NULL);
+
+ self->priv->identities_by_realm = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ (GDestroyNotify)
+ g_free, NULL);
+ self->priv->pending_operations = g_async_queue_new ();
+
+ g_mutex_init (&self->priv->scheduler_job_lock);
+ g_cond_init (&self->priv->scheduler_job_unblocked);
+
+ self->priv->scheduler_cancellable = g_cancellable_new ();
+ g_io_scheduler_push_job ((GIOSchedulerJobFunc)
+ on_job_scheduled,
+ self,
+ NULL,
+ G_PRIORITY_DEFAULT,
+ self->priv->scheduler_cancellable);
+
+}
+
+static void
+cancel_pending_operations (GoaKerberosIdentityManager *self)
+{
+ Operation *operation;
+
+ operation = g_async_queue_try_pop (self->priv->pending_operations);
+ while (operation != NULL)
+ {
+ g_cancellable_cancel (operation->cancellable);
+ operation_free (operation);
+ operation = g_async_queue_try_pop (self->priv->pending_operations);
+ }
+}
+
+static void
+goa_kerberos_identity_manager_dispose (GObject *object)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (object);
+
+ if (self->priv->identities_by_realm != NULL)
+ {
+ g_hash_table_unref (self->priv->identities_by_realm);
+ self->priv->identities_by_realm = NULL;
+ }
+
+ if (self->priv->expired_identities != NULL)
+ {
+ g_hash_table_unref (self->priv->expired_identities);
+ self->priv->expired_identities = NULL;
+ }
+
+ if (self->priv->identities != NULL)
+ {
+ g_hash_table_unref (self->priv->identities);
+ self->priv->identities = NULL;
+ }
+
+ if (self->priv->credentials_cache_monitor != NULL)
+ stop_watching_credentials_cache (self);
+
+ if (self->priv->pending_operations != NULL)
+ cancel_pending_operations (self);
+
+ if (self->priv->scheduler_cancellable != NULL)
+ {
+ if (!g_cancellable_is_cancelled (self->priv->scheduler_cancellable))
+ {
+ g_cancellable_cancel (self->priv->scheduler_cancellable);
+ }
+
+ g_clear_object (&self->priv->scheduler_cancellable);
+ }
+
+ /* Note, other thread may still be holding a local reference to queue
+ * while it shuts down from cancelled scheduler_cancellable above
+ */
+ if (self->priv->pending_operations != NULL)
+ {
+ g_async_queue_unref (self->priv->pending_operations);
+ self->priv->pending_operations = NULL;
+ }
+
+ G_OBJECT_CLASS (goa_kerberos_identity_manager_parent_class)->dispose (object);
+}
+
+static void
+goa_kerberos_identity_manager_finalize (GObject *object)
+{
+ GoaKerberosIdentityManager *self = GOA_KERBEROS_IDENTITY_MANAGER (object);
+
+ g_free (self->priv->credentials_cache_type);
+
+ g_cond_clear (&self->priv->scheduler_job_unblocked);
+ krb5_free_context (self->priv->kerberos_context);
+
+ G_OBJECT_CLASS (goa_kerberos_identity_manager_parent_class)->finalize (object);
+}
+
+static void
+goa_kerberos_identity_manager_class_init (GoaKerberosIdentityManagerClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->dispose = goa_kerberos_identity_manager_dispose;
+ object_class->finalize = goa_kerberos_identity_manager_finalize;
+
+ g_type_class_add_private (klass, sizeof (GoaKerberosIdentityManagerPrivate));
+}
+
+GoaIdentityManager *
+goa_kerberos_identity_manager_new (GCancellable * cancellable, GError ** error)
+{
+ if (goa_kerberos_identity_manager_singleton == NULL)
+ {
+ GObject *object;
+
+ object = g_object_new (GOA_TYPE_KERBEROS_IDENTITY_MANAGER, NULL);
+
+ goa_kerberos_identity_manager_singleton = GOA_IDENTITY_MANAGER (object);
+ g_object_add_weak_pointer (object,
+ (gpointer *) &
+ goa_kerberos_identity_manager_singleton);
+
+ error = NULL;
+ if (!g_initable_init (G_INITABLE (object), cancellable, error))
+ {
+ g_object_unref (object);
+ return NULL;
+ }
+
+ }
+ else
+ {
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return NULL;
+ g_object_ref (goa_kerberos_identity_manager_singleton);
+ }
+
+ return goa_kerberos_identity_manager_singleton;
+}
diff --git a/src/goaidentity/goakerberosidentitymanager.h b/src/goaidentity/goakerberosidentitymanager.h
new file mode 100644
index 0000000..c087667
--- /dev/null
+++ b/src/goaidentity/goakerberosidentitymanager.h
@@ -0,0 +1,61 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2012 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors: Ray Strode
+ */
+
+#ifndef __GOA_KERBEROS_IDENTITY_MANAGER_H__
+#define __GOA_KERBEROS_IDENTITY_MANAGER_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "goaidentitymanager.h"
+#include "goakerberosidentity.h"
+
+G_BEGIN_DECLS
+#define GOA_TYPE_KERBEROS_IDENTITY_MANAGER (goa_kerberos_identity_manager_get_type ())
+#define GOA_KERBEROS_IDENTITY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GOA_TYPE_KERBEROS_IDENTITY_MANAGER, GoaKerberosIdentityManager))
+#define GOA_KERBEROS_IDENTITY_MANAGER_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GOA_TYPE_KERBEROS_IDENTITY_MANAGER, GoaKerberosIdentityManagerClass))
+#define GOA_IS_KERBEROS_IDENTITY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GOA_TYPE_KERBEROS_IDENTITY_MANAGER))
+#define GOA_IS_KERBEROS_IDENTITY_MANAGER_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GOA_TYPE_KERBEROS_IDENTITY_MANAGER))
+#define GOA_KERBEROS_IDENTITY_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GOA_TYPE_KERBEROS_IDENTITY_MANAGER, GoaKerberosIdentityManagerClass))
+typedef struct _GoaKerberosIdentityManager GoaKerberosIdentityManager;
+typedef struct _GoaKerberosIdentityManagerClass GoaKerberosIdentityManagerClass;
+typedef struct _GoaKerberosIdentityManagerPrivate GoaKerberosIdentityManagerPrivate;
+struct _GoaKerberosIdentityManager
+{
+ GObject parent_instance;
+ GoaKerberosIdentityManagerPrivate *priv;
+};
+
+struct _GoaKerberosIdentityManagerClass
+{
+ GObjectClass parent_class;
+};
+
+GType goa_kerberos_identity_manager_get_type (void);
+GoaIdentityManager *goa_kerberos_identity_manager_new (GCancellable *cancellable,
+ GError **error);
+
+void goa_kerberos_identity_manager_start_test (GoaKerberosIdentityManager *manager,
+ GError **error);
+G_END_DECLS
+#endif /* __GOA_KERBEROS_IDENTITY_MANAGER_H__ */
diff --git a/src/goaidentity/org.gnome.Identity.xml b/src/goaidentity/org.gnome.Identity.xml
new file mode 100644
index 0000000..0bf6394
--- /dev/null
+++ b/src/goaidentity/org.gnome.Identity.xml
@@ -0,0 +1,73 @@
+<!DOCTYPE node PUBLIC
+"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd";>
+
+<!--
+ Copyright (C) 2012 Red Hat, Inc.
+
+ This library 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 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General
+ Public License along with this library; if not, write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307, USA.
+
+ Author: Ray Strode <rstrode redhat com>
+-->
+
+<node name="/" xmlns:doc="http://www.freedesktop.org/dbus/1.0/doc.dtd";>
+ <!--
+ org.gnome.Identity.Manager:
+
+ An interface used for managing identities.
+ -->
+ <interface name="org.gnome.Identity.Manager">
+
+ <!--
+ SignIn:
+ @identity: The identifier of the identity (i.e., a kerberos principal name)
+ @details: Extra key/value pairs to set.
+ @identity_object_path: The object path of the signed in identity.
+
+ Signs in an identity.
+ -->
+ <method name="SignIn">
+ <arg name="identity" type="s" direction="in"/>
+ <arg name="details" type="a{ss}" direction="in"/>
+ <arg name="identity_object_path" type="o" direction="out"/>
+ </method>
+
+ <method name="SignOut">
+ <arg name="identity" type="s" direction="in"/>
+ </method>
+ </interface>
+
+ <!--
+ org.gnome.Identity:
+
+ The identity interface.
+ -->
+ <interface name="org.gnome.Identity">
+ <!--
+ Identifier:
+ Unique string identifying identity (i.e., a kerberos principal name)
+ -->
+ <property name="Identifier" type="s" access="read"/>
+
+ <!--
+ ExpirationTimestamp:
+ The time the identity's credentials will expire
+ -->
+ <property name="ExpirationTimestamp" type="x" access="read"/>
+
+ </interface>
+
+</node>
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
