add a basic ck-history command

Refactor some event logging code to share with ck-history.  At the
moment the command only prints the events.

10 files changed, 1458 insertions, 629 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 54e37cb..3d08222 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -25,9 +25,15 @@ INCLUDES =							\
 	$(NULL)
 
 noinst_LTLIBRARIES =            \
-        libck.la         	\
+        libck.la		\
+        libck-event-log.la	\
         $(NULL)
 
+libck_event_log_la_SOURCES =	\
+	ck-log-event.h		\
+	ck-log-event.c		\
+	$(NULL)
+
 libck_la_SOURCES =		\
 	ck-sysdeps.h		\
 	ck-sysdeps-unix.c	\
@@ -122,6 +128,7 @@ EXTRA_console_kit_daemon_SOURCES = 	\
 console_kit_daemon_LDADD =	\
 	$(CONSOLE_KIT_LIBS)	\
 	libck.la		\
+	libck-event-log.la	\
 	$(NULL)
 
 noinst_PROGRAMS = 			\
@@ -138,6 +145,7 @@ test_event_logger_SOURCES = 		\
 
 test_event_logger_LDADD =		\
 	$(CONSOLE_KIT_LIBS)		\
+	libck-event-log.la		\
 	$(NULL)
 
 test_vt_monitor_SOURCES = 		\
diff --git a/src/ck-event-logger.c b/src/ck-event-logger.c
index b9e41ee..66c7ab2 100644
--- a/src/ck-event-logger.c
+++ b/src/ck-event-logger.c
@@ -37,6 +37,7 @@
 #include <glib-object.h>
 
 #include "ck-event-logger.h"
+#include "ck-log-event.h"
 
 #define CK_EVENT_LOGGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CK_TYPE_EVENT_LOGGER, CkEventLoggerPrivate))
 
@@ -73,301 +74,18 @@ ck_event_logger_error_quark (void)
         return ret;
 }
 
-static void
-event_seat_added_free (CkEventLoggerSeatAddedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-}
-
-static void
-event_seat_removed_free (CkEventLoggerSeatRemovedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-}
-
-static void
-event_seat_session_added_free (CkEventLoggerSeatSessionAddedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-
-        g_free (event->session_id);
-        event->session_id = NULL;
-        g_free (event->session_type);
-        event->session_type = NULL;
-        g_free (event->session_x11_display);
-        event->session_x11_display = NULL;
-        g_free (event->session_x11_display_device);
-        event->session_x11_display_device = NULL;
-        g_free (event->session_display_device);
-        event->session_display_device = NULL;
-        g_free (event->session_remote_host_name);
-        event->session_remote_host_name = NULL;
-        g_free (event->session_creation_time);
-        event->session_creation_time = NULL;
-}
-
-static void
-event_seat_session_removed_free (CkEventLoggerSeatSessionRemovedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-
-        g_free (event->session_id);
-        event->session_id = NULL;
-        g_free (event->session_type);
-        event->session_type = NULL;
-        g_free (event->session_x11_display);
-        event->session_x11_display = NULL;
-        g_free (event->session_x11_display_device);
-        event->session_x11_display_device = NULL;
-        g_free (event->session_display_device);
-        event->session_display_device = NULL;
-        g_free (event->session_remote_host_name);
-        event->session_remote_host_name = NULL;
-        g_free (event->session_creation_time);
-        event->session_creation_time = NULL;
-}
-
-static void
-event_seat_active_session_changed_free (CkEventLoggerSeatActiveSessionChangedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-
-        g_free (event->session_id);
-        event->session_id = NULL;
-}
-
-static void
-event_seat_device_added_free (CkEventLoggerSeatDeviceAddedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-        g_free (event->device_id);
-        event->device_id = NULL;
-        g_free (event->device_type);
-        event->device_type = NULL;
-}
-
-static void
-event_seat_device_removed_free (CkEventLoggerSeatDeviceRemovedEvent *event)
-{
-        g_assert (event != NULL);
-
-        g_free (event->seat_id);
-        event->seat_id = NULL;
-        g_free (event->device_id);
-        event->device_id = NULL;
-        g_free (event->device_type);
-        event->device_type = NULL;
-}
-
-static void
-event_seat_added_copy (CkEventLoggerSeatAddedEvent *event,
-                       CkEventLoggerSeatAddedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->seat_kind = event->seat_kind;
-}
-
-static void
-event_seat_removed_copy (CkEventLoggerSeatRemovedEvent *event,
-                         CkEventLoggerSeatRemovedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->seat_kind = event->seat_kind;
-}
-
-static void
-event_seat_session_added_copy (CkEventLoggerSeatSessionAddedEvent *event,
-                               CkEventLoggerSeatSessionAddedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->session_id = g_strdup (event->session_id);
-        event_copy->session_type = g_strdup (event->session_type);
-        event_copy->session_x11_display = g_strdup (event->session_x11_display);
-        event_copy->session_x11_display_device = g_strdup (event->session_x11_display_device);
-        event_copy->session_display_device = g_strdup (event->session_display_device);
-        event_copy->session_remote_host_name = g_strdup (event->session_remote_host_name);
-        event_copy->session_is_local = event->session_is_local;
-        event_copy->session_unix_user = event->session_unix_user;
-        event_copy->session_creation_time = g_strdup (event->session_creation_time);
-}
-
-static void
-event_seat_session_removed_copy (CkEventLoggerSeatSessionRemovedEvent *event,
-                                 CkEventLoggerSeatSessionRemovedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->session_id = g_strdup (event->session_id);
-        event_copy->session_type = g_strdup (event->session_type);
-        event_copy->session_x11_display = g_strdup (event->session_x11_display);
-        event_copy->session_x11_display_device = g_strdup (event->session_x11_display_device);
-        event_copy->session_display_device = g_strdup (event->session_display_device);
-        event_copy->session_remote_host_name = g_strdup (event->session_remote_host_name);
-        event_copy->session_is_local = event->session_is_local;
-        event_copy->session_unix_user = event->session_unix_user;
-        event_copy->session_creation_time = g_strdup (event->session_creation_time);
-}
-
-static void
-event_seat_active_session_changed_copy (CkEventLoggerSeatActiveSessionChangedEvent *event,
-                                        CkEventLoggerSeatActiveSessionChangedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->session_id = g_strdup (event->session_id);
-}
-
-static void
-event_seat_device_added_copy (CkEventLoggerSeatDeviceAddedEvent *event,
-                              CkEventLoggerSeatDeviceAddedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->device_id = g_strdup (event->device_id);
-        event_copy->device_type = g_strdup (event->device_type);
-}
-
-static void
-event_seat_device_removed_copy (CkEventLoggerSeatDeviceRemovedEvent *event,
-                                CkEventLoggerSeatDeviceRemovedEvent *event_copy)
-{
-        g_assert (event != NULL);
-        g_assert (event_copy != NULL);
-
-        event_copy->seat_id = g_strdup (event->seat_id);
-        event_copy->device_id = g_strdup (event->device_id);
-        event_copy->device_type = g_strdup (event->device_type);
-}
-
-CkEventLoggerEvent *
-ck_event_logger_event_copy (CkEventLoggerEvent *event)
-{
-        CkEventLoggerEvent *event_copy;
-
-        if (event == NULL) {
-                return NULL;
-        }
-
-        event_copy = g_new0 (CkEventLoggerEvent, 1);
-
-        event_copy->type = event->type;
-        event_copy->timestamp = event->timestamp;
-
-        switch (event->type) {
-        case CK_EVENT_LOGGER_EVENT_SEAT_ADDED:
-                event_seat_added_copy ((CkEventLoggerSeatAddedEvent *) event,
-                                       (CkEventLoggerSeatAddedEvent *) event_copy);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_REMOVED:
-                event_seat_removed_copy ((CkEventLoggerSeatRemovedEvent *) event,
-                                         (CkEventLoggerSeatRemovedEvent *) event_copy);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED:
-                event_seat_session_added_copy ((CkEventLoggerSeatSessionAddedEvent *) event,
-                                               (CkEventLoggerSeatSessionAddedEvent *) event_copy);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_REMOVED:
-                event_seat_session_removed_copy ((CkEventLoggerSeatSessionRemovedEvent *) event,
-                                                 (CkEventLoggerSeatSessionRemovedEvent *) event_copy);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_ADDED:
-                event_seat_device_added_copy ((CkEventLoggerSeatDeviceAddedEvent *) event,
-                                              (CkEventLoggerSeatDeviceAddedEvent *) event_copy);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_REMOVED:
-                event_seat_device_removed_copy ((CkEventLoggerSeatDeviceRemovedEvent *) event,
-                                                (CkEventLoggerSeatDeviceRemovedEvent *) event_copy);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
-                event_seat_active_session_changed_copy ((CkEventLoggerSeatActiveSessionChangedEvent *) event,
-                                                        (CkEventLoggerSeatActiveSessionChangedEvent *) event_copy);
-                break;
-        default:
-                g_assert_not_reached ();
-                break;
-        }
-
-        return event_copy;
-}
-
-void
-ck_event_logger_event_free (CkEventLoggerEvent *event)
-{
-        switch (event->type) {
-        case CK_EVENT_LOGGER_EVENT_SEAT_ADDED:
-                event_seat_added_free ((CkEventLoggerSeatAddedEvent *) event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_REMOVED:
-                event_seat_removed_free ((CkEventLoggerSeatRemovedEvent *) event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED:
-                event_seat_session_added_free ((CkEventLoggerSeatSessionAddedEvent *) event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_REMOVED:
-                event_seat_session_removed_free ((CkEventLoggerSeatSessionRemovedEvent *) event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_ADDED:
-                event_seat_device_added_free ((CkEventLoggerSeatDeviceAddedEvent *) event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_REMOVED:
-                event_seat_device_removed_free ((CkEventLoggerSeatDeviceRemovedEvent *) event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
-                event_seat_active_session_changed_free ((CkEventLoggerSeatActiveSessionChangedEvent *) event);
-                break;
-        default:
-                g_assert_not_reached ();
-                break;
-        }
-
-        g_free (event);
-}
-
 gboolean
 ck_event_logger_queue_event (CkEventLogger      *event_logger,
-                             CkEventLoggerEvent *event,
+                             CkLogEvent         *event,
                              GError            **error)
 {
-        CkEventLoggerEvent *event_copy;
-        gboolean            ret;
+        CkLogEvent *event_copy;
+        gboolean    ret;
 
         g_return_val_if_fail (CK_IS_EVENT_LOGGER (event_logger), FALSE);
         g_return_val_if_fail (event != NULL, FALSE);
 
-        event_copy = ck_event_logger_event_copy (event);
+        event_copy = ck_log_event_copy (event);
 
         g_async_queue_push (event_logger->priv->event_queue,
                             event_copy);
@@ -446,199 +164,15 @@ retry:
         return TRUE;
 }
 
-static void
-add_log_for_seat_added (GString            *str,
-                        CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatAddedEvent *e;
-
-        e = (CkEventLoggerSeatAddedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id=%s seat-kind=%d",
-                                e->seat_id,
-                                e->seat_kind);
-}
-
-static void
-add_log_for_seat_removed (GString            *str,
-                          CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatRemovedEvent *e;
-
-        e = (CkEventLoggerSeatRemovedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id=%s seat-kind=%d",
-                                e->seat_id,
-                                e->seat_kind);
-}
-
-static void
-add_log_for_seat_session_added (GString            *str,
-                                CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatSessionAddedEvent *e;
-
-        e = (CkEventLoggerSeatSessionAddedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id='%s' session-id='%s' session-type='%s' session-x11-display='%s' session-x11-display-device='%s' session-display-device='%s' session-remote-host-name='%s' session-is-local=%s session-unix-user=%u session-creation-time='%s'",
-                                e->seat_id ? e->seat_id : "",
-                                e->session_id ? e->session_id : "",
-                                e->session_type ? e->session_type : "",
-                                e->session_x11_display ? e->session_x11_display : "",
-                                e->session_x11_display_device ? e->session_x11_display_device : "",
-                                e->session_display_device ? e->session_display_device : "",
-                                e->session_remote_host_name ? e->session_remote_host_name : "",
-                                e->session_is_local ? "TRUE" : "FALSE",
-                                e->session_unix_user,
-                                e->session_creation_time ? e->session_creation_time : "");
-}
-
-static void
-add_log_for_seat_session_removed (GString            *str,
-                                  CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatSessionRemovedEvent *e;
-
-        e = (CkEventLoggerSeatSessionRemovedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id='%s' session-id='%s' session-type='%s' session-x11-display='%s' session-x11-display-device='%s' session-display-device='%s' session-remote-host-name='%s' session-is-local=%s session-unix-user=%u session-creation-time='%s'",
-                                e->seat_id ? e->seat_id : "",
-                                e->session_id ? e->session_id : "",
-                                e->session_type ? e->session_type : "",
-                                e->session_x11_display ? e->session_x11_display : "",
-                                e->session_x11_display_device ? e->session_x11_display_device : "",
-                                e->session_display_device ? e->session_display_device : "",
-                                e->session_remote_host_name ? e->session_remote_host_name : "",
-                                e->session_is_local ? "TRUE" : "FALSE",
-                                e->session_unix_user,
-                                e->session_creation_time ? e->session_creation_time : "");
-}
-
-static void
-add_log_for_seat_active_session_changed (GString            *str,
-                                         CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatActiveSessionChangedEvent *e;
-
-        e = (CkEventLoggerSeatActiveSessionChangedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id='%s' session-id='%s'",
-                                e->seat_id ? e->seat_id : "",
-                                e->session_id ? e->session_id : "");
-}
-
-static void
-add_log_for_seat_device_added (GString            *str,
-                               CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatDeviceAddedEvent *e;
-
-        e = (CkEventLoggerSeatDeviceAddedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id='%s' device-id='%s' device-type='%s'",
-                                e->seat_id ? e->seat_id : "",
-                                e->device_id ? e->device_id : "",
-                                e->device_type ? e->device_type : "");
-}
-
-static void
-add_log_for_seat_device_removed (GString            *str,
-                                 CkEventLoggerEvent *event)
-{
-        CkEventLoggerSeatDeviceRemovedEvent *e;
-
-        e = (CkEventLoggerSeatDeviceRemovedEvent *)event;
-        g_string_append_printf (str,
-                                " seat-id='%s' device-id='%s' device-type='%s'",
-                                e->seat_id ? e->seat_id : "",
-                                e->device_id ? e->device_id : "",
-                                e->device_type ? e->device_type : "");
-}
-
-static const char *
-event_type_to_name (int event_type)
-{
-        const char *str;
-        switch (event_type) {
-        case CK_EVENT_LOGGER_EVENT_SEAT_ADDED:
-                str = "SEAT_ADDED";
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_REMOVED:
-                str = "SEAT_REMOVED";
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED:
-                str = "SEAT_SESSION_ADDED";
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_REMOVED:
-                str = "SEAT_SESSION_REMOVED";
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_ADDED:
-                str = "SEAT_DEVICE_ADDED";
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_REMOVED:
-                str = "SEAT_DEVICE_REMOVED";
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
-                str = "SEAT_ACTIVE_SESSION_CHANGED";
-                break;
-        default:
-                str = "UNKNOWN";
-                break;
-        }
-        return str;
-}
-
-static void
-add_log_for_any (GString            *str,
-                 CkEventLoggerEvent *event)
-{
-        char *tstr;
-
-        tstr = g_time_val_to_iso8601 (&event->timestamp);
-
-        g_string_append_printf (str,
-                                "%s type=%s",
-                                tstr,
-                                event_type_to_name (event->type));
-        g_free (tstr);
-}
-
 static gboolean
-write_log_for_event (CkEventLogger      *event_logger,
-                     CkEventLoggerEvent *event)
+write_log_for_event (CkEventLogger *event_logger,
+                     CkLogEvent    *event)
 {
         GString *str;
 
         str = g_string_new (NULL);
 
-        add_log_for_any (str, event);
-
-        switch (event->type) {
-        case CK_EVENT_LOGGER_EVENT_SEAT_ADDED:
-                add_log_for_seat_added (str, event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_REMOVED:
-                add_log_for_seat_removed (str, event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED:
-                add_log_for_seat_session_added (str, event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_SESSION_REMOVED:
-                add_log_for_seat_session_removed (str, event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_ADDED:
-                add_log_for_seat_device_added (str, event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_REMOVED:
-                add_log_for_seat_device_removed (str, event);
-                break;
-        case CK_EVENT_LOGGER_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
-                add_log_for_seat_active_session_changed (str, event);
-                break;
-        default:
-                g_assert_not_reached ();
-                break;
-        }
+        ck_log_event_to_string (event, str);
 
         g_debug ("Writing log for event: %s", str->str);
 
@@ -660,11 +194,11 @@ write_log_for_event (CkEventLogger      *event_logger,
 static void *
 writer_thread_start (CkEventLogger *event_logger)
 {
-        CkEventLoggerEvent *event;
+        CkLogEvent *event;
 
         while ((event = g_async_queue_pop (event_logger->priv->event_queue)) != NULL) {
                 write_log_for_event (event_logger, event);
-                ck_event_logger_event_free (event);
+                ck_log_event_free (event);
         }
 
         g_thread_exit (NULL);
diff --git a/src/ck-event-logger.h b/src/ck-event-logger.h
index c49136e..d4645f7 100644
--- a/src/ck-event-logger.h
+++ b/src/ck-event-logger.h
@@ -22,6 +22,7 @@
 #define __CK_EVENT_LOGGER_H
 
 #include <glib-object.h>
+#include "ck-log-event.h"
 
 G_BEGIN_DECLS
 
@@ -47,98 +48,6 @@ typedef struct
 
 typedef enum
 {
-        CK_EVENT_LOGGER_EVENT_START = 0,
-        CK_EVENT_LOGGER_EVENT_STOP,
-        CK_EVENT_LOGGER_EVENT_SYSTEM_SHUTDOWN,
-        CK_EVENT_LOGGER_EVENT_SYSTEM_RUNLEVEL_CHANGED,
-        CK_EVENT_LOGGER_EVENT_SEAT_ADDED,
-        CK_EVENT_LOGGER_EVENT_SEAT_REMOVED,
-        CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED,
-        CK_EVENT_LOGGER_EVENT_SEAT_SESSION_REMOVED,
-        CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_ADDED,
-        CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_REMOVED,
-        CK_EVENT_LOGGER_EVENT_SEAT_ACTIVE_SESSION_CHANGED,
-} CkEventLoggerEventType;
-
-typedef struct
-{
-        char *seat_id;
-        int   seat_kind;
-} CkEventLoggerSeatAddedEvent;
-
-typedef struct
-{
-        char *seat_id;
-        int   seat_kind;
-} CkEventLoggerSeatRemovedEvent;
-
-typedef struct
-{
-        char    *seat_id;
-        char    *session_id;
-        char    *session_type;
-        char    *session_x11_display;
-        char    *session_x11_display_device;
-        char    *session_display_device;
-        char    *session_remote_host_name;
-        gboolean session_is_local;
-        guint    session_unix_user;
-        char    *session_creation_time;
-} CkEventLoggerSeatSessionAddedEvent;
-
-typedef struct
-{
-        char    *seat_id;
-        char    *session_id;
-        char    *session_type;
-        char    *session_x11_display;
-        char    *session_x11_display_device;
-        char    *session_display_device;
-        char    *session_remote_host_name;
-        gboolean session_is_local;
-        guint    session_unix_user;
-        char    *session_creation_time;
-} CkEventLoggerSeatSessionRemovedEvent;
-
-typedef struct
-{
-        char    *seat_id;
-        char    *session_id;
-} CkEventLoggerSeatActiveSessionChangedEvent;
-
-typedef struct
-{
-        char *seat_id;
-        char *device_type;
-        char *device_id;
-} CkEventLoggerSeatDeviceAddedEvent;
-
-typedef struct
-{
-        char *seat_id;
-        char *device_type;
-        char *device_id;
-} CkEventLoggerSeatDeviceRemovedEvent;
-
-typedef struct
-{
-        union {
-                CkEventLoggerSeatAddedEvent seat_added;
-                CkEventLoggerSeatRemovedEvent seat_removed;
-                CkEventLoggerSeatSessionAddedEvent seat_session_added;
-                CkEventLoggerSeatSessionRemovedEvent seat_session_removed;
-                CkEventLoggerSeatActiveSessionChangedEvent seat_active_session_changed;
-                CkEventLoggerSeatDeviceAddedEvent seat_device_added;
-                CkEventLoggerSeatDeviceRemovedEvent seat_device_removed;
-        } event;
-
-        GTimeVal               timestamp;
-        CkEventLoggerEventType type;
-} CkEventLoggerEvent;
-
-
-typedef enum
-{
          CK_EVENT_LOGGER_ERROR_GENERAL
 } CkEventLoggerError;
 
@@ -149,13 +58,9 @@ GType                ck_event_logger_get_type            (void);
 CkEventLogger      * ck_event_logger_new                 (const char         *filename);
 
 gboolean             ck_event_logger_queue_event         (CkEventLogger      *event_logger,
-                                                          CkEventLoggerEvent *event,
+                                                          CkLogEvent         *event,
                                                           GError            **error);
 
-CkEventLoggerEvent * ck_event_logger_event_copy          (CkEventLoggerEvent *event);
-void                 ck_event_logger_event_free          (CkEventLoggerEvent *event);
-
-
 G_END_DECLS
 
 #endif /* __CK_EVENT_LOGGER_H */
diff --git a/src/ck-log-event.c b/src/ck-log-event.c
new file mode 100644
index 0000000..5cdaa95
--- /dev/null
+++ b/src/ck-log-event.c
@@ -0,0 +1,1084 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * 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.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include "ck-log-event.h"
+
+static void
+event_seat_added_free (CkLogSeatAddedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+}
+
+static void
+event_seat_removed_free (CkLogSeatRemovedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+}
+
+static void
+event_seat_session_added_free (CkLogSeatSessionAddedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+
+        g_free (event->session_id);
+        event->session_id = NULL;
+        g_free (event->session_type);
+        event->session_type = NULL;
+        g_free (event->session_x11_display);
+        event->session_x11_display = NULL;
+        g_free (event->session_x11_display_device);
+        event->session_x11_display_device = NULL;
+        g_free (event->session_display_device);
+        event->session_display_device = NULL;
+        g_free (event->session_remote_host_name);
+        event->session_remote_host_name = NULL;
+        g_free (event->session_creation_time);
+        event->session_creation_time = NULL;
+}
+
+static void
+event_seat_session_removed_free (CkLogSeatSessionRemovedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+
+        g_free (event->session_id);
+        event->session_id = NULL;
+        g_free (event->session_type);
+        event->session_type = NULL;
+        g_free (event->session_x11_display);
+        event->session_x11_display = NULL;
+        g_free (event->session_x11_display_device);
+        event->session_x11_display_device = NULL;
+        g_free (event->session_display_device);
+        event->session_display_device = NULL;
+        g_free (event->session_remote_host_name);
+        event->session_remote_host_name = NULL;
+        g_free (event->session_creation_time);
+        event->session_creation_time = NULL;
+}
+
+static void
+event_seat_active_session_changed_free (CkLogSeatActiveSessionChangedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+
+        g_free (event->session_id);
+        event->session_id = NULL;
+}
+
+static void
+event_seat_device_added_free (CkLogSeatDeviceAddedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+        g_free (event->device_id);
+        event->device_id = NULL;
+        g_free (event->device_type);
+        event->device_type = NULL;
+}
+
+static void
+event_seat_device_removed_free (CkLogSeatDeviceRemovedEvent *event)
+{
+        g_assert (event != NULL);
+
+        g_free (event->seat_id);
+        event->seat_id = NULL;
+        g_free (event->device_id);
+        event->device_id = NULL;
+        g_free (event->device_type);
+        event->device_type = NULL;
+}
+
+static void
+event_seat_added_copy (CkLogSeatAddedEvent *event,
+                       CkLogSeatAddedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->seat_kind = event->seat_kind;
+}
+
+static void
+event_seat_removed_copy (CkLogSeatRemovedEvent *event,
+                         CkLogSeatRemovedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->seat_kind = event->seat_kind;
+}
+
+static void
+event_seat_session_added_copy (CkLogSeatSessionAddedEvent *event,
+                               CkLogSeatSessionAddedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->session_id = g_strdup (event->session_id);
+        event_copy->session_type = g_strdup (event->session_type);
+        event_copy->session_x11_display = g_strdup (event->session_x11_display);
+        event_copy->session_x11_display_device = g_strdup (event->session_x11_display_device);
+        event_copy->session_display_device = g_strdup (event->session_display_device);
+        event_copy->session_remote_host_name = g_strdup (event->session_remote_host_name);
+        event_copy->session_is_local = event->session_is_local;
+        event_copy->session_unix_user = event->session_unix_user;
+        event_copy->session_creation_time = g_strdup (event->session_creation_time);
+}
+
+static void
+event_seat_session_removed_copy (CkLogSeatSessionRemovedEvent *event,
+                                 CkLogSeatSessionRemovedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->session_id = g_strdup (event->session_id);
+        event_copy->session_type = g_strdup (event->session_type);
+        event_copy->session_x11_display = g_strdup (event->session_x11_display);
+        event_copy->session_x11_display_device = g_strdup (event->session_x11_display_device);
+        event_copy->session_display_device = g_strdup (event->session_display_device);
+        event_copy->session_remote_host_name = g_strdup (event->session_remote_host_name);
+        event_copy->session_is_local = event->session_is_local;
+        event_copy->session_unix_user = event->session_unix_user;
+        event_copy->session_creation_time = g_strdup (event->session_creation_time);
+}
+
+static void
+event_seat_active_session_changed_copy (CkLogSeatActiveSessionChangedEvent *event,
+                                        CkLogSeatActiveSessionChangedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->session_id = g_strdup (event->session_id);
+}
+
+static void
+event_seat_device_added_copy (CkLogSeatDeviceAddedEvent *event,
+                              CkLogSeatDeviceAddedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->device_id = g_strdup (event->device_id);
+        event_copy->device_type = g_strdup (event->device_type);
+}
+
+static void
+event_seat_device_removed_copy (CkLogSeatDeviceRemovedEvent *event,
+                                CkLogSeatDeviceRemovedEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+
+        event_copy->seat_id = g_strdup (event->seat_id);
+        event_copy->device_id = g_strdup (event->device_id);
+        event_copy->device_type = g_strdup (event->device_type);
+}
+
+CkLogEvent *
+ck_log_event_copy (CkLogEvent *event)
+{
+        CkLogEvent *event_copy;
+
+        if (event == NULL) {
+                return NULL;
+        }
+
+        event_copy = g_new0 (CkLogEvent, 1);
+
+        event_copy->type = event->type;
+        event_copy->timestamp = event->timestamp;
+
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_ADDED:
+                event_seat_added_copy ((CkLogSeatAddedEvent *) event,
+                                       (CkLogSeatAddedEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SEAT_REMOVED:
+                event_seat_removed_copy ((CkLogSeatRemovedEvent *) event,
+                                         (CkLogSeatRemovedEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                event_seat_session_added_copy ((CkLogSeatSessionAddedEvent *) event,
+                                               (CkLogSeatSessionAddedEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_REMOVED:
+                event_seat_session_removed_copy ((CkLogSeatSessionRemovedEvent *) event,
+                                                 (CkLogSeatSessionRemovedEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_ADDED:
+                event_seat_device_added_copy ((CkLogSeatDeviceAddedEvent *) event,
+                                              (CkLogSeatDeviceAddedEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_REMOVED:
+                event_seat_device_removed_copy ((CkLogSeatDeviceRemovedEvent *) event,
+                                                (CkLogSeatDeviceRemovedEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
+                event_seat_active_session_changed_copy ((CkLogSeatActiveSessionChangedEvent *) event,
+                                                        (CkLogSeatActiveSessionChangedEvent *) event_copy);
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+
+        return event_copy;
+}
+
+void
+ck_log_event_free (CkLogEvent *event)
+{
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_ADDED:
+                event_seat_added_free ((CkLogSeatAddedEvent *) event);
+                break;
+        case CK_LOG_EVENT_SEAT_REMOVED:
+                event_seat_removed_free ((CkLogSeatRemovedEvent *) event);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                event_seat_session_added_free ((CkLogSeatSessionAddedEvent *) event);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_REMOVED:
+                event_seat_session_removed_free ((CkLogSeatSessionRemovedEvent *) event);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_ADDED:
+                event_seat_device_added_free ((CkLogSeatDeviceAddedEvent *) event);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_REMOVED:
+                event_seat_device_removed_free ((CkLogSeatDeviceRemovedEvent *) event);
+                break;
+        case CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
+                event_seat_active_session_changed_free ((CkLogSeatActiveSessionChangedEvent *) event);
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+
+        g_free (event);
+}
+
+static void
+add_log_for_seat_added (GString    *str,
+                        CkLogEvent *event)
+{
+        CkLogSeatAddedEvent *e;
+
+        e = (CkLogSeatAddedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' seat-kind=%d",
+                                e->seat_id,
+                                e->seat_kind);
+}
+
+static void
+add_log_for_seat_removed (GString    *str,
+                          CkLogEvent *event)
+{
+        CkLogSeatRemovedEvent *e;
+
+        e = (CkLogSeatRemovedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' seat-kind=%d",
+                                e->seat_id,
+                                e->seat_kind);
+}
+
+static void
+add_log_for_seat_session_added (GString    *str,
+                                CkLogEvent *event)
+{
+        CkLogSeatSessionAddedEvent *e;
+
+        e = (CkLogSeatSessionAddedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' session-id='%s' session-type='%s' session-x11-display='%s' session-x11-display-device='%s' session-display-device='%s' session-remote-host-name='%s' session-is-local=%s session-unix-user=%u session-creation-time='%s'",
+                                e->seat_id ? e->seat_id : "",
+                                e->session_id ? e->session_id : "",
+                                e->session_type ? e->session_type : "",
+                                e->session_x11_display ? e->session_x11_display : "",
+                                e->session_x11_display_device ? e->session_x11_display_device : "",
+                                e->session_display_device ? e->session_display_device : "",
+                                e->session_remote_host_name ? e->session_remote_host_name : "",
+                                e->session_is_local ? "TRUE" : "FALSE",
+                                e->session_unix_user,
+                                e->session_creation_time ? e->session_creation_time : "");
+}
+
+static void
+add_log_for_seat_session_removed (GString    *str,
+                                  CkLogEvent *event)
+{
+        CkLogSeatSessionRemovedEvent *e;
+
+        e = (CkLogSeatSessionRemovedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' session-id='%s' session-type='%s' session-x11-display='%s' session-x11-display-device='%s' session-display-device='%s' session-remote-host-name='%s' session-is-local=%s session-unix-user=%u session-creation-time='%s'",
+                                e->seat_id ? e->seat_id : "",
+                                e->session_id ? e->session_id : "",
+                                e->session_type ? e->session_type : "",
+                                e->session_x11_display ? e->session_x11_display : "",
+                                e->session_x11_display_device ? e->session_x11_display_device : "",
+                                e->session_display_device ? e->session_display_device : "",
+                                e->session_remote_host_name ? e->session_remote_host_name : "",
+                                e->session_is_local ? "TRUE" : "FALSE",
+                                e->session_unix_user,
+                                e->session_creation_time ? e->session_creation_time : "");
+}
+
+static void
+add_log_for_seat_active_session_changed (GString    *str,
+                                         CkLogEvent *event)
+{
+        CkLogSeatActiveSessionChangedEvent *e;
+
+        e = (CkLogSeatActiveSessionChangedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' session-id='%s'",
+                                e->seat_id ? e->seat_id : "",
+                                e->session_id ? e->session_id : "");
+}
+
+static void
+add_log_for_seat_device_added (GString    *str,
+                               CkLogEvent *event)
+{
+        CkLogSeatDeviceAddedEvent *e;
+
+        e = (CkLogSeatDeviceAddedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' device-id='%s' device-type='%s'",
+                                e->seat_id ? e->seat_id : "",
+                                e->device_id ? e->device_id : "",
+                                e->device_type ? e->device_type : "");
+}
+
+static void
+add_log_for_seat_device_removed (GString    *str,
+                                 CkLogEvent *event)
+{
+        CkLogSeatDeviceRemovedEvent *e;
+
+        e = (CkLogSeatDeviceRemovedEvent *)event;
+        g_string_append_printf (str,
+                                " seat-id='%s' device-id='%s' device-type='%s'",
+                                e->seat_id ? e->seat_id : "",
+                                e->device_id ? e->device_id : "",
+                                e->device_type ? e->device_type : "");
+}
+
+static const char *
+event_type_to_name (CkLogEventType event_type)
+{
+        const char *str;
+        switch (event_type) {
+        case CK_LOG_EVENT_SEAT_ADDED:
+                str = "SEAT_ADDED";
+                break;
+        case CK_LOG_EVENT_SEAT_REMOVED:
+                str = "SEAT_REMOVED";
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                str = "SEAT_SESSION_ADDED";
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_REMOVED:
+                str = "SEAT_SESSION_REMOVED";
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_ADDED:
+                str = "SEAT_DEVICE_ADDED";
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_REMOVED:
+                str = "SEAT_DEVICE_REMOVED";
+                break;
+        case CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
+                str = "SEAT_ACTIVE_SESSION_CHANGED";
+                break;
+        default:
+                str = "UNKNOWN";
+                break;
+        }
+        return str;
+}
+
+static gboolean
+event_name_to_type (const char     *event_name,
+                    CkLogEventType *event_type)
+{
+        gboolean ret;
+
+        ret = TRUE;
+
+        if (strcmp (event_name, "SEAT_ADDED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_ADDED;
+        } else if (strcmp (event_name, "SEAT_REMOVED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_REMOVED;
+        } else if (strcmp (event_name, "SEAT_SESSION_ADDED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_SESSION_ADDED;
+        } else if (strcmp (event_name, "SEAT_SESSION_REMOVED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_SESSION_REMOVED;
+        } else if (strcmp (event_name, "SEAT_DEVICE_ADDED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_DEVICE_ADDED;
+        } else if (strcmp (event_name, "SEAT_DEVICE_REMOVED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_DEVICE_REMOVED;
+        } else if (strcmp (event_name, "SEAT_ACTIVE_SESSION_CHANGED") == 0) {
+                *event_type = CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED;
+        } else {
+                ret = FALSE;
+        }
+
+        return ret;
+}
+
+static void
+add_log_for_any (GString    *str,
+                 CkLogEvent *event)
+{
+        g_string_append_printf (str,
+                                "%lu.%03u type=%s :",
+                                (gulong)event->timestamp.tv_sec,
+                                (guint)(event->timestamp.tv_usec / 1000),
+                                event_type_to_name (event->type));
+}
+
+void
+ck_log_event_to_string (CkLogEvent  *event,
+                        GString     *str)
+{
+
+        add_log_for_any (str, event);
+
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_ADDED:
+                add_log_for_seat_added (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_REMOVED:
+                add_log_for_seat_removed (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                add_log_for_seat_session_added (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_REMOVED:
+                add_log_for_seat_session_removed (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_ADDED:
+                add_log_for_seat_device_added (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_REMOVED:
+                add_log_for_seat_device_removed (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
+                add_log_for_seat_active_session_changed (str, event);
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+}
+
+static char *
+skip_header (const char *str,
+             gssize      len)
+{
+        char *r;
+        r = g_strstr_len (str,
+                          len,
+                          " : ");
+        if (r != NULL) {
+                r += 3;
+        }
+
+        return r;
+}
+
+static gboolean
+parse_value_as_ulong (const char *value,
+                      gulong     *intval)
+{
+        char *end_of_valid_int;
+        glong ulong_value;
+
+        ulong_value = strtoul (value, &end_of_valid_int, 10);
+
+        if (*value == '\0' || *end_of_valid_int != '\0') {
+                return FALSE;
+        }
+
+        *intval = ulong_value;
+
+        return TRUE;
+}
+
+static gboolean
+parse_log_for_seat_added (const GString *str,
+                          CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        char       *tmp;
+        CkLogSeatAddedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' seat-kind=(?P<sessionid>[0-9]*)", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatAddedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+
+        tmp = g_match_info_fetch_named (match_info, "seatkind");
+        if (tmp != NULL) {
+                gulong l;
+                if (parse_value_as_ulong (tmp, &l)) {
+                        e->seat_kind = l;
+                }
+        }
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_seat_removed (const GString *str,
+                            CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        char       *tmp;
+        CkLogSeatRemovedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' seat-kind=(?P<sessionid>[0-9]*)", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatRemovedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+
+        tmp = g_match_info_fetch_named (match_info, "seatkind");
+        if (tmp != NULL) {
+                gulong l;
+                if (parse_value_as_ulong (tmp, &l)) {
+                        e->seat_kind = l;
+                }
+        }
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_seat_session_added (const GString *str,
+                                  CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        char       *tmp;
+        CkLogSeatSessionAddedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' session-id='(?P<sessionid>[a-zA-Z0-9/]+)' session-type='(?P<sessiontype>[a-zA-Z0-9 ]*)' session-x11-display='(?P<sessionx11display>[0-9a-zA-Z.:]*)' session-x11-display-device='(?P<sessionx11displaydevice>[^']*)' session-display-device='(?P<sessiondisplaydevice>[^']*)' session-remote-host-name='(?P<sessionremovehostname>[^']*)' session-is-local=(?P<sessionislocal>[a-zA-Z]*) session-unix-user=(?P<sessionunixuser>[0-9]*) session-creation-time='(?P<sessioncreationtime>[^']*)'", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatSessionAddedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+        e->session_id = g_match_info_fetch_named (match_info, "sessionid");
+        e->session_type = g_match_info_fetch_named (match_info, "sessiontype");
+        e->session_x11_display = g_match_info_fetch_named (match_info, "sessionx11display");
+        e->session_x11_display_device = g_match_info_fetch_named (match_info, "sessionx11displaydevice");
+        e->session_display_device = g_match_info_fetch_named (match_info, "sessiondisplaydevice");
+        e->session_remote_host_name = g_match_info_fetch_named (match_info, "sessionremotehostname");
+        e->session_creation_time = g_match_info_fetch_named (match_info, "sessioncreationtime");
+
+        tmp = g_match_info_fetch_named (match_info, "sessionislocal");
+        if (tmp != NULL && strcmp (tmp, "TRUE") == 0) {
+                e->session_is_local = TRUE;
+        } else {
+                e->session_is_local = FALSE;
+        }
+        g_free (tmp);
+
+        tmp = g_match_info_fetch_named (match_info, "sessionunixuser");
+        if (tmp != NULL) {
+                gulong l;
+                if (parse_value_as_ulong (tmp, &l)) {
+                        e->session_unix_user = l;
+                }
+        }
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_seat_session_removed (const GString *str,
+                                    CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        char       *tmp;
+        CkLogSeatSessionRemovedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' session-id='(?P<sessionid>[a-zA-Z0-9/]+)' session-type='(?P<sessiontype>[a-zA-Z0-9 ]*)' session-x11-display='(?P<sessionx11display>[0-9a-zA-Z.:]*)' session-x11-display-device='(?P<sessionx11displaydevice>[^']*)' session-display-device='(?P<sessiondisplaydevice>[^']*)' session-remote-host-name='(?P<sessionremovehostname>[^']*)' session-is-local=(?P<sessionislocal>[a-zA-Z]*) session-unix-user=(?P<sessionunixuser>[0-9]*) session-creation-time='(?P<sessioncreationtime>[^']*)'", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatSessionRemovedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+        e->session_id = g_match_info_fetch_named (match_info, "sessionid");
+        e->session_type = g_match_info_fetch_named (match_info, "sessiontype");
+        e->session_x11_display = g_match_info_fetch_named (match_info, "sessionx11display");
+        e->session_x11_display_device = g_match_info_fetch_named (match_info, "sessionx11displaydevice");
+        e->session_display_device = g_match_info_fetch_named (match_info, "sessiondisplaydevice");
+        e->session_remote_host_name = g_match_info_fetch_named (match_info, "sessionremotehostname");
+        e->session_creation_time = g_match_info_fetch_named (match_info, "sessioncreationtime");
+
+        tmp = g_match_info_fetch_named (match_info, "sessionislocal");
+        if (tmp != NULL && strcmp (tmp, "TRUE") == 0) {
+                e->session_is_local = TRUE;
+        } else {
+                e->session_is_local = FALSE;
+        }
+        g_free (tmp);
+
+        tmp = g_match_info_fetch_named (match_info, "sessionunixuser");
+        if (tmp != NULL) {
+                gulong l;
+                if (parse_value_as_ulong (tmp, &l)) {
+                        e->session_unix_user = l;
+                }
+        }
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_seat_active_session_changed (const GString *str,
+                                           CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        CkLogSeatActiveSessionChangedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' session-id='(?P<sessionid>[a-zA-Z0-9/]*)'", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatActiveSessionChangedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+        e->session_id = g_match_info_fetch_named (match_info, "sessionid");
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_seat_device_added (const GString *str,
+                                 CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        CkLogSeatDeviceAddedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' device-id='(?P<deviceid>[^']+)' device-type='(?P<devicetype>[^']+)'", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatDeviceAddedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+        e->device_id = g_match_info_fetch_named (match_info, "deviceid");
+        e->device_type = g_match_info_fetch_named (match_info, "devicetype");
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_seat_device_removed (const GString *str,
+                                   CkLogEvent    *event)
+{
+        gboolean    ret;
+        char       *s;
+        GRegex     *re;
+        GMatchInfo *match_info;
+        gboolean    res;
+        GError     *error;
+        CkLogSeatDeviceRemovedEvent *e;
+
+        re = NULL;
+        match_info = NULL;
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        error = NULL;
+        re = g_regex_new ("seat-id='(?P<seatid>[a-zA-Z0-9/]+)' device-id='(?P<deviceid>[^']+)' device-type='(?P<devicetype>[^']+)'", 0, 0, &error);
+        if (re == NULL) {
+                g_warning (error->message);
+                goto out;
+        }
+
+        g_regex_match (re, s, 0, &match_info);
+
+        res = g_match_info_matches (match_info);
+        if (! res) {
+                g_warning ("Unable to parse event: %s", s);
+                goto out;
+        }
+
+        e = (CkLogSeatDeviceRemovedEvent *)event;
+        e->seat_id = g_match_info_fetch_named (match_info, "seatid");
+        e->device_id = g_match_info_fetch_named (match_info, "deviceid");
+        e->device_type = g_match_info_fetch_named (match_info, "devicetype");
+
+        ret = TRUE;
+ out:
+        if (match_info != NULL) {
+                g_match_info_free (match_info);
+        }
+        if (re != NULL) {
+                g_regex_unref (re);
+        }
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_any (const GString *str,
+                   CkLogEvent    *event)
+{
+        gboolean ret;
+        int      res;
+        gulong   sec;
+        guint    frac;
+        char     buf[32];
+
+        ret = FALSE;
+
+        res = sscanf (str->str, "%lu.%u type=%30s :",
+                      &sec,
+                      &frac,
+                      buf);
+        if (res == 3) {
+                res = event_name_to_type (buf, &event->type);
+                if (! res) {
+                        goto out;
+                }
+
+                event->timestamp.tv_sec = sec;
+                event->timestamp.tv_usec = 1000 * frac;
+
+                ret = TRUE;
+        }
+ out:
+        return ret;
+}
+
+gboolean
+ck_log_event_fill_from_string (CkLogEvent    *event,
+                               const GString *str)
+{
+        gboolean res;
+        gboolean ret;
+
+        g_return_val_if_fail (str != NULL, FALSE);
+
+        ret = FALSE;
+
+        res = parse_log_for_any (str, event);
+        if (! res) {
+                goto out;
+        }
+
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_ADDED:
+                res = parse_log_for_seat_added (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_REMOVED:
+                res = parse_log_for_seat_removed (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                res = parse_log_for_seat_session_added (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_SESSION_REMOVED:
+                res = parse_log_for_seat_session_removed (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_ADDED:
+                res = parse_log_for_seat_device_added (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_DEVICE_REMOVED:
+                res = parse_log_for_seat_device_removed (str, event);
+                break;
+        case CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED:
+                res = parse_log_for_seat_active_session_changed (str, event);
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+        if (! res) {
+                goto out;
+        }
+        ret = TRUE;
+ out:
+        return ret;
+}
+
+CkLogEvent *
+ck_log_event_new_from_string (const GString *str)
+{
+        CkLogEvent *event;
+
+        g_return_val_if_fail (str != NULL, NULL);
+
+        event = g_new0 (CkLogEvent, 1);
+        ck_log_event_fill_from_string (event, str);
+
+        return event;
+}
diff --git a/src/ck-log-event.h b/src/ck-log-event.h
new file mode 100644
index 0000000..f5defed
--- /dev/null
+++ b/src/ck-log-event.h
@@ -0,0 +1,131 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * 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.
+ *
+ */
+
+#ifndef __CK_LOG_EVENT_H
+#define __CK_LOG_EVENT_H
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+typedef enum
+{
+        CK_LOG_EVENT_START = 0,
+        CK_LOG_EVENT_STOP,
+        CK_LOG_EVENT_SYSTEM_SHUTDOWN,
+        CK_LOG_EVENT_SYSTEM_RUNLEVEL_CHANGED,
+        CK_LOG_EVENT_SEAT_ADDED,
+        CK_LOG_EVENT_SEAT_REMOVED,
+        CK_LOG_EVENT_SEAT_SESSION_ADDED,
+        CK_LOG_EVENT_SEAT_SESSION_REMOVED,
+        CK_LOG_EVENT_SEAT_DEVICE_ADDED,
+        CK_LOG_EVENT_SEAT_DEVICE_REMOVED,
+        CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED,
+} CkLogEventType;
+
+typedef struct
+{
+        char *seat_id;
+        int   seat_kind;
+} CkLogSeatAddedEvent;
+
+typedef struct
+{
+        char *seat_id;
+        int   seat_kind;
+} CkLogSeatRemovedEvent;
+
+typedef struct
+{
+        char    *seat_id;
+        char    *session_id;
+        char    *session_type;
+        char    *session_x11_display;
+        char    *session_x11_display_device;
+        char    *session_display_device;
+        char    *session_remote_host_name;
+        gboolean session_is_local;
+        guint    session_unix_user;
+        char    *session_creation_time;
+} CkLogSeatSessionAddedEvent;
+
+typedef struct
+{
+        char    *seat_id;
+        char    *session_id;
+        char    *session_type;
+        char    *session_x11_display;
+        char    *session_x11_display_device;
+        char    *session_display_device;
+        char    *session_remote_host_name;
+        gboolean session_is_local;
+        guint    session_unix_user;
+        char    *session_creation_time;
+} CkLogSeatSessionRemovedEvent;
+
+typedef struct
+{
+        char    *seat_id;
+        char    *session_id;
+} CkLogSeatActiveSessionChangedEvent;
+
+typedef struct
+{
+        char *seat_id;
+        char *device_type;
+        char *device_id;
+} CkLogSeatDeviceAddedEvent;
+
+typedef struct
+{
+        char *seat_id;
+        char *device_type;
+        char *device_id;
+} CkLogSeatDeviceRemovedEvent;
+
+typedef struct
+{
+        union {
+                CkLogSeatAddedEvent seat_added;
+                CkLogSeatRemovedEvent seat_removed;
+                CkLogSeatSessionAddedEvent seat_session_added;
+                CkLogSeatSessionRemovedEvent seat_session_removed;
+                CkLogSeatActiveSessionChangedEvent seat_active_session_changed;
+                CkLogSeatDeviceAddedEvent seat_device_added;
+                CkLogSeatDeviceRemovedEvent seat_device_removed;
+        } event;
+
+        GTimeVal       timestamp;
+        CkLogEventType type;
+} CkLogEvent;
+
+CkLogEvent         * ck_log_event_copy             (CkLogEvent    *event);
+void                 ck_log_event_free             (CkLogEvent    *event);
+
+CkLogEvent         * ck_log_event_new_from_string  (const GString *str);
+gboolean             ck_log_event_fill_from_string (CkLogEvent    *event,
+                                                    const GString *str);
+
+void                 ck_log_event_to_string        (CkLogEvent    *event,
+                                                    GString       *str);
+
+G_END_DECLS
+
+#endif /* __CK_LOG_EVENT_H */
diff --git a/src/ck-manager.c b/src/ck-manager.c
index b3f1b63..0dba42a 100644
--- a/src/ck-manager.c
+++ b/src/ck-manager.c
@@ -394,15 +394,15 @@ static void
 log_seat_added_event (CkManager  *manager,
                       CkSeat     *seat)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
         CkSeatKind         seat_kind;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_ADDED;
+        event.type = CK_LOG_EVENT_SEAT_ADDED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
@@ -426,15 +426,15 @@ static void
 log_seat_removed_event (CkManager  *manager,
                         CkSeat     *seat)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
         CkSeatKind         seat_kind;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_REMOVED;
+        event.type = CK_LOG_EVENT_SEAT_REMOVED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
@@ -459,15 +459,15 @@ log_seat_session_added_event (CkManager  *manager,
                               CkSeat     *seat,
                               const char *ssid)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
         CkSession         *session;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED;
+        event.type = CK_LOG_EVENT_SEAT_SESSION_ADDED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
@@ -514,15 +514,15 @@ log_seat_session_removed_event (CkManager  *manager,
                                 CkSeat     *seat,
                                 const char *ssid)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
         CkSession         *session;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_SESSION_REMOVED;
+        event.type = CK_LOG_EVENT_SEAT_SESSION_REMOVED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
@@ -568,14 +568,14 @@ log_seat_active_session_changed_event (CkManager  *manager,
                                        CkSeat     *seat,
                                        const char *ssid)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_ACTIVE_SESSION_CHANGED;
+        event.type = CK_LOG_EVENT_SEAT_ACTIVE_SESSION_CHANGED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
@@ -599,7 +599,7 @@ log_seat_device_added_event (CkManager   *manager,
                              CkSeat      *seat,
                              GValueArray *device)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
@@ -607,9 +607,9 @@ log_seat_device_added_event (CkManager   *manager,
         char              *device_id;
         char              *device_type;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_ADDED;
+        event.type = CK_LOG_EVENT_SEAT_DEVICE_ADDED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
@@ -647,7 +647,7 @@ log_seat_device_removed_event (CkManager   *manager,
                                CkSeat      *seat,
                                GValueArray *device)
 {
-        CkEventLoggerEvent event;
+        CkLogEvent         event;
         gboolean           res;
         GError            *error;
         char              *sid;
@@ -655,9 +655,9 @@ log_seat_device_removed_event (CkManager   *manager,
         char              *device_id;
         char              *device_type;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_DEVICE_REMOVED;
+        event.type = CK_LOG_EVENT_SEAT_DEVICE_REMOVED;
         g_get_current_time (&event.timestamp);
 
         sid = NULL;
diff --git a/src/test-event-logger.c b/src/test-event-logger.c
index cc5d80b..e3d7db0 100644
--- a/src/test-event-logger.c
+++ b/src/test-event-logger.c
@@ -41,13 +41,13 @@
 static gboolean
 write_to_log (CkEventLogger    *logger)
 {
-        CkEventLoggerEvent event;
-        GError            *error;
-        gboolean           res;
+        CkLogEvent event;
+        GError    *error;
+        gboolean   res;
 
-        memset (&event, 0, sizeof (CkEventLoggerEvent));
+        memset (&event, 0, sizeof (CkLogEvent));
 
-        event.type = CK_EVENT_LOGGER_EVENT_SEAT_SESSION_ADDED;
+        event.type = CK_LOG_EVENT_SEAT_SESSION_ADDED;
         g_get_current_time (&event.timestamp);
 
         event.event.seat_session_added.session_id = "Session1";
diff --git a/tools/Makefile.am b/tools/Makefile.am
index 5283e18..ad9e589 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -26,6 +26,7 @@ INCLUDES =							\
 	-DLIBEXECDIR=\""$(libexecdir)"\"			\
 	-DDATADIR=\""$(datadir)"\"				\
 	-DSYSCONFDIR=\""$(sysconfdir)"\" 			\
+	-DLOCALSTATEDIR=\""$(localstatedir)"\" 			\
 	$(WARN_CFLAGS)						\
 	$(DEBUG_CFLAGS)						\
 	$(DBUS_CFLAGS)						\
@@ -33,6 +34,7 @@ INCLUDES =							\
 
 bin_PROGRAMS = \
 	ck-list-sessions		\
+	ck-history			\
 	$(NULL)
 
 ck_list_sessions_SOURCES =		\
@@ -43,6 +45,14 @@ ck_list_sessions_LDADD =		\
 	$(CONSOLE_KIT_LIBS)		\
 	$(NULL)
 
+ck_history_SOURCES =			\
+	ck-history.c			\
+	$(NULL)
+
+ck_history_LDADD =				\
+	$(CONSOLE_KIT_LIBS)			\
+	$(top_builddir)/src/libck-event-log.la	\
+	$(NULL)
 
 libexec_PROGRAMS = 			\
 	ck-collect-session-info		\
diff --git a/tools/ck-history.c b/tools/ck-history.c
new file mode 100644
index 0000000..9584ee1
--- /dev/null
+++ b/tools/ck-history.c
@@ -0,0 +1,157 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2007 William Jon McCann <mccann@jhu.edu>
+ *
+ * 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.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <pwd.h>
+#include <string.h>
+#include <errno.h>
+
+#include <locale.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include "ck-log-event.h"
+
+typedef enum {
+        REPORT_TYPE_SUMMARY = 0,
+} ReportType;
+
+#define DEFAULT_LOG_FILENAME LOCALSTATEDIR "/run/ConsoleKit/history"
+#define MAX_LINE_LEN 2048
+
+static GList *events = NULL;
+
+static gboolean
+process_event_line (const char *line)
+{
+        GString    *str;
+        CkLogEvent *event;
+
+        str = g_string_new (line);
+        event = ck_log_event_new_from_string (str);
+        g_string_free (str, TRUE);
+
+        if (event != NULL) {
+                events = g_list_prepend (events, event);
+        }
+
+        return TRUE;
+}
+
+static gboolean
+process_log_stream (FILE *fstream)
+{
+        char line[MAX_LINE_LEN];
+
+        while (fgets (line, sizeof (line), fstream) != NULL) {
+                if (strlen (line) == sizeof (line) - 1) {
+                        g_warning ("Log line truncated");
+                }
+
+                process_event_line (line);
+        }
+
+        return TRUE;
+}
+
+static gboolean
+process_log_file (const char *filename)
+{
+        FILE *f;
+
+        f = g_fopen (filename, "r");
+        if (f == NULL) {
+                g_warning ("Error opening %s (%s)\n",
+                           filename,
+                           g_strerror (errno));
+                return FALSE;
+        }
+
+        return process_log_stream (f);
+}
+
+static void
+generate_report (void)
+{
+        GList *l;
+
+        events = g_list_reverse (events);
+
+        for (l = events; l != NULL; l = l->next) {
+                CkLogEvent *event;
+                GString    *str;
+
+                event = l->data;
+                str = g_string_new (NULL);
+                ck_log_event_to_string (event, str);
+                g_print ("%s\n", str->str);
+                g_string_free (str, TRUE);
+        }
+}
+
+static void
+free_events (void)
+{
+        /* FIXME: */
+}
+
+int
+main (int    argc,
+      char **argv)
+{
+        GOptionContext     *context;
+        gboolean            retval;
+        GError             *error = NULL;
+        static gboolean     do_version = FALSE;
+        static GOptionEntry entries [] = {
+                { "version", 'V', 0, G_OPTION_ARG_NONE, &do_version, N_("Version of this application"), NULL },
+                { NULL }
+        };
+
+        context = g_option_context_new (NULL);
+        g_option_context_add_main_entries (context, entries, NULL);
+        retval = g_option_context_parse (context, &argc, &argv, &error);
+
+        g_option_context_free (context);
+
+        if (! retval) {
+                g_warning ("%s", error->message);
+                g_error_free (error);
+                exit (1);
+        }
+
+        if (do_version) {
+                g_print ("%s %s\n", argv [0], VERSION);
+                exit (1);
+        }
+
+        process_log_file (DEFAULT_LOG_FILENAME);
+        generate_report ();
+        free_events ();
+
+        return 0;
+}
diff --git a/tools/list-sessions.c b/tools/list-sessions.c
index 75828ed..746c2f7 100644
--- a/tools/list-sessions.c
+++ b/tools/list-sessions.c
@@ -55,10 +55,10 @@ get_int (DBusGProxy *proxy,
         gboolean res;
 
         error = NULL;
-	res = dbus_g_proxy_call (proxy,
-				 method,
-				 &error,
-				 G_TYPE_INVALID,
+        res = dbus_g_proxy_call (proxy,
+                                 method,
+                                 &error,
+                                 G_TYPE_INVALID,
                                  G_TYPE_INT, val,
                                  G_TYPE_INVALID);
         if (! res) {
@@ -78,10 +78,10 @@ get_path (DBusGProxy *proxy,
         gboolean res;
 
         error = NULL;
-	res = dbus_g_proxy_call (proxy,
-				 method,
-				 &error,
-				 G_TYPE_INVALID,
+        res = dbus_g_proxy_call (proxy,
+                                 method,
+                                 &error,
+                                 G_TYPE_INVALID,
                                  DBUS_TYPE_G_OBJECT_PATH, str,
                                  G_TYPE_INVALID);
         if (! res) {
@@ -101,10 +101,10 @@ get_string (DBusGProxy *proxy,
         gboolean res;
 
         error = NULL;
-	res = dbus_g_proxy_call (proxy,
-				 method,
-				 &error,
-				 G_TYPE_INVALID,
+        res = dbus_g_proxy_call (proxy,
+                                 method,
+                                 &error,
+                                 G_TYPE_INVALID,
                                  G_TYPE_STRING, str,
                                  G_TYPE_INVALID);
         if (! res) {
@@ -124,10 +124,10 @@ get_boolean (DBusGProxy *proxy,
         gboolean res;
 
         error = NULL;
-	res = dbus_g_proxy_call (proxy,
-				 method,
-				 &error,
-				 G_TYPE_INVALID,
+        res = dbus_g_proxy_call (proxy,
+                                 method,
+                                 &error,
+                                 G_TYPE_INVALID,
                                  G_TYPE_BOOLEAN, value,
                                  G_TYPE_INVALID);
         if (! res) {
@@ -175,7 +175,7 @@ list_session (DBusGConnection *connection,
         char       *short_sid;
         const char *short_ssid;
 
-	proxy = dbus_g_proxy_new_for_name (connection,
+        proxy = dbus_g_proxy_new_for_name (connection,
                                            CK_NAME,
                                            ssid,
                                            CK_SESSION_INTERFACE);
@@ -256,7 +256,7 @@ list_sessions (DBusGConnection *connection,
         GPtrArray  *sessions;
         int         i;
 
-	proxy = dbus_g_proxy_new_for_name (connection,
+        proxy = dbus_g_proxy_new_for_name (connection,
                                            CK_NAME,
                                            sid,
                                            CK_SEAT_INTERFACE);
@@ -267,13 +267,13 @@ list_sessions (DBusGConnection *connection,
         sessions = NULL;
 
         error = NULL;
-	res = dbus_g_proxy_call (proxy,
-				 "GetSessions",
-				 &error,
-				 G_TYPE_INVALID,
+        res = dbus_g_proxy_call (proxy,
+                                 "GetSessions",
+                                 &error,
+                                 G_TYPE_INVALID,
                                  dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH),
                                  &sessions,
-				 G_TYPE_INVALID);
+                                 G_TYPE_INVALID);
         if (! res) {
                 g_warning ("Failed to get list of sessions for %s: %s", sid, error->message);
                 g_error_free (error);
@@ -315,13 +315,13 @@ list_seats (DBusGConnection *connection)
         seats = NULL;
 
         error = NULL;
-	res = dbus_g_proxy_call (proxy,
-				 "GetSeats",
-				 &error,
-				 G_TYPE_INVALID,
+        res = dbus_g_proxy_call (proxy,
+                                 "GetSeats",
+                                 &error,
+                                 G_TYPE_INVALID,
                                  dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH),
                                  &seats,
-				 G_TYPE_INVALID);
+                                 G_TYPE_INVALID);
         if (! res) {
                 g_warning ("Failed to get list of seats: %s", error->message);
                 g_error_free (error);
@@ -387,5 +387,5 @@ main (int    argc,
 
         list_seats (connection);
 
-	return 0;
+        return 0;
 }