add support for logging start/stop/restart

Also enable reporting this information with ck-history.

4 files changed, 564 insertions, 169 deletions

diff --git a/src/ck-log-event.c b/src/ck-log-event.c
index 5cdaa95..172776e 100644
--- a/src/ck-log-event.c
+++ b/src/ck-log-event.c
@@ -47,6 +47,25 @@ event_seat_removed_free (CkLogSeatRemovedEvent *event)
 }
 
 static void
+event_system_stop_free (CkLogSystemStopEvent *event)
+{
+        g_assert (event != NULL);
+}
+
+static void
+event_system_restart_free (CkLogSystemRestartEvent *event)
+{
+        g_assert (event != NULL);
+}
+
+
+static void
+event_system_start_free (CkLogSystemStartEvent *event)
+{
+        g_assert (event != NULL);
+}
+
+static void
 event_seat_session_added_free (CkLogSeatSessionAddedEvent *event)
 {
         g_assert (event != NULL);
@@ -155,6 +174,31 @@ event_seat_removed_copy (CkLogSeatRemovedEvent *event,
 }
 
 static void
+event_system_stop_copy (CkLogSystemStopEvent *event,
+                        CkLogSystemStopEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+}
+
+static void
+event_system_restart_copy (CkLogSystemRestartEvent *event,
+                           CkLogSystemRestartEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+}
+
+
+static void
+event_system_start_copy (CkLogSystemStartEvent *event,
+                           CkLogSystemStartEvent *event_copy)
+{
+        g_assert (event != NULL);
+        g_assert (event_copy != NULL);
+}
+
+static void
 event_seat_session_added_copy (CkLogSeatSessionAddedEvent *event,
                                CkLogSeatSessionAddedEvent *event_copy)
 {
@@ -250,6 +294,18 @@ ck_log_event_copy (CkLogEvent *event)
                 event_seat_removed_copy ((CkLogSeatRemovedEvent *) event,
                                          (CkLogSeatRemovedEvent *) event_copy);
                 break;
+        case CK_LOG_EVENT_SYSTEM_STOP:
+                event_system_stop_copy ((CkLogSystemStopEvent *) event,
+                                        (CkLogSystemStopEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SYSTEM_RESTART:
+                event_system_restart_copy ((CkLogSystemRestartEvent *) event,
+                                           (CkLogSystemRestartEvent *) event_copy);
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                event_system_start_copy ((CkLogSystemStartEvent *) event,
+                                           (CkLogSystemStartEvent *) event_copy);
+                break;
         case CK_LOG_EVENT_SEAT_SESSION_ADDED:
                 event_seat_session_added_copy ((CkLogSeatSessionAddedEvent *) event,
                                                (CkLogSeatSessionAddedEvent *) event_copy);
@@ -288,6 +344,15 @@ ck_log_event_free (CkLogEvent *event)
         case CK_LOG_EVENT_SEAT_REMOVED:
                 event_seat_removed_free ((CkLogSeatRemovedEvent *) event);
                 break;
+        case CK_LOG_EVENT_SYSTEM_STOP:
+                event_system_stop_free ((CkLogSystemStopEvent *) event);
+                break;
+        case CK_LOG_EVENT_SYSTEM_RESTART:
+                event_system_restart_free ((CkLogSystemRestartEvent *) event);
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                event_system_start_free ((CkLogSystemStartEvent *) event);
+                break;
         case CK_LOG_EVENT_SEAT_SESSION_ADDED:
                 event_seat_session_added_free ((CkLogSeatSessionAddedEvent *) event);
                 break;
@@ -380,6 +445,34 @@ add_log_for_seat_session_removed (GString    *str,
 }
 
 static void
+add_log_for_system_stop (GString    *str,
+                         CkLogEvent *event)
+{
+        CkLogSystemStopEvent *e;
+
+        e = (CkLogSystemStopEvent *)event;
+}
+
+static void
+add_log_for_system_restart (GString    *str,
+                            CkLogEvent *event)
+{
+        CkLogSystemRestartEvent *e;
+
+        e = (CkLogSystemRestartEvent *)event;
+}
+
+
+static void
+add_log_for_system_start (GString    *str,
+                            CkLogEvent *event)
+{
+        CkLogSystemStartEvent *e;
+
+        e = (CkLogSystemStartEvent *)event;
+}
+
+static void
 add_log_for_seat_active_session_changed (GString    *str,
                                          CkLogEvent *event)
 {
@@ -431,6 +524,15 @@ event_type_to_name (CkLogEventType event_type)
         case CK_LOG_EVENT_SEAT_REMOVED:
                 str = "SEAT_REMOVED";
                 break;
+        case CK_LOG_EVENT_SYSTEM_STOP:
+                str = "SYSTEM_STOP";
+                break;
+        case CK_LOG_EVENT_SYSTEM_RESTART:
+                str = "SYSTEM_RESTART";
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                str = "SYSTEM_START";
+                break;
         case CK_LOG_EVENT_SEAT_SESSION_ADDED:
                 str = "SEAT_SESSION_ADDED";
                 break;
@@ -465,6 +567,12 @@ event_name_to_type (const char     *event_name,
                 *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, "SYSTEM_STOP") == 0) {
+                *event_type = CK_LOG_EVENT_SYSTEM_STOP;
+        } else if (strcmp (event_name, "SYSTEM_RESTART") == 0) {
+                *event_type = CK_LOG_EVENT_SYSTEM_RESTART;
+        } else if (strcmp (event_name, "SYSTEM_START") == 0) {
+                *event_type = CK_LOG_EVENT_SYSTEM_START;
         } 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) {
@@ -507,6 +615,15 @@ ck_log_event_to_string (CkLogEvent  *event,
         case CK_LOG_EVENT_SEAT_REMOVED:
                 add_log_for_seat_removed (str, event);
                 break;
+        case CK_LOG_EVENT_SYSTEM_STOP:
+                add_log_for_system_stop (str, event);
+                break;
+        case CK_LOG_EVENT_SYSTEM_RESTART:
+                add_log_for_system_restart (str, event);
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                add_log_for_system_start (str, event);
+                break;
         case CK_LOG_EVENT_SEAT_SESSION_ADDED:
                 add_log_for_seat_session_added (str, event);
                 break;
@@ -528,7 +645,7 @@ ck_log_event_to_string (CkLogEvent  *event,
         }
 }
 
-static char *
+static const char *
 skip_header (const char *str,
              gssize      len)
 {
@@ -566,7 +683,7 @@ parse_log_for_seat_added (const GString *str,
                           CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -626,7 +743,7 @@ parse_log_for_seat_removed (const GString *str,
                             CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -682,11 +799,80 @@ parse_log_for_seat_removed (const GString *str,
 }
 
 static gboolean
+parse_log_for_system_stop (const GString *str,
+                           CkLogEvent    *event)
+{
+        gboolean    ret;
+        const char *s;
+        CkLogSystemStopEvent *e;
+
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        e = (CkLogSystemStopEvent *)event;
+
+        ret = TRUE;
+ out:
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_system_restart (const GString *str,
+                              CkLogEvent    *event)
+{
+        gboolean    ret;
+        const char *s;
+        CkLogSystemRestartEvent *e;
+
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        e = (CkLogSystemRestartEvent *)event;
+
+        ret = TRUE;
+ out:
+
+        return ret;
+}
+
+static gboolean
+parse_log_for_system_start (const GString *str,
+                              CkLogEvent    *event)
+{
+        gboolean    ret;
+        const char *s;
+        CkLogSystemStartEvent *e;
+
+        ret = FALSE;
+
+        s = skip_header (str->str, str->len);
+        if (s == NULL) {
+                goto out;
+        }
+
+        e = (CkLogSystemStartEvent *)event;
+
+        ret = TRUE;
+ out:
+
+        return ret;
+}
+
+static gboolean
 parse_log_for_seat_session_added (const GString *str,
                                   CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -761,7 +947,7 @@ parse_log_for_seat_session_removed (const GString *str,
                                     CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -836,7 +1022,7 @@ parse_log_for_seat_active_session_changed (const GString *str,
                                            CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -888,7 +1074,7 @@ parse_log_for_seat_device_added (const GString *str,
                                  CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -941,7 +1127,7 @@ parse_log_for_seat_device_removed (const GString *str,
                                    CkLogEvent    *event)
 {
         gboolean    ret;
-        char       *s;
+        const char *s;
         GRegex     *re;
         GMatchInfo *match_info;
         gboolean    res;
@@ -1043,6 +1229,15 @@ ck_log_event_fill_from_string (CkLogEvent    *event,
         case CK_LOG_EVENT_SEAT_REMOVED:
                 res = parse_log_for_seat_removed (str, event);
                 break;
+        case CK_LOG_EVENT_SYSTEM_STOP:
+                res = parse_log_for_system_stop (str, event);
+                break;
+        case CK_LOG_EVENT_SYSTEM_RESTART:
+                res = parse_log_for_system_restart (str, event);
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                res = parse_log_for_system_start (str, event);
+                break;
         case CK_LOG_EVENT_SEAT_SESSION_ADDED:
                 res = parse_log_for_seat_session_added (str, event);
                 break;
diff --git a/src/ck-log-event.h b/src/ck-log-event.h
index f5defed..149f49b 100644
--- a/src/ck-log-event.h
+++ b/src/ck-log-event.h
@@ -29,7 +29,9 @@ typedef enum
 {
         CK_LOG_EVENT_START = 0,
         CK_LOG_EVENT_STOP,
-        CK_LOG_EVENT_SYSTEM_SHUTDOWN,
+        CK_LOG_EVENT_SYSTEM_START,
+        CK_LOG_EVENT_SYSTEM_STOP,
+        CK_LOG_EVENT_SYSTEM_RESTART,
         CK_LOG_EVENT_SYSTEM_RUNLEVEL_CHANGED,
         CK_LOG_EVENT_SEAT_ADDED,
         CK_LOG_EVENT_SEAT_REMOVED,
@@ -42,6 +44,18 @@ typedef enum
 
 typedef struct
 {
+} CkLogSystemStopEvent;
+
+typedef struct
+{
+} CkLogSystemRestartEvent;
+
+typedef struct
+{
+} CkLogSystemStartEvent;
+
+typedef struct
+{
         char *seat_id;
         int   seat_kind;
 } CkLogSeatAddedEvent;
@@ -103,6 +117,9 @@ typedef struct
 typedef struct
 {
         union {
+                CkLogSystemRestartEvent system_start;
+                CkLogSystemStopEvent system_stop;
+                CkLogSystemRestartEvent system_restart;
                 CkLogSeatAddedEvent seat_added;
                 CkLogSeatRemovedEvent seat_removed;
                 CkLogSeatSessionAddedEvent seat_session_added;
diff --git a/src/ck-manager.c b/src/ck-manager.c
index c7c045b..9d9c786 100644
--- a/src/ck-manager.c
+++ b/src/ck-manager.c
@@ -435,6 +435,50 @@ log_seat_removed_event (CkManager  *manager,
 }
 
 static void
+log_system_stop_event (CkManager  *manager)
+{
+        CkLogEvent         event;
+        gboolean           res;
+        GError            *error;
+
+        memset (&event, 0, sizeof (CkLogEvent));
+
+        event.type = CK_LOG_EVENT_SYSTEM_STOP;
+        g_get_current_time (&event.timestamp);
+
+        error = NULL;
+        res = ck_event_logger_queue_event (manager->priv->logger, &event, &error);
+        if (! res) {
+                g_debug ("Unable to log event: %s", error->message);
+                g_error_free (error);
+        }
+
+        /* FIXME: in this case we should block and wait for log to flush */
+}
+
+static void
+log_system_restart_event (CkManager  *manager)
+{
+        CkLogEvent         event;
+        gboolean           res;
+        GError            *error;
+
+        memset (&event, 0, sizeof (CkLogEvent));
+
+        event.type = CK_LOG_EVENT_SYSTEM_RESTART;
+        g_get_current_time (&event.timestamp);
+
+        error = NULL;
+        res = ck_event_logger_queue_event (manager->priv->logger, &event, &error);
+        if (! res) {
+                g_debug ("Unable to log event: %s", error->message);
+                g_error_free (error);
+        }
+
+        /* FIXME: in this case we should block and wait for log to flush */
+}
+
+static void
 log_seat_session_added_event (CkManager  *manager,
                               CkSeat     *seat,
                               const char *ssid)
@@ -1214,7 +1258,7 @@ get_system_num_users (CkManager *manager)
 
 #ifdef ENABLE_RBAC_SHUTDOWN
 static gboolean
-check_rbac_permissions (CkManager *manager,
+check_rbac_permissions (CkManager             *manager,
                         DBusGMethodInvocation *context)
 {
         const char *sender;
@@ -1243,10 +1287,11 @@ check_rbac_permissions (CkManager *manager,
 
 out:
 
-        if (res == TRUE)
+        if (res == TRUE) {
                 g_debug ("User %s has RBAC permission to stop/restart", username);
-        else
+        } else {
                 g_debug ("User %s does not have RBAC permission to stop/restart", username);
+        }
 
         g_free (username);
         return res;
@@ -1287,12 +1332,15 @@ ck_manager_restart (CkManager             *manager,
 #endif
 
 #ifdef ENABLE_RBAC_SHUTDOWN
-        if (!check_rbac_permissions (manager, context))
+        if (! check_rbac_permissions (manager, context)) {
                 goto out;
+        }
 #endif
 
         g_debug ("ConsoleKit preforming Restart: %s", action);
 
+        log_system_restart_event (manager);
+
         error = NULL;
         res = g_spawn_command_line_async (LIBDIR "/ConsoleKit/scripts/ck-system-restart",
                                           &error);
@@ -1348,6 +1396,9 @@ ck_manager_stop (CkManager             *manager,
 #endif
 
         g_debug ("Stopping system");
+
+        log_system_stop_event (manager);
+
         error = NULL;
         res = g_spawn_command_line_async (LIBDIR "/ConsoleKit/scripts/ck-system-stop",
                                           &error);
diff --git a/tools/ck-history.c b/tools/ck-history.c
index 7257c7c..8f96a9b 100644
--- a/tools/ck-history.c
+++ b/tools/ck-history.c
@@ -46,6 +46,17 @@ typedef enum {
         REPORT_TYPE_LOG,
 } ReportType;
 
+/* same record types as sysvinit last */
+typedef enum {
+        RECORD_STATUS_CRASH = 1,  /* No logout record, system boot in between */
+        RECORD_STATUS_DOWN,       /* System brought down in decent way */
+        RECORD_STATUS_NORMAL,     /* Normal */
+        RECORD_STATUS_NOW,        /* Still logged in */
+        RECORD_STATUS_REBOOT,     /* Reboot record. */
+        RECORD_STATUS_PHANTOM,    /* No logout record but session is stale. */
+        RECORD_STATUS_TIMECHANGE, /* NEW_TIME or OLD_TIME */
+} RecordStatus;
+
 #define DEFAULT_LOG_FILENAME LOCALSTATEDIR "/log/ConsoleKit/history"
 #define MAX_LINE_LEN 2048
 
@@ -221,16 +232,28 @@ find_first_matching_remove_event (GList                      *events,
         revent = NULL;
 
         for (l = events; l != NULL; l = l->next) {
-                CkLogSeatSessionRemovedEvent *e;
-
-                if (((CkLogEvent *)l->data)->type != CK_LOG_EVENT_SEAT_SESSION_REMOVED) {
+                CkLogEventType etype;
+
+                etype = ((CkLogEvent *)l->data)->type;
+                /* skip all non removal events */
+                if (etype != CK_LOG_EVENT_SEAT_SESSION_REMOVED
+                    || etype == CK_LOG_EVENT_SYSTEM_START
+                    || etype == CK_LOG_EVENT_SYSTEM_STOP
+                    || etype == CK_LOG_EVENT_SYSTEM_RESTART) {
                         continue;
                 }
-                e = l->data;
 
-                if (e->session_id != NULL
-                    && event->session_id != NULL
-                    && strcmp (e->session_id, event->session_id) == 0) {
+                if (etype == CK_LOG_EVENT_SEAT_SESSION_REMOVED) {
+                        CkLogSeatSessionRemovedEvent *e;
+                        e = l->data;
+
+                        if (e->session_id != NULL
+                            && event->session_id != NULL
+                            && strcmp (e->session_id, event->session_id) == 0) {
+                                revent = (CkLogEvent *)l->data;
+                                break;
+                        }
+                } else {
                         revent = (CkLogEvent *)l->data;
                         break;
                 }
@@ -275,119 +298,284 @@ get_uid_for_username (const char *username)
 }
 
 static char *
-get_utline_for_event (CkLogSeatSessionAddedEvent *e)
+get_utline_for_event (CkLogEvent *event)
 {
         char *utline;
 
         utline = NULL;
 
-        if (e->session_x11_display != NULL && e->session_x11_display[0] != '\0') {
-                utline = g_strdup (e->session_x11_display);
-        } else {
-                if (g_str_has_prefix (e->session_display_device, "/dev/")) {
-                        utline = g_strdup (e->session_display_device + 5);
-                } else {
-                        utline = g_strdup (e->session_display_device);
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                {
+                        CkLogSeatSessionAddedEvent *e;
+                        e = (CkLogSeatSessionAddedEvent *)event;
+                        if (e->session_x11_display != NULL && e->session_x11_display[0] != '\0') {
+                                utline = g_strdup (e->session_x11_display);
+                        } else {
+                                if (g_str_has_prefix (e->session_display_device, "/dev/")) {
+                                        utline = g_strdup (e->session_display_device + 5);
+                                } else {
+                                        utline = g_strdup (e->session_display_device);
+                                }
+                        }
                 }
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                utline = g_strdup ("system boot");
+                break;
+        default:
+                g_assert_not_reached ();
         }
 
         return utline;
 }
 
-static void
-generate_report_last (int         uid,
-                      const char *seat,
-                      const char *session_type)
+static char *
+get_user_name_for_event (CkLogEvent *event)
 {
-        GList      *oldest;
-        CkLogEvent *oldest_event;
-        GList      *l;
+        char *username;
 
-        /* print events in reverse time order */
+        username = NULL;
 
-        for (l = g_list_last (all_events); l != NULL; l = l->prev) {
-                CkLogEvent                 *event;
-                GString                    *str;
-                char                       *username;
-                char                       *utline;
-                char                       *addedtime;
-                char                       *removedtime;
-                char                       *duration;
-                CkLogSeatSessionAddedEvent *e;
-                CkLogEvent                 *remove_event;
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                username = get_user_name_for_uid (((CkLogSeatSessionAddedEvent *)event)->session_unix_user);
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                username = g_strdup ("reboot");
+                break;
+        default:
+                g_assert_not_reached ();
+        }
 
-                event = l->data;
+        return username;
+}
 
-                if (event->type != CK_LOG_EVENT_SEAT_SESSION_ADDED) {
-                        continue;
-                }
+static char *
+get_host_for_event (CkLogEvent *event)
+{
+        char *username;
+
+        username = NULL;
+
+        switch (event->type) {
+        case CK_LOG_EVENT_SEAT_SESSION_ADDED:
+                username = g_strdup (((CkLogSeatSessionAddedEvent *)event)->session_remote_host_name);
+                break;
+        case CK_LOG_EVENT_SYSTEM_START:
+                /* FIXME: get kernel version */
+                username = g_strdup ("");
+                break;
+        default:
+                g_assert_not_reached ();
+        }
+
+        return username;
+}
+
+static RecordStatus
+get_event_record_status (CkLogEvent *remove_event)
+{
+        RecordStatus status;
+
+        status = RECORD_STATUS_NOW;
+
+        if (remove_event == NULL) {
+                goto out;
+        }
+
+        if (remove_event->type == CK_LOG_EVENT_SEAT_SESSION_REMOVED) {
+                status = RECORD_STATUS_NORMAL;
+        } else if (remove_event->type == CK_LOG_EVENT_SYSTEM_START) {
+                status = RECORD_STATUS_CRASH;
+        } else if (remove_event->type == CK_LOG_EVENT_SYSTEM_STOP) {
+                status = RECORD_STATUS_DOWN;
+        } else if (remove_event->type == CK_LOG_EVENT_SYSTEM_RESTART) {
+                status = RECORD_STATUS_DOWN;
+        }
+
+ out:
+        return status;
+}
+
+static char *
+get_duration (CkLogEvent *event,
+              CkLogEvent *remove_event)
+{
+        time_t secs;
+        int    mins;
+        int    hours;
+        int    days;
+        char  *duration;
+
+        secs = remove_event->timestamp.tv_sec - event->timestamp.tv_sec;
+        mins  = (secs / 60) % 60;
+        hours = (secs / 3600) % 24;
+        days  = secs / 86400;
+        if (days > 0) {
+                duration = g_strdup_printf ("(%d+%02d:%02d)", days, hours, mins);
+        } else {
+                duration = g_strdup_printf (" (%02d:%02d)", hours, mins);
+        }
+        return duration;
+}
+
+static void
+print_last_report_record (GList      *list,
+                          CkLogEvent *event,
+                          gboolean    legacy_compat)
+{
+        GString                    *str;
+        char                       *username;
+        char                       *utline;
+        char                       *host;
+        char                       *addedtime;
+        char                       *removedtime;
+        char                       *duration;
+        char                       *session_type;
+        char                       *session_id;
+        char                       *seat_id;
+        CkLogSeatSessionAddedEvent *e;
+        CkLogEvent                 *remove_event;
+        RecordStatus                status;
+
+        if (event->type != CK_LOG_EVENT_SEAT_SESSION_ADDED
+            && event->type != CK_LOG_EVENT_SYSTEM_START) {
+                return;
+        }
 
+        remove_event = NULL;
+
+        if (event->type == CK_LOG_EVENT_SEAT_SESSION_ADDED) {
                 e = (CkLogSeatSessionAddedEvent *)event;
 
+                remove_event = find_first_matching_remove_event (list, e);
+                status = get_event_record_status (remove_event);
 
-                if (uid >= 0 && e->session_unix_user != uid) {
-                        continue;
-                }
+                session_type = e->session_type;
+                session_id = e->session_id;
+                seat_id = e->seat_id;
+        } else {
+                status = RECORD_STATUS_REBOOT;
 
-                if (seat != NULL && strcmp (e->seat_id, seat) != 0) {
-                        continue;
-                }
+                session_type = "";
+                session_id = "";
+                seat_id = "";
+        }
 
-                if (session_type != NULL && strcmp (e->session_type, session_type) != 0) {
-                        continue;
-                }
+        str = g_string_new (NULL);
 
-                str = g_string_new (NULL);
+        username = get_user_name_for_event (event);
+        utline = get_utline_for_event (event);
+        host = get_host_for_event (event);
 
-                username = get_user_name_for_uid (e->session_unix_user);
-                utline = get_utline_for_event (e);
+        addedtime = g_strndup (ctime (&event->timestamp.tv_sec), 16);
 
-                addedtime = g_strndup (ctime (&event->timestamp.tv_sec), 16);
+        if (legacy_compat) {
+                g_string_printf (str,
+                                 "%-8.8s %-12.12s %-16.16s %-16.16s",
+                                 username,
+                                 utline != NULL ? utline : "",
+                                 host != NULL ? host : "",
+                                 addedtime);
+        } else {
                 g_string_printf (str,
                                  "%-8.8s %12s %-10.10s %-7.7s %-12.12s %-16.16s %-16.16s",
                                  username,
-                                 e->session_type,
-                                 e->session_id,
-                                 e->seat_id,
+                                 session_type,
+                                 session_id,
+                                 seat_id,
                                  utline,
-                                 e->session_remote_host_name ? e->session_remote_host_name : "",
+                                 host != NULL ? host : "",
                                  addedtime);
-                g_free (username);
-                g_free (addedtime);
-                g_free (utline);
-
-                remove_event = find_first_matching_remove_event (l, e);
-                if (remove_event != NULL) {
-                        time_t secs;
-                        int    mins;
-                        int    hours;
-                        int    days;
-
-                        removedtime = g_strdup_printf ("- %s", ctime (&remove_event->timestamp.tv_sec) + 11);
-                        removedtime[7] = 0;
-                        secs = remove_event->timestamp.tv_sec - event->timestamp.tv_sec;
-                        mins  = (secs / 60) % 60;
-                        hours = (secs / 3600) % 24;
-                        days  = secs / 86400;
-                        if (days > 0) {
-                                duration = g_strdup_printf ("(%d+%02d:%02d)", days, hours, mins);
-                        } else {
-                                duration = g_strdup_printf (" (%02d:%02d)", hours, mins);
+        }
+
+        g_free (username);
+        g_free (addedtime);
+        g_free (utline);
+        g_free (host);
+
+        removedtime = NULL;
+        duration = NULL;
+
+        switch (status) {
+        case RECORD_STATUS_CRASH:
+                duration = get_duration (event, remove_event);
+                removedtime = g_strdup ("- crash");
+                break;
+        case RECORD_STATUS_DOWN:
+                duration = get_duration (event, remove_event);
+                removedtime = g_strdup ("- down ");
+                break;
+        case RECORD_STATUS_NOW:
+                duration = g_strdup ("logged in");
+                removedtime = g_strdup ("  still");
+                break;
+        case RECORD_STATUS_PHANTOM:
+                duration = g_strdup ("- no logout");
+                removedtime = g_strdup ("   gone");
+                break;
+        case RECORD_STATUS_REBOOT:
+                removedtime = g_strdup ("");
+                break;
+        case RECORD_STATUS_TIMECHANGE:
+                removedtime = g_strdup ("");
+                break;
+        case RECORD_STATUS_NORMAL:
+                duration = get_duration (event, remove_event);
+                removedtime = g_strdup_printf ("- %s", ctime (&remove_event->timestamp.tv_sec) + 11);
+                removedtime[7] = 0;
+                break;
+        default:
+                g_assert_not_reached ();
+                break;
+        }
+
+        g_string_append_printf (str,
+                                " %-7.7s %-12.12s",
+                                removedtime,
+                                duration);
+
+        g_print ("%s\n", str->str);
+        g_string_free (str, TRUE);
+        g_free (removedtime);
+        g_free (duration);
+}
+
+static void
+generate_report_last (int         uid,
+                      const char *seat,
+                      const char *session_type)
+{
+        GList      *oldest;
+        CkLogEvent *oldest_event;
+        GList      *l;
+
+        /* print events in reverse time order */
+
+        for (l = g_list_last (all_events); l != NULL; l = l->prev) {
+                CkLogEvent *event;
+
+                event = l->data;
+
+                if (event->type == CK_LOG_EVENT_SEAT_SESSION_ADDED) {
+                        CkLogSeatSessionAddedEvent *e;
+                        e = (CkLogSeatSessionAddedEvent *)event;
+
+                        if (uid >= 0 && e->session_unix_user != uid) {
+                                continue;
                         }
-                } else {
-                        removedtime = g_strdup ("  still");
-                        duration = g_strdup ("logged in");
-                }
 
-                g_string_append_printf (str,
-                                        " %-7.7s %-12.12s",
-                                        removedtime,
-                                        duration);
+                        if (seat != NULL && strcmp (e->seat_id, seat) != 0) {
+                                continue;
+                        }
 
-                g_print ("%s\n", str->str);
-                g_string_free (str, TRUE);
-                g_free (removedtime);
-                g_free (duration);
+                        if (session_type != NULL && strcmp (e->session_type, session_type) != 0) {
+                                continue;
+                        }
+                }
+
+                print_last_report_record (l, event, FALSE);
         }
 
         oldest = g_list_first (all_events);
@@ -409,84 +597,28 @@ generate_report_last_compat (int         uid,
         /* print events in reverse time order */
 
         for (l = g_list_last (all_events); l != NULL; l = l->prev) {
-                CkLogEvent                 *event;
-                GString                    *str;
-                char                       *username;
-                char                       *utline;
-                char                       *addedtime;
-                char                       *removedtime;
-                char                       *duration;
-                CkLogSeatSessionAddedEvent *e;
-                CkLogEvent                 *remove_event;
+                CkLogEvent *event;
 
                 event = l->data;
 
-                if (event->type != CK_LOG_EVENT_SEAT_SESSION_ADDED) {
-                        continue;
-                }
-
-                e = (CkLogSeatSessionAddedEvent *)event;
-
-                if (uid >= 0 && e->session_unix_user != uid) {
-                        continue;
-                }
-
-                if (seat != NULL && strcmp (e->seat_id, seat) != 0) {
-                        continue;
-                }
+                if (event->type == CK_LOG_EVENT_SEAT_SESSION_ADDED) {
+                        CkLogSeatSessionAddedEvent *e;
+                        e = (CkLogSeatSessionAddedEvent *)event;
 
-                if (session_type != NULL && strcmp (e->session_type, session_type) != 0) {
-                        continue;
-                }
-
-                str = g_string_new (NULL);
+                        if (uid >= 0 && e->session_unix_user != uid) {
+                                continue;
+                        }
 
-                username = get_user_name_for_uid (e->session_unix_user);
-                utline = get_utline_for_event (e);
+                        if (seat != NULL && strcmp (e->seat_id, seat) != 0) {
+                                continue;
+                        }
 
-                addedtime = g_strndup (ctime (&event->timestamp.tv_sec), 16);
-                g_string_printf (str,
-                                 "%-8.8s %-12.12s %-16.16s %-16.16s",
-                                 username,
-                                 utline,
-                                 e->session_remote_host_name ? e->session_remote_host_name : "",
-                                 addedtime);
-                g_free (username);
-                g_free (addedtime);
-                g_free (utline);
-
-                remove_event = find_first_matching_remove_event (l, e);
-                if (remove_event != NULL) {
-                        time_t secs;
-                        int    mins;
-                        int    hours;
-                        int    days;
-
-                        removedtime = g_strdup_printf ("- %s", ctime (&remove_event->timestamp.tv_sec) + 11);
-                        removedtime[7] = 0;
-                        secs = remove_event->timestamp.tv_sec - event->timestamp.tv_sec;
-                        mins  = (secs / 60) % 60;
-                        hours = (secs / 3600) % 24;
-                        days  = secs / 86400;
-                        if (days > 0) {
-                                duration = g_strdup_printf ("(%d+%02d:%02d)", days, hours, mins);
-                        } else {
-                                duration = g_strdup_printf (" (%02d:%02d)", hours, mins);
+                        if (session_type != NULL && strcmp (e->session_type, session_type) != 0) {
+                                continue;
                         }
-                } else {
-                        removedtime = g_strdup ("  still");
-                        duration = g_strdup ("logged in");
                 }
 
-                g_string_append_printf (str,
-                                        " %-7.7s %-12.12s",
-                                        removedtime,
-                                        duration);
-
-                g_print ("%s\n", str->str);
-                g_string_free (str, TRUE);
-                g_free (removedtime);
-                g_free (duration);
+                print_last_report_record (l, event, TRUE);
         }
 
         oldest = g_list_first (all_events);