Merge lp:upstart into lp:~daniel-sonck/upstart/cron-replacement

[Daniël Sonck]

[Daniël Sonck (daniel-sonck)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2010-12-10 04:03:25 +0000
+++ .bzrignore	2011-10-14 11:09:18 +0000
@@ -59,3 +59,7 @@
 util/shutdown
 util/telinit
 util/test_*
+extra/com.ubuntu.Upstart.[ch]
+extra/com.ubuntu.Upstart.Job.[ch]
+extra/upstart-socket-bridge
+extra/upstart-udev-bridge

=== modified file 'ChangeLog'
--- ChangeLog	2011-05-12 20:42:28 +0000
+++ ChangeLog	2011-10-14 11:09:18 +0000
@@ -1,3 +1,368 @@
[phone]  Scott James Remnant  <[e-mail]>
+
+	* init/job_process.c (job_process_spawn): Can't return on
+	dup2() error, we're in the child. Return an error back to
+	the child properly.
+
+	* init/job_process.c (job_process_spawn), init/main.c: error
+	should be ENOENT
+
+	* init/job_class.c, init/job_class.h: Move constants into the
+	header file so they can be found from other source files.
+	* init/job_process.c (job_process_spawn): Only adjust the OOM
+	score if it isn't the default
+	* init/main.c: Apply the default OOM score to the init process
+	itself.
+
+	* init/main.c: Deal with failure to setup the system console by
+	falling back to /dev/null, so we don't end up without default fds
+	and castrate the process.
+
[phone]  Scott James Remnant  <[e-mail]>
+
+	* init/job_class.c (job_class_new): nit, use #defines for the default
+	nice level and oom score adjustment.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/job_process.c: job_process_spawn():
+	  - Added dup2() return check.
+	* TESTING.sessions: Updated with information on user sessions.
+	* init/job_process.c:
+	  - job_process_spawn():
+	    - Change group before user and do it as early as possible.
+	    - Ensure non-priv user is able to read script fd. Default system
+	      behaviour is seemingly not consistent/defined, so force it
+	      to be (LP: #813052)
+	    - Ensure cwd for user job is home directory by default.
+	  - job_process_error_read():
+	    - Added handling for JOB_PROCESS_ERROR_SETUID and
+	      JOB_PROCESS_ERROR_SETGID (LP: #807293).
+	    - Added new entry for JOB_PROCESS_ERROR_CHOWN.
+	* init/job_process.h:
+	  - Added entry for JOB_PROCESS_ERROR_CHOWN in JobProcessErrorType.
+	* init/man/init.5: Update for user jobs explaining behaviour of stanzas
+	  which manipulate system resource limits and when the init
+	  daemon reads the users job directory.
+	* util/tests/test_user_sessions.sh: New script for testing user sessions
+	  (NOTE: this is *NOT* run automatically).
+	* init/session.c: session_from_dbus(): Handle case where a users
+	  home directory is changed or where a uid is re-used for a
+	  different username.
+	* init/session.h: Updated comments for Session object.
+	* init/man/init.5: Explain that symbolic links are not supported.
+
[phone]  James Hunt  <[e-mail]>
+
+	* util/man/initctl.8: Clarify semantics of restart(8)
+	  command (LP: #731225).
+
[phone]  James Hunt  <[e-mail]>
+
+	* util/tests/test_initctl.c:
+	  - test_show_config(): /* fall through :) */
+	  - test_check_config(): Manually start and stop dbus-daemon to work
+	    around change in dbus autostart behaviour which causes issues when
+	    running the tests in a chroot and non-X11 environment (see dbus commit
+	    cea055514a9dfc74e7f0515cf4a256da10a891bc).
+
[phone]  James Hunt  <[e-mail]>
+
+	* NEWS: Release 1.3
+
[phone]  James Hunt  <[e-mail]>
+
+	* contrib/vim/syntax/upstart.vim: Updates for kill, oom, expect
+	and limit.  
+
[phone]  Scott James Remnant  <[e-mail]>
+
+	* init/job_process.c (job_process_spawn): Make sure we don't close
+	our own file descriptor if it already has the right value.
+
[phone]  James Hunt  <[e-mail]>
+	
+	Add override file support.
+
+	* init/conf.c:
+	  - conf_reload_path(): Now takes an extra override_path parameter.
+	  - is_conf_file() / is_conf_file_std() / is_conf_file_override(): New
+	    functions to determine type of given file path.
+	  - toggle_conf_name(): New function which convert a conf file
+	    name to an override name and vice versa.
+	  - majority of remaining functions updated to handle override
+	    files.
+	* init/conf.h: Prototypes.
+	* init/job_class.c: Whitespace.
+	* init/man/init.5: Updated to document override file support.
+	* init/man/init.8: Added reference to control-alt-delete(7) man page.
+	* init/paths.h: New macros CONF_EXT_OVERRIDE, CONF_EXT_STD,
+	  IS_CONF_FILE_OVERRIDE and IS_CONF_FILE_STD.
+	* init/parse_conf.c: Added assertion to remind us forcibly to add
+	  override-handling code for directories if we ever allow content in
+	  'init.conf'.
+	* init/parse_job.c (parse_job): Additional parameter 'update' to
+	  allow override files to replace existing Job details.
+	* init/parse_job.h: Updated parse_job() prototype.
+	* init/test_conf.c
+	  - New macros TEST_ENSURE_CLEAN_ENV() and
+	    TEST_FORCE_WATCH_UPDATE().
+	  - test_override(): New function.
+	  - test_toggle_conf_name(): New function.
+	* init/test_parse_job.c:
+	  - Updated for extra parse_job() parameter.
+	  - added a test feature to test_parse_job() to exercise new
+	    parameter to parse_job().
+	* util/man/initctl.8: Clarified what it means to restart a job.
+
+	Add udev and socket bridges.
+	
+	* Makefile.am: Added extra directory.
+	* New files:
+	  - extra/Makefile.am
+	  - extra/conf/upstart-socket-bridge.conf
+	  - extra/conf/upstart-udev-bridge.conf
+	  - extra/man/socket-event.7
+	  - extra/man/upstart-socket-bridge.8
+	  - extra/man/upstart-udev-bridge.8
+	  - extra/upstart-socket-bridge.c
+	  - extra/upstart-udev-bridge.c
+	* configure.ac:
+	  - Check for udev (for upstart-udev-bridge).
+	  - Add extra/Makefile to AC_CONFIG_FILES.
+	* dbus/com.ubuntu.Upstart.xml: Add EmitEventWithFile method.
+	* init/control.c:
+	  - control_emit_event(): Now a wrapper for control_emit_event_with_file.
+	  - control_emit_event_with_file(): New function that operates on an fd.
+	* init/control.h: Prototype for control_emit_event_with_file().
+	* init/event.c:
+	  - event_new(): Initialize event fd.
+	  - event_pending_handle_jobs(): Now calls event_operator_fds().
+	* init/event.c: Add fd to Event struct.
+	* init/event_operator.c: event_operator_fds(): New function.
+	* init/event_operator.h: Prototype for event_operator_fds().
+	* init/job.c: job_new(): Initialize fd members.
+	* init/job.h: Add fds and num_fds to Job struct.
+
[phone]  James Hunt  <[e-mail]>
+
+	Add session support. Note that there are no automatically runnable and
+	explicit tests yet. However, see TESTING.sessions.
+	
+	* TESTING.sessions: ASCII (reStructuredText) document explaining
+	  how to run manual tests for session support (for chroots).
+	* dbus/Upstart.conf: Simplified to support allowing users to invoke
+	  all methods (since Upstart now isolates commands by user).
+	* init/Makefile.am: Added session.[ch] files.
+	* init/session.c: New file. Note that session_from_dbus() will disable sessions
+	  (by returning the NULL session) if environment variable "UPSTART_NO_SESSIONS"
+	  is set to any value (used by tests).
+	* init/session.h: New file.
+	* init/parse_job.h: parse_job(): Add session pointer to prototype.
+	* init/parse_job.c:
+	  - parse_job(): Add session parameter.
+	  - Update calls to job_class_new() to pass session pointer.
+	* init/job.c: job_new(): Crucial change to ensure chroot sessions have
+	  a unique D-Bus name (LP:#728531).
+	* init/job_class.c: 
+	  - job_class_new(): Add session parameter and session support.
+	  - job_class_remove(): Add session parameter to prototype.
+	  - job_class_consider(): Only consider jobs from the appropriate session.
+	  - job_class_reconsider(): Only consider jobs from the appropriate session.
+	  - job_class_start(): Disallow out-of-session modification.
+	  - job_class_stop(): Disallow out-of-session modification.
+	  - job_class_restart(): Disallow out-of-session modification.
+	* init/main.c: Add "--no-sessions" command-line option to disable
+	  sessions and revert to traditional behaviour.
+	* init/job_class.h: 
+	  - job_class_new(): Add session pointer to prototype.
+	  - JobClass: Add session member.
+	* init/job_process.c: job_process_spawn():
+	  - Call chroot(2) for chroot sessions.
+	  - Call setuid(2) for user session jobs.
+	* init/job.c:
+	  - job_emit_event(): Set session for event.
+	  - job_start(): Disallow out-of-session modification.
+	  - job_stop(): Disallow out-of-session modification.
+	  - job_restart(): Disallow out-of-session modification.
+	* init/event.h: Event: Add session member.
+	* init/event.c:
+	  - event_new(): initialize session to NULL.
+	  - event_pending_handle_jobs(): Add session handling.
+	  - event_finished(): Set session for failure event.
+	* init/control.c:
+	  - control_get_job_by_name(): Add session handling.
+	  - control_get_all_jobs(): Add session handling.
+	  - control_emit_event(): Add session handling.
+	* init/conf.c:
+	  - conf_source_new(): Initialise session to NULL.
+	  - conf_reload_path(): Pass session to parse_job().
+	  - conf_select_job(): Add session parameter.
+	* init/conf.h:
+	  - ConfSource: Add session member.
+	  - conf_select_job(): Add session parameter to prototype.
+	* All tests updated to set "UPSTART_NO_SESSIONS" (to disable
+	  sessions).
+
[phone]  James Hunt  <[e-mail]>
+
+	* contrib/bash_completion/upstart:
+	  - Made function names more meaningful:
+	  - _upstart_jobs: Now returns a unique list
+	  - _upstart_events (nee _upstart_named_events ) now considers all
+	    "emits" tokens.
+	  - Updates for "check-config" and "show-config".
+	  - Added "--session" option.
+	  - Added "--no-wait" for emit, reload and restart.
+
+	Man page updates.
+	
+	* init/man/init.5:
+	  - Quoted dashes.
+	  - Explain handling of duplicated stanzas.
+	  - "respawn": Document default count and interval.
+	  - "emits": Reference "initctl check-config".
+	  - Added BUGS section.
+	  - Added copyright.
+	* init/man/init.8:
+	  - Quoted dashes.
+	  - See Also: Added control-alt-delete(7).
+	* util/man/initctl.8:
+	  - Quoted dashes.
+	  - "restart": Clarified meaning.
+	  - "list": Explained "stop/waiting" jobs.
+
[phone]  James Hunt  <[e-mail]>
+
+	Add D-Bus session support to initctl.
+	
+	* util/initctl.c:
+	  - Added "--session" command-line option.
+	  - dbus_bus_type_setter(): New function used by option parser to
+	    distinguish system/session D-Bus bus type.
+	  - system_bus variable now replaced by two others: use_dbus (boolean)
+	    and dbus_bus_type.
+	  - upstart_open(): Updated to handle multiple D-Bus bus types.
+	* util/man/initctl.8: Update for "--session" option.
+	* util/tests/test_initctl.c: Updated to make use of use_dbus and
+	  dbus_bus_type rather than system_bus.
+
+	Add "show-config" command to initctl.
+	
+	* util/initctl.c:
+	  - New functions:
+	    - job_class_condition_handler(): Handler function to retrieve job conditions.
+	    - job_class_condition_err_handler(): Handler error function for
+	      job_class_condition_handler().
+	    - job_class_parse_events(): Convert RPN "start on" and "stop on" conditions to
+	      human-readable format.
+	    - job_class_show_emits(): Display events which job emits.
+	    - job_class_show_conditions(): Make D-Bus calls to retrieve "start on" and
+	      "stop on" conditions.
+	    - show_config_action: Handle "show-config" command..
+	* util/initctl.h: New file providing stack-handling functionality for
+	  RPN parsing for "show-config" command.
+	* util/Makefile.am: Added initctl.h to initctl_SOURCES.
+	* util/man/initctl.8: Updated for "show-config" command and associated
+	  options.
+	* util/tests/test_initctl.c:
+	  - New macros START_UPSTART, STOP_UPSTART, RUN_COMMAND, CREATE_FILE and DELETE_FILE.
+	    These are required since due to the introduction of the
+	    "show-config" initctl command, initctl is no longer solely a proxy
+	    to Upstart: it now has some intelligence (it parses the 
+	    "emits", "start on" and "stop on" conditions) and thus must be
+	    tested directly.
+	  - test_show_config(): New function to test "initctl show-config".
+	  - in_chroot(): New function to detect if tests are being run from
+	    within a chroot environment.
+	  - dbus_configured(): New function which performs a basic check to
+	    establish if D-Bus is configured correctly.
+	  - main(): Added call to test_show_config(), conditional on
+	    a non-chroot environment and a working D-Bus system.
+
+	Add "check-config" command to initctl.
+	
+	* util/initctl.c:
+	  - New functions:
+	    - allow_event(): Determine if specified event is erroneous or not.
+	      Handles globbing.
+	    - allow_job(): Determine if specified job is erroneous or not.
+	      Handles variables (such as instance variables).
+	    - check_condition(): High-level function to handle checking start
+	      on/stop on conditions.
+	    - check_config_action: Handler for "check-config" command.
+	    - display_check_errors(): Display errors from expression tree nodes
+	      that are in error.
+	    - eval_expr_tree(): Evaluate expression tree.
+	    - ignored_events_setter(): handler for '--ignore-events' command-line
+	      option for "check-config" command.
+	    - tree_filter(): Used for filtering expression tree nodes.
+	  - show_config_action(): Update for check-config mode.
+	  - job_class_parse_events(): Update for check-config mode.
+	  - job_class_show_emits(): Update for check-config mode.
+	* util/initctl.h:
+	  - Added structs for JobCondition, CheckConfigData and ExprNode.
+	  - New macros: MAKE_EXPR_NODE() and MAKE_JOB_CONDITION().
+	* util/tests/test_initctl.c:
+	  - test_check_config(): New function to test "initctl check-config".
+	  - main(): Added call to test_check_config(), conditional on
+	    a non-chroot environment and a working D-Bus system.
+	* util/man/initctl.8: Updated for "check-config" command and associated
+	  options.
+	* conf/rc-sysinit.conf: Added "emits" stanza, required by
+	"check-config".
+
+	Addition of initctl2dot script for visualisation.
+	
+	* Makefile.am: Added scripts directory.
+	* configure.ac: Updated AC_CONFIG_FILES for scripts/Makefile.
+	* scripts/Makefile.am: Makefile for scripts.
+	* scripts/initctl2dot.py: Python script to produce dot(1) graphs of
+	  "initctl show-config" output.
+	* scripts/man/initctl2dot.8: Man page for initctl2dot.py script.
+
+	Addition of init-checkconf script.
+	
+	* scripts/init-checkconf.sh: Script to determine if specified job
+	  config file is valid or not.
+	* scripts/man/init-checkconf.8: Man page for init-checkconf.sh.
+	* scripts/Makefile.am: Added init-checkconf script and man
+	  page.
+
[phone]  James Hunt  <[e-mail]>
+
+	Add command-line option to use D-Bus session bus (for testing).
+	
+	* init/control.c:
+	  - Added new boolean use_session_bus.
+	  - Updated comments.
+	  - control_handle_bus_type(): New function to allow selection of
+	    session bus via env var "UPSTART_USE_SESSION_BUS".
+	    Also logs use of session bus if use_session_bus set.
+	  - control_bus_open(): Now connects to either D-Bus system bus or session bus.
+	* init/control.h: New define for USE_SESSION_BUS_ENV.
+	* init/main.c: Addition of "--session" command-line option.
+	* init/man/init.8: Update for new "--session" command-line option.
+
+	* Corrected copyright notices.
+
+	Add option to allow alternate location for job config files.
+	
+	* init/main.c:
+	  - Added "--confdir <dir>" command-line option.
+	  - handle_confdir(): New function to select alternate confdir using env
+	    var "UPSTART_CONFDIR" or command-line option (for testing).
+	* init/paths.h: Added define for CONFDIR_ENV.
+	* init/man/init.8: Update for new "--confdir" command-line option.
+
+	Add ability to suppress initial event and/or change its name.
+	
+	* init/main.c: New command-line options: "--no-startup-event" and
+	  "--startup-event". If "--no-startup-event" specified, log message as a
+	  debug aid.
+	* init/man/init.8: Documentation for new command-line options:
+	  "--no-startup-event" and "--startup-event".
+
 2011-05-12  Marc - A. Dahlhaus  <[e-mail]>
 
 	* init/job_class.h (JobClass): Add kill signal member

=== modified file 'Makefile.am'
--- Makefile.am	2010-02-04 03:42:29 +0000
+++ Makefile.am	2011-10-14 11:09:18 +0000
@@ -1,6 +1,6 @@
 ## Process this file with automake to produce Makefile.in
 
-SUBDIRS = intl dbus init util conf doc contrib po
+SUBDIRS = intl dbus init util extra conf doc contrib po scripts
 
 EXTRA_DIST = HACKING
 

=== modified file 'NEWS'
--- NEWS	2011-03-22 17:53:17 +0000
+++ NEWS	2011-10-14 11:09:18 +0000
@@ -1,4 +1,38 @@
-1.3  xxxx-xx-xx
+1.4  xxxx-xx-xx
+
+1.3  2011-06-14  "Concordia"
+
+	* New upstart-socket-bridge application which allows jobs to be
+	  started when an incoming client socket connection is initiated
+	  (requires a suitably modified server daemon since jobs only
+	  need call accept(2) before reading from the socket).
+	* User session support allowing non-privileged users to
+	  manipulate their own jobs (not available within a chroot
+	  environment).
+	* Chroot support allowing jobs to be controlled within chroot
+	  environments.
+	* Updated bash completion script.
+	* Updated vim syntax script.
+	* init-checkconf script used to check syntax of Job
+	  Configuration Files (including script sections).
+	* initctl2dot script to convert initctl(8) output to GraphViz
+	  dot(1) format for analysing relationships between jobs and
+	  events.
+	* New "check-config" initctl command to check for jobs whose
+	* "start on" and "stop on" events cannot be satisfied.
+	* New "show-config" initctl command to display "start on", "stop
+	  on" and emits" information in parseable format.
+	* New initctl command-line option: "--session" for D-Bus
+	  session connection.
+	* New init command line options (mostly for testing):
+	  - "--session" for D-Bus session bus.
+	  - "--confdir <dir>".
+	  - "--startup-event <event>".
+	  - "--no-startup-event".
+	* New "kill signal" stanza to allow override of SIGTERM when
+	  stopping jobs.
+	* Add support for the oom_score_adj procfs API.
+	* Improved POSIX compliance when running shell scripts.
 
 1.2  2011-03-22  "This sort of thing is my bag, baby"
 

=== added file 'TESTING.sessions'
--- TESTING.sessions	1970-01-01 00:00:00 +0000
+++ TESTING.sessions	2011-10-14 11:09:18 +0000
@@ -0,0 +1,289 @@
+.. contents::
+
+=============================
+Testing Sessions with Upstart
+=============================
+
+Upstart now has support for two types of "sessions":
+
+* user sessions
+
+* chroots sessions
+
+Such sessions are implemented by asociating a separate Upstart session
+with every chroot environment and every non-privileged user.
+
+The session support does not yet provide full tests (as would be run by
+"``make check``"). This is mostly due to the complexity of automatically
+testing some of the scenarios below.
+
+This document attempts to outline the minimum set of tests that should
+be performed to ensure that session support works as expected.
+
+Assumptions
+===========
+
+You are running an Ubuntu or Debian system.
+
+User Sessions
+=============
+
+User sessions can be minimally tested using the script provided::
+
+  util/tests/test_user_sessions.sh
+
+Notes:
+
+- Run "``test_user_sessions.sh -h``" to understand what this script does.
+
+- that this script needs to be run on a system where the version of
+  ``/sbin/init`` has session support since the ``/sbin/init`` binary
+  itself will be tested. For this reason, the script cannot be run as part
+  of the "``make check``" run.
+
+- The script will complain loudly if any of the tests fail and tell you
+  how to raise a bug.
+
+Chroot Sessions
+===============
+
+Setup
+-----
+
+#. Install a chroot environement (such as ``schroot(1)``) and configure it.
+#. run, "``debootstrap(8)``" to install the same release as you are running into your chroot.
+#. Create the following files *outside* your chroot.
+
+   - ``/etc/init/foo.conf``::
+     
+       start on wibble
+       
+       script
+         exec 2>>/tmp/foo.$$.log
+         set -x
+         echo "foo: stat=`stat /`" 
+         echo "foo: env=`env`"
+         sleep 999 
+       end script
+
+   - ``/etc/init/outside_chroot.conf``::
+
+       start on A
+          
+       script
+         exec 2>>/tmp/outside_chroot.$$.log
+         set -x
+         echo "in_chroot: stat=`stat /`" 
+         echo "in_chroot: env=`env`"
+         sleep 999 
+       end script
+
+#. Create following files inside chroot environment.
+
+   - ``/path/to/chroot/etc/init/foo.conf``::
+
+       start on wibble
+          
+       script
+         exec 2>>/tmp/foo.$$.log
+         set -x
+         echo "foo: stat=`stat /`" 
+         echo "foo: env=`env`" 
+         sleep 999
+       end script
+
+   - ``/path/to/chroot/etc/init/in_chroot.conf``::
+
+       start on A
+        
+       script
+         exec 2>>/tmp/in_chroot.$$.log
+         set -x
+         echo "in_chroot: stat=`stat /`" 
+         echo "in_chroot: env=`env`" 
+         sleep 999
+       end script
+
+   
+Run as non-``root`` with no chroot
+----------------------------------
+
+- ``initctl list``
+
+  Ensure list is contents of ``/etc/init/``: the command below should
+  return no output::
+
+    cmp <(initctl list|awk '{print $1}'|sort -u) <(cd /etc/init && ls *.conf|cut -d: -f2-|sed 's/\.conf//g'|sort -u)
+
+- ``initctl status cron``
+
+  Should work.
+
+- ``initctl show-config``
+
+  Should work.
+
+- ``initctl check-config``
+
+  Should work.
+
+- ``start foo``
+
+  Should fail ("``initctl: Rejected send message``").
+
+- ``stop cron``
+
+  Should fail ("``initctl: Rejected send message``").
+
+- ``restart cron``
+
+  Should fail ("``initctl: Rejected send message``").
+
+- ``initctl emit bar``
+
+  Should fail ("``initctl: Rejected send message``").
+
+Run as ``root`` with no chroot
+------------------------------
+
+- ``initctl list``
+
+  Ensure list is contents of ``/etc/init/``: command below should return no output::
+
+    cmp <(initctl list|awk '{print $1}'|sort -u) <(cd /etc/init && ls *.conf|cut -d: -f2-|sed 's/\.conf//g'|sort -u)
+
+- ``initctl status outside_chroot``
+
+  Should work.
+
+- ``initctl status in_chroot``
+
+  Should fail with message::
+
+    initct: Unknown job: in_chroot
+
+- ``initctl show-config``
+
+  Should work.
+
+- ``initctl check-config``
+
+  Should work.
+
+- ``start in_chroot``
+
+  Should fail with message::
+
+    initct: Unknown job: in_chroot
+
+- ``start outside_chroot``
+
+  Should work.
+
+- ``stop in_chroot``
+
+  Should fail with message::
+
+    initct: Unknown job: in_chroot
+
+- ``restart outside_chroot``
+
+  Should work.
+
+- ``stop outside_chroot``
+
+  Should work.
+
+- ``initctl emit wibble``
+
+  - Ensure ``/etc/init/foo.conf`` runs by looking at the log and ensuring
+    the inode for the stat of '``/``' is the same as running "``stat /``" on
+    the command-line.
+
+  * Ensure ``/path/to/chroot/etc/init/foo.conf`` does *NOT* run.
+
+- ``initctl emit A``
+
+  - Ensure ``/etc/init/outside_chroot.conf`` runs.
+
+  - Ensure ``/path/to/chroot/etc/init/in_chroot.conf`` does *NOT* run.
+
+Run as ``root`` inside a chroot
+-------------------------------
+
+- ``initctl list``
+
+  Ensure list is contents of ``/path/to/chroot/etc/init/``: command below should return no output::
+
+    cmp <(initctl list|awk '{print $1}'|sort -u) <(cd /etc/init && ls *.conf|cut -d: -f2-|sed 's/\.conf//g'|sort -u)
+
+- ``initctl status in_chroot``
+
+  Should work.
+
+- ``initctl status outside_chroot``
+
+  Should fail with message::
+
+    initct: Unknown job: outside_chroot
+
+- ``initctl show-config``
+
+  Should work.
+
+- ``initctl check-config``
+
+  Should work.
+
+- ``start outside_chroot``
+
+  Should fail with message::
+
+    initct: Unknown job: outside_chroot
+
+- ``stop outside_chroot``
+
+  Should fail with message::
+
+    initct: Unknown job: outside_chroot
+
+- ``start in_chroot``
+
+  Should work.
+
+- ``restart in_chroot``
+
+  Should work.
+
+- ``stop in_chroot``
+
+  Should work.
+
+- ``initctl emit wibble``
+
+  - Ensure ``/path/to/chroot/etc/init/foo.conf`` runs by looking at the log and ensuring
+    the inode for the stat of '``/``' is the same as running "``stat /``" on the command-line.
+
+  - Ensure ``/etc/init/foo.conf`` does *NOT* run.
+
+- ``initctl emit A``
+
+  - Ensure ``/path/to/chroot/etc/init/in_chroot.conf`` runs.
+
+  - Ensure ``/etc/init/outside_chroot.conf`` does *NOT* run.
+
+Run as non-root inside a chroot
+-------------------------------
+
+Not supported.
+
+Run with ``--no-sessions``
+--------------------------
+
+The "``--no-sessions``" option makes Upstart behave as it used to prior to
+the introduction of session support.
+
+#. Reboot system and specify "``--no-sessions``" on kernel command-line.
+
+#. Ensure "``initctl list``" within a chroot displays the same list as
+   "``initctl list``" run outside of any chroot environment.

=== modified file 'conf/rc-sysinit.conf'
--- conf/rc-sysinit.conf	2010-02-04 03:59:06 +0000
+++ conf/rc-sysinit.conf	2011-10-14 11:09:18 +0000
@@ -13,6 +13,8 @@
 # or by faking an old /etc/inittab entry
 env DEFAULT_RUNLEVEL=2
 
+emits runlevel
+
 # There can be no previous runlevel here, but there might be old
 # information in /var/run/utmp that we pick up, and we don't want
 # that.

=== modified file 'configure.ac'
--- configure.ac	2011-03-22 17:53:17 +0000
+++ configure.ac	2011-10-14 11:09:18 +0000
@@ -1,8 +1,8 @@
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ(2.61)
-AC_INIT([upstart], [1.3], [[e-mail]])
-NIH_COPYRIGHT([[Copyright © 2011 Scott James Remnant, Google Inc., Canonical Ltd.]])
+AC_INIT([upstart], [1.4], [[e-mail]])
+NIH_COPYRIGHT([[Copyright © 2011 Scott James Remnant, Canonical Ltd.]])
 AC_CONFIG_SRCDIR([init/main.c])
 AC_CONFIG_MACRO_DIR([m4])
 
@@ -30,6 +30,9 @@
 PKG_CHECK_MODULES([NIH], [libnih >= 1.0.2])
 PKG_CHECK_MODULES([NIH_DBUS], [libnih-dbus >= 1.0.0])
 PKG_CHECK_MODULES([DBUS], [dbus-1 >= 1.2.16])
+PKG_CHECK_MODULES([UDEV], [libudev >= 146], [have_udev=yes], [have_udev=no])
+
+AM_CONDITIONAL([HAVE_UDEV], [test "$have_udev" = yes])
 
 # Checks for header files.
 AC_CHECK_HEADERS([valgrind/valgrind.h])
@@ -64,6 +67,7 @@
 
 AC_CONFIG_FILES([ Makefile intl/Makefile
 		  dbus/Makefile init/Makefile util/Makefile conf/Makefile
-		  doc/Makefile contrib/Makefile po/Makefile.in ])
+		  extra/Makefile doc/Makefile contrib/Makefile po/Makefile.in
+		  scripts/Makefile ])
 AC_CONFIG_HEADERS([config.h])
 AC_OUTPUT

=== modified file 'contrib/bash_completion/upstart'
--- contrib/bash_completion/upstart	2010-12-21 13:54:49 +0000
+++ contrib/bash_completion/upstart	2011-10-14 11:09:18 +0000
@@ -3,26 +3,28 @@
 #
 # We don't provide completion for 'init' itself for obvious reasons.
 have initctl &&
-_upstart_conf_events()
-{
-  initctl list|awk '{print $1}'
-} &&
-_upstart_named_events()
-{
-  (cd /etc/init && grep '^emits ' *.conf|sed 's/^emits //g')
-} &&
-_upstart_events()
-{
-  (_upstart_conf_events;_upstart_named_events)|tr ' ' '\n'|sort -u
-} &&
-_upstart_startable_events()
+_upstart_jobs()
+{
+  initctl list|awk '{print $1}'|sort -u
+} &&
+_upstart_startable_jobs()
 {
   initctl list|cut -d\, -f1|awk '$2 == "stop/waiting" {print $1}'
 } &&
-_upstart_stoppable_events()
+_upstart_stoppable_jobs()
 {
   initctl list|cut -d\, -f1|awk '$2 == "start/running" {print $1}'
 } &&
+_upstart_events()
+{
+  # note that we don't provide the internal events such as "starting"
+  # (and those from mountall) since the user should be using the
+  # associated command to emit such events.
+  (cd /etc/init && \
+   egrep '^[[:space:]]*emits ' *.conf |\
+   cut -d: -f2- | sed 's/^[[:space:]]*emits //g' |\
+   tr ' ' '\n' | awk '{print $NF}' | grep -v ^$|sort -u)
+} &&
 _upstart_initctl()
 {
   _get_comp_words_by_ref cur prev
@@ -32,34 +34,92 @@
   case "$prev" in
 
     start)
-      COMPREPLY=( $(compgen -W "-n --no-wait $(_upstart_startable_events)" -- ${cur}) )
+      COMPREPLY=( $(compgen -W "-n --no-wait $(_upstart_startable_jobs)" -- ${cur}) )
       return 0
     ;;
 
     stop)
-      COMPREPLY=( $(compgen -W "-n --no-wait $(_upstart_stoppable_events)" -- ${cur}) )
+      COMPREPLY=( $(compgen -W "-n --no-wait $(_upstart_stoppable_jobs)" -- ${cur}) )
       return 0
     ;;
 
     emit)
-      COMPREPLY=( $(compgen -W "$(_upstart_events)" -- ${cur}) )
-      return 0
-    ;;
-
-    reload|restart|status)
-      COMPREPLY=( $(compgen -W "$(_upstart_conf_events)" -- ${cur}) )
+      COMPREPLY=( $(compgen -W "-n --no-wait $(_upstart_events)" -- ${cur}) )
+      return 0
+    ;;
+
+    -i|--ignore-events)
+      # handle visualisation options after check-config command
+      for cmd in check-config
+      do
+        cwords=${COMP_WORDS[@]##}
+        filtered_cwords=${COMP_WORDS[@]##${cmd}}
+        if [ "$filtered_cwords" != "$cwords" ]
+        then
+          COMPREPLY=( $(compgen -W "$(_upstart_jobs)" -- ${cur}) )
+          return 0
+        fi
+      done
+    ;;
+
+    -e|--enumerate)
+      # handle visualisation options after show-config command
+      for cmd in show-config
+      do
+        cwords=${COMP_WORDS[@]##}
+        filtered_cwords=${COMP_WORDS[@]##${cmd}}
+        if [ "$filtered_cwords" != "$cwords" ]
+        then
+          COMPREPLY=( $(compgen -W "$(_upstart_jobs)" -- ${cur}) )
+          return 0
+        fi
+      done
+    ;;
+
+    reload|restart)
+      COMPREPLY=( $(compgen -W "-n --no-wait $(_upstart_stoppable_jobs)" -- ${cur}) )
+      return 0
+    ;;
+
+    status)
+      COMPREPLY=( $(compgen -W "$(_upstart_jobs)" -- ${cur}) )
+      return 0
+    ;;
+
+    check-config)
+      COMPREPLY=( $(compgen -W "-w --warn -i --ignore-events= $(_upstart_jobs)" -- ${cur}) )
+      return 0
+    ;;
+    show-config)
+      COMPREPLY=( $(compgen -W "-e --enumerate $(_upstart_jobs)" -- ${cur}) )
       return 0
     ;;
 
     -n|--no-wait)
-      # allow no wait after start/stop commands
-      for cmd in start stop
+      # allow 'no wait' for certain commands
+      for cmd in start stop restart emit
       do
         cwords=${COMP_WORDS[@]##}
         filtered_cwords=${COMP_WORDS[@]##${cmd}}
         if [ "$filtered_cwords" != "$cwords" ]
         then
-          COMPREPLY=( $(compgen -W "$(_upstart_${cmd}able_events)" -- ${cur}) )
+          case "$cmd" in
+            start)
+              COMPREPLY=( $(compgen -W "$(_upstart_startable_jobs)" -- ${cur}) )
+            ;;
+
+            stop)
+              COMPREPLY=( $(compgen -W "$(_upstart_stoppable_jobs)" -- ${cur}) )
+            ;;
+
+            restart)
+              COMPREPLY=( $(compgen -W "$(_upstart_stoppable_jobs)" -- ${cur}) )
+            ;;
+
+            emit)
+              COMPREPLY=( $(compgen -W "$(_upstart_events)" -- ${cur}) )
+            ;;
+          esac
           return 0
         fi
       done
@@ -71,7 +131,7 @@
     ;;
   esac
 
-  opts="--help --version -q --quiet -v --verbose --system --dest="
+  opts="--help --version -q --quiet -v --verbose --session --system --dest="
   cmds=$(initctl help|grep "^  [^ ]"|awk '{print $1}')
 
   COMPREPLY=( $(compgen -W "${opts} ${cmds}" -- ${cur}) )
@@ -84,7 +144,7 @@
   COMPREPLY=()
   _get_comp_words_by_ref cur prev
 
-  opts="--help --version -q --quiet -v --verbose --system --dest= \
+  opts="--help --version -q --quiet -v --verbose --session --system --dest= \
         -n --no-wait"
 
   case "$prev" in
@@ -94,7 +154,7 @@
     ;;
   esac
 
-  COMPREPLY=( $(compgen -W "$opts $(_upstart_startable_events)" -- ${cur}) )
+  COMPREPLY=( $(compgen -W "$opts $(_upstart_startable_jobs)" -- ${cur}) )
   return 0
 } && complete -F _upstart_start start
 
@@ -104,7 +164,7 @@
   COMPREPLY=()
   _get_comp_words_by_ref cur prev
 
-  opts="--help --version -q --quiet -v --verbose --system --dest= \
+  opts="--help --version -q --quiet -v --verbose --session --system --dest= \
         -n --no-wait"
 
   case "$prev" in
@@ -114,7 +174,7 @@
     ;;
   esac
 
-  COMPREPLY=( $(compgen -W "$opts $(_upstart_stoppable_events)" -- ${cur}) )
+  COMPREPLY=( $(compgen -W "$opts $(_upstart_stoppable_jobs)" -- ${cur}) )
   return 0
 } && complete -F _upstart_stop stop
 
@@ -124,7 +184,7 @@
   COMPREPLY=()
   _get_comp_words_by_ref cur prev
 
-  opts="--help --version -q --quiet -v --verbose --system --dest= \
+  opts="--help --version -q --quiet -v --verbose --session --system --dest= \
         -n --no-wait"
 
   case "$prev" in
@@ -134,7 +194,7 @@
     ;;
   esac
 
-  COMPREPLY=( $(compgen -W "$opts $(_upstart_events)" -- ${cur}) )
+  COMPREPLY=( $(compgen -W "$opts $(_upstart_stoppable_jobs)" -- ${cur}) )
   return 0
 
 } && complete -F _upstart_restart restart
@@ -145,7 +205,7 @@
   COMPREPLY=()
   _get_comp_words_by_ref cur prev
 
-  opts="--help --version -q --quiet -v --verbose --system --dest="
+  opts="--help --version -q -d --detail -e --enumerate --quiet -v --verbose --session --system --dest="
 
   case "$prev" in
     --help|--version)
@@ -154,7 +214,7 @@
     ;;
   esac
 
-  COMPREPLY=( $(compgen -W "$opts $(_upstart_events)" -- ${cur}) )
+  COMPREPLY=( $(compgen -W "$opts $(_upstart_jobs)" -- ${cur}) )
   return 0
 
 } && complete -F _upstart_status status
@@ -165,7 +225,7 @@
   COMPREPLY=()
   _get_comp_words_by_ref cur prev
 
-  opts="--help --version -q --quiet -v --verbose --system --dest="
+  opts="--help --version -q --quiet -v --verbose --session --system --dest="
 
   case "$prev" in
     --help|--version)
@@ -174,7 +234,7 @@
     ;;
   esac
 
-  COMPREPLY=( $(compgen -W "$opts $(_upstart_events)" -- ${cur}) )
+  COMPREPLY=( $(compgen -W "$opts $(_upstart_stoppable_jobs)" -- ${cur}) )
   return 0
 
 } && complete -F _upstart_reload reload

=== modified file 'contrib/vim/syntax/upstart.vim'
--- contrib/vim/syntax/upstart.vim	2011-01-27 18:52:25 +0000
+++ contrib/vim/syntax/upstart.vim	2011-10-14 11:09:18 +0000
@@ -1,10 +1,11 @@
 " Vim syntax file
 " Language:	Upstart job files
 " Maintainer:	Michael Biebl <[e-mail]>
-" Last Change:	2007 Feb 13
+"		James Hunt <[e-mail]>
+" Last Change:	2011 Jun 14
 " License:	GPL v2
-" Version:	0.1
-" Remark:	Syntax highlighting for upstart job files.
+" Version:	0.3
+" Remark:	Syntax highlighting for Upstart (init(8)) job files.
 "
 " It is inspired by the initng syntax file and includes sh.vim to do the
 " highlighting of script blocks.
@@ -14,11 +15,8 @@
 elseif exists("b:current_syntax")
 	finish
 endif
- 
-setlocal iskeyword=@,48-57,-,.
 
 let is_bash = 1
-"unlet! b:current_syntax
 syn include @Shell syntax/sh.vim
 
 syn case match
@@ -33,9 +31,12 @@
 syn cluster upstartShellCluster contains=@Shell
 
 " one argument
-syn keyword upstartStatement description author version
-syn keyword upstartStatement pid kill normal console env umask nice limit chroot chdir exec
-syn keyword upstartStatement expect export
+syn keyword upstartStatement description author version instance expect
+syn keyword upstartStatement pid kill normal console env exit export
+syn keyword upstartStatement umask nice oom chroot chdir exec
+
+" two arguments
+syn keyword upstartStatement limit
 
 " one or more arguments (events)
 syn keyword upstartStatement emits
@@ -43,29 +44,62 @@
 syn keyword upstartStatement on start stop
 
 " flag, no parameter
-syn keyword upstartStatement daemon respawn service instance task
+syn keyword upstartStatement respawn service instance manual debug task
 
-" prefix for exec or script
+" prefix for exec or script 
 syn keyword upstartOption pre-start post-start pre-stop post-stop
 
-" options for pid
-syn keyword upstartOption file binary timeout
-" option for
-syn keyword upstartOption timeout
-" option for respawn
-syn keyword upstartOption limit
+" option for kill
+syn keyword upstartOption timeout signal
+" option for oom
+syn keyword upstartOption score never
 " options for console
-syn keyword upstartOption logged output owner none
+syn keyword upstartOption output owner
 " options for expect
-syn keyword upstartOption daemon fork stop
-
-syn keyword upstartEvent startup stalled control-alt-delete kbdrequest starting started stopping stopped runlevel
-
-hi def link upstartComment Comment
-hi def link upstartTodo	Todo
-hi def link upstartString String
+syn keyword upstartOption stop fork daemon none
+" options for limit
+syn keyword upstartOption unlimited core cpu data fsize memlock msgqueue nice
+syn keyword upstartOption nofile nproc rss rtprio sigpending stack
+
+" 'options' for start/stop on
+syn keyword upstartOption and or
+
+" Upstart itself and associated utilities
+syn keyword upstartEvent runlevel
+syn keyword upstartEvent started
+syn keyword upstartEvent starting
+syn keyword upstartEvent startup
+syn keyword upstartEvent stopped
+syn keyword upstartEvent stopping
+syn match   upstartEvent /control-alt-delete/
+syn match   upstartEvent /keyboard-request/
+syn match   upstartEvent /power-status-changed/
+
+" D-Bus
+syn match   upstartEvent /dbus-activation/
+
+" Display Manager (ie gdm)
+syn match   upstartEvent /desktop-session-start/
+syn match   upstartEvent /login-session-start/
+
+" mountall
+syn keyword upstartEvent filesystem
+syn keyword upstartEvent mounted
+syn keyword upstartEvent mounting
+syn match   upstartEvent /\(\<local\>\|\<virtual\>\|\<remote\>\)-filesystems/
+syn match   upstartEvent /all-swaps/
+
+" upstart-udev-bridge and ifup/down
+syn match   upstartEvent /\<\i\{-1,}-device-\(\<added\>\|\<removed\>\|\<up\>\|\<down\>\)/
+
+" upstart-socket-bridge
+syn keyword upstartEvent socket
+
+hi def link upstartComment   Comment
+hi def link upstartTodo	     Todo
+hi def link upstartString    String
 hi def link upstartStatement Statement
-hi def link upstartOption Type
-hi def link upstartEvent Define
+hi def link upstartOption    Type
+hi def link upstartEvent     Define
 
 let b:current_syntax = "upstart"

=== modified file 'dbus/Upstart.conf'
--- dbus/Upstart.conf	2009-07-02 17:46:41 +0000
+++ dbus/Upstart.conf	2011-10-14 11:09:18 +0000
@@ -9,12 +9,14 @@
     <allow own="com.ubuntu.Upstart" />
   </policy>
 
-  <!-- Permit the root user to invoke all of the methods on Upstart, its jobs
-       or their instances, and to get and set properties. -->
-  <policy user="root">
+  <!-- Allow any user to invoke all of the methods on Upstart, its jobs
+       or their instances, and to get and set properties - since Upstart
+       isolates commands by user. -->
+  <policy context="default">
+    <allow send_destination="com.ubuntu.Upstart"
+	   send_interface="org.freedesktop.DBus.Introspectable" />
     <allow send_destination="com.ubuntu.Upstart"
 	   send_interface="org.freedesktop.DBus.Properties" />
-
     <allow send_destination="com.ubuntu.Upstart"
 	   send_interface="com.ubuntu.Upstart0_6" />
     <allow send_destination="com.ubuntu.Upstart"
@@ -22,36 +24,4 @@
     <allow send_destination="com.ubuntu.Upstart"
 	   send_interface="com.ubuntu.Upstart0_6.Instance" />
   </policy>
-
-  <!-- Allow any user to introspect Upstart's interfaces, to obtain the
-       values of properties (but not set them) and to invoke selected
-       methods on Upstart and its jobs that are used to walk information. -->
-  <policy context="default">
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="org.freedesktop.DBus.Introspectable" />
-
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="org.freedesktop.DBus.Properties"
-	   send_type="method_call" send_member="Get" />
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="org.freedesktop.DBus.Properties"
-	   send_type="method_call" send_member="GetAll" />
-
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="com.ubuntu.Upstart0_6"
-	   send_type="method_call" send_member="GetJobByName" />
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="com.ubuntu.Upstart0_6"
-	   send_type="method_call" send_member="GetAllJobs" />
-
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="com.ubuntu.Upstart0_6.Job"
-	   send_type="method_call" send_member="GetInstance" />
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="com.ubuntu.Upstart0_6.Job"
-	   send_type="method_call" send_member="GetInstanceByName" />
-    <allow send_destination="com.ubuntu.Upstart"
-	   send_interface="com.ubuntu.Upstart0_6.Job"
-	   send_type="method_call" send_member="GetAllInstances" />
-  </policy>
 </busconfig>

=== modified file 'dbus/com.ubuntu.Upstart.xml'
--- dbus/com.ubuntu.Upstart.xml	2009-07-03 16:08:10 +0000
+++ dbus/com.ubuntu.Upstart.xml	2011-10-14 11:09:18 +0000
@@ -49,6 +49,13 @@
       <arg name="env" type="as" direction="in" />
       <arg name="wait" type="b" direction="in" />
     </method>
+    <method name="EmitEventWithFile">
+      <annotation name="com.netsplit.Nih.Method.Async" value="true" />
+      <arg name="name" type="s" direction="in" />
+      <arg name="env" type="as" direction="in" />
+      <arg name="wait" type="b" direction="in" />
+      <arg name="file" type="h" direction="in" />
+    </method>
 
     <!-- Basic information about Upstart -->
     <property name="version" type="s" access="read" />

=== modified file 'dbus/upstart.h'
--- dbus/upstart.h	2010-12-10 04:04:51 +0000
+++ dbus/upstart.h	2011-10-14 11:09:18 +0000
@@ -31,7 +31,7 @@
 #  define DBUS_SERVICE_UPSTART "com.ubuntu.TestUpstart"
 # else
 #  define DBUS_SERVICE_UPSTART "com.ubuntu.Upstart"
-#endif
+# endif
 #endif
 
 

=== added directory 'extra'
=== added file 'extra/Makefile.am'
--- extra/Makefile.am	1970-01-01 00:00:00 +0000
+++ extra/Makefile.am	2011-10-14 11:09:18 +0000
@@ -0,0 +1,125 @@
+## Process this file with automake to produce Makefile.in
+
+AM_CFLAGS = \
+	$(NIH_CFLAGS) \
+	$(NIH_DBUS_CFLAGS) \
+	$(DBUS_CFLAGS) \
+	$(UDEV_CFLAGS)
+
+AM_CPPFLAGS = \
+	-DLOCALEDIR="\"$(localedir)\"" \
+	-DSBINDIR="\"$(sbindir)\"" \
+	-I$(top_builddir) -I$(top_srcdir) -iquote$(builddir) -iquote$(srcdir) \
+	-I$(top_srcdir)/intl
+
+
+initdir = $(sysconfdir)/init
+
+
+sbin_PROGRAMS = \
+	upstart-socket-bridge
+
+dist_init_DATA = \
+	conf/upstart-socket-bridge.conf
+
+dist_man_MANS = \
+	man/upstart-socket-bridge.8 \
+	man/socket-event.7
+
+upstart_socket_bridge_SOURCES = \
+	upstart-socket-bridge.c
+nodist_upstart_socket_bridge_SOURCES = \
+	$(com_ubuntu_Upstart_OUTPUTS) \
+	$(com_ubuntu_Upstart_Job_OUTPUTS)
+upstart_socket_bridge_LDADD = \
+	$(LTLIBINTL) \
+	$(NIH_LIBS) \
+	$(NIH_DBUS_LIBS) \
+	$(DBUS_LIBS)
+
+
+if HAVE_UDEV
+dist_init_DATA += \
+	conf/upstart-udev-bridge.conf
+
+dist_man_MANS += \
+	man/upstart-udev-bridge.8
+
+sbin_PROGRAMS += \
+	upstart-udev-bridge
+
+upstart_udev_bridge_SOURCES = \
+	upstart-udev-bridge.c
+nodist_upstart_udev_bridge_SOURCES = \
+	$(com_ubuntu_Upstart_OUTPUTS)
+upstart_udev_bridge_LDADD = \
+	$(LTLIBINTL) \
+	$(NIH_LIBS) \
+	$(NIH_DBUS_LIBS) \
+	$(DBUS_LIBS) \
+	$(UDEV_LIBS)
+
+install-data-hook:
+	src=`echo upstart-udev-bridge| sed '$(transform)'`.8; \
+	for symlink in \
+		net-device-added \
+		net-device-removed \
+		graphics-device-added \
+		drm-device-added; do \
+	  inst=`echo $$symlink | sed '$(transform)'`.7; \
+          echo " ln -sf '$(man8dir)/$$src' '$(DESTDIR)$(man7dir)/$$inst'"; \
+	  ln -sf "$(man8dir)/$$src" "$(DESTDIR)$(man7dir)/$$inst"; \
+	done
+
+else
+EXTRA_DIST = \
+	man/upstart-udev-bridge.8
+endif
+
+
+com_ubuntu_Upstart_OUTPUTS = \
+	com.ubuntu.Upstart.c \
+	com.ubuntu.Upstart.h
+
+com_ubuntu_Upstart_XML = \
+	../dbus/com.ubuntu.Upstart.xml
+
+$(com_ubuntu_Upstart_OUTPUTS): $(com_ubuntu_Upstart_XML)
+	$(AM_V_GEN)$(NIH_DBUS_TOOL) \
+		--package=$(PACKAGE) \
+		--mode=proxy --prefix=upstart \
+		--default-interface=com.ubuntu.Upstart0_6 \
+		--output=$@ $<
+
+
+com_ubuntu_Upstart_Job_OUTPUTS = \
+	com.ubuntu.Upstart.Job.c \
+	com.ubuntu.Upstart.Job.h
+
+com_ubuntu_Upstart_Job_XML = \
+	../dbus/com.ubuntu.Upstart.Job.xml
+
+$(com_ubuntu_Upstart_Job_OUTPUTS): $(com_ubuntu_Upstart_Job_XML)
+	$(AM_V_GEN)$(NIH_DBUS_TOOL) \
+		--package=$(PACKAGE) \
+		--mode=proxy --prefix=job_class \
+		--default-interface=com.ubuntu.Upstart0_6.Job \
+		--output=$@ $<
+
+
+# These have to be built sources because we can't compile object files
+# without the header file existing first
+BUILT_SOURCES = \
+	$(com_ubuntu_Upstart_OUTPUTS) \
+	$(com_ubuntu_Upstart_Job_OUTPUTS)
+
+CLEANFILES = \
+	$(com_ubuntu_Upstart_OUTPUTS) \
+	$(com_ubuntu_Upstart_Job_OUTPUTS)
+
+
+clean-local:
+	rm -f *.gcno *.gcda
+
+maintainer-clean-local:
+	rm -f *.gcov

=== added directory 'extra/conf'
=== added file 'extra/conf/upstart-socket-bridge.conf'
--- extra/conf/upstart-socket-bridge.conf	1970-01-01 00:00:00 +0000
+++ extra/conf/upstart-socket-bridge.conf	2011-10-14 11:09:18 +0000
@@ -0,0 +1,16 @@
+# upstart-socket-bridge - Bridge socket events into upstart
+#
+# This helper daemon receives socket(7) events and
+# emits equivalent Upstart events.
+
+description	"Bridge socket events into upstart"
+
+emits socket
+
+start on net-device-up IFACE=lo
+stop on runlevel [!2345]
+
+expect daemon
+respawn
+
+exec upstart-socket-bridge --daemon

=== added file 'extra/conf/upstart-udev-bridge.conf'
--- extra/conf/upstart-udev-bridge.conf	1970-01-01 00:00:00 +0000
+++ extra/conf/upstart-udev-bridge.conf	2011-10-14 11:09:18 +0000
@@ -0,0 +1,16 @@
+# upstart-udev-bridge - Bridge udev events into upstart
+#
+# This helper daemon receives udev events from the netlink socket and
+# emits equivalent Upstart events.
+
+description	"Bridge udev events into upstart"
+
+emits *-device-*
+
+start on starting udev
+stop on stopped udev
+
+expect daemon
+respawn
+
+exec upstart-udev-bridge --daemon

=== added directory 'extra/man'
=== added file 'extra/man/socket-event.7'
--- extra/man/socket-event.7	1970-01-01 00:00:00 +0000
+++ extra/man/socket-event.7	2011-10-14 11:09:18 +0000
@@ -0,0 +1,92 @@
+.TH socket\-event 8 2011-03-08 upstart
+.\"
+.SH NAME
+socket \- event signalling that a socket connection has been made
+.\"
+.SH SYNOPSIS
+.B socket
+.BI PROTO\fR= PROTO
+.BI PORT\fR= PORT
+.BI ADDR\fR= ADDR
+
+.B socket
+.BI PROTO\fR= PROTO
+.BI PATH\fR= PATH
+.\"
+.SH DESCRIPTION
+
+The
+.B socket
+event is generated by the
+.BR upstart\-socket\-bridge (8)
+daemon when a socket connection is made whose details match the
+socket event condition and environment specified in a jobs
+.B start on
+or
+.B stop on
+stanza.
+
+When an incoming connection is detected, the file descriptor
+representing the socket is passed to the job in question to allow it to
+.BR accept (2)
+the connection. Additionally, the environment variable
+.B UPSTART_JOB
+will contain the name of the event ("socket") and the environment
+variable
+.B UPSTART_FDS
+will contain the number of the file descriptor corresponding to the
+listening socket.
+.\"
+.SH EXAMPLES
+.\"
+.SS Internet socket
+Start web server when first client connects from localhost:
+.RS
+.nf
+
+start on socket PROTO=inet PORT=80 ADDR=127.0.0.1
+.fi
+.RE
+.\"
+.SS Local socket
+.P
+.RS
+.nf
+
+start on socket PROTO=unix PATH=/var/run/.s.pgsql.1234
+.fi
+.FE
+.\"
+.SS Abstract socket
+.P
+
+.RS
+.nf
+
+start on socket PROTO=unix PATH=@/at/upstart/example
+.fi
+.FE
+.\"
+.SH AUTHOR
+Written by Scott James Remnant
+.RB < [e-mail] >
+
+Manual page written by James Hunt
+.RB < [e-mail] >
+.\"
+.SH BUGS
+Report bugs at 
+.RB < https://launchpad.net/upstart/+bugs >
+.\"
+.SH COPYRIGHT
+Copyright \(co 2011 Canonical Ltd.
+.PP
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+.\"
+.SH SEE ALSO
+.BR init (5)
+.BR init (8)
+.BR socket (2)
+.BR socket (7)
+.BR upstart\-socket\-bridge (8)

=== added file 'extra/man/upstart-socket-bridge.8'
--- extra/man/upstart-socket-bridge.8	1970-01-01 00:00:00 +0000
+++ extra/man/upstart-socket-bridge.8	2011-10-14 11:09:18 +0000
@@ -0,0 +1,47 @@
+.TH upstart-socket-bridge 8 2011-03-08 upstart
+.\"
+.SH NAME
+upstart-socket-bridge \- Bridge between Upstart and sockets
+.\"
+.SH SYNOPSIS
+.B upstart-socket-bridge
+.RI [ OPTIONS ]...
+.\"
+.SH DESCRIPTION
+The
+.B upstart-socket-bridge
+queries the Upstart 
+.BR init (8)
+daemon for all job configurations which
+.B start on
+or
+.B stop on
+the socket event. It then waits for an incoming connection on each
+specified
+.BR socket (7)
+and when detected emits the socket event (\fBsocket\-event\fP (7)),
+setting a number of environment variables for the job to query.
+.\"
+.SH AUTHOR
+Written by Scott James Remnant
+.RB < [e-mail] >
+
+Manual page written by James Hunt
+.RB < [e-mail] >
+.\"
+.SH BUGS
+Report bugs at 
+.RB < https://launchpad.net/upstart/+bugs >
+.\"
+.SH COPYRIGHT
+Copyright \(co 2011 Canonical Ltd.
+.PP
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+.\"
+.SH SEE ALSO
+.BR init (5)
+.BR init (8)
+.BR socket (2)
+.BR socket (7)
+.BR socket\-event (7)

=== added file 'extra/man/upstart-udev-bridge.8'
--- extra/man/upstart-udev-bridge.8	1970-01-01 00:00:00 +0000
+++ extra/man/upstart-udev-bridge.8	2011-10-14 11:09:18 +0000
@@ -0,0 +1,57 @@
+.TH upstart\-udev\-bridge 8 2011-03-08 upstart
+.\"
+.SH NAME
+upstart\-udev\-bridge \- Bridge between Upstart and udev
+.\"
+.SH SYNOPSIS
+.B upstart\-udev\-bridge
+.RI [ OPTIONS ]...
+.\"
+.SH DESCRIPTION
+.B upstart\-udev\-bridge
+receives information about kernel uevents that
+.BR udev (8)
+has completed and creates
+.BR init (8)
+events for them.
+
+It emits events which match the pattern "\fIS\fP\-device\-\fIA\fP" where
+\(aqS\(aq is the udev \fIsubsystem\fP and \(aqA\(aq is the udev \fIaction\fP.
+See \fBudev\fP(7) and for further details.
+
+Assuming \fI/sys\fP is mounted, possible values for \fIsubsystem\fP for
+your system are viewable via \fI/sys/class/\fP.
+
+.\"
+.SH EXAMPLES
+
+.IP net\-device\-added
+Event emitted when a network device is added.
+.IP net\-device\-removed
+Event emitted when a network device is removed.
+.IP graphics\-card\-added
+Event emitted when a graphics device is available to the system.
+.\"
+.SH NOTES
+This is a temporary tool until
+.BR init (8)
+itself gains the functionality to read them directly; you should not
+rely on its behaviour.
+.\"
+.SH AUTHOR
+Written by Scott James Remnant
+.RB < [e-mail] >
+.\"
+.SH BUGS
+Report bugs at 
+.RB < https://launchpad.net/ubuntu/+source/upstart/+bugs >
+.\"
+.SH COPYRIGHT
+Copyright \(co 2009,2010,2011 Canonical Ltd.
+.PP
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+.SH SEE ALSO
+.BR init (5)
+.BR init (8)
+.BR udev (7)

=== added file 'extra/upstart-socket-bridge.c'
--- extra/upstart-socket-bridge.c	1970-01-01 00:00:00 +0000
+++ extra/upstart-socket-bridge.c	2011-10-14 11:09:18 +0000
@@ -0,0 +1,644 @@
+/* upstart
+ *
+ * Copyright © 2010 Canonical Ltd.
+ * Author: Scott James Remnant <[e-mail]>.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+
+#include <sys/epoll.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <unistd.h>
+
+#include <nih/macros.h>
+#include <nih/alloc.h>
+#include <nih/list.h>
+#include <nih/hash.h>
+#include <nih/string.h>
+#include <nih/io.h>
+#include <nih/option.h>
+#include <nih/main.h>
+#include <nih/logging.h>
+#include <nih/error.h>
+
+#include <nih-dbus/dbus_connection.h>
+#include <nih-dbus/dbus_proxy.h>
+
+#include "dbus/upstart.h"
+#include "com.ubuntu.Upstart.h"
+#include "com.ubuntu.Upstart.Job.h"
+
+
+/* Structure we use for tracking jobs */
+typedef struct job {
+	NihList entry;
+	char *path;
+	NihList sockets;
+} Job;
+
+/* Structure we use for tracking listening sockets */
+typedef struct socket {
+	NihList entry;
+
+	union {
+		struct sockaddr        addr;
+		struct sockaddr_in sin_addr;
+		struct sockaddr_un sun_addr;
+	};
+	socklen_t addrlen;
+
+	int sock;
+} Socket;
+
+
+/* Prototypes for static functions */
+static void epoll_watcher        (void *data, NihIoWatch *watch,
+				  NihIoEvents events);
+static void upstart_job_added    (void *data, NihDBusMessage *message,
+				  const char *job);
+static void upstart_job_removed  (void *data, NihDBusMessage *message,
+				  const char *job);
+static void job_add_socket       (Job *job, char **socket_info);
+static void socket_destroy       (Socket *socket);
+static void upstart_disconnected (DBusConnection *connection);
+static void emit_event_reply     (Socket *sock, NihDBusMessage *message);
+static void emit_event_error     (Socket *sock, NihDBusMessage *message);
+
+
+/**
+ * daemonise:
+ *
+ * Set to TRUE if we should become a daemon, rather than just running
+ * in the foreground.
+ **/
+static int daemonise = FALSE;
+
+/**
+ * epoll_fd:
+ *
+ * Shared epoll file descriptor for listening on.
+ **/
+static int epoll_fd = -1;
+
+/**
+ * jobs:
+ *
+ * Jobs that we're monitoring.
+ **/
+static NihHash *jobs = NULL;
+
+/**
+ * upstart:
+ *
+ * Proxy to Upstart daemon.
+ **/
+static NihDBusProxy *upstart = NULL;
+
+
+/**
+ * options:
+ *
+ * Command-line options accepted by this program.
+ **/
+static NihOption options[] = {
+	{ 0, "daemon", N_("Detach and run in the background"),
+	  NULL, NULL, &daemonise, NULL },
+
+	NIH_OPTION_LAST
+};
+
+
+int
+main (int   argc,
+      char *argv[])
+{
+	char **         args;
+	DBusConnection *connection;
+	char **         job_class_paths;
+	int             ret;
+
+	nih_main_init (argv[0]);
+
+	nih_option_set_synopsis (_("Bridge socket events into upstart"));
+	nih_option_set_help (
+		_("By default, upstart-socket-bridge does not detach from the "
+		  "console and remains in the foreground.  Use the --daemon "
+		  "option to have it detach."));
+
+	args = nih_option_parser (NULL, argc, argv, options, FALSE);
+	if (! args)
+		exit (1);
+
+	/* Create an epoll file descriptor for listening on; use this so
+	 * we can do edge triggering rather than level.
+	 */
+	epoll_fd = epoll_create1 (0);
+	if (epoll_fd < 0) {
+		nih_fatal ("%s: %s", _("Could not create epoll descriptor"),
+			   strerror (errno));
+		exit (1);
+	}
+
+	NIH_MUST (nih_io_add_watch (NULL, epoll_fd, NIH_IO_READ,
+				    epoll_watcher, NULL));
+
+	/* Allocate jobs hash table */
+	jobs = NIH_MUST (nih_hash_string_new (NULL, 0));
+
+	/* Initialise the connection to Upstart */
+	connection = NIH_SHOULD (nih_dbus_connect (DBUS_ADDRESS_UPSTART, upstart_disconnected));
+	if (! connection) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not connect to Upstart"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	upstart = NIH_SHOULD (nih_dbus_proxy_new (NULL, connection,
+						  NULL, DBUS_PATH_UPSTART,
+						  NULL, NULL));
+	if (! upstart) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not create Upstart proxy"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	/* Connect signals to be notified when jobs come and go */
+	if (! nih_dbus_proxy_connect (upstart, &upstart_com_ubuntu_Upstart0_6, "JobAdded",
+				      (NihDBusSignalHandler)upstart_job_added, NULL)) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not create JobAdded signal connection"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	if (! nih_dbus_proxy_connect (upstart, &upstart_com_ubuntu_Upstart0_6, "JobRemoved",
+				      (NihDBusSignalHandler)upstart_job_removed, NULL)) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not create JobRemoved signal connection"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	/* Request a list of all current jobs */
+	if (upstart_get_all_jobs_sync (NULL, upstart, &job_class_paths) < 0) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not obtain job list"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	for (char **job_class_path = job_class_paths;
+	     job_class_path && *job_class_path; job_class_path++)
+		upstart_job_added (NULL, NULL, *job_class_path);
+
+	nih_free (job_class_paths);
+
+	/* Become daemon */
+	if (daemonise) {
+		if (nih_main_daemonise () < 0) {
+			NihError *err;
+
+			err = nih_error_get ();
+			nih_fatal ("%s: %s", _("Unable to become daemon"),
+				   err->message);
+			nih_free (err);
+
+			exit (1);
+		}
+
+		/* Send all logging output to syslog */
+		openlog (program_name, LOG_PID, LOG_DAEMON);
+		nih_log_set_logger (nih_logger_syslog);
+	}
+
+	/* Handle TERM and INT signals gracefully */
+	nih_signal_set_handler (SIGTERM, nih_signal_handler);
+	NIH_MUST (nih_signal_add_handler (NULL, SIGTERM, nih_main_term_signal, NULL));
+
+	if (! daemonise) {
+		nih_signal_set_handler (SIGINT, nih_signal_handler);
+		NIH_MUST (nih_signal_add_handler (NULL, SIGINT, nih_main_term_signal, NULL));
+	}
+
+	ret = nih_main_loop ();
+
+	return ret;
+}
+
+
+static void
+epoll_watcher (void *      data,
+	       NihIoWatch *watch,
+	       NihIoEvents events)
+{
+	struct epoll_event event[1024];
+	int                num_events;
+
+	num_events = epoll_wait (epoll_fd, event, 1024, 0);
+	if (num_events < 0) {
+		nih_error ("%s: %s", _("Error from epoll"), strerror (errno));
+		return;
+	} else if (num_events == 0)
+		return;
+
+	for (int i = 0; i < num_events; i++) {
+		Socket *sock = (Socket *)event[i].data.ptr;
+		nih_local char **env = NULL;
+		size_t env_len = 0;
+		char *var;
+		DBusPendingCall *pending_call;
+
+		if (event[i].events & EPOLLIN)
+			nih_debug ("%p EPOLLIN", sock);
+		if (event[i].events & EPOLLERR)
+			nih_debug ("%p EPOLLERR", sock);
+		if (event[i].events & EPOLLHUP)
+			nih_debug ("%p EPOLLHUP", sock);
+
+		env = NIH_MUST (nih_str_array_new (NULL));
+
+		switch (sock->addr.sa_family) {
+		case AF_INET:
+			NIH_MUST (nih_str_array_add (&env, NULL, &env_len,
+						     "PROTO=inet"));
+
+			var = NIH_MUST (nih_sprintf (NULL, "PORT=%d",
+						     ntohs (sock->sin_addr.sin_port)));
+			NIH_MUST (nih_str_array_addp (&env, NULL, &env_len,
+						      var));
+			nih_discard (var);
+
+			var = NIH_MUST (nih_sprintf (NULL, "ADDR=%s",
+						     inet_ntoa (sock->sin_addr.sin_addr)));
+			NIH_MUST (nih_str_array_addp (&env, NULL, &env_len,
+						      var));
+			nih_discard (var);
+			break;
+		case AF_UNIX:
+			NIH_MUST (nih_str_array_add (&env, NULL, &env_len,
+						     "PROTO=unix"));
+
+			var = NIH_MUST (nih_sprintf (NULL, "PATH=%s",
+						     sock->sun_addr.sun_path));
+			NIH_MUST (nih_str_array_addp (&env, NULL, &env_len,
+						      var));
+			nih_discard (var);
+			break;
+		default:
+			nih_assert_not_reached ();
+		}
+
+		pending_call = NIH_SHOULD (upstart_emit_event_with_file (
+						   upstart, "socket", env, TRUE,
+						   sock->sock,
+						   (UpstartEmitEventWithFileReply)emit_event_reply,
+						   (NihDBusErrorHandler)emit_event_error,
+						   sock,
+						   NIH_DBUS_TIMEOUT_NEVER));
+		if (! pending_call) {
+			NihError *err;
+
+			err = nih_error_get ();
+			nih_warn ("%s: %s", _("Could not send socket event"),
+				  err->message);
+			nih_free (err);
+		}
+
+		dbus_pending_call_unref (pending_call);
+
+		// might be EPOLLIN
+		// might be EPOLLERR
+		// might be EPOLLHUP
+	}
+}
+
+
+static void
+upstart_job_added (void *          data,
+		   NihDBusMessage *message,
+		   const char *    job_class_path)
+{
+	nih_local NihDBusProxy *job_class = NULL;
+	nih_local char ***start_on = NULL;
+	nih_local char ***stop_on = NULL;
+	Job *job;
+
+	nih_assert (job_class_path != NULL);
+
+	/* Obtain a proxy to the job */
+	job_class = nih_dbus_proxy_new (NULL, upstart->connection,
+					upstart->name, job_class_path,
+					NULL, NULL);
+	if (! job_class) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_error ("Could not create proxy for job %s: %s",
+			   job_class_path, err->message);
+		nih_free (err);
+
+		return;
+	}
+
+	job_class->auto_start = FALSE;
+
+	/* Obtain the start_on and stop_on properties of the job */
+	if (job_class_get_start_on_sync (NULL, job_class, &start_on) < 0) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_error ("Could not obtain job start condition %s: %s",
+			   job_class_path, err->message);
+		nih_free (err);
+
+		return;
+	}
+
+	if (job_class_get_stop_on_sync (NULL, job_class, &stop_on) < 0) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_error ("Could not obtain job stop condition %s: %s",
+			   job_class_path, err->message);
+		nih_free (err);
+
+		return;
+	}
+
+	/* Free any existing record for the job (should never happen,
+	 * but worth being safe).
+	 */
+	job = (Job *)nih_hash_lookup (jobs, job_class_path);
+	if (job)
+		nih_free (job);
+
+	/* Create new record for the job */
+	job = NIH_MUST (nih_new (NULL, Job));
+	job->path = NIH_MUST (nih_strdup (job, job_class_path));
+
+	nih_list_init (&job->entry);
+	nih_list_init (&job->sockets);
+
+	/* Find out whether this job listens for any socket events */
+	for (char ***event = start_on; event && *event && **event; event++)
+		if (! strcmp (**event, "socket"))
+			job_add_socket (job, *event);
+	for (char ***event = stop_on; event && *event && **event; event++)
+		if (! strcmp (**event, "socket"))
+			job_add_socket (job, *event);
+
+	/* If we didn't end up with any sockets, free the job and move on */
+	if (NIH_LIST_EMPTY (&job->sockets)) {
+		nih_free (job);
+		return;
+	}
+
+	nih_debug ("Job got added %s", job_class_path);
+
+	nih_alloc_set_destructor (job, nih_list_destroy);
+	nih_hash_add (jobs, &job->entry);
+}
+
+static void
+upstart_job_removed (void *          data,
+		     NihDBusMessage *message,
+		     const char *    job_path)
+{
+	Job *job;
+
+	nih_assert (job_path != NULL);
+
+	job = (Job *)nih_hash_lookup (jobs, job_path);
+	if (job) {
+		nih_debug ("Job went away %s", job_path);
+		nih_free (job);
+	}
+}
+
+
+static void
+job_add_socket (Job *  job,
+		char **socket_info)
+{
+	Socket *sock;
+	nih_local char *error = NULL;
+	int     components = 0;
+	struct epoll_event event;
+
+	nih_assert (job != NULL);
+	nih_assert (socket_info != NULL);
+	nih_assert (! strcmp(socket_info[0], "socket"));
+
+	sock = NIH_MUST (nih_new (job, Socket));
+	memset (sock, 0, sizeof (Socket));
+	sock->sock = -1;
+
+	nih_list_init (&sock->entry);
+
+	nih_debug ("Found socket");
+	for (char **env = socket_info + 1; env && *env; env++) {
+		char  *val;
+		size_t name_len;
+
+		val = strchr (*env, '=');
+		if (! val) {
+			nih_warn ("Ignored socket event without variable name in %s",
+				  job->path);
+			goto error;
+		}
+
+		name_len = val - *env;
+		val++;
+
+		if (! strncmp (*env, "PROTO", name_len)) {
+			if (! strcmp (val, "inet")) {
+				sock->addrlen = sizeof sock->sin_addr;
+				sock->sin_addr.sin_family = AF_INET;
+				sock->sin_addr.sin_addr.s_addr = INADDR_ANY;
+				components = 1;
+			} else if (! strcmp (val, "unix")) {
+				sock->addrlen = sizeof sock->sun_addr;
+				sock->sun_addr.sun_family = AF_UNIX;
+				components = 1;
+			} else {
+				nih_warn ("Ignored socket event with unknown PROTO=%s in %s",
+					  val, job->path);
+				goto error;
+			}
+
+		} else if (! strncmp (*env, "PORT", name_len)
+			   && (sock->sin_addr.sin_family == AF_INET)) {
+			sock->sin_addr.sin_port = htons (atoi (val));
+			components--;
+
+		} else if (! strncmp (*env, "ADDR", name_len)
+			   && (sock->sin_addr.sin_family == AF_INET)) {
+			if (inet_aton (val, &(sock->sin_addr.sin_addr)) == 0) {
+				nih_warn ("Ignored socket event with invalid ADDR=%s in %s",
+					  val, job->path);
+				goto error;
+			}
+
+		} else if (! strncmp (*env, "PATH", name_len)
+			   && (sock->sun_addr.sun_family == AF_UNIX)) {
+			strncpy (sock->sun_addr.sun_path, val,
+				 sizeof sock->sun_addr.sun_path);
+
+			if (sock->sun_addr.sun_path[0] == '@')
+				sock->sun_addr.sun_path[0] = '\0';
+
+			components--;
+
+		} else {
+			nih_warn ("Ignored socket event with unknown variable %.*s in %s",
+				  (int)name_len, *env, job->path);
+			goto error;
+		}
+	}
+
+	/* Missing any required components? */
+	if (components) {
+		nih_warn ("Ignored incomplete socket event in %s",
+			  job->path);
+		goto error;
+	}
+
+	/* Let's try and set this baby up */
+	sock->sock = socket (sock->addr.sa_family, SOCK_STREAM, 0);
+	if (sock->sock < 0) {
+		nih_warn ("Failed to create socket in %s: %s",
+			  job->path, strerror (errno));
+		goto error;
+	}
+
+	int opt = 1;
+	if (setsockopt (sock->sock, SOL_SOCKET, SO_REUSEADDR,
+			&opt, sizeof opt) < 0) {
+		nih_warn ("Failed to set socket reuse in %s: %s",
+			  job->path, strerror (errno));
+		goto error;
+	}
+
+	if (bind (sock->sock, &sock->addr, sock->addrlen) < 0) {
+		nih_warn ("Failed to bind socket in %s: %s",
+			  job->path, strerror (errno));
+		goto error;
+	}
+
+	if (listen (sock->sock, SOMAXCONN) < 0) {
+		nih_warn ("Failed to listen on socket in %s: %s",
+			  job->path, strerror (errno));
+		goto error;
+	}
+
+	/* We have a listening socket, now we want to be notified when someone
+	 * connects; but we just want one notification, we don't want to get
+	 * a DDoS of wake-ups while waiting for the service to start.
+	 *
+	 * The solution is to use epoll in edge-triggered mode, this will
+	 * fire only on initial connection until a new one comes in.
+	 */
+	event.events = EPOLLIN | EPOLLET;
+	event.data.ptr = sock;
+
+	if (epoll_ctl (epoll_fd, EPOLL_CTL_ADD, sock->sock, &event) < 0) {
+		nih_warn ("Failed to watch socket in %s: %s",
+			  job->path, strerror (errno));
+		goto error;
+	}
+
+	/* Okay then, add to the job */
+	nih_alloc_set_destructor (sock, socket_destroy);
+	nih_list_add (&job->sockets, &sock->entry);
+
+	return;
+
+error:
+	if (sock->sock != -1)
+		close (sock->sock);
+	nih_free (sock);
+}
+
+static void
+socket_destroy (Socket *sock)
+{
+	epoll_ctl (epoll_fd, EPOLL_CTL_DEL, sock->sock, NULL);
+	close (sock->sock);
+
+	nih_list_destroy (&sock->entry);
+}
+
+
+static void
+upstart_disconnected (DBusConnection *connection)
+{
+	nih_fatal (_("Disconnected from Upstart"));
+	nih_main_loop_exit (1);
+}
+
+
+static void
+emit_event_reply (Socket *        sock,
+		  NihDBusMessage *message)
+{
+	nih_debug ("Event completed");
+}
+
+static void
+emit_event_error (Socket *        sock,
+		  NihDBusMessage *message)
+{
+	NihError *err;
+
+	err = nih_error_get ();
+	nih_warn ("%s: %s", _("Error emitting socket event"), err->message);
+	nih_free (err);
+}

=== added file 'extra/upstart-udev-bridge.c'
--- extra/upstart-udev-bridge.c	1970-01-01 00:00:00 +0000
+++ extra/upstart-udev-bridge.c	2011-10-14 11:09:18 +0000
@@ -0,0 +1,310 @@
+/* upstart
+ *
+ * Copyright © 2009 Canonical Ltd.
+ * Author: Scott James Remnant <[e-mail]>.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+
+#include <libudev.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+
+#include <nih/macros.h>
+#include <nih/alloc.h>
+#include <nih/string.h>
+#include <nih/io.h>
+#include <nih/option.h>
+#include <nih/main.h>
+#include <nih/logging.h>
+#include <nih/error.h>
+
+#include <nih-dbus/dbus_connection.h>
+#include <nih-dbus/dbus_proxy.h>
+
+#include "dbus/upstart.h"
+#include "com.ubuntu.Upstart.h"
+
+
+/* Prototypes for static functions */
+static void udev_monitor_watcher (struct udev_monitor *udev_monitor,
+				  NihIoWatch *watch, NihIoEvents events);
+static void upstart_disconnected (DBusConnection *connection);
+static void emit_event_error     (void *data, NihDBusMessage *message);
+
+
+/**
+ * daemonise:
+ *
+ * Set to TRUE if we should become a daemon, rather than just running
+ * in the foreground.
+ **/
+static int daemonise = FALSE;
+
+/**
+ * upstart:
+ *
+ * Proxy to Upstart daemon.
+ **/
+static NihDBusProxy *upstart = NULL;
+
+
+/**
+ * options:
+ *
+ * Command-line options accepted by this program.
+ **/
+static NihOption options[] = {
+	{ 0, "daemon", N_("Detach and run in the background"),
+	  NULL, NULL, &daemonise, NULL },
+
+	NIH_OPTION_LAST
+};
+
+
+int
+main (int   argc,
+      char *argv[])
+{
+	char **              args;
+	DBusConnection *     connection;
+	struct udev *        udev;
+	struct udev_monitor *udev_monitor;
+	int                  ret;
+
+	nih_main_init (argv[0]);
+
+	nih_option_set_synopsis (_("Bridge udev events into upstart"));
+	nih_option_set_help (
+		_("By default, upstart-udev-bridge does not detach from the "
+		  "console and remains in the foreground.  Use the --daemon "
+		  "option to have it detach."));
+
+	args = nih_option_parser (NULL, argc, argv, options, FALSE);
+	if (! args)
+		exit (1);
+
+	/* Initialise the connection to Upstart */
+	connection = NIH_SHOULD (nih_dbus_connect (DBUS_ADDRESS_UPSTART, upstart_disconnected));
+	if (! connection) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not connect to Upstart"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	upstart = NIH_SHOULD (nih_dbus_proxy_new (NULL, connection,
+						  NULL, DBUS_PATH_UPSTART,
+						  NULL, NULL));
+	if (! upstart) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_fatal ("%s: %s", _("Could not create Upstart proxy"),
+			   err->message);
+		nih_free (err);
+
+		exit (1);
+	}
+
+	/* Initialise the connection to udev */
+	nih_assert (udev = udev_new ());
+	nih_assert (udev_monitor = udev_monitor_new_from_netlink (udev, "udev"));
+	nih_assert (udev_monitor_enable_receiving (udev_monitor) == 0);
+	udev_monitor_set_receive_buffer_size(udev_monitor, 128*1024*1024);
+
+	NIH_MUST (nih_io_add_watch (NULL, udev_monitor_get_fd (udev_monitor),
+				    NIH_IO_READ,
+				    (NihIoWatcher)udev_monitor_watcher,
+				    udev_monitor));
+
+	/* Become daemon */
+	if (daemonise) {
+		if (nih_main_daemonise () < 0) {
+			NihError *err;
+
+			err = nih_error_get ();
+			nih_fatal ("%s: %s", _("Unable to become daemon"),
+				   err->message);
+			nih_free (err);
+
+			exit (1);
+		}
+
+		/* Send all logging output to syslog */
+		openlog (program_name, LOG_PID, LOG_DAEMON);
+		nih_log_set_logger (nih_logger_syslog);
+	}
+
+	/* Handle TERM and INT signals gracefully */
+	nih_signal_set_handler (SIGTERM, nih_signal_handler);
+	NIH_MUST (nih_signal_add_handler (NULL, SIGTERM, nih_main_term_signal, NULL));
+
+	if (! daemonise) {
+		nih_signal_set_handler (SIGINT, nih_signal_handler);
+		NIH_MUST (nih_signal_add_handler (NULL, SIGINT, nih_main_term_signal, NULL));
+	}
+
+	ret = nih_main_loop ();
+
+	return ret;
+}
+
+
+static void
+udev_monitor_watcher (struct udev_monitor *udev_monitor,
+		      NihIoWatch *         watch,
+		      NihIoEvents          events)
+{
+	struct udev_device *    udev_device;
+	const char *            subsystem;
+	const char *            action;
+	const char *            kernel;
+	const char *            devpath;
+	const char *            devname;
+	nih_local char *        name = NULL;
+	nih_local char **       env = NULL;
+	size_t                  env_len = 0;
+	DBusPendingCall *       pending_call;
+
+	udev_device = udev_monitor_receive_device (udev_monitor);
+	if (! udev_device)
+		return;
+
+	subsystem = udev_device_get_subsystem (udev_device);
+	action = udev_device_get_action (udev_device);
+	kernel = udev_device_get_sysname (udev_device);
+	devpath = udev_device_get_devpath (udev_device);
+	devname = udev_device_get_devnode (udev_device);
+
+	if (! strcmp (action, "add")) {
+		name = NIH_MUST (nih_sprintf (NULL, "%s-device-added",
+					      subsystem));
+	} else if (! strcmp (action, "change")) {
+		name = NIH_MUST (nih_sprintf (NULL, "%s-device-changed",
+					      subsystem));
+	} else if (! strcmp (action, "remove")) {
+		name = NIH_MUST (nih_sprintf (NULL, "%s-device-removed",
+					      subsystem));
+	} else {
+		name = NIH_MUST (nih_sprintf (NULL, "%s-device-%s",
+					      subsystem, action));
+	}
+
+	env = NIH_MUST (nih_str_array_new (NULL));
+
+	if (kernel) {
+		nih_local char *var = NULL;
+
+		var = NIH_MUST (nih_sprintf (NULL, "KERNEL=%s", kernel));
+		NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
+	}
+
+	if (devpath) {
+		nih_local char *var = NULL;
+
+		var = NIH_MUST (nih_sprintf (NULL, "DEVPATH=%s", devpath));
+		NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
+	}
+
+	if (devname) {
+		nih_local char *var = NULL;
+
+		var = NIH_MUST (nih_sprintf (NULL, "DEVNAME=%s", devname));
+		NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
+	}
+
+	if (subsystem) {
+		nih_local char *var = NULL;
+
+		var = NIH_MUST (nih_sprintf (NULL, "SUBSYSTEM=%s", subsystem));
+		NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
+	}
+
+	if (action) {
+		nih_local char *var = NULL;
+
+		var = NIH_MUST (nih_sprintf (NULL, "ACTION=%s", action));
+		NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
+	}
+
+	for (struct udev_list_entry *list_entry = udev_device_get_properties_list_entry (udev_device);
+	     list_entry != NULL;
+	     list_entry = udev_list_entry_get_next (list_entry)) {
+		const char *    key;
+		nih_local char *var = NULL;
+
+		key = udev_list_entry_get_name (list_entry);
+		if (! strcmp (key, "DEVPATH"))
+			continue;
+		if (! strcmp (key, "DEVNAME"))
+			continue;
+		if (! strcmp (key, "SUBSYSTEM"))
+			continue;
+		if (! strcmp (key, "ACTION"))
+			continue;
+
+		var = NIH_MUST (nih_sprintf (NULL, "%s=%s", key,
+					     udev_list_entry_get_value (list_entry)));
+		NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
+	}
+
+	nih_debug ("%s %s", name, devname);
+
+	pending_call = NIH_SHOULD (upstart_emit_event (upstart,
+						       name, env, FALSE,
+						       NULL, emit_event_error, NULL,
+						       NIH_DBUS_TIMEOUT_NEVER));
+	if (! pending_call) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_warn ("%s", err->message);
+		nih_free (err);
+	}
+
+	dbus_pending_call_unref (pending_call);
+
+	udev_device_unref (udev_device);
+}
+
+
+static void
+upstart_disconnected (DBusConnection *connection)
+{
+	nih_fatal (_("Disconnected from Upstart"));
+	nih_main_loop_exit (1);
+}
+
+static void
+emit_event_error (void *          data,
+		  NihDBusMessage *message)
+{
+	NihError *err;
+
+	err = nih_error_get ();
+	nih_warn ("%s", err->message);
+	nih_free (err);
+}

=== modified file 'init/Makefile.am'
--- init/Makefile.am	2010-02-04 03:42:29 +0000
+++ init/Makefile.am	2011-10-14 11:09:18 +0000
@@ -40,6 +40,7 @@
 	system.c system.h \
 	environ.c environ.h \
 	process.c process.h \
+	session.c session.h \
 	job_class.c job_class.h \
 	job_process.c job_process.h \
 	job.c job.h \
@@ -158,6 +159,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -169,6 +171,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -180,6 +183,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -191,6 +195,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -202,6 +207,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -213,6 +219,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -224,6 +231,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -235,6 +243,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -246,6 +255,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -257,6 +267,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
@@ -268,6 +279,7 @@
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
 	parse_job.o parse_conf.o conf.o control.o \
+	session.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \

=== modified file 'init/conf.c'
--- init/conf.c	2011-03-15 18:44:09 +0000
+++ init/conf.c	2011-10-14 11:09:18 +0000
@@ -2,8 +2,7 @@
  *
  * conf.c - configuration management
  *
- * Copyright © 2011 Google Inc.
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2009,2010,2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -49,7 +48,7 @@
 #include "parse_conf.h"
 #include "conf.h"
 #include "errors.h"
-
+#include "paths.h"
 
 /* Prototypes for static functions */
 static int  conf_source_reload_file    (ConfSource *source)
@@ -71,9 +70,18 @@
 					struct stat *statbuf)
 	__attribute__ ((warn_unused_result));
 
-static int  conf_reload_path           (ConfSource *source, const char *path)
-	__attribute__ ((warn_unused_result));
-
+static int  conf_reload_path           (ConfSource *source, const char *path,
+					const char *override_path)
+	__attribute__ ((warn_unused_result));
+
+static inline int  is_conf_file        (const char *path)
+	__attribute__ ((warn_unused_result));
+
+static inline int is_conf_file_std     (const char *path)
+	__attribute__ ((warn_unused_result));
+
+static inline int is_conf_file_override(const char *path)
+	__attribute__ ((warn_unused_result));
 
 /**
  * conf_sources:
@@ -86,6 +94,115 @@
 
 
 /**
+ * is_conf_file_std:
+ * @path: path to check.
+ *
+ * Determine if specified path contains a legitimate
+ * configuration file name.
+ *
+ * Returns: TRUE if @path contains a valid configuration file name,
+ * else FALSE.
+ *
+ **/
+static inline int
+is_conf_file_std (const char *path)
+{
+	char *ptr = strrchr (path, '.');
+
+	if (ptr && IS_CONF_EXT_STD (ptr))
+		return TRUE;
+
+	return FALSE;
+}
+
+/**
+ * is_conf_file_override:
+ * @path: path to check.
+ *
+ * Determine if specified path contains a legitimate
+ * override file name.
+ *
+ * Returns: TRUE if @path contains a valid override file name,
+ * else FALSE.
+ *
+ **/
+static inline int
+is_conf_file_override (const char *path)
+{
+	char *ptr = strrchr (path, '.');
+
+	if (ptr && IS_CONF_EXT_OVERRIDE (ptr))
+		return TRUE;
+
+	return FALSE;
+}
+
+/**
+ * is_conf_file:
+ * @path: path to check.
+ *
+ * Determine if specified path contains a legitimate
+ * configuration file or override file name.
+ *
+ * Returns: TRUE if @path contains a valid configuration
+ * file or override file name, else FALSE.
+ *
+ **/
+static inline int
+is_conf_file (const char *path)
+{
+	char *ptr = strrchr (path, '.');
+
+	if (ptr && (ptr > path) && (ptr[-1] != '/') && IS_CONF_EXT (ptr))
+		return TRUE;
+
+	return FALSE;
+}
+
+/**
+ * Convert a configuration file name to an override file name and vice
+ * versa.
+ *
+ * For example, if @path is "foo.conf", this function will return
+ * "foo.override", whereas if @path is "foo.override", it will return
+ * "foo.conf".
+ *
+ * Note that this function should be static, but isn't to allow the
+ * tests to access it.
+ *
+ * @parent: parent of returned path,
+ * @path: path to a configuration file.
+ *
+ * Returns: newly allocated toggled path, or NULL on error.
+ **/
+char *
+toggle_conf_name (const void     *parent,
+		 const char     *path)
+{
+	char *new_path;
+	char *ext;
+	char *new_ext;
+	size_t len;
+
+	ext = strrchr (path, '.');
+	if (!ext)
+		return NULL;
+
+	new_ext = IS_CONF_EXT_STD (ext)
+		? CONF_EXT_OVERRIDE
+		: CONF_EXT_STD;
+
+	len = strlen (new_ext);
+
+	new_path = NIH_MUST (nih_strndup (parent, path, (ext - path) + len));
+
+	memcpy (new_path + (ext - path), new_ext, len);
+
+	return new_path;
+}
+
+
+/**
  * conf_init:
  *
  * Initialise the conf_sources list.
@@ -147,6 +264,7 @@
 
 	source->type = type;
 	source->watch = NULL;
+	source->session = NULL;
 
 	source->flag = FALSE;
 	source->files = nih_hash_string_new (source, 0);
@@ -235,8 +353,8 @@
 			err = nih_error_get ();
 			if (err->number != ENOENT)
 				nih_error ("%s: %s: %s", source->path,
-					   _("Unable to load configuration"),
-					   err->message);
+					_("Unable to load configuration"),
+					err->message);
 			nih_free (err);
 		}
 	}
@@ -329,10 +447,16 @@
 conf_source_reload_file (ConfSource *source)
 {
 	NihError *err = NULL;
+	nih_local char *override_path = NULL;
+
+	struct stat statbuf;
 
 	nih_assert (source != NULL);
 	nih_assert (source->type == CONF_FILE);
 
+	/* this function should only be called for standard
+	 * configuration files.
+	 */
 	if (! source->watch) {
 		nih_local char *dpath = NULL;
 		char           *dname;
@@ -361,7 +485,7 @@
 	/* Parse the file itself.  If this fails, then we can discard the
 	 * inotify error, since this one will be better.
 	 */
-	if (conf_reload_path (source, source->path) < 0) {
+	if (conf_reload_path (source, source->path, NULL) < 0) {
 		if (err)
 			nih_free (err);
 
@@ -382,6 +506,23 @@
 		nih_free (err);
 	}
 
+	if (! is_conf_file_std (source->path))
+		return 0;
+
+	override_path = toggle_conf_name (NULL, source->path);
+
+	if (stat (override_path, &statbuf) != 0)
+		return 0;
+
+	nih_debug ("Updating configuration for %s from %s",
+		  source->path, override_path);
+	if (conf_reload_path (source, source->path, override_path) < 0) {
+		if (err)
+			nih_free (err);
+
+		return -1;
+	}
+
 	return 0;
 }
 
@@ -501,19 +642,18 @@
  * @is_dir: TRUE of @path is a directory.
  *
  * This is the file filter used for the jobs directory, we only care
- * about paths with the ".conf" extension.  Directories that
- * match the nih_file_ignore() function are also ignored.
- *
- * Returns: FALSE if @path ends in ".conf", or is the original source,
- * TRUE otherwise.
+ * about paths with particular extensions (see IS_CONF_EXT).
+ *
+ * Directories that match the nih_file_ignore() function are also ignored.
+ *
+ * Returns: FALSE if @path ends in ".conf" or ".override",
+ * or is the original source, TRUE otherwise.
  **/
 static int
 conf_dir_filter (ConfSource *source,
 		 const char *path,
 		 int         is_dir)
 {
-	char *ptr;
-
 	nih_assert (source != NULL);
 	nih_assert (path != NULL);
 
@@ -523,8 +663,7 @@
 	if (is_dir)
 		return nih_file_ignore (NULL, path);
 
-	ptr = strrchr (path, '.');
-	if (ptr && (ptr > path) && (ptr[-1] != '/') && (! strcmp (ptr, ".conf")))
+	if (is_conf_file (path))
 		return FALSE;
 
 	return TRUE;
@@ -546,29 +685,92 @@
  * After checking that it was a regular file that was changed, we reload it;
  * we expect this to fail sometimes since the file may be only partially
  * written.
-  **/
+ **/
 static void
 conf_create_modify_handler (ConfSource  *source,
 			    NihWatch    *watch,
 			    const char  *path,
 			    struct stat *statbuf)
 {
+	ConfFile *file = NULL;
+	const char *error_path = path;
+	nih_local char *new_path = NULL;
+	int ret;
+
 	nih_assert (source != NULL);
 	nih_assert (watch != NULL);
 	nih_assert (path != NULL);
 	nih_assert (statbuf != NULL);
 
+	/* note that symbolic links are ignored */
 	if (! S_ISREG (statbuf->st_mode))
 		return;
 
-	if (conf_reload_path (source, path) < 0) {
+	new_path = toggle_conf_name (NULL, path);
+	file = (ConfFile *)nih_hash_lookup (source->files, new_path);
+
+	if (is_conf_file_override (path)) {
+		if (! file) {
+			/* override file has no corresponding conf file */
+			nih_debug ("Ignoring orphan override file %s", path);
+			return;
+		}
+
+		/* reload conf file */
+		nih_debug ("Loading configuration file %s", new_path);
+		ret = conf_reload_path (source, new_path, NULL);
+		if (ret < 0) {
+			error_path = new_path;
+			goto error;
+		}
+
+		/* overlay override settings */
+		nih_debug ("Loading override file %s for %s", path, new_path);
+		ret = conf_reload_path (source, new_path, path);
+		if (ret < 0) {
+			error_path = path;
+			goto error;
+		}
+	} else {
+		nih_debug ("Loading configuration and override files for %s", path);
+
+		/* load conf file */
+		nih_debug ("Loading configuration file %s", path);
+		ret = conf_reload_path (source, path, NULL);
+		if (ret < 0) {
+			error_path = path;
+			goto error;
+		}
+
+		/* ensure we ignore directory changes (which won't have overrides. */
+		if (is_conf_file_std (path)) {
+			struct stat st;
+			if (stat (new_path, &st) == 0) {
+				/* overlay override settings */
+				nih_debug ("Loading override file %s for %s", new_path, path);
+				ret = conf_reload_path (source, path, new_path);
+				if (ret < 0) {
+					error_path = new_path;
+					goto error;
+				}
+			}
+
+		}
+	}
+
+	return;
+
+error:
+	{
 		NihError *err;
 
 		err = nih_error_get ();
-		nih_error ("%s: %s: %s", path,
-			   _("Error while loading configuration file"),
-			   err->message);
+		nih_error ("%s: %s: %s", error_path,
+				_("Error while loading configuration file"),
+				err->message);
 		nih_free (err);
+		if (file)
+			nih_unref (file, source);
 	}
 }
 
@@ -585,13 +787,14 @@
  *
  * We lookup the file in our hash table, and if we can find it, perform
  * the usual deletion of it.
-  **/
+ **/
 static void
 conf_delete_handler (ConfSource *source,
 		     NihWatch   *watch,
 		     const char *path)
 {
 	ConfFile *file;
+	nih_local char *new_path = NULL;
 
 	nih_assert (source != NULL);
 	nih_assert (watch != NULL);
@@ -603,7 +806,11 @@
 	 * it's probably a directory or something, so just ignore it.
 	 */
 	file = (ConfFile *)nih_hash_lookup (source->files, path);
-	if (! file) {
+	/* Note we have to be careful to consider deletion of directories too.
+	 * This is handled implicitly by the override check which will return
+	 * false if passed a directory in this case.
+	 */
+	if (! file && ! is_conf_file_override (path)) {
 		if (! strcmp (watch->path, path)) {
 			nih_warn ("%s: %s", source->path,
 				  _("Configuration directory deleted"));
@@ -614,7 +821,30 @@
 		return;
 	}
 
-	nih_unref (file, source);
+	/* non-override files (and directories) are the simple case, so handle
+	 * them and leave.
+	 */ 
+	if (! is_conf_file_override (path)) {
+		nih_unref (file, source);
+		return;
+	}
+
+	/* if an override file is deleted for which there is a corresponding
+	 * conf file, reload the conf file to remove any modifications
+	 * introduced by the override file.
+	 */
+	new_path = toggle_conf_name (NULL, path);
+	file = (ConfFile *)nih_hash_lookup (source->files, new_path);
+
+	if (file) {
+		nih_debug ("Reloading configuration for %s on deletion of overide (%s)",
+				new_path, path);
+
+		if ( conf_reload_path (source, new_path, NULL) < 0 ) {
+			nih_warn ("%s: %s", new_path,
+					_("Unable to reload configuration after override deletion"));
+		}
+	}
 }
 
 /**
@@ -637,22 +867,61 @@
 		   const char  *path,
 		   struct stat *statbuf)
 {
+	ConfFile *file = NULL;
+	nih_local char *new_path = NULL;
+
 	nih_assert (source != NULL);
 	nih_assert (dirname != NULL);
 	nih_assert (path != NULL);
 	nih_assert (statbuf != NULL);
 
+	/* We assume that CONF_EXT_STD files are visited before
+	 * CONF_EXT_OVERRIDE files. Happily, this assumption is currently
+	 * valid since CONF_EXT_STD comes before CONF_EXT_OVERRIDE if ordered
+	 * alphabetically.
+	 *
+	 * If this were ever to change (for example if we decided to
+	 * rename the CONF_EXT_OVERRIDE files to end in ".abc", say), the logic
+	 * in this function would be erroneous since it would never be possible when
+	 * visiting an override file (before a conf file) to lookup a conf file
+	 * in the hash, since the conf file would not yet have been seen and thus would
+	 * not exist in the hash (yet).
+	 */
+	nih_assert (CONF_EXT_STD[1] < CONF_EXT_OVERRIDE[1]);
+
 	if (! S_ISREG (statbuf->st_mode))
 		return 0;
 
-	if (conf_reload_path (source, path) < 0) {
-		NihError *err;
-
-		err = nih_error_get ();
-		nih_error ("%s: %s: %s", path,
-			   _("Error while loading configuration file"),
-			   err->message);
-		nih_free (err);
+	if (is_conf_file_std (path)) {
+		if (conf_reload_path (source, path, NULL) < 0) {
+			NihError *err;
+
+			err = nih_error_get ();
+			nih_error ("%s: %s: %s", path,
+					_("Error while loading configuration file"),
+					err->message);
+			nih_free (err);
+		}
+		return 0;
+	}
+
+	new_path = toggle_conf_name (NULL, path);
+	file = (ConfFile *)nih_hash_lookup (source->files, new_path);
+
+	if (file) {
+		/* we're visiting an override file with an associated conf file that
+		 * has already been loaded, so just overlay the override file. If
+		 * there is no corresponding conf file, we ignore the override file.
+		 */
+		if (conf_reload_path (source, new_path, path) < 0) {
+			NihError *err;
+
+			err = nih_error_get ();
+			nih_error ("%s: %s: %s", new_path,
+					_("Error while reloading configuration file"),
+					err->message);
+			nih_free (err);
+		}
 	}
 
 	return 0;
@@ -662,16 +931,20 @@
 /**
  * conf_reload_path:
  * @source: configuration source,
- * @path: path of file to be reloaded.
+ * @path: path of conf file to be reloaded.
+ * @override_path: if not NULL and @path refers to a path associated with @source,
+ * overlay the contents of @path into the existing @source entry for
+ * @path. If FALSE, discard any existing knowledge of @path.
  *
- * This function is used to parse the file at @path in the context of the
- * given configuration @source.  Necessary ConfFile structures are allocated
- * and attached to @source as appropriate.  CONF_FILE sources always have
- * a single ConfFile when the file exists.
+ * This function is used to parse the file at @path (or @override_path) in the
+ * context of the given configuration @source.  Necessary ConfFile structures
+ * are allocated and attached to @source as appropriate.  CONF_FILE sources
+ * always have a single ConfFile when the file exists.
  *
  * If the file has been parsed before, then the existing item is deleted and
  * freed if the file fails to load, or after the new item has been parsed.
- * Items are not reused between reloads.
+ * Items are only reused between reloads if @override_path is
+ * non-NULL.
  *
  * Physical errors are returned, parse errors are not.
  *
@@ -679,36 +952,47 @@
  **/
 static int
 conf_reload_path (ConfSource *source,
-		  const char *path)
+	  const char *path,
+	  const char *override_path)
 {
-	ConfFile       *file;
+	ConfFile       *file = NULL;
 	nih_local char *buf = NULL;
 	const char     *start, *end;
 	nih_local char *name = NULL;
 	size_t          len, pos, lineno;
 	NihError       *err = NULL;
+	const char     *path_to_load;
 
 	nih_assert (source != NULL);
 	nih_assert (path != NULL);
 
-	/* Look up the old file in memory, and then free it.  In cases
-	 * of failure, we discard it anyway, so there's no particular reason
+	path_to_load = (override_path ? override_path : path);
+
+	/* If there is no corresponding override file, look up the old
+	 * conf file in memory, and then free it.  In cases of failure,
+	 * we discard it anyway, so there's no particular reason
 	 * to keep it around anymore.
+	 *
+	 * Note: if @override_path has been specified, do not
+	 * free the file if found, since we want to _update_ the
+	 * existing entry.
 	 */
 	file = (ConfFile *)nih_hash_lookup (source->files, path);
-	if (file)
+	if (! override_path && file)
 		nih_unref (file, source);
 
 	/* Read the file into memory for parsing, if this fails we don't
 	 * bother creating a new ConfFile structure for it and bail out
 	 * now.
 	 */
-	buf = nih_file_read (NULL, path, &len);
+	buf = nih_file_read (NULL, path_to_load, &len);
 	if (! buf)
 		return -1;
 
-	/* Parse the file, storing the item in a new ConfFile structure. */
-	file = NIH_MUST (conf_file_new (source, path));
+	/* Create a new ConfFile structure (if no @override_path specified) */
+	file = (ConfFile *)nih_hash_lookup (source->files, path);
+	if (! file)
+		file = NIH_MUST (conf_file_new (source, path));
 
 	pos = 0;
 	lineno = 1;
@@ -717,7 +1001,14 @@
 	case CONF_FILE:
 	case CONF_DIR:
 		/* Simple file of options; usually no item attached to it. */
-		nih_debug ("Loading configuration from %s", path);
+		if (override_path) {
+			nih_debug ("Updating configuration for %s from %s",
+					path, override_path);
+		} else {
+			nih_debug ("Loading configuration from %s %s",
+					(source->type == CONF_DIR ? "directory" : "file"), path);
+		}
+
 		if (parse_conf (file, buf, len, &pos, &lineno) < 0)
 			err = nih_error_get ();
 
@@ -735,7 +1026,7 @@
 			start++;
 
 		end = strrchr (start, '.');
-		if (end && (! strcmp (end, ".conf"))) {
+		if (end && IS_CONF_EXT (end)) {
 			name = NIH_MUST (nih_strndup (NULL, start, end - start));
 		} else {
 			name = NIH_MUST (nih_strdup (NULL, start));
@@ -744,8 +1035,16 @@
 		/* Create a new job item and parse the buffer to produce
 		 * the job definition.
 		 */
-		nih_debug ("Loading %s from %s", name, path);
-		file->job = parse_job (NULL, name, buf, len, &pos, &lineno);
+		if (override_path) {
+			nih_debug ("Updating %s (%s) with %s",
+					name, path, override_path);
+		} else {
+			nih_debug ("Loading %s from %s", name, path);
+		}
+
+		file->job = parse_job (NULL, source->session, file->job,
+				name, buf, len, &pos, &lineno);
+
 		if (file->job) {
 			job_class_consider (file->job);
 		} else {
@@ -779,7 +1078,7 @@
 		case PARSE_EXPECTED_OPERATOR:
 		case PARSE_EXPECTED_VARIABLE:
 		case PARSE_MISMATCHED_PARENS:
-			nih_error ("%s:%zi: %s", path, lineno, err->message);
+			nih_error ("%s:%zi: %s", path_to_load, lineno, err->message);
 			nih_free (err);
 			err = NULL;
 			break;
@@ -849,7 +1148,8 @@
 
 /**
  * conf_select_job:
- * @name: name of job class to locate.
+ * @name: name of job class to locate,
+ * @session: session class name belongs to.
  *
  * Select the best available class of a job named @name from the registered
  * configuration sources.
@@ -857,7 +1157,7 @@
  * Returns: Best available job class or NULL if none available.
  **/
 JobClass *
-conf_select_job (const char *name)
+conf_select_job (const char *name, const Session *session)
 {
 	nih_assert (name != NULL);
 
@@ -869,6 +1169,9 @@
 		if (source->type != CONF_JOB_DIR)
 			continue;
 
+		if (source->session != session)
+			continue;
+
 		NIH_HASH_FOREACH (source->files, file_iter) {
 			ConfFile *file = (ConfFile *)file_iter;
 
@@ -882,3 +1185,149 @@
 
 	return NULL;
 }
+
+#ifdef DEBUG
+
+size_t
+debug_count_list_entries (const NihList *list)
+{
+	size_t i = 0;
+	NIH_LIST_FOREACH (list, iter) {
+		i++;
+	}
+	return i;
+}
+
+size_t
+debug_count_hash_entries (const NihHash *hash)
+{
+	size_t i = 0;
+	NIH_HASH_FOREACH_SAFE (hash, iter) {
+		i++;
+	}
+	return i;
+}
+
+void
+debug_show_job_class (const JobClass *job)
+{
+	int i;
+	char **env    = (char **)job->env;
+	char **export = (char **)job->export;
+
+	nih_assert (job);
+
+	nih_debug ("JobClass %p: name='%s', path='%s', task=%d, "
+			"respawn=%d, console=%x, deleted=%d, debug=%d",
+			job, job->name, job->path, job->task,
+			job->respawn, job->console, job->deleted, job->debug);
+
+	nih_debug ("\tstart_on=%p, stop_on=%p, emits=%p, process=%p",
+			job->start_on, job->stop_on, job->emits, job->process);
+
+	nih_debug ("\tauthor='%s', description='%s'",
+			job->author, job->description);
+
+	if (env && *env) {
+		nih_debug ("\tenv:");
+		i = 0;
+		while ( *env ) {
+			nih_debug ("\t\tenv[%d]='%s' (len=%u+1)",
+					i, *env, strlen (*env));
+			env++;
+			++i;
+		}
+	} else {
+		nih_debug ("\tenv: none.");
+	}
+
+
+	if (export && *export) {
+		nih_debug ("\texport:");
+		i = 0;
+		while ( *export ) {
+			nih_debug ("\t\tenv[%d]='%s' (len=%u+1)",
+					i, *export, strlen (*export));
+			export++;
+			++i;
+		}
+	}
+	else {
+		nih_debug ("\texport: none");
+	}
+}
+
+void
+debug_show_job_classes (void)
+{
+	nih_debug ("job_classes:");
+
+	NIH_HASH_FOREACH_SAFE (job_classes, iter) {
+		JobClass *job = (JobClass *)iter;
+		debug_show_job_class (job);
+	}
+}
+
+void
+debug_show_event (const Event *event)
+{
+	nih_assert (event);
+
+	nih_debug ("Event %p: name='%s', progress=%x, failed=%d, "
+			"blockers=%d, blocking=%p",
+			event, event->name, event->progress, event->failed,
+			event->blockers, (void *)&event->blocking);
+}
+
+void
+debug_show_conf_file (const ConfFile *file)
+{
+	nih_assert (file);
+
+	nih_debug ("ConfFile %p: path='%s', source=%p, flag=%x, job=%p",
+			file, file->path, file->source, file->flag, file->job);
+
+	/* Some ConfFile objects won't have any JobClass details, for example,
+	 * the ConfFile object associated with "/etc/init.conf".
+	 */
+	if (! file->job) {
+		nih_debug ("ConfFile %p: job: no JobClass object.", file);
+		return;
+	}
+
+	nih_debug ("ConfFile %p: job:", file);
+	debug_show_job_class (file->job);
+}
+
+void
+debug_show_conf_source (const ConfSource *source)
+{
+	nih_assert (source);
+
+	nih_debug ("ConfSource %p: path='%s', type=%x, flag=%x",
+			source, source->path, source->type, source->flag);
+
+	nih_debug ("ConfSource %p files (%d):", source,
+			debug_count_hash_entries (source->files));
+
+	NIH_HASH_FOREACH (source->files, file_iter) {
+		ConfFile *file = (ConfFile *)file_iter;
+		debug_show_conf_file (file);
+	}
+}
+
+void
+debug_show_conf_sources (void)
+{
+	nih_assert (conf_sources);
+
+	nih_debug ("conf_sources:");
+
+	NIH_LIST_FOREACH (conf_sources, iter) {
+		ConfSource *source = (ConfSource *)iter;
+		debug_show_conf_source (source);
+	}
+}
+
+#endif /* DEBUG */
+

=== modified file 'init/conf.h'
--- init/conf.h	2009-07-09 08:36:52 +0000
+++ init/conf.h	2011-10-14 11:09:18 +0000
@@ -1,6 +1,6 @@
 /* upstart
  *
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2010,2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -26,6 +26,7 @@
 #include <nih/list.h>
 #include <nih/watch.h>
 
+#include "session.h"
 #include "job_class.h"
 
 
@@ -47,6 +48,7 @@
 /**
  * ConfSource:
  * @entry: list header,
+ * @session: attached session,
  * @path: path to source,
  * @type: type of source,
  * @watch: NihWatch structure for automatic change notification,
@@ -64,6 +66,7 @@
  **/
 typedef struct conf_source {
 	NihList             entry;
+	Session *           session;
 	char               *path;
 	ConfSourceType      type;
 
@@ -122,7 +125,47 @@
 
 int         conf_file_destroy  (ConfFile *file);
 
-JobClass *  conf_select_job    (const char *name);
+JobClass *  conf_select_job    (const char *name, const Session *session);
+
+char *toggle_conf_name         (const void *parent, const char *path)
+	__attribute__ ((warn_unused_result, malloc));
+
+#ifdef DEBUG
+
+/* used for debugging only */
+
+size_t
+debug_count_hash_entries       (const NihHash *hash);
+
+size_t
+debug_count_list_entries       (const NihList *list)
+	__attribute__ ((unused));
+
+void
+debug_show_job_class           (const JobClass *job)
+	__attribute__ ((unused));
+
+void
+debug_show_job_classes         (void)
+	__attribute__ ((unused));
+
+void
+debug_show_event               (const Event *event)
+	__attribute__ ((unused));
+
+void
+debug_show_conf_file(const ConfFile *file)
+	__attribute__ ((unused));
+
+void
+debug_show_conf_source(const ConfSource *source)
+	__attribute__ ((unused));
+
+void
+debug_show_conf_sources(void)
+	__attribute__ ((unused));
+
+#endif
 
 NIH_END_EXTERN
 

=== modified file 'init/control.c'
--- init/control.c	2009-07-11 11:47:12 +0000
+++ init/control.c	2011-10-14 11:09:18 +0000
@@ -2,7 +2,7 @@
  *
  * control.c - D-Bus connections, objects and methods
  *
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2009-2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -25,8 +25,10 @@
 
 #include <dbus/dbus.h>
 
+#include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
+#include <unistd.h>
 
 #include <nih/macros.h>
 #include <nih/alloc.h>
@@ -46,6 +48,7 @@
 #include "dbus/upstart.h"
 
 #include "environ.h"
+#include "session.h"
 #include "job_class.h"
 #include "blocked.h"
 #include "conf.h"
@@ -54,12 +57,19 @@
 
 #include "com.ubuntu.Upstart.h"
 
-
 /* Prototypes for static functions */
 static int   control_server_connect (DBusServer *server, DBusConnection *conn);
 static void  control_disconnected   (DBusConnection *conn);
 static void  control_register_all   (DBusConnection *conn);
 
+/**
+ * use_session_bus:
+ *
+ * If TRUE, connect to the D-Bus session bus rather than the system bus.
+ *
+ * Used for testing.
+ **/
+int use_session_bus = FALSE;
 
 /**
  * control_server_address:
@@ -78,7 +88,7 @@
 /**
  * control_bus:
  *
- * Open connection to D-Bus system bus.  The connection may be opened with
+ * Open connection to a D-Bus bus.  The connection may be opened with
  * control_bus_open() and if lost will become NULL.
  **/
 DBusConnection *control_bus = NULL;
@@ -86,7 +96,7 @@
 /**
  * control_conns:
  *
- * Open control connections, including the connection to the D-Bus system
+ * Open control connections, including the connection to a D-Bus
  * bus and any private client connections.
  **/
 NihList *control_conns = NULL;
@@ -190,8 +200,9 @@
 /**
  * control_bus_open:
  *
- * Open a connection to the D-Bus system bus and store it in the control_bus
- * global.  The connection is handled automatically in the main loop.
+ * Open a connection to the appropriate D-Bus bus and store it in the
+ * control_bus global. The connection is handled automatically
+ * in the main loop.
  *
  * Returns: zero on success, negative value on raised error.
  **/
@@ -207,10 +218,13 @@
 
 	control_init ();
 
+	control_handle_bus_type ();
+
 	/* Connect to the D-Bus System Bus and hook everything up into
 	 * our own main loop automatically.
 	 */
-	conn = nih_dbus_bus (DBUS_BUS_SYSTEM, control_disconnected);
+	conn = nih_dbus_bus (use_session_bus ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM,
+			     control_disconnected);
 	if (! conn)
 		return -1;
 
@@ -382,7 +396,9 @@
 			 const char      *name,
 			 char           **job)
 {
-	JobClass *class;
+	Session  *session;
+	JobClass *class = NULL;
+	JobClass *global_class = NULL;
 
 	nih_assert (message != NULL);
 	nih_assert (name != NULL);
@@ -397,8 +413,30 @@
 		return -1;
 	}
 
-	/* Lookup the job and copy its path into the reply */
-	class = (JobClass *)nih_hash_lookup (job_classes, name);
+	/* Get the relevant session */
+	session = session_from_dbus (NULL, message);
+
+	/* Lookup the job */
+	class = (JobClass *)nih_hash_search (job_classes, name, NULL);
+
+	while (class && (class->session != session)) {
+
+		/* Found a match in the global session which may be used
+		 * later if no matching user session job exists.
+		 */
+		if ((! class->session) && (session && ! session->chroot))
+			global_class = class;
+
+		class = (JobClass *)nih_hash_search (job_classes, name,
+				&class->entry);
+	}
+
+	/* If no job with the given name exists in the appropriate
+	 * session, look in the global namespace (aka the NULL session).
+	 */ 
+	if (! class)
+		class = global_class;
+
 	if (! class) {
 		nih_dbus_error_raise_printf (
 			DBUS_INTERFACE_UPSTART ".Error.UnknownJob",
@@ -406,6 +444,7 @@
 		return -1;
 	}
 
+	/* Copy the path */
 	*job = nih_strdup (message, class->path);
 	if (! *job)
 		nih_return_system_error (-1);
@@ -432,6 +471,7 @@
 		      NihDBusMessage   *message,
 		      char           ***jobs)
 {
+	Session *session;
 	char   **list;
 	size_t   len;
 
@@ -445,9 +485,16 @@
 	if (! list)
 		nih_return_system_error (-1);
 
+	/* Get the relevant session */
+	session = session_from_dbus (NULL, message);
+
 	NIH_HASH_FOREACH (job_classes, iter) {
 		JobClass *class = (JobClass *)iter;
 
+		if ((class->session || (session && session->chroot))
+		    && (class->session != session))
+			continue;
+
 		if (! nih_str_array_add (&list, message, &len,
 					 class->path)) {
 			nih_error_raise_system ();
@@ -462,13 +509,24 @@
 }
 
 
+int
+control_emit_event (void            *data,
+		    NihDBusMessage  *message,
+		    const char      *name,
+		    char * const    *env,
+		    int              wait)
+{
+	return control_emit_event_with_file (data, message, name, env, wait, -1);
+}
+
 /**
- * control_emit_event:
+ * control_emit_event_with_file:
  * @data: not used,
  * @message: D-Bus connection and message received,
  * @name: name of event to emit,
  * @env: environment of environment,
- * @wait: whether to wait for event completion before returning.
+ * @wait: whether to wait for event completion before returning,
+ * @file: file descriptor.
  *
  * Implements the top half of the EmitEvent method of the com.ubuntu.Upstart
  * interface, the bottom half may be found in event_finished().
@@ -488,11 +546,12 @@
  * Returns: zero on success, negative value on raised error.
  **/
 int
-control_emit_event (void            *data,
-		    NihDBusMessage  *message,
-		    const char      *name,
-		    char * const    *env,
-		    int              wait)
+control_emit_event_with_file (void            *data,
+			      NihDBusMessage  *message,
+			      const char      *name,
+			      char * const    *env,
+			      int              wait,
+			      int              file)
 {
 	Event   *event;
 	Blocked *blocked;
@@ -505,6 +564,7 @@
 	if (! strlen (name)) {
 		nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
 					     _("Name may not be empty string"));
+		close (file);
 		return -1;
 	}
 
@@ -512,19 +572,36 @@
 	if (! environ_all_valid (env)) {
 		nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
 					     _("Env must be KEY=VALUE pairs"));
+		close (file);
 		return -1;
 	}
 
 	/* Make the event and block the message on it */
 	event = event_new (NULL, name, (char **)env);
-	if (! event)
-		nih_return_system_error (-1);
+	if (! event) {
+		nih_error_raise_system ();
+		close (file);
+		return -1;
+	}
+
+	event->fd = file;
+	if (event->fd >= 0) {
+		long flags;
+
+		flags = fcntl (event->fd, F_GETFD);
+		flags &= ~FD_CLOEXEC;
+		fcntl (event->fd, F_SETFD, flags);
+	}
+
+	/* Obtain the session */
+	event->session = session_from_dbus (NULL, message);
 
 	if (wait) {
 		blocked = blocked_new (event, BLOCKED_EMIT_METHOD, message);
 		if (! blocked) {
 			nih_error_raise_system ();
 			nih_free (event);
+			close (file);
 			return -1;
 		}
 
@@ -669,3 +746,18 @@
 
 	return 0;
 }
+
+/**
+ * control_handle_bus_type:
+ *
+ * Determine D-Bus bus type to connect to.
+ **/
+void
+control_handle_bus_type (void)
+{
+	if (getenv (USE_SESSION_BUS_ENV))
+		use_session_bus = TRUE;
+
+	if (use_session_bus)
+		nih_debug ("Using session bus");
+}

=== modified file 'init/control.h'
--- init/control.h	2009-07-09 08:36:52 +0000
+++ init/control.h	2011-10-14 11:09:18 +0000
@@ -1,6 +1,6 @@
 /* upstart
  *
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2009-2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -27,6 +27,18 @@
 #include <nih-dbus/dbus_connection.h>
 #include <nih-dbus/dbus_message.h>
 
+/**
+ * USE_SESSION_BUS_ENV:
+ *
+ * If this environment variable is set to any value, connect to
+ * D-Bus session bus rather than the system bus.
+ *
+ * Used for testing.
+ **/
+#ifndef USE_SESSION_BUS_ENV
+#define USE_SESSION_BUS_ENV "UPSTART_USE_SESSION_BUS"
+#endif
+
 
 NIH_BEGIN_EXTERN
 
@@ -60,6 +72,10 @@
 				   const char *name, char * const *env,
 				   int wait)
 	__attribute__ ((warn_unused_result));
+int  control_emit_event_with_file (void *data, NihDBusMessage *message,
+				   const char *name, char * const *env,
+				   int wait, int file)
+	__attribute__ ((warn_unused_result));
 
 int  control_get_version          (void *data, NihDBusMessage *message,
 				   char **version)
@@ -72,6 +88,8 @@
 				   const char *log_priority)
 	__attribute__ ((warn_unused_result));
 
+void control_handle_bus_type      (void);
+
 NIH_END_EXTERN
 
 #endif /* INIT_CONTROL_H */

=== modified file 'init/environ.c'
--- init/environ.c	2011-03-16 22:42:48 +0000
+++ init/environ.c	2011-10-14 11:09:18 +0000
@@ -2,7 +2,6 @@
  *
  * environ.c - environment table utilities
  *
- * Copyright © 2011 Google Inc.
  * Copyright © 2009 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *

=== modified file 'init/environ.h'
--- init/environ.h	2011-03-16 22:42:48 +0000
+++ init/environ.h	2011-10-14 11:09:18 +0000
@@ -1,6 +1,5 @@
 /* upstart
  *
- * Copyright © 2011 Google Inc.
  * Copyright © 2009 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *

=== modified file 'init/event.c'
--- init/event.c	2010-12-14 15:32:41 +0000
+++ init/event.c	2011-10-14 11:09:18 +0000
@@ -25,6 +25,7 @@
 
 
 #include <string.h>
+#include <unistd.h>
 
 #include <nih/macros.h>
 #include <nih/alloc.h>
@@ -123,6 +124,9 @@
 
 	nih_list_init (&event->entry);
 
+	event->session = NULL;
+	event->fd = -1;
+
 	event->progress = EVENT_PENDING;
 	event->failed = FALSE;
 
@@ -293,6 +297,13 @@
 	NIH_HASH_FOREACH_SAFE (job_classes, iter) {
 		JobClass *class = (JobClass *)iter;
 
+		/* Only affect jobs within the same session as the event
+		 * unless the event has no session, in which case do them
+		 * all.
+		 */
+		if (event->session && (class->session != event->session))
+			continue;
+
 		/* We stop first so that if an event is listed both as a
 		 * stop and start event, it causes an active running process
 		 * to be killed, the stop script then the start script to be
@@ -393,8 +404,16 @@
 				job->start_env = env;
 				nih_ref (job->start_env, job);
 
+				nih_discard (env);
+				env = NULL;
+
 				job_finished (job, FALSE);
 
+				NIH_MUST (event_operator_fds (class->start_on, job,
+							      &job->fds, &job->num_fds,
+							      &job->start_env, &len,
+							      "UPSTART_FDS"));
+
 				event_operator_events (job->class->start_on,
 						       job, &job->blocking);
 
@@ -459,6 +478,8 @@
 		nih_free  (blocked);
 	}
 
+	close (event->fd);
+
 	if (event->failed) {
 		char *name;
 
@@ -470,6 +491,7 @@
 			failed = NIH_MUST (nih_sprintf (NULL, "%s/failed",
 							event->name));
 			new_event = NIH_MUST (event_new (NULL, failed, NULL));
+			new_event->session = event->session;
 
 			if (event->env)
 				new_event->env = NIH_MUST (nih_str_array_copy (

=== modified file 'init/event.h'
--- init/event.h	2009-07-09 08:36:52 +0000
+++ init/event.h	2011-10-14 11:09:18 +0000
@@ -1,6 +1,6 @@
 /* upstart
  *
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2010 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -23,6 +23,8 @@
 #include <nih/macros.h>
 #include <nih/list.h>
 
+#include "session.h"
+
 
 /**
  * EventProgress:
@@ -40,6 +42,7 @@
 /**
  * Event:
  * @entry: list header,
+ * @session: session the event is attached to,
  * @name: string name of the event,
  * @env: NULL-terminated array of environment variables,
  * @progress: progress of event,
@@ -61,8 +64,10 @@
 typedef struct event {
 	NihList          entry;
 
+	Session *        session;
  	char            *name;
 	char           **env;
+	int              fd;
 
 	EventProgress    progress;
 	int              failed;

=== modified file 'init/event_operator.c'
--- init/event_operator.c	2010-11-19 14:34:51 +0000
+++ init/event_operator.c	2011-10-14 11:09:18 +0000
@@ -552,6 +552,65 @@
 	return *env;
 }
 
+int *
+event_operator_fds (EventOperator *root,
+		    const void *parent,
+		    int **fds,
+		    size_t *num_fds,
+		    char          ***env,
+		    size_t          *len,
+		    const char      *key)
+{
+	nih_local char *evlist = NULL;
+
+	nih_assert (root != NULL);
+	nih_assert (fds != NULL);
+	nih_assert (num_fds != NULL);
+	nih_assert (env != NULL);
+	nih_assert (len != NULL);
+	nih_assert (key != NULL);
+
+	/* Initialise the event list variable with the name given. */
+	evlist = nih_sprintf (NULL, "%s=", key);
+	if (! evlist)
+		return NULL;
+
+	*num_fds = 0;
+	NIH_TREE_FOREACH_FULL (&root->node, iter,
+			       (NihTreeFilter)event_operator_filter, NULL) {
+		EventOperator *oper = (EventOperator *)iter;
+
+		if (oper->type != EVENT_MATCH)
+			continue;
+
+		nih_assert (oper->event != NULL);
+
+		if (oper->event->fd >= 0) {
+			*fds = nih_realloc (*fds, parent, sizeof (int) * (*num_fds + 1));
+			if (! *fds)
+				return NULL;
+
+			(*fds)[(*num_fds)++] = oper->event->fd;
+
+			if (evlist[strlen (evlist) - 1] != '=') {
+				if (! nih_strcat_sprintf (&evlist, NULL, " %d",
+							  oper->event->fd))
+					return NULL;
+			} else {
+				if (! nih_strcat_sprintf (&evlist, NULL, "%d",
+							  oper->event->fd))
+					return NULL;
+			}
+		}
+	}
+
+	if (*num_fds)
+		if (! environ_add (env, parent, len, TRUE, evlist))
+			return NULL;
+
+	return (void *)1;
+}
+
 /**
  * event_operator_events:
  * @root: operator tree to collect from,

=== modified file 'init/event_operator.h'
--- init/event_operator.h	2009-06-23 09:29:35 +0000
+++ init/event_operator.h	2011-10-14 11:09:18 +0000
@@ -95,6 +95,14 @@
 char **        event_operator_environment (EventOperator *root, char ***env,
 					   const void *parent, size_t *len,
 					   const char *key);
+int *
+event_operator_fds (EventOperator *root,
+		    const void *parent,
+		    int **fds,
+		    size_t *num_fds,
+		    char          ***env,
+		    size_t          *len,
+		    const char      *key);
 void           event_operator_events      (EventOperator *root,
 					   const void *parent, NihList *list);
 

=== modified file 'init/job.c'
--- init/job.c	2010-12-14 15:32:41 +0000
+++ init/job.c	2011-10-14 11:09:18 +0000
@@ -2,7 +2,7 @@
  *
  * job.c - core state machine of tasks and services
  *
- * Copyright © 2010 Canonical Ltd.
+ * Copyright © 2010,2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -47,6 +47,7 @@
 #include "events.h"
 #include "environ.h"
 #include "process.h"
+#include "session.h"
 #include "job_class.h"
 #include "job.h"
 #include "job_process.h"
@@ -99,8 +100,14 @@
 
 	job->class = class;
 
-	job->path = nih_dbus_path (job, DBUS_PATH_UPSTART, "jobs",
-				   class->name, job->name, NULL);
+	if (job->class->session && job->class->session->chroot) {
+		/* JobClass already contains a valid D-Bus path prefix for the job */
+		job->path = nih_dbus_path (job, class->path, job->name, NULL);
+	} else {
+		job->path = nih_dbus_path (job, DBUS_PATH_UPSTART, "jobs",
+				class->name, job->name, NULL);
+	}
+
 	if (! job->path)
 		goto error;
 
@@ -118,6 +125,9 @@
 			goto error;
 	}
 
+	job->fds = NULL;
+	job->num_fds = 0;
+
 	job->pid = nih_alloc (job, sizeof (pid_t) * PROCESS_LAST);
 	if (! job->pid)
 		goto error;
@@ -906,6 +916,7 @@
 	}
 
 	event = NIH_MUST (event_new (NULL, name, env));
+	event->session = job->class->session;
 
 	if (block) {
 		Blocked *blocked;
@@ -1102,11 +1113,22 @@
 	   NihDBusMessage  *message,
 	   int              wait)
 {
+	Session *session;
 	Blocked *blocked = NULL;
 
 	nih_assert (job != NULL);
 	nih_assert (message != NULL);
 
+	/* Don't permit out-of-session modification */
+	session = session_from_dbus (NULL, message);
+	if (session != job->class->session) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to modify job: %s"),
+			job_name (job));
+		return -1;
+	}
+
 	if (job->goal == JOB_START) {
 		nih_dbus_error_raise_printf (
 			DBUS_INTERFACE_UPSTART ".Error.AlreadyStarted",
@@ -1166,11 +1188,22 @@
 	  NihDBusMessage *message,
 	  int             wait)
 {
+	Session *session;
 	Blocked *blocked = NULL;
 
 	nih_assert (job != NULL);
 	nih_assert (message != NULL);
 
+	/* Don't permit out-of-session modification */
+	session = session_from_dbus (NULL, message);
+	if (session != job->class->session) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to modify job: %s"),
+			job_name (job));
+		return -1;
+	}
+
 	if (job->goal == JOB_STOP) {
 		nih_dbus_error_raise_printf (
 			DBUS_INTERFACE_UPSTART ".Error.AlreadyStopped",
@@ -1231,11 +1264,22 @@
 	     NihDBusMessage *message,
 	     int             wait)
 {
+	Session *session;
 	Blocked *blocked = NULL;
 
 	nih_assert (job != NULL);
 	nih_assert (message != NULL);
 
+	/* Don't permit out-of-session modification */
+	session = session_from_dbus (NULL, message);
+	if (session != job->class->session) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to modify job: %s"),
+			job_name (job));
+		return -1;
+	}
+
 	if (job->goal == JOB_STOP) {
 		nih_dbus_error_raise_printf (
 			DBUS_INTERFACE_UPSTART ".Error.AlreadyStopped",

=== modified file 'init/job.h'
--- init/job.h	2009-07-03 16:38:02 +0000
+++ init/job.h	2011-10-14 11:09:18 +0000
@@ -1,6 +1,6 @@
 /* upstart
  *
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2010 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -134,6 +134,9 @@
 	char          **stop_env;
 	EventOperator  *stop_on;
 
+	int *fds;
+	size_t num_fds;
+
 	pid_t          *pid;
 	Event          *blocker;
 	NihList         blocking;

=== modified file 'init/job_class.c'
--- init/job_class.c	2011-05-12 20:42:28 +0000
+++ init/job_class.c	2011-10-14 11:09:18 +0000
@@ -2,7 +2,7 @@
  *
  * job_class.c - job class definition handling
  *
- * Copyright © 2010 Canonical Ltd.
+ * Copyright © 2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -45,6 +45,7 @@
 
 #include "environ.h"
 #include "process.h"
+#include "session.h"
 #include "job_class.h"
 #include "job.h"
 #include "event_operator.h"
@@ -56,51 +57,9 @@
 #include "com.ubuntu.Upstart.Job.h"
 
 
-/**
- * JOB_DEFAULT_KILL_TIMEOUT:
- *
- * The default length of time to wait after sending a process the TERM
- * signal before sending the KILL signal if it hasn't terminated.
- **/
-#define JOB_DEFAULT_KILL_TIMEOUT 5
-
-/**
- * JOB_DEFAULT_RESPAWN_LIMIT:
- *
- * The default number of times in JOB_DEFAULT_RESPAWN_INTERVAL seconds that
- * we permit a process to respawn before stoping it
- **/
-#define JOB_DEFAULT_RESPAWN_LIMIT 10
-
-/**
- * JOB_DEFAULT_RESPAWN_INTERVAL:
- *
- * The default number of seconds before resetting the respawn timer.
- **/
-#define JOB_DEFAULT_RESPAWN_INTERVAL 5
-
-/**
- * JOB_DEFAULT_UMASK:
- *
- * The default file creation mark for processes.
- **/
-#define JOB_DEFAULT_UMASK 022
-
-/**
- * JOB_DEFAULT_ENVIRONMENT:
- *
- * Environment variables to always copy from our own environment, these
- * can be overriden in the job definition or by events since they have the
- * lowest priority.
- **/
-#define JOB_DEFAULT_ENVIRONMENT \
-	"PATH",			\
-	"TERM"
-
-
 /* Prototypes for static functions */
 static void job_class_add    (JobClass *class);
-static int  job_class_remove (JobClass *class);
+static int  job_class_remove (JobClass *class, const Session *session);
 
 
 /**
@@ -128,13 +87,15 @@
 
 /**
  * job_class_new:
+ *
  * @parent: parent for new job class,
- * @name: name of new job class.
+ * @name: name of new job class,
+ * @session: session.
  *
- * Allocates and returns a new JobClass structure with the @name given.
- * It will not be automatically added to the job classes table, it is up
- * to the caller to ensure this is done using job_class_register() once
- * the class has been set up.
+ * Allocates and returns a new JobClass structure with the given @name
+ * and @session. It will not be automatically added to the job classes
+ * table, it is up to the caller to ensure this is done using
+ * job_class_register() once the class has been set up.
  *
  * If @parent is not NULL, it should be a pointer to another object which
  * will be used as a parent for the returned job class.  When all parents
@@ -145,7 +106,8 @@
  **/
 JobClass *
 job_class_new (const void *parent,
-	       const char *name)
+	       const char *name,
+	       Session    *session)
 {
 	JobClass *class;
 	int       i;
@@ -165,8 +127,41 @@
 	if (! class->name)
 		goto error;
 
-	class->path = nih_dbus_path (class, DBUS_PATH_UPSTART, "jobs",
-				     class->name, NULL);
+	class->session = session;
+	if (class->session
+	    && class->session->chroot
+	    && class->session->user) {
+		nih_local char *uid = NULL;
+
+		uid = nih_sprintf (NULL, "%d", class->session->user);
+		if (! uid)
+			goto error;
+
+		class->path = nih_dbus_path (class, DBUS_PATH_UPSTART, "jobs",
+					     session->chroot, uid,
+					     class->name, NULL);
+
+	} else if (class->session
+		   && class->session->chroot) {
+		class->path = nih_dbus_path (class, DBUS_PATH_UPSTART, "jobs",
+					     session->chroot,
+					     class->name, NULL);
+
+	} else if (class->session
+		   && class->session->user) {
+		nih_local char *uid = NULL;
+
+		uid = nih_sprintf (NULL, "%d", class->session->user);
+		if (! uid)
+			goto error;
+
+		class->path = nih_dbus_path (class, DBUS_PATH_UPSTART, "jobs",
+					     uid, class->name, NULL);
+
+	} else {
+		class->path = nih_dbus_path (class, DBUS_PATH_UPSTART, "jobs",
+					     class->name, NULL);
+	}
 	if (! class->path)
 		goto error;
 
@@ -212,8 +207,8 @@
 	class->console = CONSOLE_NONE;
 
 	class->umask = JOB_DEFAULT_UMASK;
-	class->nice = 0;
-	class->oom_score_adj = 0;
+	class->nice = JOB_DEFAULT_NICE;
+	class->oom_score_adj = JOB_DEFAULT_OOM_SCORE_ADJ;
 
 	for (i = 0; i < RLIMIT_NLIMITS; i++)
 		class->limits[i] = NULL;
@@ -245,19 +240,27 @@
 int
 job_class_consider (JobClass *class)
 {
-	JobClass *registered, *best;
+	JobClass *registered = NULL, *best = NULL;
 
 	nih_assert (class != NULL);
 
 	job_class_init ();
 
-	best = conf_select_job (class->name);
+	best = conf_select_job (class->name, class->session);
 	nih_assert (best != NULL);
-
-	registered = (JobClass *)nih_hash_lookup (job_classes, class->name);
+	nih_assert (best->session == class->session);
+
+	registered = (JobClass *)nih_hash_search (job_classes, class->name, NULL);
+
+	/* If we found an entry, ensure we only consider the appropriate session */
+	while (registered && registered->session != class->session)
+	{
+		registered = (JobClass *)nih_hash_search (job_classes, class->name, &registered->entry);
+	}
+
 	if (registered != best) {
 		if (registered)
-			if (! job_class_remove (registered))
+			if (! job_class_remove (registered, class->session))
 				return FALSE;
 
 		job_class_add (best);
@@ -282,18 +285,25 @@
 int
 job_class_reconsider (JobClass *class)
 {
-	JobClass *registered, *best;
+	JobClass *registered = NULL, *best = NULL;
 
 	nih_assert (class != NULL);
 
 	job_class_init ();
 
-	best = conf_select_job (class->name);
-
-	registered = (JobClass *)nih_hash_lookup (job_classes, class->name);
+	best = conf_select_job (class->name, class->session);
+
+	registered = (JobClass *)nih_hash_search (job_classes, class->name, NULL);
+
+	/* If we found an entry, ensure we only consider the appropriate session */
+	while (registered && registered->session != class->session)
+	{
+		registered = (JobClass *)nih_hash_search (job_classes, class->name, &registered->entry);
+	}
+
 	if (registered == class) {
 		if (class != best) {
-			if (! job_class_remove (class))
+			if (! job_class_remove (class, class->session))
 				return FALSE;
 
 			job_class_add (best);
@@ -334,19 +344,24 @@
 
 /**
  * job_class_remove:
- * @class: class to remove.
+ * @class: class to remove,
+ * @session: Session of @class.
  *
  * Removes @class from the hash table and unregisters it from all current
  * D-Bus connections.
  *
  * Returns: TRUE if class could be unregistered, FALSE if there are
- * active instances that prevent unregistration.
+ * active instances that prevent unregistration, or if @session
+ * does not match the session associated with @class.
  **/
 static int
-job_class_remove (JobClass *class)
+job_class_remove (JobClass *class, const Session *session)
 {
 	nih_assert (class != NULL);
 
+	if (class->session != session)
+		return FALSE;
+
 	control_init ();
 
 	/* Return if we have any active instances */
@@ -696,6 +711,7 @@
 		 char * const    *env,
 		 int              wait)
 {
+	Session         *session;
 	Blocked         *blocked = NULL;
 	Job             *job;
 	nih_local char **start_env = NULL;
@@ -706,6 +722,16 @@
 	nih_assert (message != NULL);
 	nih_assert (env != NULL);
 
+	/* Don't permit out-of-session modification */
+	session = session_from_dbus (NULL, message);
+	if (session != class->session) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to modify job: %s"),
+			class->name);
+		return -1;
+	}
+
 	/* Verify that the environment is valid */
 	if (! environ_all_valid (env)) {
 		nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
@@ -815,6 +841,7 @@
 		char * const   *env,
 		int             wait)
 {
+	Session         *session;
 	Blocked         *blocked = NULL;
 	Job             *job;
 	nih_local char **stop_env = NULL;
@@ -825,6 +852,16 @@
 	nih_assert (message != NULL);
 	nih_assert (env != NULL);
 
+	/* Don't permit out-of-session modification */
+	session = session_from_dbus (NULL, message);
+	if (session != class->session) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to modify job: %s"),
+			class->name);
+		return -1;
+	}
+
 	/* Verify that the environment is valid */
 	if (! environ_all_valid (env)) {
 		nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,
@@ -939,6 +976,7 @@
 		   char * const    *env,
 		   int              wait)
 {
+	Session         *session;
 	Blocked         *blocked = NULL;
 	Job             *job;
 	nih_local char **restart_env = NULL;
@@ -949,6 +987,16 @@
 	nih_assert (message != NULL);
 	nih_assert (env != NULL);
 
+	/* Don't permit out-of-session modification */
+	session = session_from_dbus (NULL, message);
+	if (session != class->session) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to modify job: %s"),
+			class->name);
+		return -1;
+	}
+
 	/* Verify that the environment is valid */
 	if (! environ_all_valid (env)) {
 		nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS,

=== modified file 'init/job_class.h'
--- init/job_class.h	2011-05-12 20:42:28 +0000
+++ init/job_class.h	2011-10-14 11:09:18 +0000
@@ -1,6 +1,6 @@
 /* upstart
  *
- * Copyright © 2010 Canonical Ltd.
+ * Copyright © 2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -35,6 +35,7 @@
 
 #include "process.h"
 #include "event_operator.h"
+#include "session.h"
 
 
 /**
@@ -67,10 +68,67 @@
 
 
 /**
+ * JOB_DEFAULT_KILL_TIMEOUT:
+ *
+ * The default length of time to wait after sending a process the TERM
+ * signal before sending the KILL signal if it hasn't terminated.
+ **/
+#define JOB_DEFAULT_KILL_TIMEOUT 5
+
+/**
+ * JOB_DEFAULT_RESPAWN_LIMIT:
+ *
+ * The default number of times in JOB_DEFAULT_RESPAWN_INTERVAL seconds that
+ * we permit a process to respawn before stoping it
+ **/
+#define JOB_DEFAULT_RESPAWN_LIMIT 10
+
+/**
+ * JOB_DEFAULT_RESPAWN_INTERVAL:
+ *
+ * The default number of seconds before resetting the respawn timer.
+ **/
+#define JOB_DEFAULT_RESPAWN_INTERVAL 5
+
+/**
+ * JOB_DEFAULT_UMASK:
+ *
+ * The default file creation mark for processes.
+ **/
+#define JOB_DEFAULT_UMASK 022
+
+/**
+ * JOB_DEFAULT_NICE:
+ *
+ * The default nice level for processes.
+ **/
+#define JOB_DEFAULT_NICE 0
+
+/**
+ * JOB_DEFAULT_OOM_SCORE_ADJ:
+ *
+ * The default OOM score adjustment for processes.
+ **/
+#define JOB_DEFAULT_OOM_SCORE_ADJ 0
+
+/**
+ * JOB_DEFAULT_ENVIRONMENT:
+ *
+ * Environment variables to always copy from our own environment, these
+ * can be overriden in the job definition or by events since they have the
+ * lowest priority.
+ **/
+#define JOB_DEFAULT_ENVIRONMENT \
+	"PATH",			\
+	"TERM"
+
+
+/**
  * JobClass:
  * @entry: list header,
  * @name: unique name,
  * @path: path of D-Bus object,
+ * @session: attached session,
  * @instance: pattern to uniquely identify multiple instances,
  * @instances: hash table of active instances,
  * @description: description; intended for humans,
@@ -110,6 +168,7 @@
 
 	char           *name;
 	char           *path;
+	Session *       session;
 
 	char           *instance;
 	NihHash        *instances;
@@ -161,7 +220,8 @@
 void        job_class_init                 (void);
 
 JobClass  * job_class_new                  (const void *parent,
-					    const char *name)
+					    const char *name,
+					    Session *session)
 	__attribute__ ((warn_unused_result, malloc));
 
 int         job_class_consider             (JobClass *class);

=== modified file 'init/job_process.c'
--- init/job_process.c	2011-05-12 20:42:28 +0000
+++ init/job_process.c	2011-10-14 11:09:18 +0000
@@ -2,7 +2,6 @@
  *
  * job_process.c - job process handling
  *
- * Copyright © 2011 Google Inc.
  * Copyright © 2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
@@ -41,6 +40,7 @@
 #include <unistd.h>
 #include <utmp.h>
 #include <utmpx.h>
+#include <pwd.h>
 
 #include <nih/macros.h>
 #include <nih/alloc.h>
@@ -373,14 +373,20 @@
 		   int           trace,
 		   int           script_fd)
 {
-	sigset_t  child_set, orig_set;
-	pid_t     pid;
-	int       i, fds[2];
-	char      filename[PATH_MAX];
-	FILE     *fd;
+	sigset_t        child_set, orig_set;
+	pid_t           pid;
+	int             i, fds[2];
+	char            filename[PATH_MAX];
+	FILE           *fd;
+	int             user_job = FALSE;
+	nih_local char *user_dir = NULL;
+
 
 	nih_assert (class != NULL);
 
+	if (class && class->session && class->session->user)
+		user_job = TRUE;
+
 	/* Create a pipe to communicate with the child process until it
 	 * execs so we know whether that was successful or an error occurred.
 	 */
@@ -439,6 +445,8 @@
 	close (fds[0]);
 	if (fds[1] == JOB_PROCESS_SCRIPT_FD) {
 		int tmp = dup2 (fds[1], fds[0]);
+		if (tmp < 0)
+			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_DUP, 0);
 		close (fds[1]);
 		fds[1] = tmp;
 	}
@@ -447,7 +455,7 @@
 	/* Move the script fd to special fd 9; the only gotcha is if that
 	 * would be our error descriptor, but that's handled above.
 	 */
-	if (script_fd != -1) {
+	if ((script_fd != -1) && (script_fd != JOB_PROCESS_SCRIPT_FD)) {
 		int tmp = dup2 (script_fd, JOB_PROCESS_SCRIPT_FD);
 		if (tmp < 0)
 			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_DUP, 0);
@@ -460,6 +468,84 @@
 	 */
 	setsid ();
 
+	/* Set the process environment from the function paramters. */
+	environ = (char **)env;
+
+	/* Handle unprivileged user job by dropping privileges to
+	 * their level as soon as possible to avoid privilege
+	 * escalations when we set resource limits.
+	 */
+	if (user_job) {
+		uid_t uid = class->session->user;
+		struct passwd *pw = NULL;
+
+		/* D-Bus does not expose a public API call to allow
+		 * us to query a users primary group.
+		 * _dbus_user_info_fill_uid () seems to exist for this
+		 * purpose, but is a "secret" API. It is unclear why
+		 * D-Bus neglects the gid when it allows the uid
+		 * to be queried directly.
+		 *
+		 * Our only recourse is to disallow user sessions in a
+		 * chroot and assume that all other user sessions
+		 * originate from the local system. In this way, we can
+		 * bypass D-Bus and use getpwuid ().
+		 */
+
+		if (class->session->chroot) {
+			/* We cannot determine the group id of the user
+			 * session in the chroot via D-Bus, so disallow
+			 * all jobs in such an environment.
+			 */
+			nih_return_error (-1, EPERM, "user jobs not supported in chroots");
+		}
+
+		pw = getpwuid (uid);
+
+		if (!pw)
+			nih_return_system_error (-1);
+
+		nih_assert (pw->pw_uid == uid);
+
+		if (! pw->pw_dir) {
+			nih_local char *message = NIH_MUST (nih_sprintf (NULL,
+						"no home directory for user with uid %d",
+						uid));
+
+			nih_return_error (-1, ENOENT, message);
+
+		}
+
+		/* Note we don't use NIH_MUST since this could result in a
+		 * DOS for a (low priority) user job in low-memory scenarios.
+		 */
+		user_dir = nih_strdup (NULL, pw->pw_dir);
+
+		if (!user_dir)
+			nih_return_no_memory_error (-1);
+
+		/* Ensure the file associated with fd 9
+		 * (/proc/self/fd/9) is owned by the user we're about to
+		 * become to avoid EPERM.
+		 */
+		if (script_fd != -1 && fchown (script_fd, pw->pw_uid, pw->pw_gid) < 0) {
+			nih_error_raise_system ();
+			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_CHOWN, 0);
+		}
+
+		if (pw->pw_gid && setgid (pw->pw_gid) < 0) {
+			nih_error_raise_system ();
+			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_SETGID, 0);
+		}
+
+		if (pw->pw_uid && setuid (pw->pw_uid) < 0) {
+			nih_error_raise_system ();
+			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_SETUID, 0);
+		}
+
+
+	}
+
 	/* Set the standard file descriptors to an output of our chosing;
 	 * any other open descriptor must be intended for the child, or have
 	 * the FD_CLOEXEC flag so it's automatically closed when we exec()
@@ -480,6 +566,7 @@
 			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_CONSOLE, 0);
 	}
 
+
 	/* Set resource limits for the process, skipping over any that
 	 * aren't set in the job class such that they inherit from
 	 * ourselves (and we inherit from kernel defaults).
@@ -495,9 +582,6 @@
 		}
 	}
 
-	/* Set the process environment from the function paramters. */
-	environ = (char **)env;
-
 	/* Set the file mode creation mask; this is one of the few operations
 	 * that can never fail.
 	 */
@@ -513,13 +597,13 @@
 
 	/* Adjust the process OOM killer priority.
 	 */
-	if (class->oom_score_adj) {
+	if (class->oom_score_adj != JOB_DEFAULT_OOM_SCORE_ADJ) {
 		int oom_value;
 		snprintf (filename, sizeof (filename),
 			  "/proc/%d/oom_score_adj", getpid ());
 		oom_value = class->oom_score_adj;
 		fd = fopen (filename, "w");
-		if ((! fd) && (errno == EACCES)) {
+		if ((! fd) && (errno == ENOENT)) {
 			snprintf (filename, sizeof (filename),
 				  "/proc/%d/oom_adj", getpid ());
 			oom_value = (class->oom_score_adj
@@ -539,6 +623,16 @@
 		}
 	}
 
+	/* Handle changing a chroot session job prior to dealing with
+	 * the 'chroot' stanza.
+	 */
+	if (class->session && class->session->chroot) {
+		if (chroot (class->session->chroot) < 0) {
+			nih_error_raise_system ();
+			job_process_error_abort (fds[1], JOB_PROCESS_ERROR_CHROOT, 0);
+		}
+	}
+
 	/* Change the root directory, confining path resolution within it;
 	 * we do this before the working directory call so that is always
 	 * relative to the new root.
@@ -555,12 +649,11 @@
 	 * configured in the job, or to the root directory of the filesystem
 	 * (or at least relative to the chroot).
 	 */
-	if (chdir (class->chdir ? class->chdir : "/") < 0) {
+	if (chdir (class->chdir ? class->chdir : user_job ? user_dir : "/") < 0) {
 		nih_error_raise_system ();
 		job_process_error_abort (fds[1], JOB_PROCESS_ERROR_CHDIR, 0);
 	}
 
-
 	/* Reset all the signal handlers back to their default handling so
 	 * the child isn't unexpectedly ignoring any, and so we won't
 	 * surprisingly handle them before we've exec()d the new process.
@@ -787,6 +880,21 @@
 				  err, _("unable to execute: %s"),
 				  strerror (err->errnum)));
 		break;
+	case JOB_PROCESS_ERROR_SETUID:
+		err->error.message = NIH_MUST (nih_sprintf (
+				  err, _("unable to setuid: %s"),
+				  strerror (err->errnum)));
+		break;
+	case JOB_PROCESS_ERROR_SETGID:
+		err->error.message = NIH_MUST (nih_sprintf (
+				  err, _("unable to setgid: %s"),
+				  strerror (err->errnum)));
+		break;
+	case JOB_PROCESS_ERROR_CHOWN:
+		err->error.message = NIH_MUST (nih_sprintf (
+				  err, _("unable to chown: %s"),
+				  strerror (err->errnum)));
+		break;
 	default:
 		nih_assert_not_reached ();
 	}

=== modified file 'init/job_process.h'
--- init/job_process.h	2011-05-12 19:21:16 +0000
+++ init/job_process.h	2011-10-14 11:09:18 +0000
@@ -1,7 +1,6 @@
 /* upstart
  *
- * Copyright © 2011 Google Inc.
- * Copyright © 2009 Canonical Ltd.
+ * Copyright © 2009,2010,2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -57,7 +56,10 @@
 	JOB_PROCESS_ERROR_CHROOT,
 	JOB_PROCESS_ERROR_CHDIR,
 	JOB_PROCESS_ERROR_PTRACE,
-	JOB_PROCESS_ERROR_EXEC
+	JOB_PROCESS_ERROR_EXEC,
+	JOB_PROCESS_ERROR_SETUID,
+	JOB_PROCESS_ERROR_SETGID,
+	JOB_PROCESS_ERROR_CHOWN
 } JobProcessErrorType;
 
 /**

=== modified file 'init/main.c'
--- init/main.c	2011-05-30 00:06:07 +0000
+++ init/main.c	2011-10-14 11:09:18 +0000
@@ -1,7 +1,6 @@