Merge lp:~xnox/ubuntu/trusty/plymouth/private-upstart-socket into lp:ubuntu/trusty/plymouth

[Dimitri John Ledkov]

* debian/patches/use-upstart-private-socket.patch: instead of using
  system dbus, use private upstart socket in the plymouth-upstart-bridge.
* debian/plymouth.plymouth-upstart-bridge.upstart: start
  plymouth-upstart-bridge on startup, and thus gather a more complete
  boot.log.
* debian/patches/dont-bail-on-dummy-terms.patch: don't bail
  plymouth-upstart-bridge if TERM is not set and/or running on a dummy
  terminal, as we can run on those. This makes console-log useful in
  lxc-containers and actually contain messages from upstart jobs
  starting and stopping.
* debian/patches/no-print-empty-description.patch: do not store
  description when dbus returns empty string, and thus stop printing
  empty "Starting... done" messages.
* debian/plymouth.plymouth-upstart-bridge.upstart: update stop on
  conditions to stop when plymouth-shutdown finishes.
* Make ubuntu-logo theme support scale factor, provide one plymouth
  theme with scale 1 and another with scale 2, until scale factor can be
  dynamically detected.
* Mark plymouth-upstart-bridge to respawn.

First this patch series fixes to use upstart private socket, and thus able to start on startup. That was mostly removing code to deal with system-bus, looking up nameowner, and monitoring nameowner changes.

Next I've tried testing plymouth-upstart-bridge in an lxc container, only to notice that it didn't work, thus i fixed running plymouth-upstart-bridge when $TERM is not set.

This resulted in loads of empty messages, but it was never intended to print empty messages, so i've fixed that (dbus returns empty string, not NULL).

And i've also removed description stanza from the startpar bridge (separate upload) such that one does not get extra messages about startpar bridge firing, for every upstart job that is printed.

One now gets a more complete /var/log/boot.log on more ubuntu configurations.

For HiDPI support, I've tweaked ubuntu-logo theme to support "scalingfactor" for all loaded images/text/layout, and generated one theme with scalingfactor set to 1 (same as current theme) and another one with scalingfactor set to 2 to support highdpi screens via update-alternatives, until we get scalingfactor detection and passing that to plymouth.

[lp:~xnox/ubuntu/trusty/plymouth/private-upstart-socket]

1473. By Dimitri John Ledkov on 2014-03-13

system dbus, use private upstart socket in the plymouth-upstart-bridge.
* debian/patches/dont-bail-on-dummy-terms.patch: don't bail
plymouth-upstart-bridge if TERM is not set and/or running on a dummy
terminal, as we can run on those.

1474. By Dimitri John Ledkov on 2014-03-13

* debian/patches/no-print-empty-description.patch: do not store
description when dbus returns empty string, and thus stop printing
empty "Starting... done" messages.

1475. By Dimitri John Ledkov on 2014-03-13

debian/plymouth.plymouth-upstart-bridge.upstart: update stop on
conditions to stop when plymouth-shutdown finishes.

1476. By Dimitri John Ledkov on 2014-03-13

  empty "Starting... done" messages. LP: #1185560.

1477. By Dimitri John Ledkov on 2014-03-13

Make ubuntu-logo theme support scale factor, provide one plymouth
theme with scale 1 and another with scale 2, until scale factor can be
dynamically detected.

1478. By Dimitri John Ledkov on 2014-03-13

Mark plymouth-upstart-bridge to respawn.

1479. By Dimitri John Ledkov on 2014-03-13

Fix up scale-factor-2 patch

1480. By Dimitri John Ledkov on 2014-03-14

[ Dimitri John Ledkov ] LP: #1292458

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-12-02 04:53:37 +0000
+++ .pc/applied-patches	2014-03-14 10:43:52 +0000
@@ -13,3 +13,7 @@
 Miscellaneous-fixes-for-compiler-warnings.patch
 autoreconf.patch
 details-update-status.patch
+use-upstart-private-socket.patch
+dont-bail-on-dummy-terms.patch
+no-print-empty-description.patch
+ubuntu-logo-scale-factor-2.patch

=== added directory '.pc/dont-bail-on-dummy-terms.patch'
=== added directory '.pc/dont-bail-on-dummy-terms.patch/src'
=== added directory '.pc/dont-bail-on-dummy-terms.patch/src/upstart-bridge'
=== added file '.pc/dont-bail-on-dummy-terms.patch/src/upstart-bridge/plymouth-upstart-bridge.c'
--- .pc/dont-bail-on-dummy-terms.patch/src/upstart-bridge/plymouth-upstart-bridge.c	1970-01-01 00:00:00 +0000
+++ .pc/dont-bail-on-dummy-terms.patch/src/upstart-bridge/plymouth-upstart-bridge.c	2014-03-14 10:43:52 +0000
@@ -0,0 +1,339 @@
+/* plymouth-upstart-bridge.c - bridge Upstart job state changes to Plymouth
+ *
+ * Copyright (C) 2010, 2011 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by: Colin Watson <[e-mail]>
+ */
+#include "config.h"
+
+#include <stdbool.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#if defined(HAVE_NCURSESW_TERM_H)
+#include <ncursesw/term.h>
+#elif defined(HAVE_NCURSES_TERM_H)
+#include <ncurses/term.h>
+#else
+#include <term.h>
+#endif
+
+#include "ply-boot-client.h"
+#include "ply-command-parser.h"
+#include "ply-event-loop.h"
+#include "ply-logger.h"
+#include "ply-upstart-monitor.h"
+
+typedef struct
+{
+  ply_event_loop_t      *loop;
+  ply_boot_client_t     *client;
+  ply_upstart_monitor_t *upstart;
+  ply_command_parser_t  *command_parser;
+} state_t;
+
+#ifndef TERMINAL_COLOR_RED
+#define TERMINAL_COLOR_RED 1
+#endif
+
+/* We don't care about the difference between "not a string capability" and
+ * "cancelled or absent".
+ */
+static const char *
+get_string_capability (const char *name)
+{
+  const char *value;
+
+  value = tigetstr ((char *) name);
+  if (value == (const char *) -1)
+    value = NULL;
+
+  return value;
+}
+
+static bool
+terminal_ignores_new_line_after_80_chars (void)
+{
+  return tigetflag ((char *) "xenl") != 0;
+}
+
+static int
+get_number_of_columns (void)
+{
+  int number_of_columns;
+
+  number_of_columns = tigetnum ((char *) "cols");
+
+  return number_of_columns;
+}
+
+static bool
+can_set_cursor_column (void)
+{
+  const char *capability;
+
+  capability = get_string_capability ("hpa");
+
+  return capability != NULL;
+}
+
+static void
+set_cursor_column (int column)
+{
+  const char *capability;
+  const char *terminal_string;
+
+  capability = get_string_capability ("hpa");
+  terminal_string = tiparm (capability, column);
+  fputs (terminal_string, stdout);
+}
+
+static bool
+can_set_fg_color (void)
+{
+  const char *capability;
+
+  capability = get_string_capability ("setaf");
+
+  return capability != NULL;
+}
+
+static void
+set_fg_color (int color)
+{
+  const char *capability;
+  const char *terminal_string;
+
+  capability = get_string_capability ("setaf");
+  terminal_string = tiparm (capability, color);
+  fputs (terminal_string, stdout);
+}
+
+static void
+unset_fg_color (void)
+{
+  const char *terminal_string;
+
+  terminal_string = get_string_capability ("op");
+
+  if (terminal_string == NULL)
+    return;
+
+  fputs (terminal_string, stdout);
+}
+
+static void
+update_status (state_t                                   *state,
+               ply_upstart_monitor_job_properties_t      *job,
+               ply_upstart_monitor_instance_properties_t *instance,
+               const char                                *action,
+               bool                                       is_okay)
+{
+  ply_boot_client_update_daemon (state->client, job->name, NULL, NULL, state);
+
+  if (job->description == NULL)
+    return;
+
+  printf (" * %s%s%s",
+          action ? action : "", action ? " " : "", job->description);
+
+  if (terminal_ignores_new_line_after_80_chars () && can_set_cursor_column ())
+    {
+      int number_of_columns, column;
+
+      number_of_columns = get_number_of_columns ();
+
+      if (number_of_columns < (int) strlen("[fail]"))
+        number_of_columns = 80;
+
+      column = number_of_columns - strlen ("[fail]") - 1;
+
+      set_cursor_column (column);
+
+      if (is_okay)
+        puts ("[ OK ]");
+      else
+        {
+          bool supports_color;
+
+          supports_color = can_set_fg_color ();
+
+          fputs ("[", stdout);
+
+          if (supports_color)
+            set_fg_color (TERMINAL_COLOR_RED);
+
+          fputs ("fail", stdout);
+
+          if (supports_color)
+            unset_fg_color ();
+
+          puts ("]");
+        }
+    }
+  else
+    {
+      if (is_okay)
+        puts ("   ...done.");
+      else
+        puts ("   ...fail!");
+    }
+}
+
+static void
+on_failed (void                                      *data,
+           ply_upstart_monitor_job_properties_t      *job,
+           ply_upstart_monitor_instance_properties_t *instance,
+           int                                        status)
+{
+  state_t *state = data;
+
+  if (job->is_task)
+    update_status (state, job, instance, NULL, false);
+  else
+    {
+      if (strcmp (instance->goal, "start") == 0)
+        update_status (state, job, instance, "Starting", false);
+      else if (strcmp (instance->goal, "stop") == 0)
+        update_status (state, job, instance, "Stopping", false);
+    }
+}
+
+static void
+on_state_changed (state_t                                   *state,
+                  const char                                *old_state,
+                  ply_upstart_monitor_job_properties_t      *job,
+                  ply_upstart_monitor_instance_properties_t *instance)
+{
+  if (instance->failed)
+    return;
+
+  if (job->is_task)
+    {
+      if (strcmp (instance->state, "waiting") == 0)
+        update_status (state, job, instance, NULL, true);
+    }
+  else
+    {
+      if (strcmp (instance->goal, "start") == 0)
+        {
+          if (strcmp (instance->state, "running") == 0)
+            update_status (state, job, instance, "Starting", true);
+        }
+      else if (strcmp (instance->goal, "stop") == 0)
+        {
+          if (strcmp (instance->state, "waiting") == 0)
+            update_status (state, job, instance, "Stopping", true);
+        }
+    }
+}
+
+static void
+on_disconnect (state_t *state)
+{
+  ply_trace ("disconnected from boot status daemon");
+  ply_event_loop_exit (state->loop, 0);
+}
+
+int
+main (int    argc,
+      char **argv)
+{
+  state_t state = { 0 };
+  bool should_help, should_be_verbose;
+  bool is_connected;
+  int exit_code;
+
+  exit_code = 0;
+
+  signal (SIGPIPE, SIG_IGN);
+
+  state.loop = ply_event_loop_new ();
+  state.client = ply_boot_client_new ();
+  state.command_parser = ply_command_parser_new ("plymouth-upstart-bridge", "Upstart job state bridge");
+
+  ply_command_parser_add_options (state.command_parser,
+                                  "help", "This help message", PLY_COMMAND_OPTION_TYPE_FLAG,
+                                  "debug", "Enable verbose debug logging", PLY_COMMAND_OPTION_TYPE_FLAG,
+                                  NULL);
+
+  if (!ply_command_parser_parse_arguments (state.command_parser, state.loop, argv, argc))
+    {
+      char *help_string;
+
+      help_string = ply_command_parser_get_help_string (state.command_parser);
+
+      ply_error ("%s", help_string);
+
+      free (help_string);
+      return 1;
+    }
+
+  ply_command_parser_get_options (state.command_parser,
+                                  "help", &should_help,
+                                  "debug", &should_be_verbose,
+                                  NULL);
+
+  if (should_help)
+    {
+      char *help_string;
+
+      help_string = ply_command_parser_get_help_string (state.command_parser);
+
+      puts (help_string);
+
+      free (help_string);
+      return 0;
+    }
+
+  if (should_be_verbose && !ply_is_tracing ())
+    ply_toggle_tracing ();
+
+  setupterm (NULL, STDOUT_FILENO, NULL);
+
+  is_connected = ply_boot_client_connect (state.client,
+                                          (ply_boot_client_disconnect_handler_t)
+                                          on_disconnect, &state);
+  if (!is_connected)
+    {
+      ply_trace ("daemon not running");
+      return 1;
+    }
+
+  ply_boot_client_attach_to_event_loop (state.client, state.loop);
+  state.upstart = ply_upstart_monitor_new (state.loop);
+  if (!state.upstart)
+    return 1;
+  ply_upstart_monitor_add_state_changed_handler (state.upstart,
+                                                 (ply_upstart_monitor_state_changed_handler_t)
+                                                 on_state_changed, &state);
+  ply_upstart_monitor_add_failed_handler (state.upstart, on_failed, &state);
+
+  exit_code = ply_event_loop_run (state.loop);
+
+  ply_upstart_monitor_free (state.upstart);
+  ply_boot_client_free (state.client);
+
+  ply_event_loop_free (state.loop);
+
+  return exit_code;
+}
+/* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */

=== added directory '.pc/no-print-empty-description.patch'
=== added directory '.pc/no-print-empty-description.patch/src'
=== added directory '.pc/no-print-empty-description.patch/src/upstart-bridge'
=== added file '.pc/no-print-empty-description.patch/src/upstart-bridge/ply-upstart-monitor.c'
--- .pc/no-print-empty-description.patch/src/upstart-bridge/ply-upstart-monitor.c	1970-01-01 00:00:00 +0000
+++ .pc/no-print-empty-description.patch/src/upstart-bridge/ply-upstart-monitor.c	2014-03-14 10:43:52 +0000
@@ -0,0 +1,1182 @@
+/* ply-upstart-monitor.c - Upstart D-Bus monitor
+ *
+ * Copyright (C) 2010, 2011 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by: Colin Watson <[e-mail]>
+ */
+#include "config.h"
+#include "ply-upstart-monitor.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/eventfd.h>
+
+#include <dbus/dbus.h>
+
+#include "ply-logger.h"
+#include "ply-event-loop.h"
+#include "ply-hashtable.h"
+#include "ply-list.h"
+#include "ply-utils.h"
+
+typedef struct
+{
+  ply_upstart_monitor_t *monitor;
+  DBusTimeout           *timeout;
+} ply_upstart_monitor_timeout_t;
+
+struct _ply_upstart_monitor
+{
+  DBusConnection                              *connection;
+  ply_event_loop_t                            *loop;
+  ply_hashtable_t                             *jobs;
+  ply_hashtable_t                             *all_instances;
+  ply_upstart_monitor_state_changed_handler_t  state_changed_handler;
+  void                                        *state_changed_data;
+  ply_upstart_monitor_failed_handler_t         failed_handler;
+  void                                        *failed_data;
+  int                                          dispatch_fd;
+};
+
+typedef struct
+{
+  ply_upstart_monitor_t                *monitor;
+  ply_upstart_monitor_job_properties_t  properties;
+  ply_hashtable_t                      *instances;
+  ply_list_t                           *pending_calls;
+} ply_upstart_monitor_job_t;
+
+typedef struct
+{
+  ply_upstart_monitor_job_t                 *job;
+  ply_upstart_monitor_instance_properties_t  properties;
+  ply_list_t                                *pending_calls;
+  uint32_t                                   state_changed : 1;
+  uint32_t                                   call_failed : 1;
+} ply_upstart_monitor_instance_t;
+
+#define UPSTART_SERVICE                 NULL
+#define DBUS_ADDRESS_UPSTART            "unix:abstract=/com/ubuntu/upstart"
+#define UPSTART_PATH                    "/com/ubuntu/Upstart"
+#define UPSTART_INTERFACE_0_6           "com.ubuntu.Upstart0_6"
+#define UPSTART_INTERFACE_0_6_JOB       "com.ubuntu.Upstart0_6.Job"
+#define UPSTART_INTERFACE_0_6_INSTANCE  "com.ubuntu.Upstart0_6.Instance"
+
+/* Remove an entry from a hashtable, free the key, and return the data. */
+static void *
+hashtable_remove_and_free_key (ply_hashtable_t *hashtable,
+                               const void      *key)
+{
+  void *reply_key, *reply_data;
+
+  if (!ply_hashtable_lookup_full (hashtable, (void *) key,
+                                  &reply_key, &reply_data))
+    return NULL;
+  ply_hashtable_remove (hashtable, (void *) key);
+  free (reply_key);
+
+  return reply_data;
+}
+
+/* We assume, in general, that Upstart responds to D-Bus messages in a
+ * single thread, and that it processes messages on a given connection in
+ * the order in which they were sent.  Taken together, these assumptions
+ * imply a kind of coherence: a Properties.GetAll reply received after a
+ * StateChanged signal must have been computed entirely after the state
+ * change.  Thus, if this function returns false (properties have not been
+ * fetched yet), it should be safe to record an event as call until such
+ * time as the properties of the instance are known.
+ */
+static bool
+instance_is_initialized (ply_upstart_monitor_instance_t *instance)
+{
+  /* Note that the job may not have a description. */
+  if (instance->job->properties.name &&
+      instance->properties.name && instance->properties.goal &&
+      instance->properties.state)
+    return true;
+  else
+    return false;
+}
+
+static void
+on_get_all_instance_properties_finished (DBusPendingCall                *call,
+                                         ply_upstart_monitor_instance_t *instance)
+{
+  DBusMessage *reply;
+  DBusMessageIter iter, array_iter, dict_iter, variant_iter;
+  const char *key, *name, *goal, *state;
+  ply_upstart_monitor_t *monitor;
+
+  assert (call != NULL);
+  assert (instance != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_message_iter_init (reply, &iter);
+  if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
+    goto out;
+  dbus_message_iter_recurse (&iter, &array_iter);
+
+  while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_DICT_ENTRY)
+    {
+      dbus_message_iter_recurse (&array_iter, &dict_iter);
+
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_STRING)
+        goto next_item;
+
+      dbus_message_iter_get_basic (&dict_iter, &key);
+      if (key == NULL)
+        goto next_item;
+
+      dbus_message_iter_next (&dict_iter);
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_VARIANT)
+        goto next_item;
+      dbus_message_iter_recurse (&dict_iter, &variant_iter);
+      if (dbus_message_iter_get_arg_type (&variant_iter) != DBUS_TYPE_STRING)
+        goto next_item;
+
+      if (strcmp (key, "name") == 0)
+        {
+          dbus_message_iter_get_basic (&variant_iter, &name);
+          if (name != NULL)
+            {
+              ply_trace ("%s: name = '%s'",
+                         instance->job->properties.name, name);
+              instance->properties.name = strdup (name);
+            }
+        }
+      else if (strcmp (key, "goal") == 0)
+        {
+          dbus_message_iter_get_basic (&variant_iter, &goal);
+          if (goal != NULL)
+            {
+              ply_trace ("%s: goal = '%s'",
+                         instance->job->properties.name, goal);
+              instance->properties.goal = strdup (goal);
+            }
+        }
+      else if (strcmp (key, "state") == 0)
+        {
+          dbus_message_iter_get_basic (&variant_iter, &state);
+          if (state != NULL)
+            {
+              ply_trace ("%s: state = '%s'",
+                         instance->job->properties.name, state);
+              instance->properties.state = strdup (state);
+            }
+        }
+
+next_item:
+      dbus_message_iter_next (&array_iter);
+    }
+
+out:
+  dbus_message_unref (reply);
+
+  if (instance_is_initialized (instance))
+    {
+      /* Process any call events. */
+      monitor = instance->job->monitor;
+
+      if (instance->state_changed && monitor->state_changed_handler)
+        monitor->state_changed_handler (monitor->state_changed_data, NULL,
+                                        &instance->job->properties,
+                                        &instance->properties);
+      instance->state_changed = false;
+
+      if (instance->call_failed && monitor->failed_handler)
+        monitor->failed_handler (monitor->failed_data,
+                                 &instance->job->properties,
+                                 &instance->properties,
+                                 instance->properties.failed);
+      instance->call_failed = false;
+    }
+}
+
+static void
+on_get_all_job_properties_finished (DBusPendingCall           *call,
+                                    ply_upstart_monitor_job_t *job)
+{
+  DBusMessage *reply;
+  DBusMessageIter iter, array_iter, dict_iter, variant_iter;
+  const char *key, *name, *description;
+  dbus_uint32_t task;
+
+  assert (call != NULL);
+  assert (job != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_message_iter_init (reply, &iter);
+  if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
+    goto out;
+  dbus_message_iter_recurse (&iter, &array_iter);
+
+  while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_DICT_ENTRY)
+    {
+      dbus_message_iter_recurse (&array_iter, &dict_iter);
+
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_STRING)
+        goto next_item;
+
+      dbus_message_iter_get_basic (&dict_iter, &key);
+      if (key == NULL)
+        goto next_item;
+
+      dbus_message_iter_next (&dict_iter);
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_VARIANT)
+        goto next_item;
+      dbus_message_iter_recurse (&dict_iter, &variant_iter);
+
+      if (strcmp (key, "name") == 0)
+        {
+          if (dbus_message_iter_get_arg_type (&variant_iter) !=
+              DBUS_TYPE_STRING)
+            goto next_item;
+          dbus_message_iter_get_basic (&variant_iter, &name);
+          if (name != NULL)
+            {
+              ply_trace ("name = '%s'", name);
+              job->properties.name = strdup (name);
+            }
+        }
+      else if (strcmp (key, "description") == 0)
+        {
+          if (dbus_message_iter_get_arg_type (&variant_iter) !=
+              DBUS_TYPE_STRING)
+            goto next_item;
+          dbus_message_iter_get_basic (&variant_iter, &description);
+          if (description != NULL)
+            {
+              ply_trace ("description = '%s'", description);
+              job->properties.description = strdup (description);
+            }
+        }
+      else if (strcmp (key, "task") == 0)
+        {
+          if (dbus_message_iter_get_arg_type (&variant_iter) !=
+              DBUS_TYPE_BOOLEAN)
+            goto next_item;
+          dbus_message_iter_get_basic (&variant_iter, &task);
+          ply_trace ("task = %s", task ? "TRUE" : "FALSE");
+          job->properties.is_task = task ? true : false;
+        }
+
+next_item:
+      dbus_message_iter_next (&array_iter);
+    }
+
+out:
+  dbus_message_unref (reply);
+}
+
+static void
+remove_instance_internal (ply_upstart_monitor_job_t *job, const char *path)
+{
+  ply_upstart_monitor_instance_t *instance;
+  ply_list_node_t *node;
+
+  instance = hashtable_remove_and_free_key (job->instances, path);
+  if (instance == NULL)
+    return;
+  hashtable_remove_and_free_key (job->monitor->all_instances, path);
+
+  node = ply_list_get_first_node (instance->pending_calls);
+  while (node != NULL)
+    {
+      DBusPendingCall *call;
+      ply_list_node_t *next_node;
+
+      call = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (instance->pending_calls, node);
+      dbus_pending_call_cancel (call);
+      dbus_pending_call_unref (call);
+      node = next_node;
+    }
+  ply_list_free (instance->pending_calls);
+
+  free (instance->properties.name);
+  free (instance->properties.goal);
+  free (instance->properties.state);
+  free (instance);
+}
+
+static void
+add_instance (ply_upstart_monitor_job_t *job,
+              const char                *path)
+{
+  ply_upstart_monitor_instance_t *instance;
+  DBusMessage *message;
+  const char *interface = UPSTART_INTERFACE_0_6_INSTANCE;
+  DBusPendingCall *call;
+
+  ply_trace ("adding instance: %s", path);
+
+  remove_instance_internal (job, path);
+
+  instance = calloc (1, sizeof (ply_upstart_monitor_instance_t));
+  instance->job = job;
+  instance->properties.name = NULL;
+  instance->properties.goal = NULL;
+  instance->properties.state = NULL;
+  instance->properties.failed = false;
+  instance->pending_calls = ply_list_new ();
+  instance->state_changed = false;
+  instance->call_failed = false;
+
+  /* Keep a hash of instances per job, to make InstanceRemoved handling
+   * easy.
+   */
+  ply_hashtable_insert (job->instances, strdup (path), instance);
+  /* Keep a separate hash of all instances, to make StateChanged handling
+   * easy.
+   */
+  ply_hashtable_insert (job->monitor->all_instances, strdup (path), instance);
+
+  /* Ask Upstart for the name, goal, and state properties. */
+  ply_trace ("fetching properties of instance %s", path);
+  message = dbus_message_new_method_call (UPSTART_SERVICE, path,
+                                          DBUS_INTERFACE_PROPERTIES, "GetAll");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING, &interface,
+                            DBUS_TYPE_INVALID);
+  dbus_connection_send_with_reply (job->monitor->connection, message,
+                                   &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    {
+      dbus_pending_call_set_notify (call,
+                                    (DBusPendingCallNotifyFunction)
+                                    on_get_all_instance_properties_finished,
+                                    instance, NULL);
+      ply_list_append_data (instance->pending_calls, call);
+    }
+}
+
+static void
+remove_instance (ply_upstart_monitor_job_t *job,
+                 const char                *path)
+{
+  ply_trace ("removing instance: %s", path);
+
+  remove_instance_internal (job, path);
+}
+
+static void
+on_get_all_instances_finished (DBusPendingCall           *call,
+                               ply_upstart_monitor_job_t *job)
+{
+  DBusMessage *reply;
+  DBusError error;
+  char **instances;
+  int n_instances, i;
+
+  assert (call != NULL);
+  assert (job != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_error_init (&error);
+  dbus_message_get_args (reply, &error,
+                         DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH,
+                         &instances, &n_instances,
+                         DBUS_TYPE_INVALID);
+  if (dbus_error_is_set (&error))
+    goto out;
+  dbus_error_free (&error);
+
+  for (i = 0; i < n_instances; ++i)
+    add_instance (job, instances[i]);
+
+  dbus_free_string_array (instances);
+
+out:
+  dbus_message_unref (reply);
+}
+
+static void
+free_job_instance (void *key, void *data, void *user_data)
+{
+  const char *path = key;
+  ply_upstart_monitor_instance_t *instance = data;
+  ply_upstart_monitor_t *monitor = user_data;
+
+  assert (monitor != NULL);
+
+  if (instance == NULL)
+    return;
+
+  hashtable_remove_and_free_key (monitor->all_instances, path);
+  free (instance->properties.name);
+  free (instance->properties.goal);
+  free (instance->properties.state);
+  free (instance);
+}
+
+static void
+remove_job_internal (ply_upstart_monitor_t *monitor, const char *path)
+{
+  ply_upstart_monitor_job_t *job;
+  ply_list_node_t *node;
+
+  job = hashtable_remove_and_free_key (monitor->jobs, path);
+  if (job == NULL)
+    return;
+
+  node = ply_list_get_first_node (job->pending_calls);
+  while (node != NULL)
+    {
+      DBusPendingCall *call;
+      ply_list_node_t *next_node;
+
+      call = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (job->pending_calls, node);
+      dbus_pending_call_cancel (call);
+      dbus_pending_call_unref (call);
+      node = next_node;
+    }
+  ply_list_free (job->pending_calls);
+
+  free (job->properties.name);
+  free (job->properties.description);
+  ply_hashtable_foreach (job->instances, free_job_instance, monitor);
+  ply_hashtable_free (job->instances);
+  free (job);
+}
+
+static void
+add_job (ply_upstart_monitor_t *monitor, const char *path)
+{
+  ply_upstart_monitor_job_t *job;
+  DBusMessage *message;
+  const char *interface = UPSTART_INTERFACE_0_6_JOB;
+  DBusPendingCall *call;
+
+  ply_trace ("adding job: %s", path);
+
+  remove_job_internal (monitor, path);
+
+  job = calloc (1, sizeof (ply_upstart_monitor_job_t));
+  job->monitor = monitor;
+  job->properties.name = NULL;
+  job->properties.description = NULL;
+  job->properties.is_task = false;
+  job->instances = ply_hashtable_new (ply_hashtable_string_hash,
+                                      ply_hashtable_string_compare);
+  job->pending_calls = ply_list_new ();
+
+  ply_hashtable_insert (monitor->jobs, strdup (path), job);
+
+  /* Ask Upstart for the name and description properties. */
+  ply_trace ("fetching properties of job %s", path);
+  message = dbus_message_new_method_call (UPSTART_SERVICE, path,
+                                          DBUS_INTERFACE_PROPERTIES, "GetAll");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING, &interface,
+                            DBUS_TYPE_INVALID);
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    {
+      dbus_pending_call_set_notify (call,
+                                    (DBusPendingCallNotifyFunction)
+                                    on_get_all_job_properties_finished,
+                                    job,
+                                    NULL);
+      ply_list_append_data (job->pending_calls, call);
+    }
+
+  /* Ask Upstart for a list of all instances of this job. */
+  ply_trace ("calling GetAllInstances on job %s", path);
+  message = dbus_message_new_method_call (UPSTART_SERVICE, path,
+                                          UPSTART_INTERFACE_0_6_JOB,
+                                          "GetAllInstances");
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    {
+      dbus_pending_call_set_notify (call,
+                                    (DBusPendingCallNotifyFunction)
+                                    on_get_all_instances_finished,
+                                    job,
+                                    NULL);
+      ply_list_append_data (job->pending_calls, call);
+    }
+}
+
+static void
+remove_job (ply_upstart_monitor_t *monitor, const char *path)
+{
+  ply_trace ("removing job: %s", path);
+
+  remove_job_internal (monitor, path);
+}
+
+static void
+on_get_all_jobs_finished (DBusPendingCall       *call,
+                          ply_upstart_monitor_t *monitor)
+{
+  DBusMessage *reply;
+  DBusError error;
+  char **jobs;
+  int n_jobs, i;
+
+  assert (call != NULL);
+  assert (monitor != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_error_init (&error);
+  dbus_message_get_args (reply, &error,
+                         DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH,
+                         &jobs, &n_jobs,
+                         DBUS_TYPE_INVALID);
+  if (dbus_error_is_set (&error))
+    goto out;
+  dbus_error_free (&error);
+
+  for (i = 0; i < n_jobs; ++i)
+    add_job (monitor, jobs[i]);
+
+  dbus_free_string_array (jobs);
+
+out:
+  dbus_message_unref (reply);
+}
+
+
+static DBusHandlerResult
+job_added_handler (DBusConnection        *connection,
+                   DBusMessage           *message,
+                   ply_upstart_monitor_t *monitor)
+{
+  DBusError error;
+  const char *signal_path;
+
+  ply_trace ("got JobAdded");
+  dbus_error_init (&error);
+  if (dbus_message_get_args (message, &error,
+                             DBUS_TYPE_OBJECT_PATH, &signal_path,
+                             DBUS_TYPE_INVALID))
+    add_job (monitor, signal_path);
+  dbus_error_free (&error);
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+job_removed_handler (DBusConnection        *connection,
+                     DBusMessage           *message,
+                     ply_upstart_monitor_t *monitor)
+{
+  DBusError error;
+  const char *signal_path;
+
+  ply_trace ("got JobRemoved");
+  dbus_error_init (&error);
+  if (dbus_message_get_args (message, &error,
+                             DBUS_TYPE_OBJECT_PATH, &signal_path,
+                             DBUS_TYPE_INVALID))
+    remove_job (monitor, signal_path);
+  dbus_error_free (&error);
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+instance_added_handler (DBusConnection *connection, DBusMessage *message,
+                        ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *signal_path;
+  ply_upstart_monitor_job_t *job;
+
+  ply_trace ("got %s InstanceAdded", path);
+  job = ply_hashtable_lookup (monitor->jobs, (void *) path);
+  if (job != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_OBJECT_PATH, &signal_path,
+                                 DBUS_TYPE_INVALID))
+        add_instance (job, signal_path);
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+instance_removed_handler (DBusConnection *connection, DBusMessage *message,
+                          ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *signal_path;
+  ply_upstart_monitor_job_t *job;
+
+  ply_trace ("got %s InstanceRemoved", path);
+  job = ply_hashtable_lookup (monitor->jobs, (void *) path);
+  if (job != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_OBJECT_PATH, &signal_path,
+                                 DBUS_TYPE_INVALID))
+        remove_instance (job, signal_path);
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+goal_changed_handler (DBusConnection *connection, DBusMessage *message,
+                      ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *goal;
+  ply_upstart_monitor_instance_t *instance;
+  char *old_goal;
+
+  ply_trace ("got %s GoalChanged", path);
+  instance = ply_hashtable_lookup (monitor->all_instances, (void *) path);
+  if (instance != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_STRING, &goal,
+                                 DBUS_TYPE_INVALID))
+        {
+          old_goal = instance->properties.goal;
+          instance->properties.goal = strdup (goal);
+          ply_trace ("goal changed from '%s' to '%s'", old_goal, goal);
+          free (old_goal);
+        }
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+state_changed_handler (DBusConnection *connection, DBusMessage *message,
+                       ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *state;
+  ply_upstart_monitor_instance_t *instance;
+  char *old_state;
+
+  ply_trace ("got %s StateChanged", path);
+  instance = ply_hashtable_lookup (monitor->all_instances, (void *) path);
+  if (instance != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_STRING, &state,
+                                 DBUS_TYPE_INVALID))
+        {
+          old_state = instance->properties.state;
+          instance->properties.state = strdup (state);
+          ply_trace ("state changed from '%s' to '%s'", old_state, state);
+          if (strcmp (state, "starting") == 0)
+            {
+              /* Clear any old failed information. */
+              instance->properties.failed = 0;
+              instance->call_failed = false;
+            }
+          if (instance_is_initialized (instance))
+            {
+              if (monitor->state_changed_handler)
+                monitor->state_changed_handler (monitor->state_changed_data,
+                                                old_state,
+                                                &instance->job->properties,
+                                                &instance->properties);
+            }
+          else
+            instance->state_changed = true;
+          free (old_state);
+        }
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+failed_handler (DBusConnection *connection, DBusMessage *message,
+                ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  ply_upstart_monitor_instance_t *instance;
+  dbus_int32_t failed_status;
+
+  ply_trace ("got %s Failed", path);
+  instance = ply_hashtable_lookup (monitor->all_instances, (void *) path);
+  if (instance != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_INT32, &failed_status,
+                                 DBUS_TYPE_INVALID))
+        {
+          instance->properties.failed = failed_status;
+          if (instance_is_initialized (instance))
+            {
+              if (monitor->failed_handler)
+                monitor->failed_handler (monitor->failed_data,
+                                         &instance->job->properties,
+                                         &instance->properties,
+                                         (int) failed_status);
+            }
+          else
+            instance->call_failed = true;
+        }
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+message_handler (DBusConnection *connection, DBusMessage *message, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  const char *path;
+
+  assert (connection != NULL);
+  assert (message != NULL);
+  assert (monitor != NULL);
+
+  path = dbus_message_get_path (message);
+  if (path == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6,
+                              "JobAdded"))
+    return job_added_handler (connection, message, monitor);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6,
+                              "JobRemoved"))
+    return job_removed_handler (connection, message, monitor);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_JOB,
+                              "InstanceAdded"))
+    return instance_added_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_JOB,
+                              "InstanceRemoved"))
+    return instance_removed_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_INSTANCE,
+                              "GoalChanged"))
+    return goal_changed_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_INSTANCE,
+                              "StateChanged"))
+    return state_changed_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_INSTANCE,
+                              "Failed"))
+    return failed_handler (connection, message, monitor, path);
+
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+ply_upstart_monitor_t *
+ply_upstart_monitor_new (ply_event_loop_t *loop)
+{
+  DBusError error;
+  DBusConnection *connection;
+  ply_upstart_monitor_t *monitor;
+  DBusMessage *message;
+  DBusPendingCall *call;
+
+  dbus_error_init (&error);
+
+  /* Get a connection to the system bus and set it up to listen for messages
+   * from Upstart.
+   */
+  connection = dbus_connection_open (DBUS_ADDRESS_UPSTART, &error);
+  if (connection == NULL)
+    {
+      ply_error ("unable to connect to system bus: %s", error.message);
+      dbus_error_free (&error);
+      return NULL;
+    }
+  dbus_error_free (&error);
+
+  monitor = calloc (1, sizeof (ply_upstart_monitor_t));
+  monitor->connection = connection;
+  monitor->loop = NULL;
+  monitor->jobs = ply_hashtable_new (ply_hashtable_string_hash,
+                                     ply_hashtable_string_compare);
+  monitor->all_instances = ply_hashtable_new (ply_hashtable_string_hash,
+                                              ply_hashtable_string_compare);
+  monitor->state_changed_handler = NULL;
+  monitor->state_changed_data = NULL;
+  monitor->failed_handler = NULL;
+  monitor->failed_data = NULL;
+  monitor->dispatch_fd = -1;
+
+  if (!dbus_connection_add_filter (connection, message_handler, monitor, NULL))
+    {
+      ply_error ("unable to add filter to system bus connection");
+      ply_upstart_monitor_free (monitor);
+      return NULL;
+    }
+
+  ply_trace ("calling GetAllJobs");
+  message = dbus_message_new_method_call (UPSTART_SERVICE, UPSTART_PATH,
+                                          UPSTART_INTERFACE_0_6,
+                                          "GetAllJobs");
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    dbus_pending_call_set_notify (call,
+                                  (DBusPendingCallNotifyFunction)
+                                  on_get_all_jobs_finished,
+                                  monitor, NULL);
+
+  if (loop != NULL)
+    ply_upstart_monitor_connect_to_event_loop (monitor, loop);
+
+  return monitor;
+}
+
+void
+ply_upstart_monitor_free (ply_upstart_monitor_t *monitor)
+{
+  if (monitor == NULL)
+    return;
+
+  ply_hashtable_free (monitor->all_instances);
+  ply_hashtable_free (monitor->jobs);
+  dbus_connection_unref (monitor->connection);
+  if (monitor->dispatch_fd >= 0)
+    close (monitor->dispatch_fd);
+  free (monitor);
+}
+
+static void
+read_watch_handler (void *data, int fd)
+{
+  DBusWatch *watch = data;
+
+  assert (watch != NULL);
+
+  dbus_watch_handle (watch, DBUS_WATCH_READABLE);
+}
+
+static void
+write_watch_handler (void *data, int fd)
+{
+  DBusWatch *watch = data;
+
+  assert (watch != NULL);
+
+  dbus_watch_handle (watch, DBUS_WATCH_WRITABLE);
+}
+
+static dbus_bool_t
+add_watch (DBusWatch *watch, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  unsigned int flags;
+  int fd;
+  ply_event_loop_fd_status_t status;
+  ply_fd_watch_t *read_watch_event = NULL, *write_watch_event = NULL;
+
+  assert (monitor != NULL);
+  assert (watch != NULL);
+
+  if (!dbus_watch_get_enabled (watch))
+    return TRUE;
+
+  assert (dbus_watch_get_data (watch) == NULL);
+
+  flags = dbus_watch_get_flags (watch);
+  fd = dbus_watch_get_unix_fd (watch);
+
+  if (flags & DBUS_WATCH_READABLE)
+    {
+      status = PLY_EVENT_LOOP_FD_STATUS_HAS_DATA;
+      read_watch_event = ply_event_loop_watch_fd (monitor->loop, fd, status,
+                                                  read_watch_handler, NULL,
+                                                  watch);
+      if (read_watch_event == NULL)
+        return FALSE;
+      dbus_watch_set_data (watch, read_watch_event, NULL);
+    }
+
+  if (flags & DBUS_WATCH_WRITABLE)
+    {
+      status = PLY_EVENT_LOOP_FD_STATUS_CAN_TAKE_DATA;
+      write_watch_event = ply_event_loop_watch_fd (monitor->loop, fd, status,
+                                                   write_watch_handler, NULL,
+                                                   watch);
+      if (write_watch_event == NULL)
+        {
+          if (read_watch_event != NULL)
+            ply_event_loop_stop_watching_fd (monitor->loop, read_watch_event);
+          return FALSE;
+        }
+      dbus_watch_set_data (watch, write_watch_event, NULL);
+    }
+
+  return TRUE;
+}
+
+static void
+remove_watch (DBusWatch *watch, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  ply_fd_watch_t *watch_event;
+
+  assert (monitor != NULL);
+  assert (watch != NULL);
+
+  watch_event = dbus_watch_get_data (watch);
+  if (watch_event == NULL)
+    return;
+
+  ply_event_loop_stop_watching_fd (monitor->loop, watch_event);
+
+  dbus_watch_set_data (watch, NULL, NULL);
+}
+
+static void
+toggled_watch (DBusWatch *watch, void *data)
+{
+  if (dbus_watch_get_enabled (watch))
+    add_watch (watch, data);
+  else
+    remove_watch (watch, data);
+}
+
+static ply_upstart_monitor_timeout_t *
+timeout_user_data_new (ply_upstart_monitor_t *monitor, DBusTimeout *timeout)
+{
+  ply_upstart_monitor_timeout_t *monitor_timeout;
+
+  monitor_timeout = calloc (1, sizeof (ply_upstart_monitor_timeout_t));
+  monitor_timeout->monitor = monitor;
+  monitor_timeout->timeout = timeout;
+
+  return monitor_timeout;
+}
+
+static void
+timeout_user_data_free (void *data)
+{
+  ply_upstart_monitor_timeout_t *monitor_timeout = data;
+
+  free (monitor_timeout);
+}
+
+static void
+timeout_handler (void *data, ply_event_loop_t *loop)
+{
+  ply_upstart_monitor_timeout_t *monitor_timeout = data;
+
+  assert (monitor_timeout != NULL);
+
+  dbus_timeout_handle (monitor_timeout->timeout);
+}
+
+static dbus_bool_t
+add_timeout (DBusTimeout *timeout, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  int interval;
+  ply_upstart_monitor_timeout_t *monitor_timeout;
+
+  assert (monitor != NULL);
+  assert (timeout != NULL);
+
+  if (!dbus_timeout_get_enabled (timeout))
+    return TRUE;
+
+  interval = dbus_timeout_get_interval (timeout) * 1000;
+
+  monitor_timeout = timeout_user_data_new (monitor, timeout);
+
+  ply_event_loop_watch_for_timeout (monitor->loop, (double) interval,
+                                    timeout_handler, monitor_timeout);
+
+  dbus_timeout_set_data (timeout, monitor_timeout, timeout_user_data_free);
+
+  return TRUE;
+}
+
+static void
+remove_timeout (DBusTimeout *timeout, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  ply_upstart_monitor_timeout_t *monitor_timeout;
+
+  assert (monitor != NULL);
+  assert (timeout != NULL);
+
+  monitor_timeout = dbus_timeout_get_data (timeout);
+  if (monitor_timeout == NULL)
+    return;
+
+  ply_event_loop_stop_watching_for_timeout (monitor->loop,
+                                            timeout_handler, monitor_timeout);
+
+  dbus_timeout_set_data (timeout, NULL, NULL);
+}
+
+static void
+toggled_timeout (DBusTimeout *timeout, void *data)
+{
+  if (dbus_timeout_get_enabled (timeout))
+    add_timeout (timeout, data);
+  else
+    remove_timeout (timeout, data);
+}
+
+static void
+dispatch_status (DBusConnection *connection, DBusDispatchStatus new_status,
+                 void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  uint64_t event_payload;
+
+  assert (monitor != NULL);
+
+  if (new_status != DBUS_DISPATCH_DATA_REMAINS)
+    return;
+
+  /* wake up event loop */
+  event_payload = 1;
+  ply_write (monitor->dispatch_fd, &event_payload, sizeof (event_payload));
+}
+
+static void
+dispatch (void *data, int fd)
+{
+  ply_upstart_monitor_t *monitor = data;
+  uint64_t event_payload;
+
+  assert (monitor != NULL);
+
+  /* reset eventfd to zero */
+  ply_read (fd, &event_payload, sizeof (event_payload));
+
+  while (dbus_connection_dispatch (monitor->connection) ==
+         DBUS_DISPATCH_DATA_REMAINS)
+    ;
+}
+
+bool
+ply_upstart_monitor_connect_to_event_loop (ply_upstart_monitor_t    *monitor,
+                                           ply_event_loop_t         *loop)
+{
+  ply_fd_watch_t *dispatch_event = NULL;
+  uint64_t event_payload;
+
+  assert (monitor != NULL);
+
+  monitor->loop = loop;
+  monitor->dispatch_fd = -1;
+
+  if (!dbus_connection_set_watch_functions (monitor->connection,
+                                            add_watch,
+                                            remove_watch,
+                                            toggled_watch,
+                                            monitor, NULL))
+    goto err;
+
+  if (!dbus_connection_set_timeout_functions (monitor->connection,
+                                              add_timeout,
+                                              remove_timeout,
+                                              toggled_timeout,
+                                              monitor, NULL))
+    goto err;
+
+  monitor->dispatch_fd = eventfd (0, EFD_CLOEXEC | EFD_NONBLOCK);
+  if (monitor->dispatch_fd < 0)
+    goto err;
+  /* make sure we wake up to dispatch the first time through */
+  event_payload = 1;
+  ply_write (monitor->dispatch_fd, &event_payload, sizeof (event_payload));
+
+  dispatch_event = ply_event_loop_watch_fd (monitor->loop,
+                                            monitor->dispatch_fd,
+                                            PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,
+                                            dispatch, NULL, monitor);
+  if (dispatch_event == NULL)
+    goto err;
+
+  dbus_connection_set_dispatch_status_function (monitor->connection,
+                                                dispatch_status,
+                                                monitor, NULL);
+
+  return true;
+
+err:
+  dbus_connection_set_watch_functions (monitor->connection,
+                                       NULL, NULL, NULL, NULL, NULL);
+  dbus_connection_set_timeout_functions (monitor->connection,
+                                         NULL, NULL, NULL, NULL, NULL);
+  dbus_connection_set_dispatch_status_function (monitor->connection,
+                                                NULL, NULL, NULL);
+  if (dispatch_event != NULL)
+    ply_event_loop_stop_watching_fd (monitor->loop, dispatch_event);
+  if (monitor->dispatch_fd >= 0)
+    {
+      close (monitor->dispatch_fd);
+      monitor->dispatch_fd = -1;
+    }
+  monitor->loop = NULL;
+  return false;
+}
+
+void
+ply_upstart_monitor_add_state_changed_handler (ply_upstart_monitor_t                       *monitor,
+                                               ply_upstart_monitor_state_changed_handler_t  handler,
+                                               void                                        *user_data)
+{
+  monitor->state_changed_handler = handler;
+  monitor->state_changed_data = user_data;
+}
+
+void
+ply_upstart_monitor_add_failed_handler (ply_upstart_monitor_t                *monitor,
+                                        ply_upstart_monitor_failed_handler_t  handler,
+                                        void                                 *user_data)
+{
+  monitor->failed_handler = handler;
+  monitor->failed_data = user_data;
+}
+/* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */

=== added directory '.pc/ubuntu-logo-scale-factor-2.patch'
=== added directory '.pc/ubuntu-logo-scale-factor-2.patch/themes'
=== added directory '.pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo'
=== added file '.pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/Makefile.am'
--- .pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/Makefile.am	1970-01-01 00:00:00 +0000
+++ .pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/Makefile.am	2014-03-14 10:43:52 +0000
@@ -0,0 +1,23 @@
+themedir = $(datadir)/plymouth/themes/ubuntu-logo
+nodist_theme_DATA = ubuntu-logo.plymouth
+dist_theme_DATA =   ubuntu-logo.script                                \
+                    ubuntu-logo.grub                                  \
+                    ubuntu_logo.png                                   \
+                    ubuntu_logo16.png                                 \
+                    password_field.png                                \
+                    password_field16.png                              \
+                    progress_dot_off.png                              \
+                    progress_dot_off16.png                            \
+                    progress_dot_on.png                               \
+                    progress_dot_on16.png
+
+
+
+MAINTAINERCLEANFILES = Makefile.in ubuntu-logo.plymouth
+CLEANFILES = ubuntu-logo.plymouth
+
+ubuntu-logo.plymouth: $(srcdir)/ubuntu-logo.plymouth.in
+	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g' \
+	       $(srcdir)/ubuntu-logo.plymouth.in > ubuntu-logo.plymouth
+
+EXTRA_DIST = ubuntu-logo.plymouth.in

=== added file '.pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/ubuntu-logo.plymouth.in'
--- .pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/ubuntu-logo.plymouth.in	1970-01-01 00:00:00 +0000
+++ .pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/ubuntu-logo.plymouth.in	2014-03-14 10:43:52 +0000
@@ -0,0 +1,8 @@
+[Plymouth Theme]
+Name=Ubuntu Logo
+Description=A theme that features a blank background with a logo.
+ModuleName=script
+
+[script]
+ImageDir=@PLYMOUTH_THEME_PATH@/ubuntu-logo
+ScriptFile=@PLYMOUTH_THEME_PATH@/ubuntu-logo/ubuntu-logo.script

=== added file '.pc/ubuntu-logo-scale-factor-2.patch/themes/ubuntu-logo/ubuntu-logo.script.in'
=== added directory '.pc/use-upstart-private-socket.patch'
=== added directory '.pc/use-upstart-private-socket.patch/src'
=== added directory '.pc/use-upstart-private-socket.patch/src/upstart-bridge'
=== added file '.pc/use-upstart-private-socket.patch/src/upstart-bridge/ply-upstart-monitor.c'
--- .pc/use-upstart-private-socket.patch/src/upstart-bridge/ply-upstart-monitor.c	1970-01-01 00:00:00 +0000
+++ .pc/use-upstart-private-socket.patch/src/upstart-bridge/ply-upstart-monitor.c	2014-03-14 10:43:52 +0000
@@ -0,0 +1,1301 @@
+/* ply-upstart-monitor.c - Upstart D-Bus monitor
+ *
+ * Copyright (C) 2010, 2011 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Written by: Colin Watson <[e-mail]>
+ */
+#include "config.h"
+#include "ply-upstart-monitor.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/eventfd.h>
+
+#include <dbus/dbus.h>
+
+#include "ply-logger.h"
+#include "ply-event-loop.h"
+#include "ply-hashtable.h"
+#include "ply-list.h"
+#include "ply-utils.h"
+
+typedef struct
+{
+  ply_upstart_monitor_t *monitor;
+  DBusTimeout           *timeout;
+} ply_upstart_monitor_timeout_t;
+
+struct _ply_upstart_monitor
+{
+  DBusConnection                              *connection;
+  char                                        *owner;
+  ply_event_loop_t                            *loop;
+  ply_hashtable_t                             *jobs;
+  ply_hashtable_t                             *all_instances;
+  ply_upstart_monitor_state_changed_handler_t  state_changed_handler;
+  void                                        *state_changed_data;
+  ply_upstart_monitor_failed_handler_t         failed_handler;
+  void                                        *failed_data;
+  int                                          dispatch_fd;
+};
+
+typedef struct
+{
+  ply_upstart_monitor_t                *monitor;
+  ply_upstart_monitor_job_properties_t  properties;
+  ply_hashtable_t                      *instances;
+  ply_list_t                           *pending_calls;
+} ply_upstart_monitor_job_t;
+
+typedef struct
+{
+  ply_upstart_monitor_job_t                 *job;
+  ply_upstart_monitor_instance_properties_t  properties;
+  ply_list_t                                *pending_calls;
+  uint32_t                                   state_changed : 1;
+  uint32_t                                   call_failed : 1;
+} ply_upstart_monitor_instance_t;
+
+#define UPSTART_SERVICE                 "com.ubuntu.Upstart"
+#define UPSTART_PATH                    "/com/ubuntu/Upstart"
+#define UPSTART_INTERFACE_0_6           "com.ubuntu.Upstart0_6"
+#define UPSTART_INTERFACE_0_6_JOB       "com.ubuntu.Upstart0_6.Job"
+#define UPSTART_INTERFACE_0_6_INSTANCE  "com.ubuntu.Upstart0_6.Instance"
+
+/* Remove an entry from a hashtable, free the key, and return the data. */
+static void *
+hashtable_remove_and_free_key (ply_hashtable_t *hashtable,
+                               const void      *key)
+{
+  void *reply_key, *reply_data;
+
+  if (!ply_hashtable_lookup_full (hashtable, (void *) key,
+                                  &reply_key, &reply_data))
+    return NULL;
+  ply_hashtable_remove (hashtable, (void *) key);
+  free (reply_key);
+
+  return reply_data;
+}
+
+/* We assume, in general, that Upstart responds to D-Bus messages in a
+ * single thread, and that it processes messages on a given connection in
+ * the order in which they were sent.  Taken together, these assumptions
+ * imply a kind of coherence: a Properties.GetAll reply received after a
+ * StateChanged signal must have been computed entirely after the state
+ * change.  Thus, if this function returns false (properties have not been
+ * fetched yet), it should be safe to record an event as call until such
+ * time as the properties of the instance are known.
+ */
+static bool
+instance_is_initialized (ply_upstart_monitor_instance_t *instance)
+{
+  /* Note that the job may not have a description. */
+  if (instance->job->properties.name &&
+      instance->properties.name && instance->properties.goal &&
+      instance->properties.state)
+    return true;
+  else
+    return false;
+}
+
+static void
+on_get_all_instance_properties_finished (DBusPendingCall                *call,
+                                         ply_upstart_monitor_instance_t *instance)
+{
+  DBusMessage *reply;
+  DBusMessageIter iter, array_iter, dict_iter, variant_iter;
+  const char *key, *name, *goal, *state;
+  ply_upstart_monitor_t *monitor;
+
+  assert (call != NULL);
+  assert (instance != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_message_iter_init (reply, &iter);
+  if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
+    goto out;
+  dbus_message_iter_recurse (&iter, &array_iter);
+
+  while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_DICT_ENTRY)
+    {
+      dbus_message_iter_recurse (&array_iter, &dict_iter);
+
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_STRING)
+        goto next_item;
+
+      dbus_message_iter_get_basic (&dict_iter, &key);
+      if (key == NULL)
+        goto next_item;
+
+      dbus_message_iter_next (&dict_iter);
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_VARIANT)
+        goto next_item;
+      dbus_message_iter_recurse (&dict_iter, &variant_iter);
+      if (dbus_message_iter_get_arg_type (&variant_iter) != DBUS_TYPE_STRING)
+        goto next_item;
+
+      if (strcmp (key, "name") == 0)
+        {
+          dbus_message_iter_get_basic (&variant_iter, &name);
+          if (name != NULL)
+            {
+              ply_trace ("%s: name = '%s'",
+                         instance->job->properties.name, name);
+              instance->properties.name = strdup (name);
+            }
+        }
+      else if (strcmp (key, "goal") == 0)
+        {
+          dbus_message_iter_get_basic (&variant_iter, &goal);
+          if (goal != NULL)
+            {
+              ply_trace ("%s: goal = '%s'",
+                         instance->job->properties.name, goal);
+              instance->properties.goal = strdup (goal);
+            }
+        }
+      else if (strcmp (key, "state") == 0)
+        {
+          dbus_message_iter_get_basic (&variant_iter, &state);
+          if (state != NULL)
+            {
+              ply_trace ("%s: state = '%s'",
+                         instance->job->properties.name, state);
+              instance->properties.state = strdup (state);
+            }
+        }
+
+next_item:
+      dbus_message_iter_next (&array_iter);
+    }
+
+out:
+  dbus_message_unref (reply);
+
+  if (instance_is_initialized (instance))
+    {
+      /* Process any call events. */
+      monitor = instance->job->monitor;
+
+      if (instance->state_changed && monitor->state_changed_handler)
+        monitor->state_changed_handler (monitor->state_changed_data, NULL,
+                                        &instance->job->properties,
+                                        &instance->properties);
+      instance->state_changed = false;
+
+      if (instance->call_failed && monitor->failed_handler)
+        monitor->failed_handler (monitor->failed_data,
+                                 &instance->job->properties,
+                                 &instance->properties,
+                                 instance->properties.failed);
+      instance->call_failed = false;
+    }
+}
+
+static void
+on_get_all_job_properties_finished (DBusPendingCall           *call,
+                                    ply_upstart_monitor_job_t *job)
+{
+  DBusMessage *reply;
+  DBusMessageIter iter, array_iter, dict_iter, variant_iter;
+  const char *key, *name, *description;
+  dbus_uint32_t task;
+
+  assert (call != NULL);
+  assert (job != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_message_iter_init (reply, &iter);
+  if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
+    goto out;
+  dbus_message_iter_recurse (&iter, &array_iter);
+
+  while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_DICT_ENTRY)
+    {
+      dbus_message_iter_recurse (&array_iter, &dict_iter);
+
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_STRING)
+        goto next_item;
+
+      dbus_message_iter_get_basic (&dict_iter, &key);
+      if (key == NULL)
+        goto next_item;
+
+      dbus_message_iter_next (&dict_iter);
+      if (dbus_message_iter_get_arg_type (&dict_iter) != DBUS_TYPE_VARIANT)
+        goto next_item;
+      dbus_message_iter_recurse (&dict_iter, &variant_iter);
+
+      if (strcmp (key, "name") == 0)
+        {
+          if (dbus_message_iter_get_arg_type (&variant_iter) !=
+              DBUS_TYPE_STRING)
+            goto next_item;
+          dbus_message_iter_get_basic (&variant_iter, &name);
+          if (name != NULL)
+            {
+              ply_trace ("name = '%s'", name);
+              job->properties.name = strdup (name);
+            }
+        }
+      else if (strcmp (key, "description") == 0)
+        {
+          if (dbus_message_iter_get_arg_type (&variant_iter) !=
+              DBUS_TYPE_STRING)
+            goto next_item;
+          dbus_message_iter_get_basic (&variant_iter, &description);
+          if (description != NULL)
+            {
+              ply_trace ("description = '%s'", description);
+              job->properties.description = strdup (description);
+            }
+        }
+      else if (strcmp (key, "task") == 0)
+        {
+          if (dbus_message_iter_get_arg_type (&variant_iter) !=
+              DBUS_TYPE_BOOLEAN)
+            goto next_item;
+          dbus_message_iter_get_basic (&variant_iter, &task);
+          ply_trace ("task = %s", task ? "TRUE" : "FALSE");
+          job->properties.is_task = task ? true : false;
+        }
+
+next_item:
+      dbus_message_iter_next (&array_iter);
+    }
+
+out:
+  dbus_message_unref (reply);
+}
+
+static void
+remove_instance_internal (ply_upstart_monitor_job_t *job, const char *path)
+{
+  ply_upstart_monitor_instance_t *instance;
+  ply_list_node_t *node;
+
+  instance = hashtable_remove_and_free_key (job->instances, path);
+  if (instance == NULL)
+    return;
+  hashtable_remove_and_free_key (job->monitor->all_instances, path);
+
+  node = ply_list_get_first_node (instance->pending_calls);
+  while (node != NULL)
+    {
+      DBusPendingCall *call;
+      ply_list_node_t *next_node;
+
+      call = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (instance->pending_calls, node);
+      dbus_pending_call_cancel (call);
+      dbus_pending_call_unref (call);
+      node = next_node;
+    }
+  ply_list_free (instance->pending_calls);
+
+  free (instance->properties.name);
+  free (instance->properties.goal);
+  free (instance->properties.state);
+  free (instance);
+}
+
+static void
+add_instance (ply_upstart_monitor_job_t *job,
+              const char                *path)
+{
+  ply_upstart_monitor_instance_t *instance;
+  DBusMessage *message;
+  const char *interface = UPSTART_INTERFACE_0_6_INSTANCE;
+  DBusPendingCall *call;
+
+  ply_trace ("adding instance: %s", path);
+
+  remove_instance_internal (job, path);
+
+  instance = calloc (1, sizeof (ply_upstart_monitor_instance_t));
+  instance->job = job;
+  instance->properties.name = NULL;
+  instance->properties.goal = NULL;
+  instance->properties.state = NULL;
+  instance->properties.failed = false;
+  instance->pending_calls = ply_list_new ();
+  instance->state_changed = false;
+  instance->call_failed = false;
+
+  /* Keep a hash of instances per job, to make InstanceRemoved handling
+   * easy.
+   */
+  ply_hashtable_insert (job->instances, strdup (path), instance);
+  /* Keep a separate hash of all instances, to make StateChanged handling
+   * easy.
+   */
+  ply_hashtable_insert (job->monitor->all_instances, strdup (path), instance);
+
+  /* Ask Upstart for the name, goal, and state properties. */
+  ply_trace ("fetching properties of instance %s", path);
+  message = dbus_message_new_method_call (UPSTART_SERVICE, path,
+                                          DBUS_INTERFACE_PROPERTIES, "GetAll");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING, &interface,
+                            DBUS_TYPE_INVALID);
+  dbus_connection_send_with_reply (job->monitor->connection, message,
+                                   &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    {
+      dbus_pending_call_set_notify (call,
+                                    (DBusPendingCallNotifyFunction)
+                                    on_get_all_instance_properties_finished,
+                                    instance, NULL);
+      ply_list_append_data (instance->pending_calls, call);
+    }
+}
+
+static void
+remove_instance (ply_upstart_monitor_job_t *job,
+                 const char                *path)
+{
+  ply_trace ("removing instance: %s", path);
+
+  remove_instance_internal (job, path);
+}
+
+static void
+on_get_all_instances_finished (DBusPendingCall           *call,
+                               ply_upstart_monitor_job_t *job)
+{
+  DBusMessage *reply;
+  DBusError error;
+  char **instances;
+  int n_instances, i;
+
+  assert (call != NULL);
+  assert (job != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_error_init (&error);
+  dbus_message_get_args (reply, &error,
+                         DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH,
+                         &instances, &n_instances,
+                         DBUS_TYPE_INVALID);
+  if (dbus_error_is_set (&error))
+    goto out;
+  dbus_error_free (&error);
+
+  for (i = 0; i < n_instances; ++i)
+    add_instance (job, instances[i]);
+
+  dbus_free_string_array (instances);
+
+out:
+  dbus_message_unref (reply);
+}
+
+static void
+free_job_instance (void *key, void *data, void *user_data)
+{
+  const char *path = key;
+  ply_upstart_monitor_instance_t *instance = data;
+  ply_upstart_monitor_t *monitor = user_data;
+
+  assert (monitor != NULL);
+
+  if (instance == NULL)
+    return;
+
+  hashtable_remove_and_free_key (monitor->all_instances, path);
+  free (instance->properties.name);
+  free (instance->properties.goal);
+  free (instance->properties.state);
+  free (instance);
+}
+
+static void
+remove_job_internal (ply_upstart_monitor_t *monitor, const char *path)
+{
+  ply_upstart_monitor_job_t *job;
+  ply_list_node_t *node;
+
+  job = hashtable_remove_and_free_key (monitor->jobs, path);
+  if (job == NULL)
+    return;
+
+  node = ply_list_get_first_node (job->pending_calls);
+  while (node != NULL)
+    {
+      DBusPendingCall *call;
+      ply_list_node_t *next_node;
+
+      call = ply_list_node_get_data (node);
+      next_node = ply_list_get_next_node (job->pending_calls, node);
+      dbus_pending_call_cancel (call);
+      dbus_pending_call_unref (call);
+      node = next_node;
+    }
+  ply_list_free (job->pending_calls);
+
+  free (job->properties.name);
+  free (job->properties.description);
+  ply_hashtable_foreach (job->instances, free_job_instance, monitor);
+  ply_hashtable_free (job->instances);
+  free (job);
+}
+
+static void
+add_job (ply_upstart_monitor_t *monitor, const char *path)
+{
+  ply_upstart_monitor_job_t *job;
+  DBusMessage *message;
+  const char *interface = UPSTART_INTERFACE_0_6_JOB;
+  DBusPendingCall *call;
+
+  ply_trace ("adding job: %s", path);
+
+  remove_job_internal (monitor, path);
+
+  job = calloc (1, sizeof (ply_upstart_monitor_job_t));
+  job->monitor = monitor;
+  job->properties.name = NULL;
+  job->properties.description = NULL;
+  job->properties.is_task = false;
+  job->instances = ply_hashtable_new (ply_hashtable_string_hash,
+                                      ply_hashtable_string_compare);
+  job->pending_calls = ply_list_new ();
+
+  ply_hashtable_insert (monitor->jobs, strdup (path), job);
+
+  /* Ask Upstart for the name and description properties. */
+  ply_trace ("fetching properties of job %s", path);
+  message = dbus_message_new_method_call (UPSTART_SERVICE, path,
+                                          DBUS_INTERFACE_PROPERTIES, "GetAll");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING, &interface,
+                            DBUS_TYPE_INVALID);
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    {
+      dbus_pending_call_set_notify (call,
+                                    (DBusPendingCallNotifyFunction)
+                                    on_get_all_job_properties_finished,
+                                    job,
+                                    NULL);
+      ply_list_append_data (job->pending_calls, call);
+    }
+
+  /* Ask Upstart for a list of all instances of this job. */
+  ply_trace ("calling GetAllInstances on job %s", path);
+  message = dbus_message_new_method_call (UPSTART_SERVICE, path,
+                                          UPSTART_INTERFACE_0_6_JOB,
+                                          "GetAllInstances");
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    {
+      dbus_pending_call_set_notify (call,
+                                    (DBusPendingCallNotifyFunction)
+                                    on_get_all_instances_finished,
+                                    job,
+                                    NULL);
+      ply_list_append_data (job->pending_calls, call);
+    }
+}
+
+static void
+remove_job (ply_upstart_monitor_t *monitor, const char *path)
+{
+  ply_trace ("removing job: %s", path);
+
+  remove_job_internal (monitor, path);
+}
+
+static void
+on_get_all_jobs_finished (DBusPendingCall       *call,
+                          ply_upstart_monitor_t *monitor)
+{
+  DBusMessage *reply;
+  DBusError error;
+  char **jobs;
+  int n_jobs, i;
+
+  assert (call != NULL);
+  assert (monitor != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_error_init (&error);
+  dbus_message_get_args (reply, &error,
+                         DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH,
+                         &jobs, &n_jobs,
+                         DBUS_TYPE_INVALID);
+  if (dbus_error_is_set (&error))
+    goto out;
+  dbus_error_free (&error);
+
+  for (i = 0; i < n_jobs; ++i)
+    add_job (monitor, jobs[i]);
+
+  dbus_free_string_array (jobs);
+
+out:
+  dbus_message_unref (reply);
+}
+
+static void
+on_get_name_owner_finished (DBusPendingCall       *call,
+                            ply_upstart_monitor_t *monitor)
+{
+  DBusMessage *reply, *message;
+  DBusError error;
+  const char *owner;
+
+  assert (call != NULL);
+  assert (monitor != NULL);
+
+  reply = dbus_pending_call_steal_reply (call);
+  if (reply == NULL)
+    return;
+  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+    goto out;
+
+  dbus_error_init (&error);
+  dbus_message_get_args (reply, &error,
+                         DBUS_TYPE_STRING, &owner,
+                         DBUS_TYPE_INVALID);
+  if (dbus_error_is_set (&error))
+    goto out;
+  dbus_error_free (&error);
+
+  ply_trace ("owner = '%s'", owner);
+
+  free (monitor->owner);
+  monitor->owner = strdup (owner);
+
+  ply_trace ("calling GetAllJobs");
+  message = dbus_message_new_method_call (UPSTART_SERVICE, UPSTART_PATH,
+                                          UPSTART_INTERFACE_0_6,
+                                          "GetAllJobs");
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    dbus_pending_call_set_notify (call,
+                                  (DBusPendingCallNotifyFunction)
+                                  on_get_all_jobs_finished,
+                                  monitor, NULL);
+
+out:
+  dbus_message_unref (reply);
+}
+
+static DBusHandlerResult
+name_owner_changed_handler (DBusConnection        *connection,
+                            DBusMessage           *message,
+                            ply_upstart_monitor_t *monitor)
+{
+  DBusError error;
+  const char *name, *old_owner, *new_owner;
+
+  assert (connection != NULL);
+  assert (message != NULL);
+  assert (monitor != NULL);
+
+  dbus_error_init (&error);
+  if (dbus_message_get_args (message, &error,
+                             DBUS_TYPE_STRING, &name,
+                             DBUS_TYPE_STRING, &old_owner,
+                             DBUS_TYPE_STRING, &new_owner,
+                             DBUS_TYPE_INVALID) &&
+      strcmp (name, UPSTART_SERVICE) == 0)
+    {
+      if (new_owner)
+        ply_trace ("owner changed from '%s' to '%s'", old_owner, new_owner);
+      else
+        ply_trace ("owner left bus");
+      free (monitor->owner);
+      monitor->owner = new_owner ? strdup (new_owner) : NULL;
+    }
+
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* let other handlers try */
+}
+
+static DBusHandlerResult
+job_added_handler (DBusConnection        *connection,
+                   DBusMessage           *message,
+                   ply_upstart_monitor_t *monitor)
+{
+  DBusError error;
+  const char *signal_path;
+
+  ply_trace ("got JobAdded");
+  dbus_error_init (&error);
+  if (dbus_message_get_args (message, &error,
+                             DBUS_TYPE_OBJECT_PATH, &signal_path,
+                             DBUS_TYPE_INVALID))
+    add_job (monitor, signal_path);
+  dbus_error_free (&error);
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+job_removed_handler (DBusConnection        *connection,
+                     DBusMessage           *message,
+                     ply_upstart_monitor_t *monitor)
+{
+  DBusError error;
+  const char *signal_path;
+
+  ply_trace ("got JobRemoved");
+  dbus_error_init (&error);
+  if (dbus_message_get_args (message, &error,
+                             DBUS_TYPE_OBJECT_PATH, &signal_path,
+                             DBUS_TYPE_INVALID))
+    remove_job (monitor, signal_path);
+  dbus_error_free (&error);
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+instance_added_handler (DBusConnection *connection, DBusMessage *message,
+                        ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *signal_path;
+  ply_upstart_monitor_job_t *job;
+
+  ply_trace ("got %s InstanceAdded", path);
+  job = ply_hashtable_lookup (monitor->jobs, (void *) path);
+  if (job != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_OBJECT_PATH, &signal_path,
+                                 DBUS_TYPE_INVALID))
+        add_instance (job, signal_path);
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+instance_removed_handler (DBusConnection *connection, DBusMessage *message,
+                          ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *signal_path;
+  ply_upstart_monitor_job_t *job;
+
+  ply_trace ("got %s InstanceRemoved", path);
+  job = ply_hashtable_lookup (monitor->jobs, (void *) path);
+  if (job != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_OBJECT_PATH, &signal_path,
+                                 DBUS_TYPE_INVALID))
+        remove_instance (job, signal_path);
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+goal_changed_handler (DBusConnection *connection, DBusMessage *message,
+                      ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *goal;
+  ply_upstart_monitor_instance_t *instance;
+  char *old_goal;
+
+  ply_trace ("got %s GoalChanged", path);
+  instance = ply_hashtable_lookup (monitor->all_instances, (void *) path);
+  if (instance != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_STRING, &goal,
+                                 DBUS_TYPE_INVALID))
+        {
+          old_goal = instance->properties.goal;
+          instance->properties.goal = strdup (goal);
+          ply_trace ("goal changed from '%s' to '%s'", old_goal, goal);
+          free (old_goal);
+        }
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+state_changed_handler (DBusConnection *connection, DBusMessage *message,
+                       ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  const char *state;
+  ply_upstart_monitor_instance_t *instance;
+  char *old_state;
+
+  ply_trace ("got %s StateChanged", path);
+  instance = ply_hashtable_lookup (monitor->all_instances, (void *) path);
+  if (instance != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_STRING, &state,
+                                 DBUS_TYPE_INVALID))
+        {
+          old_state = instance->properties.state;
+          instance->properties.state = strdup (state);
+          ply_trace ("state changed from '%s' to '%s'", old_state, state);
+          if (strcmp (state, "starting") == 0)
+            {
+              /* Clear any old failed information. */
+              instance->properties.failed = 0;
+              instance->call_failed = false;
+            }
+          if (instance_is_initialized (instance))
+            {
+              if (monitor->state_changed_handler)
+                monitor->state_changed_handler (monitor->state_changed_data,
+                                                old_state,
+                                                &instance->job->properties,
+                                                &instance->properties);
+            }
+          else
+            instance->state_changed = true;
+          free (old_state);
+        }
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+failed_handler (DBusConnection *connection, DBusMessage *message,
+                ply_upstart_monitor_t *monitor, const char *path)
+{
+  DBusError error;
+  ply_upstart_monitor_instance_t *instance;
+  dbus_int32_t failed_status;
+
+  ply_trace ("got %s Failed", path);
+  instance = ply_hashtable_lookup (monitor->all_instances, (void *) path);
+  if (instance != NULL)
+    {
+      dbus_error_init (&error);
+      if (dbus_message_get_args (message, &error,
+                                 DBUS_TYPE_INT32, &failed_status,
+                                 DBUS_TYPE_INVALID))
+        {
+          instance->properties.failed = failed_status;
+          if (instance_is_initialized (instance))
+            {
+              if (monitor->failed_handler)
+                monitor->failed_handler (monitor->failed_data,
+                                         &instance->job->properties,
+                                         &instance->properties,
+                                         (int) failed_status);
+            }
+          else
+            instance->call_failed = true;
+        }
+      dbus_error_free (&error);
+    }
+  return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static DBusHandlerResult
+message_handler (DBusConnection *connection, DBusMessage *message, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  const char *path;
+
+  assert (connection != NULL);
+  assert (message != NULL);
+  assert (monitor != NULL);
+
+  path = dbus_message_get_path (message);
+  if (path == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
+                              "NameOwnerChanged") &&
+      dbus_message_has_path (message, DBUS_PATH_DBUS) &&
+      dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+    return name_owner_changed_handler (connection, message, monitor);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6,
+                              "JobAdded"))
+    return job_added_handler (connection, message, monitor);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6,
+                              "JobRemoved"))
+    return job_removed_handler (connection, message, monitor);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_JOB,
+                              "InstanceAdded"))
+    return instance_added_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_JOB,
+                              "InstanceRemoved"))
+    return instance_removed_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_INSTANCE,
+                              "GoalChanged"))
+    return goal_changed_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_INSTANCE,
+                              "StateChanged"))
+    return state_changed_handler (connection, message, monitor, path);
+
+  if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6_INSTANCE,
+                              "Failed"))
+    return failed_handler (connection, message, monitor, path);
+
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+ply_upstart_monitor_t *
+ply_upstart_monitor_new (ply_event_loop_t *loop)
+{
+  DBusError error;
+  DBusConnection *connection;
+  ply_upstart_monitor_t *monitor;
+  char *rule;
+  DBusMessage *message;
+  const char *monitor_service = UPSTART_SERVICE;
+  DBusPendingCall *call;
+
+  dbus_error_init (&error);
+
+  /* Get a connection to the system bus and set it up to listen for messages
+   * from Upstart.
+   */
+  connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
+  if (connection == NULL)
+    {
+      ply_error ("unable to connect to system bus: %s", error.message);
+      dbus_error_free (&error);
+      return NULL;
+    }
+  dbus_error_free (&error);
+
+  monitor = calloc (1, sizeof (ply_upstart_monitor_t));
+  monitor->connection = connection;
+  monitor->loop = NULL;
+  monitor->jobs = ply_hashtable_new (ply_hashtable_string_hash,
+                                     ply_hashtable_string_compare);
+  monitor->all_instances = ply_hashtable_new (ply_hashtable_string_hash,
+                                              ply_hashtable_string_compare);
+  monitor->state_changed_handler = NULL;
+  monitor->state_changed_data = NULL;
+  monitor->failed_handler = NULL;
+  monitor->failed_data = NULL;
+  monitor->dispatch_fd = -1;
+
+  if (!dbus_connection_add_filter (connection, message_handler, monitor, NULL))
+    {
+      ply_error ("unable to add filter to system bus connection");
+      ply_upstart_monitor_free (monitor);
+      return NULL;
+    }
+
+  asprintf (&rule, "type='%s',sender='%s',path='%s',"
+                   "interface='%s',member='%s',arg0='%s'",
+            "signal", DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+            DBUS_INTERFACE_DBUS, "NameOwnerChanged", UPSTART_SERVICE);
+  dbus_bus_add_match (connection, rule, &error);
+  free (rule);
+  if (dbus_error_is_set (&error))
+    {
+      ply_error ("unable to add match rule to system bus connection: %s",
+                 error.message);
+      ply_upstart_monitor_free (monitor);
+      dbus_error_free (&error);
+      return NULL;
+    }
+
+  asprintf (&rule, "type='%s',sender='%s'", "signal", UPSTART_SERVICE);
+  dbus_bus_add_match (connection, rule, &error);
+  free (rule);
+  if (dbus_error_is_set (&error))
+    {
+      ply_error ("unable to add match rule to system bus connection: %s",
+                 error.message);
+      ply_upstart_monitor_free (monitor);
+      dbus_error_free (&error);
+      return NULL;
+    }
+
+  /* Start the state machine going: find out the current owner of the
+   * well-known Upstart name.
+   * Ignore errors: the worst case is that we don't get any messages back
+   * and our state machine does nothing.
+   */
+  ply_trace ("calling GetNameOwner");
+  message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+                                          DBUS_INTERFACE_DBUS, "GetNameOwner");
+  dbus_message_append_args (message,
+                            DBUS_TYPE_STRING, &monitor_service,
+                            DBUS_TYPE_INVALID);
+  dbus_connection_send_with_reply (connection, message, &call, -1);
+  dbus_message_unref (message);
+  if (call != NULL)
+    dbus_pending_call_set_notify (call,
+                                  (DBusPendingCallNotifyFunction)
+                                  on_get_name_owner_finished,
+                                  monitor,
+                                  NULL);
+
+  if (loop != NULL)
+    ply_upstart_monitor_connect_to_event_loop (monitor, loop);
+
+  return monitor;
+}
+
+void
+ply_upstart_monitor_free (ply_upstart_monitor_t *monitor)
+{
+  if (monitor == NULL)
+    return;
+
+  ply_hashtable_free (monitor->all_instances);
+  ply_hashtable_free (monitor->jobs);
+  dbus_connection_unref (monitor->connection);
+  if (monitor->dispatch_fd >= 0)
+    close (monitor->dispatch_fd);
+  free (monitor);
+}
+
+static void
+read_watch_handler (void *data, int fd)
+{
+  DBusWatch *watch = data;
+
+  assert (watch != NULL);
+
+  dbus_watch_handle (watch, DBUS_WATCH_READABLE);
+}
+
+static void
+write_watch_handler (void *data, int fd)
+{
+  DBusWatch *watch = data;
+
+  assert (watch != NULL);
+
+  dbus_watch_handle (watch, DBUS_WATCH_WRITABLE);
+}
+
+static dbus_bool_t
+add_watch (DBusWatch *watch, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  unsigned int flags;
+  int fd;
+  ply_event_loop_fd_status_t status;
+  ply_fd_watch_t *read_watch_event = NULL, *write_watch_event = NULL;
+
+  assert (monitor != NULL);
+  assert (watch != NULL);
+
+  if (!dbus_watch_get_enabled (watch))
+    return TRUE;
+
+  assert (dbus_watch_get_data (watch) == NULL);
+
+  flags = dbus_watch_get_flags (watch);
+  fd = dbus_watch_get_unix_fd (watch);
+
+  if (flags & DBUS_WATCH_READABLE)
+    {
+      status = PLY_EVENT_LOOP_FD_STATUS_HAS_DATA;
+      read_watch_event = ply_event_loop_watch_fd (monitor->loop, fd, status,
+                                                  read_watch_handler, NULL,
+                                                  watch);
+      if (read_watch_event == NULL)
+        return FALSE;
+      dbus_watch_set_data (watch, read_watch_event, NULL);
+    }
+
+  if (flags & DBUS_WATCH_WRITABLE)
+    {
+      status = PLY_EVENT_LOOP_FD_STATUS_CAN_TAKE_DATA;
+      write_watch_event = ply_event_loop_watch_fd (monitor->loop, fd, status,
+                                                   write_watch_handler, NULL,
+                                                   watch);
+      if (write_watch_event == NULL)
+        {
+          if (read_watch_event != NULL)
+            ply_event_loop_stop_watching_fd (monitor->loop, read_watch_event);
+          return FALSE;
+        }
+      dbus_watch_set_data (watch, write_watch_event, NULL);
+    }
+
+  return TRUE;
+}
+
+static void
+remove_watch (DBusWatch *watch, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  ply_fd_watch_t *watch_event;
+
+  assert (monitor != NULL);
+  assert (watch != NULL);
+
+  watch_event = dbus_watch_get_data (watch);
+  if (watch_event == NULL)
+    return;
+
+  ply_event_loop_stop_watching_fd (monitor->loop, watch_event);
+
+  dbus_watch_set_data (watch, NULL, NULL);
+}
+
+static void
+toggled_watch (DBusWatch *watch, void *data)
+{
+  if (dbus_watch_get_enabled (watch))
+    add_watch (watch, data);
+  else
+    remove_watch (watch, data);
+}
+
+static ply_upstart_monitor_timeout_t *
+timeout_user_data_new (ply_upstart_monitor_t *monitor, DBusTimeout *timeout)
+{
+  ply_upstart_monitor_timeout_t *monitor_timeout;
+
+  monitor_timeout = calloc (1, sizeof (ply_upstart_monitor_timeout_t));
+  monitor_timeout->monitor = monitor;
+  monitor_timeout->timeout = timeout;
+
+  return monitor_timeout;
+}
+
+static void
+timeout_user_data_free (void *data)
+{
+  ply_upstart_monitor_timeout_t *monitor_timeout = data;
+
+  free (monitor_timeout);
+}
+
+static void
+timeout_handler (void *data, ply_event_loop_t *loop)
+{
+  ply_upstart_monitor_timeout_t *monitor_timeout = data;
+
+  assert (monitor_timeout != NULL);
+
+  dbus_timeout_handle (monitor_timeout->timeout);
+}
+
+static dbus_bool_t
+add_timeout (DBusTimeout *timeout, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  int interval;
+  ply_upstart_monitor_timeout_t *monitor_timeout;
+
+  assert (monitor != NULL);
+  assert (timeout != NULL);
+
+  if (!dbus_timeout_get_enabled (timeout))
+    return TRUE;
+
+  interval = dbus_timeout_get_interval (timeout) * 1000;
+
+  monitor_timeout = timeout_user_data_new (monitor, timeout);
+
+  ply_event_loop_watch_for_timeout (monitor->loop, (double) interval,
+                                    timeout_handler, monitor_timeout);
+
+  dbus_timeout_set_data (timeout, monitor_timeout, timeout_user_data_free);
+
+  return TRUE;
+}
+
+static void
+remove_timeout (DBusTimeout *timeout, void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  ply_upstart_monitor_timeout_t *monitor_timeout;
+
+  assert (monitor != NULL);
+  assert (timeout != NULL);
+
+  monitor_timeout = dbus_timeout_get_data (timeout);
+  if (monitor_timeout == NULL)
+    return;
+
+  ply_event_loop_stop_watching_for_timeout (monitor->loop,
+                                            timeout_handler, monitor_timeout);
+
+  dbus_timeout_set_data (timeout, NULL, NULL);
+}
+
+static void
+toggled_timeout (DBusTimeout *timeout, void *data)
+{
+  if (dbus_timeout_get_enabled (timeout))
+    add_timeout (timeout, data);
+  else
+    remove_timeout (timeout, data);
+}
+
+static void
+dispatch_status (DBusConnection *connection, DBusDispatchStatus new_status,
+                 void *data)
+{
+  ply_upstart_monitor_t *monitor = data;
+  uint64_t event_payload;
+
+  assert (monitor != NULL);
+
+  if (new_status != DBUS_DISPATCH_DATA_REMAINS)
+    return;
+
+  /* wake up event loop */
+  event_payload = 1;
+  ply_write (monitor->dispatch_fd, &event_payload, sizeof (event_payload));
+}
+
+static void
+dispatch (void *data, int fd)
+{
+  ply_upstart_monitor_t *monitor = data;
+  uint64_t event_payload;
+
+  assert (monitor != NULL);
+
+  /* reset eventfd to zero */
+  ply_read (fd, &event_payload, sizeof (event_payload));
+
+  while (dbus_connection_dispatch (monitor->connection) ==
+         DBUS_DISPATCH_DATA_REMAINS)
+    ;
+}
+
+bool
+ply_upstart_monitor_connect_to_event_loop (ply_upstart_monitor_t    *monitor,
+                                           ply_event_loop_t         *loop)
+{
+  ply_fd_watch_t *dispatch_event = NULL;
+  uint64_t event_payload;
+
+  assert (monitor != NULL);
+
+  monitor->loop = loop;
+  monitor->dispatch_fd = -1;
+
+  if (!dbus_connection_set_watch_functions (monitor->connection,
+                                            add_watch,
+                                            remove_watch,
+                                            toggled_watch,
+                                            monitor, NULL))
+    goto err;
+
+  if (!dbus_connection_set_timeout_functions (monitor->connection,
+                                              add_timeout,
+                                              remove_timeout,
+                                              toggled_timeout,
+                                              monitor, NULL))
+    goto err;
+
+  monitor->dispatch_fd = eventfd (0, EFD_CLOEXEC | EFD_NONBLOCK);
+  if (monitor->dispatch_fd < 0)
+    goto err;
+  /* make sure we wake up to dispatch the first time through */
+  event_payload = 1;
+  ply_write (monitor->dispatch_fd, &event_payload, sizeof (event_payload));
+
+  dispatch_event = ply_event_loop_watch_fd (monitor->loop,
+                                            monitor->dispatch_fd,
+                                            PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,
+                                            dispatch, NULL, monitor);
+  if (dispatch_event == NULL)
+    goto err;
+
+  dbus_connection_set_dispatch_status_function (monitor->connection,
+                                                dispatch_status,
+                                                monitor, NULL);
+
+  return true;
+
+err:
+  dbus_connection_set_watch_functions (monitor->connection,
+                                       NULL, NULL, NULL, NULL, NULL);
+  dbus_connection_set_timeout_functions (monitor->connection,
+                                         NULL, NULL, NULL, NULL, NULL);
+  dbus_connection_set_dispatch_status_function (monitor->connection,
+                                                NULL, NULL, NULL);
+  if (dispatch_event != NULL)
+    ply_event_loop_stop_watching_fd (monitor->loop, dispatch_event);
+  if (monitor->dispatch_fd >= 0)
+    {
+      close (monitor->dispatch_fd);
+      monitor->dispatch_fd = -1;
+    }
+  monitor->loop = NULL;
+  return false;
+}
+
+void
+ply_upstart_monitor_add_state_changed_handler (ply_upstart_monitor_t                       *monitor,
+                                               ply_upstart_monitor_state_changed_handler_t  handler,
+                                               void                                        *user_data)
+{
+  monitor->state_changed_handler = handler;
+  monitor->state_changed_data = user_data;
+}
+
+void
+ply_upstart_monitor_add_failed_handler (ply_upstart_monitor_t                *monitor,
+                                        ply_upstart_monitor_failed_handler_t  handler,
+                                        void                                 *user_data)
+{
+  monitor->failed_handler = handler;
+  monitor->failed_data = user_data;
+}
+/* vim: set ts=4 sw=4 expandtab autoindent cindent cino={.5s,(0: */

=== modified file 'debian/changelog'
--- debian/changelog	2014-03-06 17:52:51 +0000
+++ debian/changelog	2014-03-14 10:43:52 +0000
@@ -1,10 +1,32 @@
 plymouth (0.8.8-0ubuntu16) UNRELEASED; urgency=medium
 
+  [ Steve Langasek ]
   * Fix debian/patches/tty1-after-boot.patch: when we have multiple
     non-default console options on the kernel commandline,
     local_console_terminal will not be set, so we should avoid the resulting
     assert.  LP: #1160079, LP: #1235231.
 
+  [ Dimitri John Ledkov ] LP: #1292458
+  * debian/patches/use-upstart-private-socket.patch: instead of using
+    system dbus, use private upstart socket in the plymouth-upstart-bridge.
+  * debian/plymouth.plymouth-upstart-bridge.upstart: start
+    plymouth-upstart-bridge on startup, and thus gather a more complete
+    boot.log.
+  * debian/patches/dont-bail-on-dummy-terms.patch: don't bail
+    plymouth-upstart-bridge if TERM is not set and/or running on a dummy
+    terminal, as we can run on those. This makes console-log useful in
+    lxc-containers and actually contain messages from upstart jobs
+    starting and stopping.
+  * debian/patches/no-print-empty-description.patch: do not store
+    description when dbus returns empty string, and thus stop printing
+    empty "Starting... done" messages. LP: #1185560.
+  * debian/plymouth.plymouth-upstart-bridge.upstart: update stop on
+    conditions to stop when plymouth-shutdown finishes.
+  * Make ubuntu-logo theme support scale factor, provide one plymouth
+    theme with scale 1 and another with scale 2, until scale factor can be
+    dynamically detected.
+  * Mark plymouth-upstart-bridge to respawn.
+
  -- Steve Langasek <[e-mail]>  Tue, 04 Mar 2014 14:30:16 -0800
 
 plymouth (0.8.8-0ubuntu15) trusty; urgency=medium

=== modified file 'debian/control'
--- debian/control	2014-02-04 17:07:35 +0000
+++ debian/control	2014-03-14 10:43:52 +0000
@@ -178,7 +178,7 @@
 
 Package: plymouth-theme-ubuntu-logo
 Architecture: any
-Depends: plymouth, plymouth-label, ${misc:Depends}, ${shlibs:Depends}
+Depends: plymouth, plymouth-label, ttf-ubuntu-font-family, ${misc:Depends}, ${shlibs:Depends}
 Provides: plymouth-theme
 Replaces: plymouth (<< 0.8.1-1~)
 Description: graphical boot animation and logger - ubuntu-logo theme

=== added file 'debian/patches/dont-bail-on-dummy-terms.patch'
--- debian/patches/dont-bail-on-dummy-terms.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/dont-bail-on-dummy-terms.patch	2014-03-14 10:43:52 +0000
@@ -0,0 +1,17 @@
+Description: don't bail plymouth-upstart-bridge if TERM is not set
+ and/or running on a dummy terminal, as we can run on those.
+Author: Dimitri John Ledkov <[e-mail]>
+
+--- a/src/upstart-bridge/plymouth-upstart-bridge.c
++++ b/src/upstart-bridge/plymouth-upstart-bridge.c
+@@ -307,7 +307,9 @@
+   if (should_be_verbose && !ply_is_tracing ())
+     ply_toggle_tracing ();
+ 
+-  setupterm (NULL, STDOUT_FILENO, NULL);
++  /* Don't bail on dummy/hardcopy terminals */
++  int errret=0;
++  setupterm (NULL, STDOUT_FILENO, &errret);
+ 
+   is_connected = ply_boot_client_connect (state.client,
+                                           (ply_boot_client_disconnect_handler_t)

=== added file 'debian/patches/no-print-empty-description.patch'
--- debian/patches/no-print-empty-description.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/no-print-empty-description.patch	2014-03-14 10:43:52 +0000
@@ -0,0 +1,14 @@
+Description: do not store empty descriptions
+Author: Dimitri John Ledkov <[e-mail]>
+
+--- plymouth-0.8.8.orig/src/upstart-bridge/ply-upstart-monitor.c
++++ plymouth-0.8.8/src/upstart-bridge/ply-upstart-monitor.c
+@@ -273,7 +273,7 @@ on_get_all_job_properties_finished (DBus
+               DBUS_TYPE_STRING)
+             goto next_item;
+           dbus_message_iter_get_basic (&variant_iter, &description);
+-          if (description != NULL)
++          if (description != NULL && description[0])
+             {
+               ply_trace ("description = '%s'", description);
+               job->properties.description = strdup (description);

=== modified file 'debian/patches/series'
--- debian/patches/series	2013-12-02 04:53:37 +0000
+++ debian/patches/series	2014-03-14 10:43:52 +0000
@@ -13,3 +13,7 @@
 Miscellaneous-fixes-for-compiler-warnings.patch
 autoreconf.patch
 details-update-status.patch
+use-upstart-private-socket.patch
+dont-bail-on-dummy-terms.patch
+no-print-empty-description.patch
+ubuntu-logo-scale-factor-2.patch

=== added file 'debian/patches/ubuntu-logo-scale-factor-2.patch'
--- debian/patches/ubuntu-logo-scale-factor-2.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/ubuntu-logo-scale-factor-2.patch	2014-03-14 10:43:52 +0000
@@ -0,0 +1,1202 @@
+Description: Make ubuntu-logo theme support scale factor, provide one plymouth
+     theme with scale 1 and another with scale 2, until scale factor can be
+     dynamically detected.
+Author: Dimitri John Ledkov <[e-mail]>
+
+--- a/themes/ubuntu-logo/Makefile.am
++++ b/themes/ubuntu-logo/Makefile.am
+@@ -1,6 +1,7 @@
+ themedir = $(datadir)/plymouth/themes/ubuntu-logo
+-nodist_theme_DATA = ubuntu-logo.plymouth
++nodist_theme_DATA = ubuntu-logo.plymouth ubuntu-logo-scale-2.plymouth
+ dist_theme_DATA =   ubuntu-logo.script                                \
++                    ubuntu-logo-scale-2.script                        \
+                     ubuntu-logo.grub                                  \
+                     ubuntu_logo.png                                   \
+                     ubuntu_logo16.png                                 \
+@@ -13,11 +14,23 @@
+ 
+ 
+ 
+-MAINTAINERCLEANFILES = Makefile.in ubuntu-logo.plymouth
+-CLEANFILES = ubuntu-logo.plymouth
++MAINTAINERCLEANFILES = Makefile.in ubuntu-logo.plymouth ubuntu-logo-scale-2.plymouth ubuntu-logo.script ubuntu-logo-scale-2.script
++CLEANFILES = ubuntu-logo.plymouth ubuntu-logo-scale-2.plymouth ubuntu-logo.script ubuntu-logo-scale-2.script
+ 
+ ubuntu-logo.plymouth: $(srcdir)/ubuntu-logo.plymouth.in
+-	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g' \
++	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g;s,[@]EXTRA_NAME[@],,g;s,[@]SCRIPT_NAME[@],ubuntu-logo,g' \
+ 	       $(srcdir)/ubuntu-logo.plymouth.in > ubuntu-logo.plymouth
+ 
+-EXTRA_DIST = ubuntu-logo.plymouth.in
++ubuntu-logo-scale-2.plymouth: $(srcdir)/ubuntu-logo.plymouth.in
++	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g;s,[@]EXTRA_NAME[@],(Scale x2),g;s,[@]SCRIPT_NAME[@],ubuntu-logo-scale-2,g' \
++	       $(srcdir)/ubuntu-logo.plymouth.in > ubuntu-logo-scale-2.plymouth
++
++ubuntu-logo.script: $(srcdir)/ubuntu-logo.script.in
++	sed -e 's,[@]SCALEFACTOR[@],1,g' \
++	       $(srcdir)/ubuntu-logo.script.in > ubuntu-logo.script
++
++ubuntu-logo-scale-2.script: $(srcdir)/ubuntu-logo.script.in
++	sed -e 's,[@]SCALEFACTOR[@],2,g' \
++	       $(srcdir)/ubuntu-logo.script.in > ubuntu-logo-scale-2.script
++
++EXTRA_DIST = ubuntu-logo.plymouth.in ubuntu-logo.script.in
+--- a/themes/ubuntu-logo/ubuntu-logo.plymouth.in
++++ b/themes/ubuntu-logo/ubuntu-logo.plymouth.in
+@@ -1,8 +1,8 @@
+ [Plymouth Theme]
+-Name=Ubuntu Logo
++Name=Ubuntu Logo @EXTRA_NAME@
+ Description=A theme that features a blank background with a logo.
+ ModuleName=script
+ 
+ [script]
+ ImageDir=@PLYMOUTH_THEME_PATH@/ubuntu-logo
+-ScriptFile=@PLYMOUTH_THEME_PATH@/ubuntu-logo/ubuntu-logo.script
++ScriptFile=@PLYMOUTH_THEME_PATH@/ubuntu-logo/@SCRIPT_NAME@.script
+--- /dev/null
++++ b/themes/ubuntu-logo/ubuntu-logo.script.in
+@@ -0,0 +1,1142 @@
++#  ubuntu-logo.script - boot splash plugin
++# 
++#  Copyright (C) 2009 Canonical Ltd.
++# 
++#  This program is free software; you can redistribute it and/or modify
++#  it under the terms of the GNU General Public License as published by
++#  the Free Software Foundation; either version 2, or (at your option)
++#  any later version.
++# 
++#  This program is distributed in the hope that it will be useful,
++#  but WITHOUT ANY WARRANTY; without even the implied warranty of
++#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++#  GNU General Public License for more details.
++# 
++#  You should have received a copy of the GNU General Public License
++#  along with this program; if not, write to the Free Software
++#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
++#  02111-1307, USA.
++# 
++#  Written by: Alberto Milone <[e-mail]>
++#
++#  Based on the example provided with the "script plugin" written by:
++#              Charlie Brej   <[e-mail]>
++#
++#  Question stuff written by: Markus Waas <[e-mail]>
++#
++# 
++
++# Set the text colour in (rgb / 256)
++text_colour.red = 1.0;
++text_colour.green = 1.0;
++text_colour.blue = 1.0;
++
++# Tinted text #988592
++tinted_text_colour.red = 0.59;
++tinted_text_colour.green = 0.52;
++tinted_text_colour.blue = 0.57;
++
++# Action Text - #ffffff - RGB 255 255 255
++action_text_colour.red = 1.0;
++action_text_colour.green = 1.0;
++action_text_colour.blue = 1.0;
++
++# Orange - #ff4012 - RGB 255 64 18
++debugsprite = Sprite();
++debugsprite_bottom = Sprite();
++debugsprite_medium = Sprite();
++
++# Ubuntu Font
++ubuntufont = "Ubuntu 11";
++ubuntualignment = "center";
++
++# Scale factor
++scalefactor = @SCALEFACTOR@;
++
++# are we currently prompting for a password?
++prompt_active = 0;
++
++# Generic scalable image loader
++fun LoadScaleImage (imagepath) {
++    image = Image (imagepath);
++    image = image.Scale (image.GetWidth() * scalefactor, image.GetHeight() * scalefactor);
++    return image;
++}
++
++# General purpose function to create text
++fun WriteText (text, colour) {
++    image = Image.Text (text, colour.red, colour.green, colour.blue, color.alpha, ubuntufont, ubuntualignment);
++    image = image.Scale (image.GetWidth() * scalefactor, image.GetHeight() * scalefactor);
++    return image;
++}
++
++fun ImageToText (text) {
++    image = WriteText (text, text_colour);
++    return image;
++}
++
++fun ImageToTintedText (text) {
++    image = WriteText (text, tinted_text_colour);
++    return image;
++}
++
++fun ImageToActionText (text) {
++    image = WriteText (text, action_text_colour);
++    return image;
++}
++
++fun Debug(text) {
++    debugsprite.SetImage(ImageToText (text));
++}
++
++fun DebugBottom(text) {
++    debugsprite_bottom.SetImage(ImageToText (text));
++    debugsprite_bottom.SetPosition(0, (Window.GetHeight (0) - 20), 1);
++}
++
++fun DebugMedium(text) {
++    debugsprite_medium.SetImage(ImageToText (text));
++    debugsprite_medium.SetPosition(0, (Window.GetHeight (0) - 60), 1);
++}
++
++fun TextYOffset() {
++    local.y;
++    local.text_height;
++    local.min_height;
++
++    # Put the 1st line below the logo + some spacing 
++    y = logo.y + logo.height + (progress_indicator.bullet_height * 7 ); # + logo_spacing;
++
++    text_height = first_line_height * 7.5;
++
++    min_height = Window.GetHeight();
++    if (y + text_height > min_height)
++        y = min_height - text_height;
++
++    if (y < progress_indicator.y + progress_indicator.height)
++        return progress_indicator.y + progress_indicator.height;
++    return y;
++}
++
++#------------------------------String functions-------------------------------
++
++# This is the equivalent for strstr()
++fun StringString(string, substring) {
++    start = 0;
++    while (String(string).CharAt (start)) {
++        walk = 0;
++        while (String(substring).CharAt (walk) == String(string).CharAt (start + walk) ) {
++            walk++;
++            if (!String(substring).CharAt (walk)) return start;
++        }
++        start++;
++    }
++    
++    return NULL;
++}
++
++fun StringLength (string) {
++    index = 0;
++    while (String(string).CharAt(index)) index++;
++    return index;
++}
++
++fun StringCopy (source, beginning, end) {
++    local.destination = "";
++    for (index = beginning; ( ( (end == NULL) || (index <= end) ) && (String(source).CharAt(index)) ); index++) {
++        local.destination += String(source).CharAt(index);
++    }
++    
++    return local.destination;
++}
++
++fun StringReplace (source, pattern, replacement) {
++    local.found = StringString(source, pattern);
++    if (local.found == NULL)
++        return source;
++
++    local.new_string = StringCopy (source, 0, local.found - 1) +
++                       replacement +
++                       StringCopy (source, local.found + StringLength(pattern), NULL);
++
++    return local.new_string;
++}
++
++# it makes sense to use it only for
++# numbers up to 100
++fun StringToInteger (str) {
++    int = -1;
++    for (i=0; i<=100; i++) {
++        if (i+"" == str) {
++            int = i;
++            break;
++        }
++    }
++    return int;
++}
++
++#-----------------------------------------------------------------------------
++# Previous background colour
++# #300a24 --> 0.19, 0.04, 0.14
++# New background colour
++# #2c001e --> 0.16, 0.00, 0.12
++#
++Window.SetBackgroundTopColor (0.16, 0.00, 0.12);     # Nice colour on top of the screen fading to
++Window.SetBackgroundBottomColor (0.16, 0.00, 0.12);  # an equally nice colour on the bottom
++
++bits_per_pixel = Window.GetBitsPerPixel ();
++if (bits_per_pixel == 4) {
++    logo_filename = "ubuntu_logo16.png";
++    progress_dot_off_filename = "progress_dot_off16.png";
++    progress_dot_on_filename = "progress_dot_on16.png";
++    password_field_filename = "password_field16.png";
++    question_field_filename = "password_field16.png";
++} else {
++    logo_filename = "ubuntu_logo.png";
++    progress_dot_off_filename = "progress_dot_off.png";
++    progress_dot_on_filename = "progress_dot_on.png";
++    password_field_filename = "password_field.png";
++    question_field_filename = "password_field.png";
++}
++
++logo.image = LoadScaleImage (logo_filename);
++logo.sprite = Sprite ();
++logo.sprite.SetImage (logo.image);
++logo.width = logo.image.GetWidth ();
++logo.height = logo.image.GetHeight ();
++logo.x = Window.GetX () + Window.GetWidth () / 2 - logo.width  / 2;
++logo.y = Window.GetY () + Window.GetHeight () / 2 - logo.height;
++logo.z = 1000;
++logo.sprite.SetX (logo.x);
++logo.sprite.SetY (logo.y);
++logo.sprite.SetZ (logo.z);
++logo.sprite.SetOpacity (1);
++
++# Spacing below the logo - in pixels
++logo_spacing = logo.height * 4;
++
++message_notification[0].image = ImageToTintedText ("");
++message_notification[1].image = ImageToTintedText ("");
++fsck_notification.image = ImageToActionText ("");
++
++status = "normal";
++
++progress_indicator.bullet_off = LoadScaleImage (progress_dot_off_filename);
++progress_indicator.bullet_on = LoadScaleImage (progress_dot_on_filename);
++progress_indicator.bullet_width = progress_indicator.bullet_off.GetWidth ();
++progress_indicator.bullet_height = progress_indicator.bullet_off.GetHeight ();
++progress_indicator.bullet_hspacing = progress_indicator.bullet_width * 1.1;
++progress_indicator.width = progress_indicator.bullet_width * 5;
++progress_indicator.height = progress_indicator.bullet_height;
++progress_indicator.y = logo.y + logo.height + (logo.height / 4);
++progress_indicator.x = Window.GetX () + Window.GetWidth () / 2 - progress_indicator.width / 2; # logo.x + 26;
++
++# use a fixed string with ascending and descending stems to calibrate the
++# bounding box for the first message, so the messages below don't move up
++# and down according to *their* height.
++first_line_height = ImageToTintedText ("AfpqtM").GetHeight();
++
++# if the user has a 640x480 or 800x600 display, we can't quite fit everything
++# (including passphrase prompts) with the target spacing, so scoot the text up
++# a bit if needed.
++top_of_the_text = TextYOffset();
++
++#-----------------------------------------Logo functions------------------------------
++
++# Call this when updating the screen
++fun draw_logo () {
++    logo.sprite.SetX (logo.x);
++    logo.sprite.SetY (logo.y);
++    logo.sprite.SetZ (logo.z);
++    logo.sprite.SetOpacity (1);
++}
++
++
++#-----------------------------------------Progress Indicator--------------------------
++fun set_progress_indicator () {
++    
++    
++    # Here we assume that we can store half bullets on each half of the screen
++    # together with some spacing
++    local.x = progress_indicator.x;
++    
++    for (index = 0; index <= 4; index++) {
++        # Set the "off" bullets
++        progress_indicator.bullets_off[index].sprite = Sprite (progress_indicator.bullet_off);
++        progress_indicator.bullets_off[index].sprite.SetPosition (local.x, progress_indicator.y, 1000);
++        progress_indicator.bullets_off[index].x = local.x;
++        progress_indicator.bullets_off[index].y = progress_indicator.y;
++        progress_indicator.bullets_off[index].sprite.SetOpacity (1);
++        
++        #local.debug_medium_string = "Progress indicator " + index + ": x = " + progress_indicator.bullets_off[index].x +
++        #                  ", y = " + progress_indicator.bullets_off[index].y  + ", logo width = " + logo.width +
++        #                  ", logo height = " + logo.height + " " + screen_width + " " + screen_height;
++        #   
++        #(index % 2) && DebugMedium (local.debug_medium_string) || DebugBottom (local.debug_medium_string);
++
++        # Set the "on" bullets on top of the "off" bullets and make them transparent
++        progress_indicator.bullets_on[index].sprite = Sprite (progress_indicator.bullet_on);
++        progress_indicator.bullets_on[index].x = progress_indicator.bullets_off[index].x;
++        progress_indicator.bullets_on[index].y = progress_indicator.bullets_off[index].y;
++        progress_indicator.bullets_on[index].sprite.SetPosition (progress_indicator.bullets_on[index].x, progress_indicator.bullets_on[index].y, 10000);
++
++        progress_indicator.bullets_on[index].sprite.SetOpacity (0);
++        
++        local.x += progress_indicator.bullet_hspacing;
++    }
++    #local.debug_string = "Progress indicator: x1 = " + progress_indicator.x + ", x2 = " + local.x + ", y = " + progress_indicator.y +
++    #                      ", x logo = " + logo.x + ", y logo = " + logo.y + ", indicator width = " + progress_indicator.width;
++    #Debug(progress_indicator.bullets_off[0].x);
++}
++
++
++# We have 2 bullets, one on top of the other:
++# The white one is on top of the red one and the former should
++# slowly fade so as to get a nice transition effect.
++fun switch_on_bullet (bullets_off, bullets_on, bullet_number, opacity) {
++    local.x = bullets_on[bullet_number].x;
++    local.y = bullets_on[bullet_number].y;
++    local.z = bullets_on[bullet_number].z;
++    
++    # Hide the bullets which are off
++    bullets_off[bullet_number].sprite.SetOpacity (0);
++    
++    # Show the bullets which are on
++    bullets_on[bullet_number].sprite.SetPosition (local.x, local.y, local.z);
++    bullets_on[bullet_number].sprite.SetOpacity (opacity);
++    
++    # Bump the number of times we have switched on bullets
++    global.times_bullets_switched++;
++}
++
++fun switch_off_bullets () {
++    # Debug("Switching off progress indicator");
++    
++    set_progress_indicator ();
++    global.times_bullets_switched = 0;
++    global.on_off = 1;
++}
++
++# This is something that we can call when we exit
++fun switch_on_bullets () {
++    # Debug("Switching off progress indicator");
++    if (!global.progress_indicator.bullets_on) set_progress_indicator ();
++    local = global.progress_indicator;
++
++    for (index = 0; bullets_on[index]; index++) {
++        switch_on_bullet (bullets_off, bullets_on, index, 1.0);
++    }
++}
++
++
++# Implement in boot progress callback
++fun animate_progress_indicator (progress, time) {
++    if (global.progress_time == NULL) {
++        global.progress_time = progress;  #time;
++        switch_off_bullets ();
++    }
++
++#    Debug ("progress = " + progress + ", time = " + time + " times switched = " + global.times_bullets_switched + " on_off " + global.on_off);
++
++#    if (global.times_bullets_switched == NULL)
++#        global.times_bullets_switched = 5;
++
++#    if (global.on_off == NULL)
++#        global.on_off = 0;
++
++    if ((progress - global.progress_time) >= 1.0) {
++        global.progress_time = progress;
++        
++        if (global.times_bullets_switched == 5) {
++            # Change which bullets are switched on
++            # and which ones are switched off
++            global.on_off = !global.on_off;
++            global.times_bullets_switched = 0;
++        }
++        
++        if (global.on_off) {
++            switch_on_bullet (progress_indicator.bullets_off, progress_indicator.bullets_on,
++                              global.times_bullets_switched, 1.0);
++        }
++        else {
++            switch_on_bullet (progress_indicator.bullets_on, progress_indicator.bullets_off,
++                              global.times_bullets_switched, 1.0);
++        }
++    }
++    
++    
++    # Start setting bullets to "on" with translucency
++#    for (index = 0; index <= 5; index++) {
++#        opacity = 0.0;
++#        while (opacity <= 1.0) {
++#            switch_on_bullet (progress_indicator.bullets_off, progress_indicator.bullets_on,
++#                              index, opacity);
++#            opacity += 0.1;
++#        }
++#    }
++}
++
++
++#-----------------------------------------Label utility functions---------------------
++
++# label should be either a string or NULL
++# Images for n lines will be created and returned as items of the
++# message_label array
++#
++fun get_message_label (label, is_fake, is_action_line) {
++    # Debug("Get Label position");
++    local.message_label;
++    
++    if (is_fake)
++        # Create a fake label so as to get the y coordinate of
++        # a standard-length label.
++        local.message_image = ImageToTintedText ("This is a fake message");
++    else
++        local.message_image = (is_action_line) && ImageToActionText (label) || ImageToTintedText (label);
++        
++    message_label.width = message_image.GetWidth ();
++    message_label.height = message_image.GetHeight ();
++
++    # Center the line horizontally
++    message_label.x = Window.GetX () + Window.GetWidth () / 2 - message_label.width / 2;
++
++    message_label.y = top_of_the_text;
++
++    # Put the 2nd line below the fsck line
++    if (is_action_line) {
++        local.fsck_label.y = message_label.y + (first_line_height + first_line_height / 2);
++        message_label.y = local.fsck_label.y + (first_line_height * 2);
++    }
++
++    # Debug("action label x = " + message_label.x + " y = " + message_label.y );
++
++#    message_debug = "msg_x = " + message_label.x + " msg_y = " + message_label.y +
++#                    "msg_width = " + message_label.width + " msg_height = " +
++#                    message_label.height + " message = " + label;
++#    Debug(message_debug);
++    
++    return message_label;
++
++}
++
++# Create an fsck label and/or get its position
++fun get_fsck_label (label, is_fake) {
++    # Debug("Get Label position");
++    local.fsck_label = global.progress_label;
++    
++    if (is_fake)
++        fsck_label.image = ImageToTintedText ("This is a fake message");
++    else
++        fsck_label.image = ImageToTintedText (label);
++    
++    fsck_label.width = fsck_label.image.GetWidth ();
++    fsck_label.height = fsck_label.image.GetHeight ();
++    
++    # Centre the label horizontally
++    fsck_label.x = Window.GetX () + Window.GetWidth () / 2 - fsck_label.width / 2;
++    
++    local.first_label = get_message_label (label, 1, 0);
++    
++    # Place the label below the 1st message line
++    fsck_label.y = local.first_label.y + local.first_label.height + (local.first_label.height / 2);
++    
++#    message_debug = "msg_x = " + fsck_label.x + " msg_y = " + fsck_label.y +
++#                    "msg_width = " + fsck_label.width + " msg_height = " +
++#                    fsck_label.height + " message = " + label;
++#    Debug(message_debug);
++    
++    return fsck_label;
++}
++
++#-----------------------------------------Message stuff --------------------------------
++#
++
++# Set up a message label
++#
++# NOTE: this is called when doing something like 'plymouth message "hello world"'
++#
++fun setup_message (message_text, x, y, z, index) {
++    # Debug("Message setup");
++    global.message_notification[index].image = (index) && ImageToActionText (message_text) || ImageToTintedText (message_text);
++
++    # Set up the text message, if any
++    message_notification[index].x = x;
++    message_notification[index].y = y;
++    message_notification[index].z = z;
++    
++    message_notification[index].sprite = Sprite ();
++    message_notification[index].sprite.SetImage (message_notification[index].image);
++    message_notification[index].sprite.SetX (message_notification[index].x);
++    message_notification[index].sprite.SetY (message_notification[index].y);
++    message_notification[index].sprite.SetZ (message_notification[index].z);
++
++}
++
++fun show_message (index) {
++    if (global.message_notification[index].sprite) global.message_notification[index].sprite.SetOpacity(1);
++}
++
++fun hide_message (index) {
++    if (global.message_notification[index].sprite) global.message_notification[index].sprite.SetOpacity(0);
++}
++
++
++
++
++# the callback function is called when new message should be displayed.
++# First arg is message to display.
++fun message_callback (message)
++{
++    # Debug("Message callback");
++    is_fake = 0;
++    if (!message || (message == "")) is_fake = 1;
++    
++    local.substring = "keys:";
++    
++    # Look for the "keys:" prefix
++    local.keys = StringString(message, local.substring);
++    
++    local.is_action_line = (keys != NULL);
++    #Debug("keys " + local.keys + " substring length = " + StringLength(local.substring));
++
++    # Get the message without the "keys:" prefix
++    if (keys != NULL)
++        message = StringCopy (message, keys + StringLength(local.substring), NULL);
++
++    local.label.is_fake = is_fake;
++    label = get_message_label(message, is_fake, is_action_line);
++    label.z = 10000;
++    
++    setup_message (message, label.x, label.y, label.z, is_action_line);
++    if (prompt_active && local.is_action_line)
++        hide_message (is_action_line);
++    else
++        show_message (is_action_line);
++
++}
++
++
++#-----------------------------------------Display Password stuff -----------------------
++#
++
++fun password_dialogue_setup (message_label) {
++    # Debug("Password dialog setup");
++    
++    local.entry;
++    local.bullet_image;
++    bullet_image = LoadScaleImage (progress_dot_off_filename);
++    entry.image = LoadScaleImage (password_field_filename);
++    
++    # Hide the normal labels
++    prompt_active = 1;
++    if (message_notification[1].sprite) hide_message (1);
++    
++    # Set the prompt label
++    label = get_message_label(message_label, 0, 1);
++    label.z = 10000;
++    
++    setup_message (message_label, label.x, label.y, label.z, 2);
++    show_message (2);
++
++    # Set up the text entry which contains the bullets
++    entry.sprite = Sprite ();
++    entry.sprite.SetImage (entry.image);
++    
++    # Centre the box horizontally
++    entry.x = Window.GetX () + Window.GetWidth () / 2 - entry.image.GetWidth () / 2;
++
++    # Put the entry below the second label.
++    entry.y = message_notification[2].y + label.height;
++
++    #Debug ("entry x = " + entry.x + ", y = " + entry.y);
++    entry.z = 10000;
++    entry.sprite.SetX (entry.x);
++    entry.sprite.SetY (entry.y);
++    entry.sprite.SetZ (entry.z);
++
++    global.password_dialogue = local;
++}
++
++fun password_dialogue_opacity (opacity) {
++    # Debug("Password dialog opacity");
++    global.password_dialogue.opacity = opacity;
++    local = global.password_dialogue;
++
++    # You can make the box translucent with a float
++    # entry.sprite.SetOpacity (0.3);
++    entry.sprite.SetOpacity (opacity);
++    label.sprite.SetOpacity (opacity);
++    
++    if (bullets) {
++        for (index = 0; bullets[index]; index++) {
++            bullets[index].sprite.SetOpacity (opacity);
++        }
++    }
++}
++
++
++# The callback function is called when the display should display a password dialogue.
++# First arg is prompt string, the second is the number of bullets.
++fun display_password_callback (prompt, bullets) {
++    # Debug("Password dialog setup");
++    
++    global.status = "password";
++    if (!global.password_dialogue) password_dialogue_setup(prompt);
++    password_dialogue_opacity (1);
++    bullet_width = password_dialogue.bullet_image.GetWidth();
++    bullet_y = password_dialogue.entry.y +
++               password_dialogue.entry.image.GetHeight () / 2 -
++               password_dialogue.bullet_image.GetHeight () / 2;
++    margin = bullet_width;
++    spaces = Math.Int( (password_dialogue.entry.image.GetWidth () - (margin * 2) ) / ( 2 * bullet_width / 3 ) );
++    #Debug ("spaces = " + spaces + ", bullets = " + bullets);
++    bullets_area.width = margin + spaces * ( 2 * bullet_width / 3);
++    bullets_area.x = Window.GetX () + Window.GetWidth () / 2 - bullets_area.width / 2;
++    #DebugBottom ("pwd_entry x = " + password_dialogue.entry.x + ", bullets_area.x = " + bullets_area.x + ", bullets_area.width = " + bullets_area.width);
++    if (bullets > spaces)
++        bullets = spaces;
++    for (index = 0; password_dialogue.bullets[index] || index < spaces ; index++){
++        if (!password_dialogue.bullets[index]) {
++            password_dialogue.bullets[index].sprite = Sprite ();
++            password_dialogue.bullets[index].sprite.SetImage (password_dialogue.bullet_image);
++            password_dialogue.bullets[index].x = bullets_area.x + # password_dialogue.entry.x + margin +
++                                                 index * ( 2 * bullet_width / 3 ) ;
++            password_dialogue.bullets[index].sprite.SetX (password_dialogue.bullets[index].x);
++            password_dialogue.bullets[index].y = bullet_y;
++            password_dialogue.bullets[index].sprite.SetY (password_dialogue.bullets[index].y);
++            password_dialogue.bullets[index].z = password_dialogue.entry.z + 100 - index;
++            password_dialogue.bullets[index].sprite.SetZ (password_dialogue.bullets[index].z);
++        }
++
++        password_dialogue.bullets[index].sprite.SetOpacity (0);
++
++        if (index < bullets ) {
++            password_dialogue.bullets[index].sprite.SetOpacity (1);
++        }
++    }
++}
++
++Plymouth.SetDisplayPasswordFunction (display_password_callback); 
++
++Plymouth.SetMessageFunction (message_callback);
++
++Plymouth.SetBootProgressFunction (animate_progress_indicator);
++
++# Plymouth.SetBootProgressFunction: the callback function is called with two numbers, the progress (between 0 and 1) and the time spent booting so far
++# Plymouth.SetRootMountedFunction: the callback function is called when a new root is mounted
++# Plymouth.SetKeyboardInputFunction: the callback function is called with a string containing a new character entered on the keyboard
++
++#----------------------------------------- FSCK Counter --------------------------------
++
++# Initialise the counter
++fun init_fsck_count () {
++    # The number of fsck checks in this cycle
++    global.counter.total = 0;
++    # The number of fsck checks already performed + the current one
++    global.counter.current = 1;
++    # The previous fsck
++    global.counter.last = 0;
++}
++
++# Increase the total counter
++fun increase_fsck_count () {
++    global.counter.total++;
++}
++
++fun increase_current_fsck_count () {
++    global.counter.last = global.counter.current++;
++}
++
++# Clear the counter
++fun clear_fsck_count () {
++    global.counter = NULL;
++    init_fsck_count ();
++}
++
++#----------------------------------------- Progress Label ------------------------------
++
++
++# Change the opacity level of a progress label
++#
++# opacity = 1 -> show
++# opacity = 0 -> hide
++# opacity = 0.3 (or any other float) -> translucent
++#
++fun set_progress_label_opacity (opacity) {
++    # the label
++    progress_label.sprite.SetOpacity (opacity);
++    
++    # Make the slot available again when hiding the bar
++    # So that another bar can take its place
++    if (opacity == 0) {
++        progress_label.is_available = 1;
++        progress_label.device = "";
++    }
++}
++
++# Set up a new Progress Bar
++#
++# TODO: Make it possible to reuse (rather than recreate) a bar
++#       if .is_available = 1. Ideally this would just reset the
++#       label, the associated
++#       device and the image size of the sprite.
++
++fun init_progress_label (device, status_string) {
++    # Make the slot unavailable
++    global.progress_label.is_available = 0;
++    progress_label.progress = 0;
++    progress_label.device = device;
++    progress_label.status_string = status_string;
++}
++
++# See if the progress label is keeping track of the fsck
++# of "device"
++#
++fun device_has_progress_label (device) {
++    #DebugBottom ("label device = " + progress_label.device + " checking device " + device);
++    return (progress_label.device == device);
++}
++
++# Update the Progress bar which corresponds to index
++#
++fun update_progress_label (progress) {
++    # If progress is NULL then we just refresh the label.
++    # This happens when only counter.total has changed.
++    if (progress != NULL) {
++        progress_label.progress = progress;
++    
++        #Debug("device " + progress_label.device + " progress " + progress);
++    
++        # If progress >= 100% hide the label and make it available again
++        if (progress >= 100) {
++            set_progress_label_opacity (0);
++        
++            # See if we any other fsck check is complete
++            # and, if so, hide the progress bars and the labels
++            on_fsck_completed ();
++        
++            return 0;
++        }
++    }    
++    # Update progress label here
++    #
++    # FIXME: the queue logic from this theme should really be moved into mountall
++    # instead of using string replacement to deal with localised strings.
++    label = StringReplace (progress_label.status_string[0], "%1$d", global.counter.current);
++    label = StringReplace (label, "%2$d",  global.counter.total);
++    label = StringReplace (label, "%3$d",  progress_label.progress);
++    label = StringReplace (label, "%%",  "%");
++
++    progress_label = get_fsck_label (label, 0);
++    #progress_label.progress = progress;
++
++    progress_label.sprite = Sprite (progress_label.image);
++    
++    # Set up the bar
++    progress_label.sprite.SetPosition(progress_label.x, progress_label.y, 1);
++
++    set_progress_label_opacity (1);
++
++}
++
++# Refresh the label so as to update counters
++fun refresh_progress_label () {
++    update_progress_label (NULL);
++}
++
++#----------------------------------------- FSCK Queue ----------------------------------
++
++# Initialise the fsck queue
++fun init_queue () {
++    global.fsck_queue[0].device;
++    global.fsck_queue[0].progress;
++    global.fsck_queue.counter = 0;
++    global.fsck_queue.biggest_item = 0;    
++}
++
++fun clear_queue () {
++    global.fsck_queue = NULL;
++    init_queue ();
++}
++
++# Return either the device index in the queue or -1
++fun queue_look_up_by_device (device) {
++    for (i=0; i <= fsck_queue.biggest_item; i++) {
++        if ((fsck_queue[i]) && (fsck_queue[i].device == device))
++            return i;
++    }
++    return -1;
++}
++
++# Keep track of an fsck process in the queue
++fun add_fsck_to_queue (device, progress) {
++    # Look for an empty slot in the queue
++    for (i=0; global.fsck_queue[i].device; i++) {
++        continue;
++    }
++    local.index = i;
++    
++    # Set device and progress
++    global.fsck_queue[local.index].device = device;
++    global.fsck_queue[local.index].progress = progress;
++    
++    # Increase the queue counter
++    global.fsck_queue.counter++;
++    
++    # Update the max index of the array for iterations
++    if (local.index > global.fsck_queue.biggest_item)
++        global.fsck_queue.biggest_item = local.index;
++    
++    #DebugMedium ("Adding " + device + " at " + local.index);
++}
++
++fun is_queue_empty () {
++    return (fsck_queue.counter == 0);
++}
++
++fun is_progress_label_available () {
++    return (progress_label.is_available == 1);
++}
++
++
++# This should cover the case in which the fsck checks in
++# the queue are completed before the ones showed in the
++# progress label
++fun on_queued_fsck_completed () {
++    if (!is_queue_empty ())
++        return;
++    
++    # Hide the extra label, if any
++    #if (progress_bar.extra_label.sprite)
++    #    progress_bar.extra_label.sprite.SetOpacity(0);
++}
++
++fun remove_fsck_from_queue (index) {
++    # Free memory which was previously allocated for
++    # device and progress
++    global.fsck_queue[index].device = NULL;
++    global.fsck_queue[index].progress = NULL;
++
++    # Decrease the queue counter
++    global.fsck_queue.counter--;
++    
++    # See if there are other processes in the queue
++    # if not, clear the extra_label
++    on_queued_fsck_completed ();
++}
++
++fun on_fsck_completed () {
++    # We have moved on to tracking the next fsck
++    increase_current_fsck_count ();
++
++    if (!is_progress_label_available ())
++        return;
++    
++    if (!is_queue_empty ())
++        return;
++    
++    # Hide the progress label
++    if (progress_label.sprite)
++        progress_label.sprite.SetOpacity (0);
++    
++    # Clear the queue
++    clear_queue ();
++
++    # Clear the fsck counter
++    clear_fsck_count ();
++}
++
++# Update an fsck process that we keep track of in the queue
++fun update_progress_in_queue (index, device, progress) {
++    # If the fsck is complete, remove it from the queue
++    if (progress >= 100) {
++        remove_fsck_from_queue (index);
++        on_queued_fsck_completed ();
++        return;
++    }
++    
++    global.fsck_queue[index].device = device;
++    global.fsck_queue[index].progress = progress;
++    
++}
++
++# TODO: Move it to some function
++# Create an empty queue
++#init_queue ();
++
++
++#----------------------------------------- FSCK Functions ------------------------------
++
++
++# Either add a new bar for fsck checks or update an existing bar
++#
++# NOTE: no more than "progress_bar.max_number" bars are allowed
++#
++fun fsck_check (device, progress, status_string) {
++
++    # The 1st time this will take place
++    if (!global.progress_label) {
++        # Increase the fsck counter
++        increase_fsck_count ();
++
++        # Set up a new label for the check
++        init_progress_label (device, status_string);
++        update_progress_label (progress);
++
++        return;
++    }
++
++    
++    if (device_has_progress_label (device)) {
++        # Update the progress of the existing label
++        update_progress_label (progress);
++    }
++    else {
++        # See if there's already a slot in the queue for the device
++        local.queue_device_index = queue_look_up_by_device(device);
++
++        # See if the progress_label is available
++        if (progress_label.is_available) {
++            
++#            local.my_string = "available index " + local.available_index + " progress_bar counter is " + progress_bar.counter;
++#            Debug(local.my_string);
++            
++                
++            # If the fsck check for the device was in the queue, then
++            # remove it from the queue
++            if (local.queue_device_index >= 0) {
++                remove_fsck_from_queue (index);
++            }
++            else {
++                # Increase the fsck counter
++                increase_fsck_count ();
++            }
++            
++#            local.my_string += local.message;
++            #Debug("setting new label for device " + device + " progress " + progress);
++
++            # Set up a new label for the check
++            init_progress_label (device, status_string);
++            update_progress_label (progress);
++            
++        }
++        # If the progress_label is not available
++        else {
++            
++            # If the fsck check for the device is already in the queue
++            # just update its progress in the queue
++            if (local.queue_device_index >= 0) {
++                #DebugMedium("Updating queue at " + local.queue_device_index + " for device " + device);
++                update_progress_in_queue (local.queue_device_index, device, progress);
++            }
++            # Otherwise add the check to the queue
++            else {
++                #DebugMedium("Adding device " + device + " to queue at " + local.queue_device_index);
++                add_fsck_to_queue (device, progress);
++
++                # Increase the fsck counter
++                increase_fsck_count ();
++
++                refresh_progress_label ();
++            }
++            
++        }
++    }
++    
++#    if (!is_queue_empty ()) {
++#        DebugBottom("Extra label for "+ device);
++    #}
++#    else {
++#        DebugBottom("No extra label for " + device + ". 1st Device in the queue "+ fsck_queue[0].device + " counter = " + global.fsck_queue.counter);
++#    }
++}
++
++
++#-----------------------------------------Update Status stuff --------------------------
++#
++# The update_status_callback is what we can use to pass plymouth whatever we want so
++# as to make use of features which are available only in this program (as opposed to
++# being available for any theme for the script plugin).
++#
++# Example:
++#
++#   Thanks to the current implementation, some scripts can call "plymouth --update=fsck:sda1:40"
++#   and this program will know that 1) we're performing and fsck check, 2) we're checking sda1,
++#   3) the program should set the label progress to 40%
++#
++# Other features can be easily added by parsing the string that we pass plymouth with "--update"
++#
++fun update_status_callback (status) {
++#    Debug(status);
++    if (!status) return;
++    
++    string_it = 0;
++    update_strings[string_it] = "";
++    
++    for (i=0; (String(status).CharAt(i) != ""); i++) {
++        local.temp_char = String(status).CharAt(i);
++        if (temp_char != ":")
++            update_strings[string_it] += temp_char;
++        else
++            update_strings[++string_it] = "";
++    }
++    
++#    my_string = update_strings[0] + " " + update_strings[1] + " " + update_strings[2];
++#    Debug(my_string);
++    # Let's assume that we're dealing with these strings fsck:sda1:40
++    if ((string_it >= 2) && (update_strings[0] == "fsck")) {
++        
++        device = update_strings[1];
++        progress = update_strings[2];
++        status_string[0] = update_strings[3]; # "Checking disk %1$d of %2$d (%3$d %% complete)"
++        if (!status_string[0])
++            status_string[0] = "Checking disk %1$d of %2$d (%3$d %% complete)";
++        
++        if ((device != "") && (progress != "")) {
++            progress = StringToInteger (progress);
++        
++            # Make sure that the fsck_queue is initialised
++            if (!global.fsck_queue)
++                init_queue ();
++
++            # Make sure that the fsck counter is initialised
++            if (!global.counter)
++                init_fsck_count ();
++
++#            if (!global.progress_bar.extra_label.sprite)
++#                create_extra_fsck_label ();
++            
++            # Keep track of the fsck check
++            fsck_check (device, progress, status_string);
++        }
++        
++    }
++
++}
++Plymouth.SetUpdateStatusFunction (update_status_callback); 
++
++#-----------------------------------------Display Question stuff -----------------------
++
++fun question_dialogue_setup (message_label, text_image) {
++    #Debug("Question dialog setup");
++    
++    local.field;
++    local.content;
++    local.margin;
++    
++    field.image = LoadScaleImage (question_field_filename);
++    content = Sprite ();    
++    bullet_image = LoadScaleImage (progress_dot_off_filename);
++    margin = bullet_image.GetWidth() / 2;
++    
++    # Hide the normal labels
++    prompt_active = 1;
++    if (message_notification[1].sprite) hide_message (1);
++    
++    # Set the prompt label
++    label = get_message_label(message_label, 0, 1);
++    label.z = 10000;
++    
++    setup_message (message_label, label.x, label.y, label.z, 2);
++    show_message (2);
++
++    # Set up the text field which contains the contents
++    field.sprite = Sprite ();
++    field.sprite.SetImage (field.image);
++    
++    # Centre the box horizontally
++    field.x = Window.GetX () + Window.GetWidth () / 2 - field.image.GetWidth () / 2;    
++    content_x = field.x + margin;
++
++    # Put the field below the second label.
++    field.y = message_notification[2].y + label.height;
++    content_y = field.y + field.image.GetHeight () / 2 - text_image.GetHeight () / 2;
++
++    #Debug ("field x = " + field.x + ", y = " + field.y);
++    field.z = 10000;
++    field.sprite.SetX (field.x);
++    field.sprite.SetY (field.y);
++    field.sprite.SetZ (field.z);   
++    
++    #Debug ("content_x = " + content_x + " content_y = " + content_y);
++    content_z = field.z + 1;
++    content.SetPosition (content_x, content_y, content_z);
++
++    global.question_dialogue = local;
++}
++
++# The callback function is called when the display should display a question dialogue.
++# First arg is prompt string, the second is the field contents.
++fun display_question_callback (prompt, contents) {  
++    global.status = "question";
++    #Debug ("Reply: " + contents);
++
++    textImage = ImageToText(contents); 
++    if (!global.question_dialogue) {
++        question_dialogue_setup(prompt, textImage);
++    }    
++
++    margin = global.question_dialogue.margin;
++    fieldWidth = global.question_dialogue.field.image.GetWidth ();
++    for (i = 0; ( (textImage.GetWidth () + 2 * margin ) > fieldWidth ); i++) {        
++        textImage = ImageToText(StringCopy (contents, i, StringLength (contents)));
++    }
++     
++    global.question_dialogue.content.SetImage (textImage);   
++}
++
++
++Plymouth.SetDisplayQuestionFunction (display_question_callback); 
++
++#-----------------------------------------Refresh stuff --------------------------------
++#
++# Calling Plymouth.SetRefreshFunction with a function will set that function to be
++# called up to 50 times every second, e.g.
++#
++# NOTE: if a refresh function is not set, Plymouth doesn't seem to be able to update
++#       the screen correctly
++#
++fun refresh_callback ()
++{
++    draw_logo ();
++}
++Plymouth.SetRefreshFunction (refresh_callback);
++
++
++#-----------------------------------------Display Normal stuff -----------------------
++#
++# The callback function is called when the display should return to normal
++fun display_normal_callback ()
++{
++    global.status = "normal";
++    if (global.password_dialogue) {
++        password_dialogue_opacity (0);
++        global.password_dialogue = NULL;
++        if (message_notification[2].sprite) hide_message(2);
++        prompt_active = 0;
++    }
++    if (global.question_dialogue) {
++        question_dialogue_opacity (0);
++        global.question_dialogue = NULL;
++        if (message_notification[2].sprite) hide_message(2);
++        prompt_active = 0;
++    }
++    
++    if (message_notification[1].sprite) show_message (1);    
++    
++}
++
++Plymouth.SetDisplayNormalFunction (display_normal_callback);
++
++
++#----------------------------------------- Quit --------------------------------
++
++# TODO: Maybe we should also hide any other dialog
++# Show the logo and make the progress indicator look full when on exit
++fun quit_callback ()
++{
++    logo.sprite.SetOpacity (1);
++    switch_on_bullets (); 
++}
++
++Plymouth.SetQuitFunction(quit_callback);

=== added file 'debian/patches/use-upstart-private-socket.patch'
--- debian/patches/use-upstart-private-socket.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/use-upstart-private-socket.patch	2014-03-14 10:43:52 +0000
@@ -0,0 +1,198 @@
+Description: use private upstart socket to start earlier
+Author: Dimitri John Ledkov <[e-mail]>
+
+--- a/src/upstart-bridge/ply-upstart-monitor.c
++++ b/src/upstart-bridge/ply-upstart-monitor.c
+@@ -46,7 +46,6 @@
+ struct _ply_upstart_monitor
+ {
+   DBusConnection                              *connection;
+-  char                                        *owner;
+   ply_event_loop_t                            *loop;
+   ply_hashtable_t                             *jobs;
+   ply_hashtable_t                             *all_instances;
+@@ -74,7 +73,8 @@
+   uint32_t                                   call_failed : 1;
+ } ply_upstart_monitor_instance_t;
+ 
+-#define UPSTART_SERVICE                 "com.ubuntu.Upstart"
++#define UPSTART_SERVICE                 NULL
++#define DBUS_ADDRESS_UPSTART            "unix:abstract=/com/ubuntu/upstart"
+ #define UPSTART_PATH                    "/com/ubuntu/Upstart"
+ #define UPSTART_INTERFACE_0_6           "com.ubuntu.Upstart0_6"
+ #define UPSTART_INTERFACE_0_6_JOB       "com.ubuntu.Upstart0_6.Job"
+@@ -579,82 +579,6 @@
+   dbus_message_unref (reply);
+ }
+ 
+-static void
+-on_get_name_owner_finished (DBusPendingCall       *call,
+-                            ply_upstart_monitor_t *monitor)
+-{
+-  DBusMessage *reply, *message;
+-  DBusError error;
+-  const char *owner;
+-
+-  assert (call != NULL);
+-  assert (monitor != NULL);
+-
+-  reply = dbus_pending_call_steal_reply (call);
+-  if (reply == NULL)
+-    return;
+-  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
+-    goto out;
+-
+-  dbus_error_init (&error);
+-  dbus_message_get_args (reply, &error,
+-                         DBUS_TYPE_STRING, &owner,
+-                         DBUS_TYPE_INVALID);
+-  if (dbus_error_is_set (&error))
+-    goto out;
+-  dbus_error_free (&error);
+-
+-  ply_trace ("owner = '%s'", owner);
+-
+-  free (monitor->owner);
+-  monitor->owner = strdup (owner);
+-
+-  ply_trace ("calling GetAllJobs");
+-  message = dbus_message_new_method_call (UPSTART_SERVICE, UPSTART_PATH,
+-                                          UPSTART_INTERFACE_0_6,
+-                                          "GetAllJobs");
+-  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+-  dbus_message_unref (message);
+-  if (call != NULL)
+-    dbus_pending_call_set_notify (call,
+-                                  (DBusPendingCallNotifyFunction)
+-                                  on_get_all_jobs_finished,
+-                                  monitor, NULL);
+-
+-out:
+-  dbus_message_unref (reply);
+-}
+-
+-static DBusHandlerResult
+-name_owner_changed_handler (DBusConnection        *connection,
+-                            DBusMessage           *message,
+-                            ply_upstart_monitor_t *monitor)
+-{
+-  DBusError error;
+-  const char *name, *old_owner, *new_owner;
+-
+-  assert (connection != NULL);
+-  assert (message != NULL);
+-  assert (monitor != NULL);
+-
+-  dbus_error_init (&error);
+-  if (dbus_message_get_args (message, &error,
+-                             DBUS_TYPE_STRING, &name,
+-                             DBUS_TYPE_STRING, &old_owner,
+-                             DBUS_TYPE_STRING, &new_owner,
+-                             DBUS_TYPE_INVALID) &&
+-      strcmp (name, UPSTART_SERVICE) == 0)
+-    {
+-      if (new_owner)
+-        ply_trace ("owner changed from '%s' to '%s'", old_owner, new_owner);
+-      else
+-        ply_trace ("owner left bus");
+-      free (monitor->owner);
+-      monitor->owner = new_owner ? strdup (new_owner) : NULL;
+-    }
+-
+-  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* let other handlers try */
+-}
+ 
+ static DBusHandlerResult
+ job_added_handler (DBusConnection        *connection,
+@@ -856,12 +780,6 @@
+   if (path == NULL)
+     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ 
+-  if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
+-                              "NameOwnerChanged") &&
+-      dbus_message_has_path (message, DBUS_PATH_DBUS) &&
+-      dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
+-    return name_owner_changed_handler (connection, message, monitor);
+-
+   if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6,
+                               "JobAdded"))
+     return job_added_handler (connection, message, monitor);
+@@ -899,9 +817,7 @@
+   DBusError error;
+   DBusConnection *connection;
+   ply_upstart_monitor_t *monitor;
+-  char *rule;
+   DBusMessage *message;
+-  const char *monitor_service = UPSTART_SERVICE;
+   DBusPendingCall *call;
+ 
+   dbus_error_init (&error);
+@@ -909,7 +825,7 @@
+   /* Get a connection to the system bus and set it up to listen for messages
+    * from Upstart.
+    */
+-  connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
++  connection = dbus_connection_open (DBUS_ADDRESS_UPSTART, &error);
+   if (connection == NULL)
+     {
+       ply_error ("unable to connect to system bus: %s", error.message);
+@@ -938,52 +854,17 @@
+       return NULL;
+     }
+ 
+-  asprintf (&rule, "type='%s',sender='%s',path='%s',"
+-                   "interface='%s',member='%s',arg0='%s'",
+-            "signal", DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+-            DBUS_INTERFACE_DBUS, "NameOwnerChanged", UPSTART_SERVICE);
+-  dbus_bus_add_match (connection, rule, &error);
+-  free (rule);
+-  if (dbus_error_is_set (&error))
+-    {
+-      ply_error ("unable to add match rule to system bus connection: %s",
+-                 error.message);
+-      ply_upstart_monitor_free (monitor);
+-      dbus_error_free (&error);
+-      return NULL;
+-    }
+-
+-  asprintf (&rule, "type='%s',sender='%s'", "signal", UPSTART_SERVICE);
+-  dbus_bus_add_match (connection, rule, &error);
+-  free (rule);
+-  if (dbus_error_is_set (&error))
+-    {
+-      ply_error ("unable to add match rule to system bus connection: %s",
+-                 error.message);
+-      ply_upstart_monitor_free (monitor);
+-      dbus_error_free (&error);
+-      return NULL;
+-    }
+-
+-  /* Start the state machine going: find out the current owner of the
+-   * well-known Upstart name.
+-   * Ignore errors: the worst case is that we don't get any messages back
+-   * and our state machine does nothing.
+-   */
+-  ply_trace ("calling GetNameOwner");
+-  message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+-                                          DBUS_INTERFACE_DBUS, "GetNameOwner");
+-  dbus_message_append_args (message,
+-                            DBUS_TYPE_STRING, &monitor_service,
+-                            DBUS_TYPE_INVALID);
+-  dbus_connection_send_with_reply (connection, message, &call, -1);
++  ply_trace ("calling GetAllJobs");
++  message = dbus_message_new_method_call (UPSTART_SERVICE, UPSTART_PATH,
++                                          UPSTART_INTERFACE_0_6,
++                                          "GetAllJobs");
++  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
+   dbus_message_unref (message);
+   if (call != NULL)
+     dbus_pending_call_set_notify (call,
+                                   (DBusPendingCallNotifyFunction)
+-                                  on_get_name_owner_finished,
+-                                  monitor,
+-                                  NULL);
++                                  on_get_all_jobs_finished,
++                                  monitor, NULL);
+ 
+   if (loop != NULL)
+     ply_upstart_monitor_connect_to_event_loop (monitor, loop);

=== modified file 'debian/plymouth-theme-ubuntu-logo.postinst'
--- debian/plymouth-theme-ubuntu-logo.postinst	2011-04-15 13:35:04 +0000
+++ debian/plymouth-theme-ubuntu-logo.postinst	2014-03-14 10:43:52 +0000
@@ -24,6 +24,12 @@
 		--slave /lib/plymouth/themes/default.grub default.plymouth.grub \
 		/lib/plymouth/themes/ubuntu-logo/ubuntu-logo.grub
 
+	update-alternatives \
+		--install /lib/plymouth/themes/default.plymouth default.plymouth \
+		/lib/plymouth/themes/ubuntu-logo/ubuntu-logo-scale-2.plymouth 99 \
+		--slave /lib/plymouth/themes/default.grub default.plymouth.grub \
+		/lib/plymouth/themes/ubuntu-logo/ubuntu-logo.grub
+
 	if which update-initramfs >/dev/null 2>&1
 	then
 	    update-initramfs -u

=== modified file 'debian/plymouth-theme-ubuntu-logo.prerm'
--- debian/plymouth-theme-ubuntu-logo.prerm	2011-02-09 20:41:53 +0000
+++ debian/plymouth-theme-ubuntu-logo.prerm	2014-03-14 10:43:52 +0000
@@ -5,6 +5,8 @@
 if [ "x$1" = xremove ]; then
 	update-alternatives \
 		--remove default.plymouth /lib/plymouth/themes/ubuntu-logo/ubuntu-logo.plymouth
+	update-alternatives \
+		--remove default.plymouth /lib/plymouth/themes/ubuntu-logo/ubuntu-logo-scale-2.plymouth
 fi
 
 #DEBHELPER#

=== modified file 'debian/plymouth.plymouth-upstart-bridge.upstart'
--- debian/plymouth.plymouth-upstart-bridge.upstart	2012-09-07 18:03:39 +0000
+++ debian/plymouth.plymouth-upstart-bridge.upstart	2014-03-14 10:43:52 +0000
@@ -5,9 +5,12 @@
 
 description	"bridge from Upstart state changes to Plymouth"
 
-start on (started dbus
+respawn
+
+start on (startup
           or runlevel [06])
-stop on stopping plymouth
+stop on (stopping plymouth
+         or stopping plymouth-shutdown)     	
 
 console output
 

=== modified file 'src/upstart-bridge/ply-upstart-monitor.c'
--- src/upstart-bridge/ply-upstart-monitor.c	2011-03-12 22:54:53 +0000
+++ src/upstart-bridge/ply-upstart-monitor.c	2014-03-14 10:43:52 +0000
@@ -46,7 +46,6 @@
 struct _ply_upstart_monitor
 {
   DBusConnection                              *connection;
-  char                                        *owner;
   ply_event_loop_t                            *loop;
   ply_hashtable_t                             *jobs;
   ply_hashtable_t                             *all_instances;
@@ -74,7 +73,8 @@
   uint32_t                                   call_failed : 1;
 } ply_upstart_monitor_instance_t;
 
-#define UPSTART_SERVICE                 "com.ubuntu.Upstart"
+#define UPSTART_SERVICE                 NULL
+#define DBUS_ADDRESS_UPSTART            "unix:abstract=/com/ubuntu/upstart"
 #define UPSTART_PATH                    "/com/ubuntu/Upstart"
 #define UPSTART_INTERFACE_0_6           "com.ubuntu.Upstart0_6"
 #define UPSTART_INTERFACE_0_6_JOB       "com.ubuntu.Upstart0_6.Job"
@@ -273,7 +273,7 @@
               DBUS_TYPE_STRING)
             goto next_item;
           dbus_message_iter_get_basic (&variant_iter, &description);
-          if (description != NULL)
+          if (description != NULL && description[0])
             {
               ply_trace ("description = '%s'", description);
               job->properties.description = strdup (description);
@@ -579,82 +579,6 @@
   dbus_message_unref (reply);
 }
 
-static void
-on_get_name_owner_finished (DBusPendingCall       *call,
-                            ply_upstart_monitor_t *monitor)
-{
-  DBusMessage *reply, *message;
-  DBusError error;
-  const char *owner;
-
-  assert (call != NULL);
-  assert (monitor != NULL);
-
-  reply = dbus_pending_call_steal_reply (call);
-  if (reply == NULL)
-    return;
-  if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN)
-    goto out;
-
-  dbus_error_init (&error);
-  dbus_message_get_args (reply, &error,
-                         DBUS_TYPE_STRING, &owner,
-                         DBUS_TYPE_INVALID);
-  if (dbus_error_is_set (&error))
-    goto out;
-  dbus_error_free (&error);
-
-  ply_trace ("owner = '%s'", owner);
-
-  free (monitor->owner);
-  monitor->owner = strdup (owner);
-
-  ply_trace ("calling GetAllJobs");
-  message = dbus_message_new_method_call (UPSTART_SERVICE, UPSTART_PATH,
-                                          UPSTART_INTERFACE_0_6,
-                                          "GetAllJobs");
-  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
-  dbus_message_unref (message);
-  if (call != NULL)
-    dbus_pending_call_set_notify (call,
-                                  (DBusPendingCallNotifyFunction)
-                                  on_get_all_jobs_finished,
-                                  monitor, NULL);
-
-out:
-  dbus_message_unref (reply);
-}
-
-static DBusHandlerResult
-name_owner_changed_handler (DBusConnection        *connection,
-                            DBusMessage           *message,
-                            ply_upstart_monitor_t *monitor)
-{
-  DBusError error;
-  const char *name, *old_owner, *new_owner;
-
-  assert (connection != NULL);
-  assert (message != NULL);
-  assert (monitor != NULL);
-
-  dbus_error_init (&error);
-  if (dbus_message_get_args (message, &error,
-                             DBUS_TYPE_STRING, &name,
-                             DBUS_TYPE_STRING, &old_owner,
-                             DBUS_TYPE_STRING, &new_owner,
-                             DBUS_TYPE_INVALID) &&
-      strcmp (name, UPSTART_SERVICE) == 0)
-    {
-      if (new_owner)
-        ply_trace ("owner changed from '%s' to '%s'", old_owner, new_owner);
-      else
-        ply_trace ("owner left bus");
-      free (monitor->owner);
-      monitor->owner = new_owner ? strdup (new_owner) : NULL;
-    }
-
-  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* let other handlers try */
-}
 
 static DBusHandlerResult
 job_added_handler (DBusConnection        *connection,
@@ -856,12 +780,6 @@
   if (path == NULL)
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
-  if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
-                              "NameOwnerChanged") &&
-      dbus_message_has_path (message, DBUS_PATH_DBUS) &&
-      dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
-    return name_owner_changed_handler (connection, message, monitor);
-
   if (dbus_message_is_signal (message, UPSTART_INTERFACE_0_6,
                               "JobAdded"))
     return job_added_handler (connection, message, monitor);
@@ -899,9 +817,7 @@
   DBusError error;
   DBusConnection *connection;
   ply_upstart_monitor_t *monitor;
-  char *rule;
   DBusMessage *message;
-  const char *monitor_service = UPSTART_SERVICE;
   DBusPendingCall *call;
 
   dbus_error_init (&error);
@@ -909,7 +825,7 @@
   /* Get a connection to the system bus and set it up to listen for messages
    * from Upstart.
    */
-  connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
+  connection = dbus_connection_open (DBUS_ADDRESS_UPSTART, &error);
   if (connection == NULL)
     {
       ply_error ("unable to connect to system bus: %s", error.message);
@@ -938,52 +854,17 @@
       return NULL;
     }
 
-  asprintf (&rule, "type='%s',sender='%s',path='%s',"
-                   "interface='%s',member='%s',arg0='%s'",
-            "signal", DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
-            DBUS_INTERFACE_DBUS, "NameOwnerChanged", UPSTART_SERVICE);
-  dbus_bus_add_match (connection, rule, &error);
-  free (rule);
-  if (dbus_error_is_set (&error))
-    {
-      ply_error ("unable to add match rule to system bus connection: %s",
-                 error.message);
-      ply_upstart_monitor_free (monitor);
-      dbus_error_free (&error);
-      return NULL;
-    }
-
-  asprintf (&rule, "type='%s',sender='%s'", "signal", UPSTART_SERVICE);
-  dbus_bus_add_match (connection, rule, &error);
-  free (rule);
-  if (dbus_error_is_set (&error))
-    {
-      ply_error ("unable to add match rule to system bus connection: %s",
-                 error.message);
-      ply_upstart_monitor_free (monitor);
-      dbus_error_free (&error);
-      return NULL;
-    }
-
-  /* Start the state machine going: find out the current owner of the
-   * well-known Upstart name.
-   * Ignore errors: the worst case is that we don't get any messages back
-   * and our state machine does nothing.
-   */
-  ply_trace ("calling GetNameOwner");
-  message = dbus_message_new_method_call (DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
-                                          DBUS_INTERFACE_DBUS, "GetNameOwner");
-  dbus_message_append_args (message,
-                            DBUS_TYPE_STRING, &monitor_service,
-                            DBUS_TYPE_INVALID);
-  dbus_connection_send_with_reply (connection, message, &call, -1);
+  ply_trace ("calling GetAllJobs");
+  message = dbus_message_new_method_call (UPSTART_SERVICE, UPSTART_PATH,
+                                          UPSTART_INTERFACE_0_6,
+                                          "GetAllJobs");
+  dbus_connection_send_with_reply (monitor->connection, message, &call, -1);
   dbus_message_unref (message);
   if (call != NULL)
     dbus_pending_call_set_notify (call,
                                   (DBusPendingCallNotifyFunction)
-                                  on_get_name_owner_finished,
-                                  monitor,
-                                  NULL);
+                                  on_get_all_jobs_finished,
+                                  monitor, NULL);
 
   if (loop != NULL)
     ply_upstart_monitor_connect_to_event_loop (monitor, loop);

=== modified file 'src/upstart-bridge/plymouth-upstart-bridge.c'
--- src/upstart-bridge/plymouth-upstart-bridge.c	2011-03-12 22:54:53 +0000
+++ src/upstart-bridge/plymouth-upstart-bridge.c	2014-03-14 10:43:52 +0000
@@ -307,7 +307,9 @@
   if (should_be_verbose && !ply_is_tracing ())
     ply_toggle_tracing ();
 
-  setupterm (NULL, STDOUT_FILENO, NULL);
+  /* Don't bail on dummy/hardcopy terminals */
+  int errret=0;
+  setupterm (NULL, STDOUT_FILENO, &errret);
 
   is_connected = ply_boot_client_connect (state.client,
                                           (ply_boot_client_disconnect_handler_t)

=== modified file 'themes/ubuntu-logo/Makefile.am'
--- themes/ubuntu-logo/Makefile.am	2011-04-15 13:35:04 +0000
+++ themes/ubuntu-logo/Makefile.am	2014-03-14 10:43:52 +0000
@@ -1,6 +1,7 @@
 themedir = $(datadir)/plymouth/themes/ubuntu-logo
-nodist_theme_DATA = ubuntu-logo.plymouth
+nodist_theme_DATA = ubuntu-logo.plymouth ubuntu-logo-scale-2.plymouth
 dist_theme_DATA =   ubuntu-logo.script                                \
+                    ubuntu-logo-scale-2.script                        \
                     ubuntu-logo.grub                                  \
                     ubuntu_logo.png                                   \
                     ubuntu_logo16.png                                 \
@@ -13,11 +14,23 @@
 
 
 
-MAINTAINERCLEANFILES = Makefile.in ubuntu-logo.plymouth
-CLEANFILES = ubuntu-logo.plymouth
+MAINTAINERCLEANFILES = Makefile.in ubuntu-logo.plymouth ubuntu-logo-scale-2.plymouth ubuntu-logo.script ubuntu-logo-scale-2.script
+CLEANFILES = ubuntu-logo.plymouth ubuntu-logo-scale-2.plymouth ubuntu-logo.script ubuntu-logo-scale-2.script
 
 ubuntu-logo.plymouth: $(srcdir)/ubuntu-logo.plymouth.in
-	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g' \
+	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g;s,[@]EXTRA_NAME[@],,g;s,[@]SCRIPT_NAME[@],ubuntu-logo,g' \
 	       $(srcdir)/ubuntu-logo.plymouth.in > ubuntu-logo.plymouth
 
-EXTRA_DIST = ubuntu-logo.plymouth.in
+ubuntu-logo-scale-2.plymouth: $(srcdir)/ubuntu-logo.plymouth.in
+	sed -e 's,[@]PLYMOUTH_THEME_PATH[@],$(PLYMOUTH_THEME_PATH),g;s,[@]EXTRA_NAME[@],(Scale x2),g;s,[@]SCRIPT_NAME[@],ubuntu-logo-scale-2,g' \
+	       $(srcdir)/ubuntu-logo.plymouth.in > ubuntu-logo-scale-2.plymouth
+
+ubuntu-logo.script: $(srcdir)/ubuntu-logo.script.in
+	sed -e 's,[@]SCALEFACTOR[@],1,g' \
+	       $(srcdir)/ubuntu-logo.script.in > ubuntu-logo.script
+
+ubuntu-logo-scale-2.script: $(srcdir)/ubuntu-logo.script.in
+	sed -e 's,[@]SCALEFACTOR[@],2,g' \
+	       $(srcdir)/ubuntu-logo.script.in > ubuntu-logo-scale-2.script
+
+EXTRA_DIST = ubuntu-logo.plymouth.in ubuntu-logo.script.in

=== modified file 'themes/ubuntu-logo/ubuntu-logo.plymouth.in'
--- themes/ubuntu-logo/ubuntu-logo.plymouth.in	2009-12-07 19:55:24 +0000
+++ themes/ubuntu-logo/ubuntu-logo.plymouth.in	2014-03-14 10:43:52 +0000
@@ -1,8 +1,8 @@
 [Plymouth Theme]
-Name=Ubuntu Logo
+Name=Ubuntu Logo @EXTRA_NAME@
 Description=A theme that features a blank background with a logo.
 ModuleName=script
 
 [script]
 ImageDir=@PLYMOUTH_THEME_PATH@/ubuntu-logo
-ScriptFile=@PLYMOUTH_THEME_PATH@/ubuntu-logo/ubuntu-logo.script
+ScriptFile=@PLYMOUTH_THEME_PATH@/ubuntu-logo/@SCRIPT_NAME@.script

=== renamed file 'themes/ubuntu-logo/ubuntu-logo.script' => 'themes/ubuntu-logo/ubuntu-logo.script.in'
--- themes/ubuntu-logo/ubuntu-logo.script	2013-02-14 00:56:49 +0000
+++ themes/ubuntu-logo/ubuntu-logo.script.in	2014-03-14 10:43:52 +0000
@@ -46,12 +46,27 @@
 debugsprite_bottom = Sprite();
 debugsprite_medium = Sprite();
 
+# Ubuntu Font
+ubuntufont = "Ubuntu 11";
+ubuntualignment = "center";
+
+# Scale factor
+scalefactor = @SCALEFACTOR@;
+
 # are we currently prompting for a password?
 prompt_active = 0;
 
+# Generic scalable image loader
+fun LoadScaleImage (imagepath) {
+    image = Image (imagepath);
+    image = image.Scale (image.GetWidth() * scalefactor, image.GetHeight() * scalefactor);
+    return image;
+}
+
 # General purpose function to create text
 fun WriteText (text, colour) {
-    image = Image.Text (text, colour.red, colour.green, colour.blue);
+    image = Image.Text (text, colour.red, colour.green, colour.blue, color.alpha, ubuntufont, ubuntualignment);
+    image = image.Scale (image.GetWidth() * scalefactor, image.GetHeight() * scalefactor);
     return image;
 }
 
@@ -184,7 +199,7 @@
     question_field_filename = "password_field.png";
 }
 
-logo.image = Image (logo_filename);
+logo.image = LoadScaleImage (logo_filename);
 logo.sprite = Sprite ();
 logo.sprite.SetImage (logo.image);
 logo.width = logo.image.GetWidth ();
@@ -206,8 +221,8 @@
 
 status = "normal";
 
-progress_indicator.bullet_off = Image (progress_dot_off_filename);
-progress_indicator.bullet_on = Image (progress_dot_on_filename);
+progress_indicator.bullet_off = LoadScaleImage (progress_dot_off_filename);
+progress_indicator.bullet_on = LoadScaleImage (progress_dot_on_filename);
 progress_indicator.bullet_width = progress_indicator.bullet_off.GetWidth ();
 progress_indicator.bullet_height = progress_indicator.bullet_off.GetHeight ();
 progress_indicator.bullet_hspacing = progress_indicator.bullet_width * 1.1;
@@ -509,9 +524,8 @@
     
     local.entry;
     local.bullet_image;
-    
-    bullet_image = Image (progress_dot_off_filename);
-    entry.image = Image (password_field_filename);
+    bullet_image = LoadScaleImage (progress_dot_off_filename);
+    entry.image = LoadScaleImage (password_field_filename);
     
     # Hide the normal labels
     prompt_active = 1;
@@ -1010,9 +1024,9 @@
     local.content;
     local.margin;
     
-    field.image = Image (question_field_filename);
+    field.image = LoadScaleImage (question_field_filename);
     content = Sprite ();    
-    bullet_image = Image (progress_dot_off_filename);
+    bullet_image = LoadScaleImage (progress_dot_off_filename);
     margin = bullet_image.GetWidth() / 2;
     
     # Hide the normal labels