Merge lp:~jamesodhunt/ubuntu/precise/upstart/fix-for-bug-912558 into lp:ubuntu/precise/upstart

[James Hunt]

  [ Stéphane Graber ]
  * Mark upstart Multi-Arch:foreign

  [ James Hunt ]
  * Merge of important logger fixes from upstream lp:upstart
    (LP: #912558).
  * Reverted temporary fix to disable job logging.

[Colin Watson (cjwatson)]

review: Approve

=== modified file 'ChangeLog'
--- ChangeLog	2011-12-22 16:52:22 +0000
+++ ChangeLog	2012-01-26 15:59:26 +0000
@@ -1,3 +1,46 @@
[phone]  James Hunt  <[e-mail]>
+
+	* init/job_process.c: job_process_terminated(): Free log to ensure data
+	  written as soon as _any_ process ends (consider respawn jobs).
+	* init/log.c:
+	  - log_destroy():
+	    - Improved documentation.
+	    - Now calls new function log_flush().
+	  - log_flush(): New function to ensure no lingering buffered job data
+	    remains. Now considers EBADF (LP: #912558).
+	  - log_io_reader():
+	    - Added missing assert for @len.
+	    - Simplified ENOSPC handling.
+	    - Ensure log->io set to NULL to allow other routines to detect it
+	      really has gone.
+	  - log_file_write(): Added @len checks.
+	  - log_read_watch(): New function to drain data from a watch descriptor
+	    (which also must consider EBADF).
+	* init/log.h: Added define for LOG_READ_SIZE.
+	* init/tests/test_job_process.c:
+	  - test_run():
+	    - Added some extra pointer checks.
+	    - Free class *before* checking file to ensure destructor invoked at
+	      correct point.
+	    - Added test "with single-line command running an invalid command"
+	      (for scenario bug 912558 exposed).
+	    - Added test "with single-line command writing fast and exiting".
+	* init/tests/test_log.c: Changed all tests to use openpty(3) rather than
+	  pipe(2) for semantic parity with actual code.
+	* util/tests/test_user_sessions.sh:
+	  - ensure_no_output(): Now calls check_job_output() and delete_job() to
+	    simplify logic.
+	  - delete_job(): Call get_job_file() rather than doing it long-hand.
+	  - check_job_output(): New function.
+	  - start_job(): Added allow_failure parameter.
+	  - test_ensure_no_unexpected_output(): New test
+	    "ensure command job does not create log file with invalid command".
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/man/init.5: Explain that all job processes affected
+	  by 'setuid' and 'setgid' stanzas.
+
 2011-12-22  James Hunt  <[e-mail]>
 
 	* init/job_process.c: job_process_spawn():

=== modified file 'debian/changelog'
--- debian/changelog	2012-01-09 10:10:08 +0000
+++ debian/changelog	2012-01-26 15:59:26 +0000
@@ -1,8 +1,14 @@
-upstart (1.4-0ubuntu3) UNRELEASED; urgency=low
+upstart (1.4-0ubuntu3) precise; urgency=low
 
+  [ Stéphane Graber ]
   * Mark upstart Multi-Arch:foreign
 
- -- Stéphane Graber <[e-mail]>  Mon, 09 Jan 2012 11:08:27 +0100
+  [ James Hunt ]
+  * Merge of important logger fixes from upstream lp:upstart
+    (LP: #912558).
+  * Reverted temporary fix to disable job logging. 
+
+ -- James Hunt <[e-mail]>  Thu, 26 Jan 2012 15:13:25 +0000
 
 upstart (1.4-0ubuntu2) precise; urgency=low
 

=== modified file 'init/job_process.c'
--- init/job_process.c	2011-12-22 16:52:22 +0000
+++ init/job_process.c	2012-01-26 15:59:26 +0000
@@ -1571,6 +1571,18 @@
 		job->kill_process = -1;
 	}
 
+	if (job->class->console == CONSOLE_LOG) {
+		/* It is imperative that we free the log at this stage to ensure
+		 * that jobs which respawn have their log written _now_
+		 * (and not just when the overall Job object is freed at
+		 * some distant future point).
+		 */
+		if (job->log) {
+			nih_free (job->log);
+			job->log = NULL;
+		}
+	}
+
 	/* Find existing utmp entry for the process pid */
 	setutxent();
 	while ((utmptr = getutxent()) != NULL) {

=== modified file 'init/log.c'
--- init/log.c	2011-12-15 17:50:14 +0000
+++ init/log.c	2012-01-26 15:59:26 +0000
@@ -35,6 +35,8 @@
 
 static int  log_file_open   (Log *log);
 static int  log_file_write  (Log *log, const char *buf, size_t len);
+static void log_read_watch  (Log *log);
+static void log_flush       (Log *log);
 
 /**
  * log_new:
@@ -140,11 +142,54 @@
  * @log: Log.
  *
  * Called automatically when Log is being destroyed.
+ *
+ * XXX: Note that the fd associated with the jobs stdout and stderr (as
+ * passed to log_new()) *MUST* be closed by the time this function is
+ * called since it will continue to read from the fd until an error is
+ * detected. This behaviour is required to ensure all job output is
+ * read.
+ *
+ * Returns: 0 always.
  **/
 int
 log_destroy (Log *log)
 {
+	nih_assert (log);
+
+	/* User job logging not currently available */
+	nih_assert (log->uid == 0);
+
+	log_flush (log);
+
+	/* Force file to flush */
+	if (log->fd != -1)
+		close (log->fd);
+
+	log->fd = -1;
+
+	return 0;
+}
+
+/**
+ * log_flush:
+ *
+ * @log: Log.
+ *
+ * Ensure that no job output data is buffered and attempt to flush all
+ * unflushed data to disk.
+ *
+ * It is safe to call this function multiple times and may in fact be
+ * necessary if the log file cannot be written for any reason.
+ *
+ * Note no return value since there isn't much that can be done at
+ * the point this function is called should the flushing operations
+ * fail.
+ **/
+static void
+log_flush (Log *log)
+{
 	int ret;
+	int flags;
 
 	nih_assert (log);
 
@@ -162,21 +207,49 @@
 			goto out;
 
 		ret = log_file_write (log, NULL, 0);
-		if (ret < 0)
+		if (ret < 0) {
+			close (log->fd);
+			log->fd = -1;
 			goto out;
-	}
-
-	/* Force file to flush
-	 *
-	 * Only attempt this for jobs which the current process is
-	 * in control of.
-	 */
-	if (log->fd > 0)
+		}
+	}
+
+	if (log->io) {
+		nih_assert (log->io->watch);
+
+		/* If the job associated with this log produces output _after_
+		 * nih_io_handle_fds() has been called in any loop of the main
+		 * loop and just before the job is destroyed, we will miss it.
+		 * 
+		 * Therefore, attempt to read from the watch fd until we get an error.
+		 */
+		log_read_watch (log);
+
+		flags = fcntl (log->io->watch->fd, F_GETFL);
+
+		if (flags < 0 && errno == EBADF) {
+			/* The watch fd is now known to be invalid, so disable
+			 * the error handler to avoid an infinite loop where the
+			 * error handler attempts to free the NihIo, which would
+			 * error, causing the error handler to be called
+			 * ad infinitum.
+			 *
+			 * Note that the NihIo is freed via
+			 * nih_io_destroy().
+			 */
+			log->io->error_handler = NULL;
+
+			nih_free (log->io);
+			log->io = NULL;
+		}
+	}
+
+	/* Force file to flush */
+	if (log->fd != -1)
 		close (log->fd);
 
 out:
 	log->fd = -1;
-	return 0;
 }
 
 /**
@@ -191,7 +264,7 @@
  * encapsulated in @io.
  *
  * Notes for user jobs:
-
+ *
  * User jobs by necessity are handled differently to system jobs. Since
  * a user job must log their data to files owned by a non-root user, the
  * safest technique is for a process running as that user to create the
@@ -223,45 +296,37 @@
 	nih_assert (io);
 	nih_assert (log->io == io);
 	nih_assert (buf);
+	nih_assert (len);
 
 	/* User job logging not currently available */
 	nih_assert (log->uid == 0);
 
-	/* Note we don't assert @len in case we are being called after
-	 * an error is detected (where there is no new data, but may be
-	 * unflushed data).
-	 */
-
 	/* Just in case we try to write more than read can inform us
 	 * about (this should really be a build-time assertion).
 	 */
 	nih_assert (sizeof (size_t) == sizeof (ssize_t));
 
 	if (log_file_open (log) < 0) {
-		if (errno == ENOSPC) {
-			/* Always discard when out of space */
-			nih_io_buffer_shrink (io->recv_buf, len);
-			return;
-		} else {
+		if (errno != ENOSPC) {
 			/* Add new data to unflushed buffer */
 			if (nih_io_buffer_push (log->unflushed, buf, len) < 0)
 				return;
-
-			nih_io_buffer_shrink (io->recv_buf, len);
-			/* No point attempting to write if we cannot
-			 * open the file.
-			 */
-			return;
 		}
+
+		/* Note that we always discard when out of space */
+		nih_io_buffer_shrink (io->recv_buf, len);
+
+		/* No point attempting to write if we cannot
+		 * open the file.
+		 */
+		return;
 	}
 
 	ret = log_file_write (log, buf, len);
-	if (ret < 0) {
+	if (ret < 0)
 		nih_warn ("%s %s", _("Failed to write to log file"), log->path);
-	}
 }
 
-
 /**
  * log_io_error_handler:
  *
@@ -289,12 +354,12 @@
 	err = nih_error_get ();
 
 	nih_assert (err->number == EIO);
+
 	nih_free (err);
 
-	if (log->io) {
-		/* Close the connection */
-		nih_free (log->io);
-	}
+	/* Ensure the NihIo is closed */
+	nih_free (log->io);
+	log->io = NULL;
 }
 
 /**
@@ -448,10 +513,12 @@
 			 * Note that data is always discarded when out of
 			 * space.
 			 */
-			if (saved != ENOSPC && nih_io_buffer_push (log->unflushed, buf, len) < 0)
+			if (saved != ENOSPC && len
+					&& nih_io_buffer_push (log->unflushed, buf, len) < 0)
 				goto error;
 
-			nih_io_buffer_shrink (io->recv_buf, len);
+			if (len)
+				nih_io_buffer_shrink (io->recv_buf, len);
 
 			/* Still need to indicate that the write failed */
 			goto error;
@@ -466,6 +533,9 @@
 	 * next time.
 	 */
 	if (log->unflushed->len) {
+		if (! len)
+			goto error;
+
 		/* Save new data */
 		if (nih_io_buffer_push (log->unflushed, buf, len) < 0)
 			goto error;
@@ -504,3 +574,62 @@
 	return -1;
 }
 
+/**
+ * log_read_watch:
+ *
+ * @log: Log.
+ *
+ * Attempt a final read from the watch descriptor to ensure we've
+ * drained all the data from the job.
+ **/
+void
+log_read_watch (Log *log)
+{
+	NihIo   *io;
+	ssize_t  len;
+	int      saved;
+
+	nih_assert (log);
+
+	/* Must not be called if there is unflushed data as the log
+	 * would then not be written in order .
+	 */
+	nih_assert (! log->unflushed->len);
+
+	io = log->io;
+
+	if (! io)
+		return;
+
+	while (1) {
+		/* Ensure we have some space to read data from the job */
+		if (nih_io_buffer_resize (io->recv_buf, LOG_READ_SIZE) < 0)
+			break;
+
+		/* Append to buffer */
+		len = read (io->watch->fd,
+				io->recv_buf->buf + io->recv_buf->len,
+				io->recv_buf->size - io->recv_buf->len);
+		saved = errno;
+
+		if (len > 0)
+			io->recv_buf->len += len;
+
+		if (io->recv_buf->len)
+			log_io_reader (log, io, io->recv_buf->buf, io->recv_buf->len);
+
+		/* If an error occurs, it is likely to be EIO or EBADF.
+		 * But erring on the side of caution, any unusual error
+		 * causes the loop to be exited.
+		 */
+		if ((len < 0 && saved != EAGAIN && saved != EWOULDBLOCK) || len == 0) {
+			/* Either the job process end of the pty has
+			 * been closed, or there really
+			 * is no (more) data to be read.
+			 */
+			close (log->fd);
+			log->fd = -1;
+			break;
+		}
+	}
+}

=== modified file 'init/log.h'
--- init/log.h	2011-12-09 14:07:11 +0000
+++ init/log.h	2012-01-26 15:59:26 +0000
@@ -41,6 +41,12 @@
  **/
 #define LOG_DEFAULT_MODE         (S_IRWXU | S_IRGRP)
 
+/** LOG_READ_SIZE:
+ *
+ * Minimum buffer size for reading log data.
+ **/
+#define LOG_READ_SIZE            1024
+
 /**
  * Log:
  *

=== modified file 'init/main.c'
--- init/main.c	2012-01-06 16:12:52 +0000
+++ init/main.c	2012-01-26 15:59:26 +0000
@@ -121,7 +121,6 @@
 
 extern int          disable_sessions;
 extern int          disable_job_logging;
-int                 force_logging;
 extern int          use_session_bus;
 extern int          default_console;
 extern char        *log_dir;
@@ -139,9 +138,6 @@
 	{ 0, "default-console", N_("default value for console stanza"),
 		NULL, "VALUE", NULL, console_type_setter },
 
-	{ 0, "log", N_("enable job logging"),
-		NULL, NULL, &force_logging, NULL },
-
 	{ 0, "logdir", N_("specify alternative directory to store job output logs in"),
 		NULL, "DIR", &log_dir, NULL },
 
@@ -185,9 +181,6 @@
 		  "process id 1 to denote its special status.  When executed "
 		  "by a user process, it will actually run /sbin/telinit."));
 
-	/* Temporarily disable job logging (bug 912558) */
-	disable_job_logging = 1;
-
 	args = nih_option_parser (NULL, argc, argv, options, FALSE);
 	if (! args)
 		exit (1);
@@ -195,9 +188,6 @@
 	handle_confdir ();
 	handle_logdir ();
 
-	if (force_logging)
-		disable_job_logging = 0;
-
 	if (disable_job_logging)
 		nih_debug ("Job logging disabled");
 

=== modified file 'init/man/init.5'
--- init/man/init.5	2011-12-15 17:50:14 +0000
+++ init/man/init.5	2012-01-26 15:59:26 +0000
@@ -761,10 +761,10 @@
 .B setuid \fIUSERNAME
 Changes to the user
 .I USERNAME
-before running the job's process.
+before running any job process.
 
-If this stanza is unspecified, the job will run as root in the case of
-system jobs, and as the user in the case of user jobs.
+If this stanza is unspecified, all job processes will run as root in the
+case of system jobs, and as the user in the case of user jobs.
 
 Note that system jobs using the
 .B setuid
@@ -777,14 +777,15 @@
 .B setgid \fIGROUPNAME
 Changes to the group
 .I GROUPNAME
-before running the job's process.
+before running any job process.
 
 If this stanza is unspecified, the primary group of the user specified
 in the
 .B setuid
-block is used. If both stanzas are unspecified, the job will run with
-its group ID set to 0 in the case of system jobs, and as the primary
-group of the user in the case of User Jobs.
+block is used for all job processes. If both stanzas are unspecified,
+all job processes will run with its group ID set to 0 in the case of
+system jobs, and as the primary group of the user in the case of User
+Jobs.
 .\"
 .SS Override File Handling
 Override files allow a jobs environment to be changed without modifying

=== modified file 'init/tests/test_job_process.c'
--- init/tests/test_job_process.c	2011-12-22 16:52:22 +0000
+++ init/tests/test_job_process.c	2012-01-26 15:59:26 +0000
@@ -296,13 +296,21 @@
 	char            *p;
 	int              ok;
 	char             buffer[1024];
-
+	pid_t            pid;
 
 	TEST_FUNCTION ("job_process_run");
 
 	TEST_FILENAME (filename);
 	program_name = "test";
 
+	TEST_FILENAME (dirname);       
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* Override default location to ensure job output goes to a
+	 * writeable location
+	 */
+	TEST_EQ (setenv ("UPSTART_LOGDIR", dirname, 1), 0);
+
 	/* Check that we can run a simple command, and have the process id
 	 * and state filled in.  We should be able to wait for the pid to
 	 * finish and see that it has been run as expected.
@@ -1277,6 +1285,8 @@
 	class->process[PROCESS_MAIN]->script = FALSE;
 
 	job = job_new (class, "");
+	TEST_NE_P (job, NULL);
+
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
@@ -1293,6 +1303,9 @@
 	TEST_TRUE (WIFSIGNALED (status));
 	TEST_EQ (WTERMSIG (status), SIGKILL);
 
+	/* allow destructor to write any lingering unflushed data */
+	nih_free (class);
+
 	TEST_EQ (stat (filename, &statbuf), 0);
 
 	TEST_TRUE (S_ISREG (statbuf.st_mode));
@@ -1333,7 +1346,6 @@
 	fclose (output);
 
 	TEST_EQ (unlink (filename), 0);
-	nih_free (class);
 
 	/************************************************************/
 	TEST_FEATURE ("with multi-line script that is killed");
@@ -2523,14 +2535,36 @@
 	nih_free (class);
 
 	/************************************************************
-	 * No point in running a test for:
-	 *
-	 *   TEST_FEATURE ("with single-line command running an invalid command");
-	 *
-	 * Since as such commands are exec'ed directly, there is no shell to report
-	 * an error back - exec just fails.
-	 *
+	 * Superficially, there seems little point in running a test for
+	 * this scenario since if Upstart attempts to exec(2) directly a
+	 * command that does not exist, the exec simply fails (since
+	 * there is no shell to report the error).
+	 *
+	 * And yet -- ironically -- bug 912558 would have been prevented
+	 * had we originally tested this scenario!
 	 ************************************************************/
+	TEST_FEATURE ("with single-line command running an invalid command");
+
+	class = job_class_new (NULL, "buzz", NULL);
+	TEST_NE_P (class, NULL);
+
+	TEST_FILENAME (filename);
+	TEST_GT (sprintf (filename, "%s/buzz.log", dirname), 0);
+
+	class->console = CONSOLE_LOG;
+	class->process[PROCESS_MAIN] = process_new (class);
+	class->process[PROCESS_MAIN]->command = nih_strdup (
+			class->process[PROCESS_MAIN],
+			"/this/command/does/not/exist");
+	class->process[PROCESS_MAIN]->script = FALSE;
+
+	job = job_new (class, "");
+	job->goal = JOB_START;
+	job->state = JOB_SPAWNED;
+
+	ret = job_process_run (job, PROCESS_MAIN);
+	TEST_LT (ret, 0);
+	nih_free (class);
 
 	/************************************************************/
 	TEST_FEATURE ("with multi-line script running an invalid command");
@@ -2713,6 +2747,246 @@
 	TEST_EQ (unlink (filename), 0);
 	nih_free (class);
 
+	/************************************************************/
+	/* XXX: Note that we don't force a watch update here to simulate
+	 * a job that writes data _after_ Upstart has run nih_io_handle_fds()
+	 * in the main loop and just _before_ it exits _in the same main
+	 * loop iteration_.
+	 */
+	TEST_FEATURE ("with single line command writing fast and exiting");
+
+	class = job_class_new (NULL, "budapest", NULL);
+	TEST_NE_P (class, NULL);
+
+	TEST_FILENAME (filename);
+	TEST_GT (sprintf (filename, "%s/budapest.log", dirname), 0);
+
+	class->console = CONSOLE_LOG;
+	class->process[PROCESS_MAIN] = process_new (class);
+	/* program to run "fast", so directly exec a program with
+	 * no shell intervention.
+	 */
+	class->process[PROCESS_MAIN]->command = nih_sprintf (
+			class->process[PROCESS_MAIN],
+			"%s hello\n",
+			TEST_CMD_ECHO);
+	class->process[PROCESS_MAIN]->script = FALSE;
+
+	job = job_new (class, "");
+	job->goal = JOB_START;
+	job->state = JOB_SPAWNED;
+
+	ret = job_process_run (job, PROCESS_MAIN);
+	TEST_EQ (ret, 0);
+
+	/* allow destructor to write any lingering unflushed data */
+	nih_free (class);
+
+	TEST_EQ (stat (filename, &statbuf), 0);
+
+	TEST_TRUE (S_ISREG (statbuf.st_mode));
+
+	TEST_TRUE  (statbuf.st_mode & S_IRUSR);
+	TEST_TRUE  (statbuf.st_mode & S_IWUSR);
+	TEST_FALSE (statbuf.st_mode & S_IXUSR);
+
+	TEST_TRUE  (statbuf.st_mode & S_IRGRP);
+	TEST_FALSE (statbuf.st_mode & S_IWGRP);
+	TEST_FALSE (statbuf.st_mode & S_IXGRP);
+
+	TEST_FALSE (statbuf.st_mode & S_IROTH);
+	TEST_FALSE (statbuf.st_mode & S_IWOTH);
+	TEST_FALSE (statbuf.st_mode & S_IXOTH);
+
+	output = fopen (filename, "r");
+	TEST_NE_P (output, NULL);
+
+	TEST_FILE_EQ (output, "hello\r\n");
+	TEST_FILE_END (output);
+	fclose (output);
+
+	TEST_EQ (unlink (filename), 0);
+
+	/************************************************************/
+	TEST_FEATURE ("with single line command writing lots of data fast and exiting");
+
+	class = job_class_new (NULL, "foo", NULL);
+	TEST_NE_P (class, NULL);
+
+	TEST_FILENAME (filename);
+	TEST_GT (sprintf (filename, "%s/foo.log", dirname), 0);
+
+	class->console = CONSOLE_LOG;
+	class->process[PROCESS_MAIN] = process_new (class);
+	/* program must run "fast", so directly exec with
+	 * no shell intervention.
+	 *
+	 * Writes large number of nulls (3MB).
+	 */
+#define EXPECTED_1K_BLOCKS	(1024*3)
+#define TEST_BLOCKSIZE           1024
+
+	class->process[PROCESS_MAIN]->command = nih_sprintf (
+			class->process[PROCESS_MAIN],
+			"%s if=/dev/zero bs=%d count=%d",
+			TEST_CMD_DD, TEST_BLOCKSIZE, EXPECTED_1K_BLOCKS);
+	class->process[PROCESS_MAIN]->script = FALSE;
+
+	NIH_MUST (nih_child_add_watch (NULL,
+				-1,
+				NIH_CHILD_ALL,
+				job_process_handler,
+				NULL)); 
+
+	job = job_new (class, "");
+	job->goal = JOB_START;
+	job->state = JOB_SPAWNED;
+
+	ret = job_process_run (job, PROCESS_MAIN);
+	TEST_EQ (ret, 0);
+
+	pid = job->pid[PROCESS_MAIN];
+
+	/* job will block until something reads the other end of the pty */
+	TEST_EQ (kill (pid, 0), 0);
+
+	{
+		size_t  bytes;
+		size_t  expected_bytes = TEST_BLOCKSIZE * EXPECTED_1K_BLOCKS;
+		off_t   filesize = (off_t)-1;
+
+		/* Check repeatedly for job log output jobs until
+		 * we've either read the expected number of nulls, or we
+		 * timed out.
+		 */
+		while ( 1 ) {
+			size_t           length;
+			size_t           i;
+			struct timeval   t;
+			nih_local char  *file = NULL;
+
+			t.tv_sec  = 1;
+			t.tv_usec = 0;
+
+			TEST_FORCE_WATCH_UPDATE_TIMEOUT (t);
+
+			TEST_EQ (stat (filename, &statbuf), 0);
+
+			/* We expect the file size to change */
+			if (statbuf.st_size == filesize) {
+				break;
+			}
+
+			filesize = statbuf.st_size;
+
+			file = nih_file_read (NULL, filename, &length);
+			TEST_NE_P (file, NULL);
+
+			bytes = 0;
+			for (i=0; i < length; ++i) {
+				if (file[i] == '\0')
+					bytes++;
+			}
+
+			if (bytes == expected_bytes) {
+				break;
+			}
+		}
+
+		TEST_EQ (bytes, expected_bytes);
+	}
+
+	TEST_EQ (kill (pid, 0), 0);
+	nih_child_poll ();
+
+	/* The process should now be dead */
+	TEST_EQ (kill (pid, 0), -1);
+	TEST_EQ (errno, ESRCH);
+
+	nih_free (class);
+	TEST_EQ (stat (filename, &statbuf), 0);
+
+	TEST_TRUE (S_ISREG (statbuf.st_mode));
+
+	TEST_TRUE  (statbuf.st_mode & S_IRUSR);
+	TEST_TRUE  (statbuf.st_mode & S_IWUSR);
+	TEST_FALSE (statbuf.st_mode & S_IXUSR);
+
+	TEST_TRUE  (statbuf.st_mode & S_IRGRP);
+	TEST_FALSE (statbuf.st_mode & S_IWGRP);
+	TEST_FALSE (statbuf.st_mode & S_IXGRP);
+
+	TEST_FALSE (statbuf.st_mode & S_IROTH);
+	TEST_FALSE (statbuf.st_mode & S_IWOTH);
+	TEST_FALSE (statbuf.st_mode & S_IXOTH);
+
+	TEST_EQ (unlink (filename), 0);
+
+#undef  EXPECTED_1K_BLOCKS
+#undef  TEST_BLOCKSIZE
+
+	/************************************************************/
+	/* Applies to respawn jobs too */
+
+	TEST_FEATURE ("with log object freed on process exit");
+
+	class = job_class_new (NULL, "acorn", NULL);
+	TEST_NE_P (class, NULL);
+
+	TEST_FILENAME (filename);
+	TEST_GT (sprintf (filename, "%s/acorn.log", dirname), 0);
+
+	class->console = CONSOLE_LOG;
+	class->process[PROCESS_MAIN] = process_new (class);
+	class->process[PROCESS_MAIN]->command = nih_sprintf (
+			class->process[PROCESS_MAIN],
+			"%s hello",
+			TEST_CMD_ECHO);
+	class->process[PROCESS_MAIN]->script = FALSE;
+
+	/* XXX: Manually add the class so job_process_find() works */
+	nih_hash_add (job_classes, &class->entry);
+
+	NIH_MUST (nih_child_add_watch (NULL,
+				-1,
+				NIH_CHILD_ALL,
+				job_process_handler,
+				NULL)); 
+
+	job = job_new (class, "");
+	job->goal = JOB_START;
+	job->state = JOB_SPAWNED;
+
+	TEST_EQ_P (job->log, NULL);
+
+	ret = job_process_run (job, PROCESS_MAIN);
+	TEST_EQ (ret, 0);
+
+	pid = job->pid[PROCESS_MAIN];
+
+	job->goal = JOB_STOP;
+	job->state = JOB_KILLED;
+
+	TEST_NE (job->pid[PROCESS_MAIN], 0);
+
+	TEST_NE_P (job->log, NULL);
+
+	TEST_FREE_TAG (job);
+	TEST_FREE_TAG (job->log);
+
+	TEST_FORCE_WATCH_UPDATE ();
+
+	nih_child_poll ();
+
+	/* Should have been destroyed now */
+	TEST_FREE (job);
+	TEST_FREE (job->log);
+
+	nih_free (class);
+	unlink (filename);
+
+	/************************************************************/
+
 	/* Check that we can succesfully setuid and setgid to
 	 * ourselves. This should always work, privileged or
 	 * otherwise.
@@ -3315,7 +3589,7 @@
 
 	TEST_EQ (fclose (output), 0);
 
-	unlink (filename);
+	TEST_EQ (unlink (filename), 0);
 
 	TEST_EQ (rmdir (dirname), 0);
 	TEST_EQ (unsetenv ("UPSTART_LOGDIR"), 0);
@@ -3409,6 +3683,9 @@
 
 	TEST_FORCE_WATCH_UPDATE ();
 
+	/* This will eventually call the log destructor */
+	nih_free (class);
+
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
@@ -3423,8 +3700,6 @@
 	TEST_EQ (rmdir (dirname), 0);
 	TEST_EQ (unsetenv ("UPSTART_LOGDIR"), 0);
 
-	nih_free (job);
-
 	/************************************************************/
 	TEST_FEATURE ("read data from daemon process");
 
@@ -3456,10 +3731,14 @@
 	pid = job_process_spawn (job, args, NULL, FALSE, -1);
 	TEST_GT (pid, 0);
 
+	TEST_FORCE_WATCH_UPDATE ();
+
 	TEST_EQ (waitpid (pid, &status, 0), pid);
 	TEST_TRUE (WIFEXITED (status));
+	TEST_EQ (WEXITSTATUS (status), 0);
 
-	TEST_FORCE_WATCH_UPDATE ();
+	/* This will eventually call the log destructor */
+	nih_free (class);
 
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
@@ -3475,9 +3754,6 @@
 	TEST_EQ (rmdir (dirname), 0);
 	TEST_EQ (unsetenv ("UPSTART_LOGDIR"), 0);
 
-	nih_free (job);
-
-
 	/* FIXME */
 #if 0
 	/************************************************************/
@@ -3538,14 +3814,13 @@
 			TEST_EQ (err->number, ENOMEM);
 			nih_free (err);
 		}
-		nih_free (job);
+		nih_free (class);
 	}
 #else
 		/* FIXME */
 		TEST_FEATURE ("WARNING: FIXME: test 'when no free ptys' disabled due to kernel bug");
 #endif
 
-	nih_free (class);
 	TEST_EQ (unsetenv ("UPSTART_LOGDIR"), 0);
 }
 

=== modified file 'init/tests/test_log.c'
--- init/tests/test_log.c	2011-12-09 14:07:11 +0000
+++ init/tests/test_log.c	2012-01-26 15:59:26 +0000
@@ -91,7 +91,6 @@
 test_log_new (void)
 {
 	Log	        *log;
-	int	         fds[2] = { -1, -1 };
 	char	         path[] = "/foo";
 	char             str[] = "hello, world!";
 	char             str2[] = "The end?";
@@ -104,6 +103,8 @@
 	FILE            *output;
 	mode_t           old_perms;
 	off_t            old_size;
+	int              pty_master;
+	int              pty_slave;
 
 	TEST_FUNCTION ("log_new");
 
@@ -130,8 +131,8 @@
 	TEST_FEATURE ("object checks with uid 0");
 
 	TEST_ALLOC_FAIL {
-		TEST_EQ (pipe (fds), 0);
-		log = log_new (NULL, path, fds[0], 0);
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
+		log = log_new (NULL, path, pty_master, 0);
 
 		/* Handle all alloc failures where the alloc calls were
                  * initiated by log_new().
@@ -140,8 +141,8 @@
 				(test_alloc_failed <= LOG_NEW_ALLOC_CALLS)) {
  
 			TEST_EQ_P (log, NULL);
-			close (fds[0]);
-			close (fds[1]);
+			close (pty_master);
+			close (pty_slave);
 			continue;
 		}
 
@@ -153,11 +154,11 @@
 		TEST_ALLOC_PARENT (log->path, log);
 
 		TEST_EQ_STR (log->path, path);
-		TEST_EQ (log->io->watch->fd, fds[0]);
+		TEST_EQ (log->io->watch->fd, pty_master);
 		TEST_EQ (log->uid, 0);
 		TEST_LT (log->fd, 0);
 
-		close (fds[1]);
+		close (pty_slave);
 
 		/* frees fds[0] */
 		nih_free (log);
@@ -168,13 +169,13 @@
 	/* XXX: No support for logging of user job output currently */
 	TEST_FEATURE ("ensure logging disallowed for uid >0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-	log = log_new (NULL, path, fds[0], 1);
+	log = log_new (NULL, path, pty_master, 1);
 	TEST_EQ (log, NULL);
 
-	close (fds[0]);
-	close (fds[1]);
+	close (pty_master);
+	close (pty_slave);
 
 	/************************************************************/
 	TEST_FEATURE ("parent check");
@@ -185,14 +186,15 @@
 			string = NIH_MUST (nih_strdup (NULL, str));
 		}
 
-		TEST_EQ (pipe (fds), 0);
-
-		log = log_new (string, path, fds[0], 0);
-
-		if (test_alloc_failed) {
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
+
+		log = log_new (string, path, pty_master, 0);
+
+		if (test_alloc_failed &&
+				(test_alloc_failed <= LOG_NEW_ALLOC_CALLS)) {
 			TEST_EQ_P (log, NULL);         
-			close (fds[0]);
-			close (fds[1]);
+			close (pty_master);
+			close (pty_slave);
 			nih_free (string);
 			continue;
 		}
@@ -201,7 +203,7 @@
 		TEST_ALLOC_PARENT (log, string);
 		TEST_FREE_TAG (log);
 
-		close (fds[1]);
+		close (pty_slave);
 
 		/* Freeing the parent should free the child */
 		nih_free (string);
@@ -215,9 +217,9 @@
 
 		TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 		TEST_LT (stat (filename, &statbuf), 0);
-		TEST_EQ (pipe (fds), 0);
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-		log = log_new (NULL, filename, fds[0], 0);
+		log = log_new (NULL, filename, pty_master, 0);
 
 		/* First time through at this point only log_new() has been called.
                  * But by the end of the first loop, log_io_reader() will have
@@ -232,16 +234,16 @@
 		if (test_alloc_failed &&
 				(test_alloc_failed <= LOG_NEW_ALLOC_CALLS)) {
 			TEST_EQ_P (log, NULL);         
-			close (fds[0]);
-			close (fds[1]);
+			close (pty_master);
+			close (pty_slave);
 			continue;
 		}
 
 		TEST_NE_P (log, NULL);
 
-		ret = write (fds[1], str, strlen (str));
+		ret = write (pty_slave, str, strlen (str));
 		TEST_GT (ret, 0);
-		ret = write (fds[1], "\n", 1);
+		ret = write (pty_slave, "\n", 1);
 		TEST_EQ (ret, 1);
 
 		TEST_FORCE_WATCH_UPDATE ();
@@ -251,12 +253,13 @@
                  */
 		if (test_alloc_failed == 1+LOG_NEW_ALLOC_CALLS) {
 			TEST_NE_P (log, NULL);         
-			close (fds[1]);
+			close (pty_slave);
 			nih_free (log);
+			TEST_EQ (unlink (filename), 0);
 			continue;
 		}
 
-		close (fds[1]);
+		close (pty_slave);
 		nih_free (log);
 
 		TEST_EQ (stat (filename, &statbuf), 0);
@@ -277,7 +280,7 @@
 		output = fopen (filename, "r");
 		TEST_NE_P (output, NULL);
 
-		TEST_FILE_EQ (output, "hello, world!\n");
+		TEST_FILE_EQ (output, "hello, world!\r\n");
 		TEST_FILE_END (output);
 		fclose (output);
 
@@ -287,17 +290,17 @@
 	/************************************************************/
 	TEST_FEATURE ("same logger appending to file with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 	TEST_LT (stat (filename, &statbuf), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -321,11 +324,11 @@
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
-	TEST_FILE_EQ (output, "hello, world!\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
-	ret = write (fds[1], str2, strlen (str2));
+	ret = write (pty_slave, str2, strlen (str2));
 	TEST_GT (ret, 0);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -351,31 +354,32 @@
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
-	TEST_FILE_EQ (output, "hello, world!\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
 	TEST_FILE_EQ (output, str2);
 	TEST_FILE_END (output);
 	fclose (output);
 
 	TEST_EQ (unlink (filename), 0);
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	/************************************************************/
 	TEST_FEATURE ("different logger appending to file with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
 	bytes = 0;
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
 	bytes += ret;
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
-	bytes += ret;
+	/* XXX: '+1' for '\r' */
+	bytes += (ret+1);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
@@ -400,16 +404,16 @@
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
-	TEST_FILE_EQ (output, "hello, world!\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -430,16 +434,17 @@
 	TEST_EQ (statbuf.st_size, old_size);
 
 	bytes = 0;
-	ret = write (fds[1], str2, strlen (str2));
+	ret = write (pty_slave, str2, strlen (str2));
 	TEST_GT (ret, 0);
 	bytes += ret;
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
-	bytes += ret;
+	/* '+1' for '\r' */
+	bytes += (1+ret);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -462,8 +467,8 @@
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
-	TEST_FILE_EQ (output, "hello, world!\n");
-	TEST_FILE_EQ (output, "The end?\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
+	TEST_FILE_EQ (output, "The end?\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
@@ -472,15 +477,15 @@
 	/************************************************************/
 	TEST_FEATURE ("ensure logging resumes when file made accessible with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -508,7 +513,7 @@
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
-	TEST_FILE_EQ (output, "hello, world!\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
@@ -516,9 +521,9 @@
 	TEST_EQ (chmod (filename, 0x0), 0);
 
 	/* Send more data to logger */
-	ret = write (fds[1], str2, strlen (str2));
+	ret = write (pty_slave, str2, strlen (str2));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
 	/* File shouldn't have changed */
@@ -531,12 +536,12 @@
 	/* Further data should cause previous data that could not be
 	 * written to be flushed to the file.
 	 */
-	ret = write (fds[1], "foo\n", 4);
+	ret = write (pty_slave, "foo\n", 4);
 	TEST_EQ (ret, 4);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -559,9 +564,9 @@
 	TEST_NE_P (output, NULL);
 
 	/* Re-check entire file contents */
-	TEST_FILE_EQ (output, "hello, world!\n");
-	TEST_FILE_EQ (output, "The end?\n");
-	TEST_FILE_EQ (output, "foo\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
+	TEST_FILE_EQ (output, "The end?\r\n");
+	TEST_FILE_EQ (output, "foo\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
@@ -570,18 +575,18 @@
 	/************************************************************/
 	TEST_FEATURE ("ensure logger flushes when destroyed with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 
 	TEST_EQ (rmdir (dirname), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -591,7 +596,7 @@
 	umask (old_perms);
 
 	/* No more data sent to ensure logger writes it on log destroy */
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	output = fopen (filename, "r");
@@ -611,7 +616,7 @@
 	TEST_FALSE (statbuf.st_mode & S_IROTH);
 	TEST_FALSE (statbuf.st_mode & S_IWOTH);
 	TEST_FALSE (statbuf.st_mode & S_IXOTH);
-	TEST_FILE_EQ (output, "hello, world!\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
@@ -620,35 +625,31 @@
 	/************************************************************/
 	TEST_FEATURE ("ensure log written when directory created accessible with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 
 	TEST_EQ (rmdir (dirname), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
-	TEST_FORCE_WATCH_UPDATE ();
-
 	old_perms = umask (0);
 	TEST_EQ (mkdir (dirname, 0755), 0);
 	umask (old_perms);
 
 	/* Send more data */
-	ret = write (fds[1], str2, strlen (str2));
+	ret = write (pty_slave, str2, strlen (str2));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
-	TEST_FORCE_WATCH_UPDATE ();
-
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	output = fopen (filename, "r");
@@ -668,8 +669,8 @@
 	TEST_FALSE (statbuf.st_mode & S_IROTH);
 	TEST_FALSE (statbuf.st_mode & S_IWOTH);
 	TEST_FALSE (statbuf.st_mode & S_IXOTH);
-	TEST_FILE_EQ (output, "hello, world!\n");
-	TEST_FILE_EQ (output, "The end?\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
+	TEST_FILE_EQ (output, "The end?\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
@@ -678,16 +679,16 @@
 	/************************************************************/
 	TEST_FEATURE ("ensure remainder of log written when file deleted with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -711,7 +712,7 @@
 	TEST_FALSE (statbuf.st_mode & S_IXOTH);
 	TEST_EQ (fstat (log->fd, &statbuf), 0);
 
-	TEST_FILE_EQ (output, "hello, world!\n");
+	TEST_FILE_EQ (output, "hello, world!\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
@@ -720,9 +721,9 @@
 	TEST_EQ (fstat (log->fd, &statbuf), 0);
 
 	/* Send more data */
-	ret = write (fds[1], str2, strlen (str2));
+	ret = write (pty_slave, str2, strlen (str2));
 	TEST_GT (ret, 0);
-	ret = write (fds[1], "\n", 1);
+	ret = write (pty_slave, "\n", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -744,31 +745,31 @@
 	TEST_FALSE (statbuf.st_mode & S_IROTH);
 	TEST_FALSE (statbuf.st_mode & S_IWOTH);
 	TEST_FALSE (statbuf.st_mode & S_IXOTH);
-	TEST_FILE_EQ (output, "The end?\n");
+	TEST_FILE_EQ (output, "The end?\r\n");
 	TEST_FILE_END (output);
 	fclose (output);
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 	TEST_EQ (unlink (filename), 0);
 
 	/************************************************************/
 	TEST_FEATURE ("writing 1 null with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 	TEST_LT (stat (filename, &statbuf), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], "\000", 1);
+	ret = write (pty_slave, "\000", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -799,20 +800,20 @@
 	/************************************************************/
 	TEST_FEATURE ("writing >1 null with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 	TEST_LT (stat (filename, &statbuf), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], "\000\000\000", 3);
+	ret = write (pty_slave, "\000\000\000", 3);
 	TEST_EQ (ret, 3);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -843,20 +844,20 @@
 	/************************************************************/
 	TEST_FEATURE ("writing 1 non-printable only with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 	TEST_LT (stat (filename, &statbuf), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], " ", 1);
+	ret = write (pty_slave, " ", 1);
 	TEST_EQ (ret, 1);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -887,20 +888,20 @@
 	/************************************************************/
 	TEST_FEATURE ("writing >1 non-printable only with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
 	TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 	TEST_LT (stat (filename, &statbuf), 0);
 
-	log = log_new (NULL, filename, fds[0], 0);
+	log = log_new (NULL, filename, pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], "\n \t", 3);
+	ret = write (pty_slave, "\n \t", 3);
 	TEST_EQ (ret, 3);
 
 	TEST_FORCE_WATCH_UPDATE ();
 
-	close (fds[1]);
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_EQ (stat (filename, &statbuf), 0);
@@ -917,15 +918,18 @@
 	TEST_FALSE (statbuf.st_mode & S_IROTH);
 	TEST_FALSE (statbuf.st_mode & S_IWOTH);
 	TEST_FALSE (statbuf.st_mode & S_IXOTH);
-	TEST_EQ (statbuf.st_size, 3);
+
+	/* '\r', '\n', ' ', '\t' */
+	TEST_EQ (statbuf.st_size, 4);
 
 	output = fopen (filename, "r");
 	TEST_NE_P (output, NULL);
 
-	TEST_EQ (fread (buffer, 1, 3,  output), 3);
-	TEST_EQ (buffer[0], '\n');
-	TEST_EQ (buffer[1], ' ');
-	TEST_EQ (buffer[2], '\t');
+	TEST_EQ (fread (buffer, 1, 4,  output), 4);
+	TEST_EQ (buffer[0], '\r');
+	TEST_EQ (buffer[1], '\n');
+	TEST_EQ (buffer[2], ' ');
+	TEST_EQ (buffer[3], '\t');
 
 	TEST_FILE_END (output);
 	fclose (output);
@@ -949,13 +953,17 @@
 
 		memset (long_path+len, 'J', sizeof(long_path)-len-1);
 
-		TEST_EQ (pipe (fds), 0);
-
-		log = log_new (NULL, long_path, fds[0], 0);
+		nih_debug("long_path='%s'", long_path);
+
+		pty_master = -1; pty_slave = -1;
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
+
+		log = log_new (NULL, long_path, pty_master, 0);
 		TEST_NE_P (log, NULL);
 
+		close (pty_slave);
+		pty_slave = -1;
 		nih_free (log);
-		close (fds[1]);
 	}
 
 	/************************************************************/
@@ -975,12 +983,13 @@
 
 		memset (illegal_path+len, 'z', sizeof(illegal_path)-len-1);
 
-		TEST_EQ (pipe (fds), 0);
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-		log = log_new (NULL, illegal_path, fds[0], 0);
+		log = log_new (NULL, illegal_path, pty_master, 0);
 		TEST_EQ_P (log, NULL);
 
-		close (fds[1]);
+		close (pty_master);
+		close (pty_slave);
 	}
 
 	/************************************************************/
@@ -997,13 +1006,13 @@
 
 		memset (long_path+len, 'J', sizeof(long_path)-len-1);
 
-		TEST_EQ (pipe (fds), 0);
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-		log = log_new (NULL, long_path, fds[0], 0);
+		log = log_new (NULL, long_path, pty_master, 0);
 		TEST_NE_P (log, NULL);
 
+		close (pty_slave);
 		nih_free (log);
-		close (fds[1]);
 	}
 
 	/************************************************************/
@@ -1020,12 +1029,13 @@
 
 		memset (illegal_path+len, 'z', sizeof(illegal_path)-len-1);
 
-		TEST_EQ (pipe (fds), 0);
+		TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-		log = log_new (NULL, illegal_path, fds[0], 0);
+		log = log_new (NULL, illegal_path, pty_master, 0);
 		TEST_EQ_P (log, NULL);
 
-		close (fds[1]);
+		close (pty_master);
+		close (pty_slave);
 	}
 
 	/************************************************************/
@@ -1035,48 +1045,48 @@
 	TEST_EQ (unsetenv ("UPSTART_LOGDIR"), 0);
 }
 
-	void
+void
 test_log_destroy (void)
 {
 	Log  *log;
-	int   fd;
 	int   ret;
 	int   flags;
-	int   fds[2];
 	char  str[] = "hello, world!";
+	int   pty_master;
+	int   pty_slave;
 
 	TEST_FUNCTION ("log_destroy");
 
 	/************************************************************/
 	TEST_FEATURE ("ensure log fd closed with uid 0");
 
-	fd = dup (2);
-	TEST_GT (fd, 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-	flags = fcntl (fd, F_GETFL);
+	flags = fcntl (pty_master, F_GETFL);
 	TEST_NE (flags, -1);
 
-	log = log_new (NULL, "/foo", fd, 0);
+	log = log_new (NULL, "/foo", pty_master, 0);
 	TEST_NE_P (log, NULL);
 
+	close (pty_slave);
 	nih_free (log);
 
-	flags = fcntl (fd, F_GETFL);
+	flags = fcntl (pty_master, F_GETFL);
 	TEST_EQ (flags, -1);
 	TEST_EQ (errno, EBADF);
 
 	/************************************************************/
 	TEST_FEATURE ("ensure path and io elements freed with uid 0");
 
-	fd = dup (2);
-	TEST_GT (fd, 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-	log = log_new (NULL, "/bar", fd, 0);
+	log = log_new (NULL, "/bar", pty_master, 0);
 	TEST_NE_P (log, NULL);
 
 	TEST_FREE_TAG (log->path);
 	TEST_FREE_TAG (log->io);
 
+	close (pty_slave);
 	nih_free (log);
 
 	TEST_FREE (log->path);
@@ -1085,13 +1095,12 @@
 	/************************************************************/
 	TEST_FEATURE ("ensure unflushed data freed with uid 0");
 
-	TEST_EQ (pipe (fds), 0);
-	TEST_GT (fd, 0);
+	TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
-	log = log_new (NULL, "/bar", fds[0], 0);
+	log = log_new (NULL, "/bar", pty_master, 0);
 	TEST_NE_P (log, NULL);
 
-	ret = write (fds[1], str, strlen (str));
+	ret = write (pty_slave, str, strlen (str));
 	TEST_GT (ret, 0);
 
 	TEST_FORCE_WATCH_UPDATE ();
@@ -1100,6 +1109,7 @@
 	TEST_EQ_STR (log->unflushed->buf, str);
 	TEST_FREE_TAG (log->unflushed);
 
+	close (pty_slave);
 	nih_free (log);
 	TEST_FREE (log->unflushed);
 }

=== added file 'util/tests/test_user_sessions.sh'
--- util/tests/test_user_sessions.sh	1970-01-01 00:00:00 +0000
+++ util/tests/test_user_sessions.sh	2012-01-26 15:59:26 +0000
@@ -0,0 +1,1091 @@
+#!/bin/sh
+#---------------------------------------------------------------------
+# Script to run minimal Upstart user session tests.
+#
+# Note that this script _cannot_ be run as part of the "make check"
+# tests since those tests stimulate functions and features of the
+# as-yet-uninstalled version of Upstart. However, this script needs to
+# run on a system where the version of Upstart under test has _already_
+# been fully installed.
+#---------------------------------------------------------------------
+#
+# Copyright (C) 2011 Canonical Ltd.
+#
+# Author: James Hunt <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+#
+#---------------------------------------------------------------------
+
+script_name=${0##*/}
+sys_job_dir="/etc/init"
+user_job_dir="$HOME/.init"
+user_log_dir="$HOME/.cache/upstart/log"
+sys_log_dir="/var/log/upstart"
+bug_url="https://bugs.launchpad.net/upstart/+filebug"
+test_dir=
+test_dir_suffix=
+user_to_create=
+uid=
+gid=
+opt=
+OPTARG=
+debug_enabled=0
+feature=
+
+# allow non-priv users to find 'initctl'
+export PATH=$PATH:/sbin
+
+# for assertions
+die()
+{
+  msg="$*"
+  echo "ERROR: $msg" >&2
+  exit 1
+}
+
+debug()
+{
+  str="$1"
+  [ "$debug_enabled" = 1 ] && echo "DEBUG: $str"
+}
+
+get_job_pid()
+{
+  job="$1"
+  [ -z "$job" ] && die "need job"
+
+  pid=$(initctl status "$job"|grep process|awk '{print $NF}')
+  [ -z "$pid" ] && die "job $job has no pid"
+
+  echo "$pid"
+}
+
+# take a string and convert it into a valid job name
+make_job_name()
+{
+  str="$1"
+
+  echo "$str" |\
+    sed -e 's/>/ gt /g' -e 's/</ lt /g' -e 's/+/ and /g' |\
+    sed -e 's/[[:punct:]]//g' -e 's/  */ /g' |\
+    tr ' ' '-'
+}
+
+upstart_encode()
+{
+  str="$1"
+
+  echo "$str" | sed 's!/!_!g'
+}
+
+# take a string and convert it into a valid job log file name
+make_log_name()
+{
+  str="$1"
+  upstart_encode "$str"
+}
+
+TEST_FAILED()
+{
+  args="$*"
+
+  [ -z "$args" ] && die "need args"
+
+  echo
+  echo "ERROR: TEST FAILED ('$feature')"
+  echo
+  printf "BAD: ${args}\n"
+  printf "\nPlease report a bug at $bug_url including the following details:\n"
+  printf "\nUpstart:\n"
+  /sbin/init --version|head -n1
+  /sbin/initctl --version|head -n1
+  echo
+  printf "cmdline:\n"
+  cat /proc/cmdline
+  echo
+  printf "Upstart Env:\n"
+  set|grep UPSTART_
+  echo
+  printf "lsb:\n"
+  lsb_release -a
+  printf "\nuname:\n"
+  uname -a
+  echo
+  sync
+  echo "ERROR: TEST FAILED ('$feature')"
+  echo
+  exit 1
+}
+
+TEST_GROUP()
+{
+  name="$1"
+
+  [ -z "$name" ] && die "need name"
+
+  printf "Testing %s\n" "$name"
+}
+
+TEST_FEATURE()
+{
+  feature="$1"
+
+  [ -z "$feature" ] && die "need feature"
+
+  printf "...%s\n" "$feature"
+}
+
+TEST_NE()
+{
+  cmd="$1"
+  value="$2"
+  expected="$3"
+
+  # XXX: no checks on value or expected since they might be blank
+  [ -z "$cmd" ] && die "need cmd"
+
+  [ "$value" = "$expected" ] && TEST_FAILED \
+  "wrong value for '$cmd', expected $expected got $value"
+}
+
+TEST_EQ()
+{
+  cmd="$1"
+  value="$2"
+  expected="$3"
+
+  # XXX: no checks on value or expected since they might be blank
+  [ -z "$cmd" ] && die "need cmd"
+
+  [ "$value" != "$expected" ] && TEST_FAILED \
+  "wrong value for '$cmd', expected '$expected' got '$value'"
+}
+
+checks()
+{
+  cmd=initctl
+  [ -z "$(command -v $cmd)" ] && die "cannot find command $cmd"
+
+  [ "$(id -u)" = 0 ] && die "ERROR: should not run this function as root"
+
+  # This will fail for a non-root user unless D-Bus is correctly
+  # configured
+  $cmd emit foo || die \
+    "You do not appear to have configured D-Bus for Upstart user sessions. See usage."
+}
+
+setup()
+{
+  uid=$(id -u)
+  gid=$(id -g)
+
+  if [ "$uid" = 0 ]
+  then
+    [ -z "$user_to_create" ] && die "need '-u' option when running as root"
+
+    getent passwd "$user_to_create" && \
+      die "user '$user_to_create' already exists"
+
+    echo "Creating user '$user_to_create'"
+    cmd="useradd -mU -c 'Upstart Test User' $user_to_create"
+    eval "$cmd"
+    TEST_EQ "$cmd" $? 0
+
+    echo "Locking account for user '$user_to_create'"
+    cmd="usermod -L $user_to_create"
+    eval "$cmd"
+    TEST_EQ "$cmd" $? 0
+
+    # Run ourselves again as the new user
+    su -c "$0 -a" "$user_to_create"
+    test_run_rc=$?
+
+    if [ $test_run_rc -eq 0 ]
+    then
+      echo "Deleting user '$user_to_create'"
+      cmd="userdel -r \"$user_to_create\""
+      eval "$cmd"
+      TEST_EQ "$cmd" $? 0
+    fi
+
+    exit $test_run_rc
+  fi
+
+  checks
+
+  # setup
+  if [ ! -d "$user_job_dir" ]
+  then
+    cmd="mkdir -p \"$user_job_dir\""
+    eval $cmd
+    TEST_EQ "$cmd" $? 0
+
+    cmd="chmod 755 \"$user_job_dir\""
+    eval "$cmd"
+    TEST_EQ "$cmd" $? 0
+  fi
+
+  # create somewhere to store user jobs
+  cmd="mktemp -d --tmpdir=\"$user_job_dir\""
+  test_dir=$(eval "$cmd")
+  TEST_EQ "$cmd" $? 0
+  TEST_NE "$test_dir" "$test_dir" ""
+  test_dir_suffix=${test_dir#${user_job_dir}/}
+
+  # ensure files in this directory are accessible since
+  # mktemp sets directory perms to 0700 regardless of umask.
+  cmd="chmod 755 \"$test_dir\""
+  eval "$cmd"
+  TEST_EQ "$cmd" $? 0
+
+  TEST_NE "HOME" "$HOME" ""
+}
+
+cleanup()
+{
+  if [ -d "$test_dir" ]
+  then
+    echo "Removing test directory '$test_dir'"
+    cmd="rmdir \"$test_dir\""
+    eval "$cmd"
+    TEST_EQ "$cmd" $? 0
+  fi
+}
+
+ensure_job_known()
+{
+  job="$1"
+  job_name="$2"
+
+  [ -z "$job" ] && die "no job"
+  [ -z "$job_name" ] && die "no job name"
+
+  TEST_FEATURE "ensure 'initctl' recognises job"
+  initctl list|grep -q "^$job " || \
+    TEST_FAILED "job $job_name not known to initctl"
+
+  TEST_FEATURE "ensure 'status' recognises job"
+  cmd="status ${job}"
+  eval "$cmd" >/dev/null 2>&1
+  rc=$?
+  TEST_EQ "$cmd" $rc 0
+}
+
+# Note that if the specified job is *not* as task, it is expected to run
+# indefinately. This allows us to perform PID checks, etc.
+run_user_job_tests()
+{
+  job_name="$1"
+  job_file="$2"
+  task="$3"
+  env="$4"
+
+  # XXX: env can be empty
+  [ -z "$job_name" ] && die "no job name"
+  [ -z "$job_file" ] && die "no job file"
+  [ -z "$task" ] && die "no task value"
+
+  job="${test_dir_suffix}/${job_name}"
+
+  [ -f "$job_file" ] || TEST_FAILED "job file '$job_file' does not exist"
+
+  ensure_job_known "$job" "$job_name"
+
+  TEST_FEATURE "ensure job can be started"
+  cmd="start ${job} ${env}"
+  output=$(eval "$cmd")
+  rc=$?
+  TEST_EQ "$cmd" $rc 0
+
+  if [ "$task" = no ]
+  then
+    TEST_FEATURE "ensure 'start' shows job pid"
+    pid=$(echo "$output"|awk '{print $4}')
+    TEST_NE "pid" "$pid" ""
+
+    TEST_FEATURE "ensure 'initctl' shows job is running with pid"
+    initctl list|grep -q "^$job start/running, process $pid" || \
+      TEST_FAILED "job $job_name did not start"
+
+    TEST_FEATURE "ensure 'status' shows job is running with pid"
+    cmd="status ${job}"
+    output=$(eval "$cmd")
+    echo "$output"|while read job_tmp state ignored status_pid
+    do
+      state=$(echo $state|tr -d ',')
+      TEST_EQ "job name"  "$job_tmp" "$job"
+      TEST_EQ "job state" "$state" "start/running"
+      TEST_EQ "job pid"   "$status_pid" "$pid"
+    done
+
+    TEST_FEATURE "ensure job pid is running with correct uids"
+    pid_uids=$(ps --no-headers -p $pid -o euid,ruid)
+    for pid_uid in $pid_uids
+    do
+      TEST_EQ "pid uid" "$pid_uid" "$uid"
+    done
+
+    TEST_FEATURE "ensure job pid is running with correct gids"
+    pid_gids=$(ps --no-headers -p $pid -o egid,rgid)
+    for pid_gid in $pid_gids
+    do
+      TEST_EQ "pid gid" "$pid_gid" "$gid"
+    done
+
+    TEST_FEATURE "ensure process is running in correct directory"
+    cwd=$(readlink /proc/$pid/cwd)
+    TEST_EQ "cwd" "$cwd" "$HOME"
+
+    TEST_FEATURE "ensure job can be stopped"
+    cmd="stop ${job}"
+    output=$(eval "$cmd")
+    rc=$?
+    TEST_EQ "$cmd" $rc 0
+
+    TEST_FEATURE "ensure job pid no longer exists"
+    pid_ids=$(ps --no-headers -p $pid -o euid,ruid,egid,rgid)
+    TEST_EQ "pid uids+gids" "$pid_ids" ""
+  fi
+
+  remove_job_file "$job_file"
+  ensure_job_gone "$job" "$job_name" "$env"
+}
+
+remove_job_file()
+{
+  job_file="$1"
+
+  [ -z "$job_file" ] && die "no job file"
+  [ ! -f "$job_file" ] && TEST_FAILED "job file '$job_file' does not exist"
+
+  cmd="rm $job_file"
+  eval "$cmd"
+  TEST_EQ "$cmd" $? 0
+}
+
+ensure_job_gone()
+{
+  job="$1"
+  job_name="$2"
+  env="$3"
+
+  # XXX: no check on env since it can be empty
+  [ -z "$job" ] && die "no job"
+  [ -z "$job_name" ] && die "no job name"
+
+  TEST_FEATURE "ensure 'initctl' no longer recognises job"
+  initctl list|grep -q "^$job " && \
+    TEST_FAILED "deleted job $job_name still known to initctl"
+
+  TEST_FEATURE "ensure 'status' no longer recognises job"
+  cmd="status ${job}"
+  eval "$cmd" >/dev/null 2>&1
+  rc=$?
+  TEST_NE "$cmd" $rc 0
+}
+
+test_user_job()
+{
+  test_group="$1"
+  job_name="$2"
+  script="$3"
+  task="$4"
+  env="$5"
+
+  # XXX: no test on script or env since they might be empty
+  [ -z "$test_group" ] && die "no test group"
+  [ -z "$job_name" ] && die "no job name"
+  [ -z "$task" ] && die "no task"
+
+  TEST_GROUP "$test_group"
+
+  job_file="${test_dir}/${job_name}.conf"
+
+  echo "$script" > $job_file
+
+  run_user_job_tests "$job_name" "$job_file" "$task" "$env"
+}
+
+test_user_job_binary()
+{
+  group="user job running a binary"
+  job_name="binary_test"
+  script="exec sleep 999"
+  test_user_job "$group" "$job_name" "$script" no ""
+}
+
+test_user_job_binary_task()
+{
+  group="user job running a binary task"
+  job_name="binary_task_test"
+  OUTFILE=$(mktemp)
+
+  script="\
+task
+exec /bin/true > $OUTFILE"
+
+  test_user_job "$group" "$job_name" "$script" yes "OUTFILE=$OUTFILE"
+  rm -f $OUTFILE
+}
+
+test_user_job_single_line_script()
+{
+  group="user job running a single-line script"
+  job_name="single_line_script_test"
+  script="\
+script
+  sleep 999
+end script"
+  test_user_job "$group" "$job_name" "$script" no ""
+}
+
+test_user_job_single_line_script_task()
+{
+  group="user job running a single-line script task"
+  job_name="single_line_script_task_test"
+  OUTFILE=$(mktemp)
+
+  script="\
+task
+script
+  exec /bin/true > $OUTFILE
+end script"
+  test_user_job "$group" "$job_name" "$script" yes "OUTFILE=$OUTFILE"
+  rm -f $OUTFILE
+}
+
+test_user_job_multi_line_script()
+{
+  group="user job running a multi-line script"
+  job_name="multi_line_script_test"
+  script="\
+script
+
+  /bin/true
+  /bin/true;/bin/true
+  sleep 999
+
+end script"
+  test_user_job "$group" "$job_name" "$script" no ""
+}
+
+test_user_job_multi_line_script_task()
+{
+  group="user job running a multi-line script task"
+  job_name="multi_line_script_task_test"
+  OUTFILE=$(mktemp)
+
+  script="\
+task
+script
+
+  /bin/true
+  /bin/true
+  /bin/true
+
+end script"
+  test_user_job "$group" "$job_name" "$script" yes "OUTFILE=$OUTFILE"
+  rm -f $OUTFILE
+}
+
+test_user_emit_events()
+{
+  job_name="start_on_foo"
+
+  TEST_GROUP "user emitting an event"
+  initctl emit foo || TEST_FAILED "failed to emit event as user"
+
+  TEST_GROUP "user emitting an event to start a job"
+  script="\
+    start on foo BAR=2
+    stop on baz cow=moo or hello
+    exec sleep 999"
+
+  job_file="${test_dir}/${job_name}.conf"
+  job="${test_dir_suffix}/${job_name}"
+
+  echo "$script" > $job_file
+
+  ensure_job_known "$job" "$job_name"
+
+  initctl list|grep -q "^$job stop/waiting" || \
+      TEST_FAILED "job $job_name not stopped"
+
+  TEST_FEATURE "ensure job can be started with event"
+  initctl emit foo BAR=2 || \
+    TEST_FAILED "failed to emit event for user job"
+
+  initctl status "$job"|grep -q "^$job start/running" || \
+      TEST_FAILED "job $job_name failed to start"
+
+  TEST_FEATURE "ensure job can be stopped with event"
+  initctl emit baz cow=moo || \
+    TEST_FAILED "failed to emit event for user job"
+
+  initctl list|grep -q "^$job stop/waiting" || \
+      TEST_FAILED "job $job_name not stopped"
+
+  rm -f "$job_file"
+}
+
+test_user_job_setuid_setgid()
+{
+    group="user job with setuid and setgid me"
+    job_name="setuid_setgid_me_test"
+    script="\
+setuid $(id -un)
+setgid $(id -gn)
+exec sleep 999"
+    test_user_job "$group" "$job_name" "$script" no ""
+
+    TEST_GROUP "user job with setuid and setgid root"
+    script="\
+setuid root
+setgid root
+exec sleep 999"
+
+    job_name="setuid_setgid_root_test"
+    job_file="${test_dir}/${job_name}.conf"
+    job="${test_dir_suffix}/${job_name}"
+
+    echo "$script" > $job_file
+
+    ensure_job_known "$job" "$job_name"
+
+    TEST_FEATURE "ensure job fails to start as root"
+    cmd="start ${job}"
+    output=$(eval "$cmd" 2>&1)
+    rc=$?
+    TEST_EQ "$cmd" $rc 1
+
+    TEST_FEATURE "ensure 'start' indicates job failure"
+    error=$(echo "$output"|grep failed)
+    TEST_NE "error" "$error" ""
+
+    TEST_FEATURE "ensure 'initctl' does not list job"
+    initctl list|grep -q "^$job stop/waiting" || \
+        TEST_FAILED "job $job_name not listed as stopped"
+
+    delete_job "$job_name"
+}
+
+get_job_file()
+{
+  job_name="$1"
+
+  [ -z "$job_name" ] && die "no job name"
+  echo "${test_dir}/${job_name}.conf"
+}
+
+ensure_no_output()
+{
+  job_name="$1"
+  script="$2"
+  instance="$3"
+
+  job="${test_dir_suffix}/${job_name}"
+
+  create_job "$job_name" "$script"
+  start_job "$job" "$job_name" "$instance"
+
+  check_job_output "$job_name"
+  delete_job "$job_name"
+}
+
+create_job()
+{
+  job_name="$1"
+  script="$2"
+
+  # XXX: script could be empty
+  [ -z "$job_name" ] && die "no job name"
+
+  debug "create_job: job_name='$job_name'"
+  debug "create_job: script='$script'"
+
+  # Not currently possible to have a user job with the
+  # same name as a system job.
+  #
+  # XXX: Note that this test assumes that user has *not* specified
+  # XXX: an alternate configuration directory using the
+  # XXX: '--confdir' option.
+  [ -e "${sys_job_dir}/${job_name}.conf" ] && \
+    die "job '$job_name' already exists as a system job"
+
+  job_file="${test_dir}/${job_name}.conf"
+  job="${test_dir_suffix}/${job_name}"
+
+  echo "$script" > "$job_file"
+  sync
+}
+
+delete_job()
+{
+  job_name="$1"
+
+  [ -z "$job_name" ] && die "no job name"
+
+  job_file="$(get_job_file $job_name)"
+
+  rm "$job_file" || TEST_FAILED "unable to remove job file '$job_file'"
+}
+
+check_job_output()
+{
+  job_name="$1"
+
+  [ ! -z "$(ls $user_log_dir 2>/dev/null)" ] && \
+    TEST_FAILED "job $job_name created logfile unexpectedly in '$user_log_dir'"
+
+  # XXX: note that it might appear that checking in $sys_log_dir
+  # could result in false positives, but this isn't so since
+  # (currently) it is not possible for a user job to have the
+  # same name as a system job. start_job() will detect this
+  # scenario.
+  for dir in "$user_log_dir" "$sys_log_dir"
+  do
+    log_file="${dir}/${job_name}.log"
+    [ -f "$log_file" ] && \
+      TEST_FAILED "job $job_name created logfile unexpectedly as '$log_file'"
+  done
+}
+
+start_job()
+{
+  job="$1"
+  job_file="$2"
+  instance="$3"
+  allow_failure="$4"
+
+  # XXX: instance may be blank
+  [ -z "$job" ] && die "no job"
+  [ -z "$job_file" ] && die "no job file"
+
+  debug "start_job: job='$job'"
+  debug "start_job: job_file='$job_file'"
+  debug "start_job: instance='$instance'"
+  debug "start_job: allow_failure='$allow_failure'"
+
+  eval output=$(mktemp)
+
+  # XXX: Don't quote instance as we don't want to pass a null instance to
+  # start(8).
+  cmd="start \"$job\" $instance >${output} 2>&1"
+  debug "start_job: running '$cmd'"
+  eval "$cmd"
+  rc=$?
+
+  if [ $rc -ne 0 -a -z "$allow_failure" ]
+  then
+    TEST_FAILED "job $job_file not started: $(cat $output)"
+  fi
+
+  rm -f "$output"
+}
+
+get_job_logfile_name()
+{
+  job_name="$1"
+  instance_value="$2"
+
+  # XXX: instance may be null
+  [ -z "$job_name" ] && die "no job name"
+
+  encoded_test_dir_suffix=$(upstart_encode "${test_dir_suffix}/")
+  file_name="${encoded_test_dir_suffix}$(make_log_name $job_name)"
+
+  if [ ! -z "$instance_value" ]
+  then
+    log_file="${user_log_dir}/${file_name}-${instance_value}.log"
+  else
+    log_file="${user_log_dir}/${file_name}.log"
+  fi
+
+  echo "$log_file"
+}
+
+run_job()
+{
+  job="$1"
+  job_name="$2"
+  script="$3"
+  instance="$4"
+
+  # XXX: script, instance might be blank
+  [ -z "$job" ] && die "no job"
+  [ -z "$job_name" ] && die "no job name"
+
+  debug "run_job: job='$job'"
+  debug "run_job: job_name='$job_name'"
+  debug "run_job: script='$script'"
+  debug "run_job: instance='$instance'"
+
+  create_job "$job_name" "$script"
+  start_job "$job" "$job_name" "$instance"
+}
+
+ensure_file_meta()
+{
+  file="$1"
+  expected_owner="$2"
+  expected_group="$3"
+  expected_perms="$4"
+
+  [ -z "$file" ] && die "no file"
+  [ -z "$expected_owner" ] && die "no expected owner"
+  [ -z "$expected_group" ] && die "no expected group"
+  [ -z "$expected_perms" ] && die "no expected perms"
+
+  [ ! -f "$file" ] && die "file $file does not exist"
+
+  expected_perms="640"
+  umask_value=$(umask)
+  umask_expected=0022
+
+  if [ "$umask_value" != "$umask_expected" ]
+  then
+    msg="umask value is $umask_value -"
+    msg="${msg} changing it to $umask_expected."
+    echo "WARNING: $msg"
+    umask "$umask_expected" || TEST_FAILED "unable to change umask"
+  fi
+
+  owner=$(ls -l "$file"|awk '{print $3}')
+  group=$(ls -l "$file"|awk '{print $4}')
+  perms=$(stat --printf "%a\n" "$file")
+
+  [ "$owner" = "$expected_owner" ] || TEST_FAILED \
+    "file $file has wrong owner (expected $expected_owner, got $owner)"
+
+  [ "$group" = "$expected_group" ] || TEST_FAILED \
+    "file $file has wrong group (expected $expected_group, got $group)"
+
+  [ "$perms" = "$expected_perms" ] || TEST_FAILED \
+    "file $file has wrong group (expected $expected_perms, got $perms)"
+}
+
+
+ensure_output()
+{
+  job_name="$1"
+  script="$2"
+  expected_output="$3"
+  instance="$4"
+  instance_value="$5"
+  options="$6"
+
+  # XXX: remaining args could be null
+  [ -z "$job_name" ] && die "no job name"
+
+  debug "ensure_output: job_name='$job_name'"
+  debug "ensure_output: script='$script'"
+  debug "ensure_output: expected_ouput='$expected_ouput'"
+  debug "ensure_output: instance='$instance'"
+  debug "ensure_output: instance_value='$instance_value'"
+  debug "ensure_output: options='$options'"
+
+  regex=n
+  retain=n
+  unique=""
+  use_od=n
+
+  for opt in $options
+  do
+    case "$opt" in
+      regex)
+        regex=y
+        ;;
+      retain)
+        retain=y
+        ;;
+      unique)
+        unique='|sort -u'
+        ;;
+      use_od)
+        use_od=y
+        ;;
+    esac
+  done
+
+  debug "ensure_output: regex='$regex'"
+  debug "ensure_output: retain='$retain'"
+  debug "ensure_output: unique='$unique'"
+  debug "ensure_output: use_od='$use_od'"
+
+  expected_owner=$(id -un)
+  expected_group=$(id -gn)
+  expected_perms="640"
+
+  job="${test_dir_suffix}/${job_name}"
+
+  run_job "$job" "$job_name" "$script" "$instance"
+
+  debug "ensure_output: user_log_dir='$user_log_dir'"
+  debug "ensure_output: test_dir='$test_dir'"
+  debug "ensure_output: test_dir_suffix='$test_dir_suffix'"
+
+  log_file=$(get_job_logfile_name "$job_name" "$instance_value")
+
+  debug "ensure_output: log_file='$log_file'"
+
+  # Give Upstart a chance to parse the file
+  count=1
+  while ! status "$job" >/dev/null 2>&1
+  do
+    sleep 1
+    count=$((count+1))
+    [ "$count" -eq 5 ] && break
+  done
+
+  # give job a chance to start
+  count=1
+  while [ ! -f "$log_file" ]
+  do
+    sleep 1
+    count=$((count+1))
+    [ "$count" -eq 5 ] && break
+  done
+
+  [ ! -f "$log_file" ] && \
+      TEST_FAILED "job '$job_name' failed to create logfile"
+
+  ensure_file_meta \
+    "$log_file" \
+    "$expected_owner" \
+    "$expected_group" \
+    "$expected_perms"
+
+  # XXX: note we have to remove carriage returns added by the line
+  # discipline
+  if [ "$regex" = y ]
+  then
+    log=$(eval "cat $log_file|tr -d '\r' $unique")
+    msg="job '$job_name' failed to log correct data\n"
+    msg="${msg}\texpected regex: '$expected_output'\n"
+    msg="${msg}\tgot           : '$log'"
+    cat "$log_file" | egrep "$expected_output" || TEST_FAILED "$msg"
+  elif [ "$use_od" = y ]
+  then
+    log=$(eval "cat $log_file|tr -d '\r' $unique|od -x")
+    msg="job '$job_name' failed to log correct data\n"
+    msg="${msg}\texpected hex: '$expected_output'\n"
+    msg="${msg}\tgot         : '$log'"
+    [ "$expected_output" != "$log" ] && TEST_FAILED "$msg"
+  else
+    log=$(eval "cat $log_file|tr -d '\r' $unique")
+    msg="job '$job_name' failed to log correct data\n"
+    msg="${msg}\texpected text: '$expected_output'\n"
+    msg="${msg}\tgot          : '$log'"
+    [ "$expected_output" != "$log" ] && TEST_FAILED "$msg"
+  fi
+
+  if [ "$retain" = n ]
+  then
+    delete_job "$job_name"
+    rm "$log_file" || TEST_FAILED "unable to remove log file '$log_file'"
+  fi
+}
+
+test_ensure_no_unexpected_output()
+{
+  #---------------------------------------------------------------------
+  feature="ensure command job does not create log file with no console"
+  TEST_FEATURE "$feature"
+
+  job_name=$(make_job_name "$feature")
+
+  script="\
+    console none
+    exec echo hello world"
+
+  ensure_no_output "$job_name" "$script" ""
+
+  #---------------------------------------------------------------------
+  feature="ensure 1-line script job does not create log file with no console"
+  TEST_FEATURE "$feature"
+
+  job_name=$(make_job_name "$feature")
+
+  script="\
+    console none
+    script
+      echo hello world
+    end script
+  "
+
+  ensure_no_output "$job_name" "$script" ""
+
+  #---------------------------------------------------------------------
+  feature="ensure multi-line script job does not create log file with no console"
+  TEST_FEATURE "$feature"
+
+  job_name=$(make_job_name "$feature")
+
+  script="\
+    console none
+    script
+      /bin/true
+      echo hello world
+    end script
+  "
+
+  ensure_no_output "$job_name" "$script" ""
+
+  #---------------------------------------------------------------------
+  feature="ensure no output if log directory does not exist"
+  TEST_FEATURE "$feature"
+
+  rmdir "${user_log_dir}" || \
+    TEST_FAILED "unable to delete log directory '$user_log_dir'"
+
+  job_name=$(make_job_name "$feature")
+  string="hello world"
+  script="\
+    console log
+    script
+      /bin/true
+      /bin/echo hello world
+    end script
+  "
+
+  ensure_no_output "$job_name" "$script" ""
+
+  mkdir "${user_log_dir}" || \
+    TEST_FAILED "unable to recreate log directory '$user_log_dir'"
+
+  #---------------------------------------------------------------------
+  feature="ensure command job does not create log file with invalid command"
+  TEST_FEATURE "$feature"
+
+  job_name=$(make_job_name "$feature")
+
+  script="\
+    console log
+    exec /this/command/does/not/exist"
+
+  job="${test_dir_suffix}/${job_name}"
+  create_job "$job_name" "$script"
+  start_job "$job" "$job_name" "" 1
+  check_job_output "$job_name"
+  delete_job "$job_name"
+}
+
+test_output_logged()
+{
+  # XXX: upstart won't create this
+  mkdir -p "$user_log_dir"
+
+  test_ensure_no_unexpected_output
+}
+
+test_user_jobs()
+{
+  test_user_job_binary
+  test_user_job_single_line_script
+  test_user_job_multi_line_script
+
+  test_user_job_binary_task
+  test_user_job_single_line_script_task
+  test_user_job_multi_line_script_task
+
+  test_user_job_setuid_setgid
+
+  test_user_emit_events
+
+  test_output_logged
+}
+
+tests()
+{
+  echo
+  echo -n "Running Upstart user session tests as user '`whoami`'"
+  echo " (uid $uid, gid $gid) in directory '$test_dir'"
+  echo
+
+  test_user_jobs
+
+  echo
+  echo "All tests completed successfully"
+  echo
+}
+
+usage()
+{
+cat <<EOT
+USAGE: $script_name [options]
+
+OPTIONS:
+
+ -a        : Actually run this script.
+ -h        : Show this help.
+ -u <user> : Specify name of test user to create.
+
+DESCRIPTION:
+
+Run simple set of Upstart user session tests.
+
+PREREQUISITE:
+
+For this test to run, non-root users must be allowed to invoke all D-Bus
+methods on Upstart via configuration file:
+
+  /etc/dbus-1/system.d/Upstart.conf 
+
+See dbus-daemon(1) for further details.
+
+WARNING: Note that this script is unavoidably invasive, so read what
+WARNING: follows before running!
+
+If run as a non-root user, this script will create a uniquely-named
+subdirectory below "\$HOME/.init/" to run its tests in. On successful
+completion of these tests, the unique subdirectory and its contents will
+be removed.
+
+If however, this script is invoked as the root user, the script will
+refuse to run until given the name of a test user to create via the "-u"
+option. If the user specified to this option already exists, this script
+will exit with an error. If the user does not already exist, it will be
+created, the script then run *as that user* and assuming successful
+completion of the tests, the test user and their home directory will
+then be deleted.
+
+EOT
+}
+
+#---------------------------------------------------------------------
+# main
+#---------------------------------------------------------------------
+
+while getopts "dhu:" opt
+do
+  case "$opt" in
+    d)
+      debug_enabled=1
+    ;;
+
+    h)
+      usage
+      exit 0
+    ;;
+
+    u)
+      user_to_create="$OPTARG"
+    ;;
+  esac
+done
+
+setup
+tests
+cleanup
+exit 0

=== removed file 'util/tests/test_user_sessions.sh'
--- util/tests/test_user_sessions.sh	2011-07-26 01:09:47 +0000
+++ util/tests/test_user_sessions.sh	1970-01-01 00:00:00 +0000
@@ -1,553 +0,0 @@
-#!/bin/sh -u
-#---------------------------------------------------------------------
-# Script to run minimal Upstart user session tests.
-#
-# Note that this script _cannot_ be run as part of the "make check"
-# tests since those tests stimulate functions and features of the
-# as-yet-uninstalled version of Upstart. However, this script needs to
-# run on a system where the version of Upstart under test has _already_
-# been fully installed.
-#---------------------------------------------------------------------
-#
-# Copyright (C) 2011 Canonical Ltd.
-#
-# Author: James Hunt <[e-mail]>
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# 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, see <http://www.gnu.org/licenses/>.
-#
-#---------------------------------------------------------------------
-
-script_name=${0##*/}
-user_job_dir="$HOME/.init"
-bug_url="https://bugs.launchpad.net/upstart/+filebug"
-test_dir=
-test_dir_suffix=
-user_to_create=
-uid=
-gid=
-opt=
-OPTARG=
-
-# allow non-priv users to find 'initctl'
-export PATH=$PATH:/sbin
-
-# for assertions
-die()
-{
-  msg="$*"
-  echo "ERROR: $msg" >&2
-  exit 1
-}
-
-TEST_FAILED()
-{
-  args="$*"
-
-  [ -z "$args" ] && die "need args"
-
-  printf "BAD: %s\n" "$args"
-  printf "\nPlease report a bug at $bug_url including the following details:\n"
-  printf "\nUpstart:\n"
-  /sbin/init --version|head -n1
-  /sbin/initctl --version|head -n1
-  echo
-  printf "cmdline:\n"
-  cat /proc/cmdline
-  echo
-  printf "Upstart Env:\n"
-  set|grep UPSTART_
-  echo
-  printf "lsb:\n"
-  lsb_release -a
-  printf "\nuname:\n"
-  uname -a
-  echo
-  sync
-  exit 1
-}
-
-TEST_GROUP()
-{
-  name="$1"
-
-  [ -z "$name" ] && die "need name"
-
-  printf "Testing %s\n", "$name"
-}
-
-TEST_FEATURE()
-{
-  feature="$1"
-
-  [ -z "$feature" ] && die "need feature"
-
-  printf "...%s\n" "$feature"
-}
-
-TEST_NE()
-{
-  cmd="$1"
-  value="$2"
-  expected="$3"
-
-  # XXX: no checks on value or expected since they might be blank
-  [ -z "$cmd" ] && die "need cmd"
-
-  [ "$value" = "$expected" ] && TEST_FAILED \
-  "wrong value for '$cmd', expected $expected got $value"
-}
-
-TEST_EQ()
-{
-  cmd="$1"
-  value="$2"
-  expected="$3"
-
-  # XXX: no checks on value or expected since they might be blank
-  [ -z "$cmd" ] && die "need cmd"
-
-  [ "$value" != "$expected" ] && TEST_FAILED \
-  "wrong value for '$cmd', expected '$expected' got '$value'"
-}
-
-setup()
-{
-  uid=$(id -u)
-  gid=$(id -g)
-
-  if [ "$uid" = 0 ]
-  then
-    [ -z "$user_to_create" ] && die "need '-u' option when running as root"
-
-    getent passwd "$user_to_create" && \
-      die "user '$user_to_create' already exists"
-
-    echo "Creating user '$user_to_create'"
-    cmd="useradd -mU -c 'Upstart Test User' $user_to_create"
-    eval "$cmd"
-    TEST_EQ "$cmd" $? 0
-
-    echo "Locking account for user '$user_to_create'"
-    cmd="usermod -L $user_to_create"
-    eval "$cmd"
-    TEST_EQ "$cmd" $? 0
-
-    # Run ourselves again as the new user
-    su -c "$0 -a" "$user_to_create"
-    test_run_rc=$?
-
-    if [ $test_run_rc -eq 0 ]
-    then
-      echo "Deleting user '$user_to_create'"
-      cmd="userdel -r \"$user_to_create\""
-      eval "$cmd"
-      TEST_EQ "$cmd" $? 0
-    fi
-
-    exit $test_run_rc
-  fi
-
-  # setup
-  if [ ! -d "$user_job_dir" ]
-  then
-    cmd="mkdir -p \"$user_job_dir\""
-    eval $cmd
-    TEST_EQ "$cmd" $? 0
-
-    cmd="chmod 755 \"$user_job_dir\""
-    eval "$cmd"
-    TEST_EQ "$cmd" $? 0
-  fi
-  
-  # create somewhere to store user jobs
-  cmd="mktemp -d --tmpdir=\"$user_job_dir\""
-  test_dir=$(eval "$cmd")
-  TEST_EQ "$cmd" $? 0
-  TEST_NE "$test_dir" "$test_dir" ""
-  test_dir_suffix=${test_dir#${user_job_dir}/}
-
-  # ensure files in this directory are accessible since
-  # mktemp sets directory perms to 0700 regardless of umask.
-  cmd="chmod 755 \"$test_dir\""
-  eval "$cmd"
-  TEST_EQ "$cmd" $? 0
-
-  TEST_NE "HOME" "$HOME" ""
-}
-
-cleanup()
-{
-  if [ -d "$test_dir" ]
-  then
-    echo "Removing test directory '$test_dir'"
-    cmd="rmdir \"$test_dir\""
-    eval "$cmd"
-    TEST_EQ "$cmd" $? 0
-  fi
-}
-
-ensure_job_known()
-{
-  job="$1"
-  job_name="$2"
-
-  [ -z "$job" ] && die "no job"
-  [ -z "$job_name" ] && die "no job name"
-
-  TEST_FEATURE "ensure 'initctl' recognises job"
-  initctl list|grep -q "^$job " || \
-    TEST_FAILED "job $job_name not known to initctl"
-
-  TEST_FEATURE "ensure 'status' recognises job"
-  cmd="status ${job}"
-  eval "$cmd"
-  rc=$?
-  TEST_EQ "$cmd" $rc 0
-}
-
-run_user_job_tests()
-{
-  job_name="$1"
-  job_file="$2"
-  task="$3"
-  env="$4"
-
-  # XXX: env can be empty
-  [ -z "$job_name" ] && die "no job name"
-  [ -z "$job_file" ] && die "no job file"
-  [ -z "$task" ] && die "no task value"
-
-  job="${test_dir_suffix}/${job_name}"
-
-  [ -f "$job_file" ] || TEST_FAILED "job file '$job_file' does not exist"
-
-  ensure_job_known "$job" "$job_name"
-
-  TEST_FEATURE "ensure job can be started"
-  cmd="start ${job} ${env}"
-  output=$(eval "$cmd")
-  rc=$?
-  TEST_EQ "$cmd" $rc 0
-
-  if [ "$task" = no ]
-  then
-    TEST_FEATURE "ensure 'start' shows job pid"
-    pid=$(echo "$output"|awk '{print $4}')
-    TEST_NE "pid" "$pid" ""
-  
-    TEST_FEATURE "ensure 'initctl' shows job is running with pid"
-    initctl list|grep -q "^$job start/running, process $pid" || \
-      TEST_FAILED "job $job_name did not start"
-  
-    TEST_FEATURE "ensure 'status' shows job is running with pid"
-    cmd="status ${job}"
-    output=$(eval "$cmd")
-    echo "$output"|while read job_tmp state ignored status_pid
-    do
-      state=$(echo $state|tr -d ',')
-      TEST_EQ "job name"  "$job_tmp" "$job"
-      TEST_EQ "job state" "$state" "start/running"
-      TEST_EQ "job pid"   "$status_pid" "$pid"
-    done
-  
-    TEST_FEATURE "ensure job pid is running with correct uids"
-    pid_uids=$(ps --no-headers -p $pid -o euid,ruid)
-    for pid_uid in $pid_uids
-    do
-      TEST_EQ "pid uid" "$pid_uid" "$uid"
-    done
-  
-    TEST_FEATURE "ensure job pid is running with correct gids"
-    pid_gids=$(ps --no-headers -p $pid -o egid,rgid)
-    for pid_gid in $pid_gids
-    do
-      TEST_EQ "pid gid" "$pid_gid" "$gid"
-    done
-  
-    TEST_FEATURE "ensure process is running in correct directory"
-    cwd=$(readlink /proc/$pid/cwd)
-    TEST_EQ "cwd" "$cwd" "$HOME"
-  
-    TEST_FEATURE "ensure job can be stopped"
-    cmd="stop ${job}"
-    output=$(eval "$cmd")
-    rc=$?
-    TEST_EQ "$cmd" $rc 0
-  
-    TEST_FEATURE "ensure job pid no longer exists"
-    pid_ids=$(ps --no-headers -p $pid -o euid,ruid,egid,rgid)
-    TEST_EQ "pid uids+gids" "$pid_ids" ""
-  fi
-
-  remove_job_file "$job_file"
-  ensure_job_gone "$job" "$job_name" "$env"
-}
-
-remove_job_file()
-{
-  job_file="$1"
-
-  [ -z "$job_file" ] && die "no job file"
-  [ ! -f "$job_file" ] && TEST_FAILED "job file '$job_file' does not exist"
-
-  cmd="rm $job_file"
-  eval "$cmd"
-  TEST_EQ "$cmd" $? 0
-}
-
-ensure_job_gone()
-{
-  job="$1"
-  job_name="$2"
-  env="$3"
-
-  # XXX: no check on env since it can be empty
-  [ -z "$job" ] && die "no job"
-  [ -z "$job_name" ] && die "no job name"
-
-  TEST_FEATURE "ensure 'initctl' no longer recognises job"
-  initctl list|grep -q "^$job " && \
-    TEST_FAILED "deleted job $job_name still known to initctl"
-
-  TEST_FEATURE "ensure 'status' no longer recognises job"
-  cmd="status ${job}"
-  eval "$cmd"
-  rc=$?
-  TEST_NE "$cmd" $rc 0
-}
-
-test_user_job()
-{
-  test_group="$1"
-  job_name="$2"
-  script="$3"
-  task="$4"
-  env="$5"
-
-  # XXX: no test on script or env since they might be empty
-  [ -z "$test_group" ] && die "no test group"
-  [ -z "$job_name" ] && die "no job name"
-  [ -z "$task" ] && die "no task"
-
-  TEST_GROUP "$test_group"
-
-  job_file="${test_dir}/${job_name}.conf"
-  
-  echo "$script" > $job_file
-
-  run_user_job_tests "$job_name" "$job_file" "$task" "$env"
-}
-
-test_user_job_binary()
-{
-  group="user job running a binary"
-  job_name="binary_test"
-  script="exec sleep 999"
-  test_user_job "$group" "$job_name" "$script" no ""
-}
-
-test_user_job_binary_task()
-{
-  group="user job running a binary task"
-  job_name="binary_task_test"
-  OUTFILE=$(mktemp)
-
-  script="\
-task
-exec true > $OUTFILE"
-
-  test_user_job "$group" "$job_name" "$script" yes "OUTFILE=$OUTFILE"
-  rm -f $OUTFILE
-}
-
-test_user_job_single_line_script()
-{
-  group="user job running a single-line script"
-  job_name="single_line_script_test"
-  script="\
-script
-  sleep 999
-end script"
-  test_user_job "$group" "$job_name" "$script" no ""
-}
-
-test_user_job_single_line_script_task()
-{
-  group="user job running a single-line script task"
-  job_name="single_line_script_task_test"
-  OUTFILE=$(mktemp)
-
-  script="\
-task
-script
-  exec true > $OUTFILE
-end script"
-  test_user_job "$group" "$job_name" "$script" yes "OUTFILE=$OUTFILE"
-  rm -f $OUTFILE
-}
-
-test_user_job_multi_line_script()
-{
-  group="user job running a multi-line script"
-  job_name="multi_line_script_test"
-  script="\
-script
-
-  true
-  true;true
-  sleep 999
-
-end script"
-  test_user_job "$group" "$job_name" "$script" no ""
-}
-
-test_user_job_multi_line_script_task()
-{
-  group="user job running a multi-line script task"
-  job_name="multi_line_script_task_test"
-  OUTFILE=$(mktemp)
-
-  script="\
-task
-script
-
-  true
-  true
-  true
-
-end script"
-  test_user_job "$group" "$job_name" "$script" yes "OUTFILE=$OUTFILE"
-  rm -f $OUTFILE
-}
-
-test_user_emit_events()
-{
-  job_name="start_on_foo"
-
-  TEST_GROUP "user emitting an event"
-  initctl emit foo || TEST_FAILED "failed to emit event as user"
-
-  TEST_GROUP "user emitting an event to start a job"
-  script="\
-    start on foo BAR=2
-    stop on baz cow=moo or hello
-    exec sleep 999"
-
-  job_file="${test_dir}/${job_name}.conf"
-  job="${test_dir_suffix}/${job_name}"
-
-  echo "$script" > $job_file
-
-  ensure_job_known "$job" "$job_name"
-
-  initctl list|grep -q "^$job stop/waiting" || \
-      TEST_FAILED "job $job_name not stopped"
-
-  TEST_FEATURE "ensure job can be started with event"
-  initctl emit foo BAR=2 || \
-    TEST_FAILED "failed to emit event for user job"
-
-  initctl status "$job"|grep -q "^$job start/running" || \
-      TEST_FAILED "job $job_name failed to start"
-  
-  TEST_FEATURE "ensure job can be stopped with event"
-  initctl emit baz cow=moo || \
-    TEST_FAILED "failed to emit event for user job"
-
-  initctl list|grep -q "^$job stop/waiting" || \
-      TEST_FAILED "job $job_name not stopped"
-
-  rm -f "$job_file"
-}
-
-test_user_jobs()
-{
-  test_user_job_binary
-  test_user_job_single_line_script
-  test_user_job_multi_line_script
-
-  test_user_job_binary_task
-  test_user_job_single_line_script_task
-  test_user_job_multi_line_script_task
-
-  test_user_emit_events
-}
-
-tests()
-{
-  echo
-  echo -n "Running user session tests as user '`whoami`'"
-  echo " (uid $uid, gid $gid) in directory '$test_dir'"
-  echo
-
-  test_user_jobs
-
-  echo
-  echo "All tests completed successfully"
-  echo
-}
-
-usage()
-{
-cat <<EOT
-USAGE: $script_name [options]
-
-OPTIONS:
-
- -a        : Actually run this script.      
- -h        : Show this help.
- -u <user> : Specify name of test user to create.
-
-DESCRIPTION: Run simple set of Upstart user session tests.
-
-WARNING: Note that this script is unavoidably invasive, so read what
-WARNING: follows before running!
-
-If run as a non-root user, this script will create a uniquely-named
-subdirectory below "\$HOME/.init/" to run its tests in. On successful
-completion of these tests, the unique subdirectory and its contents will
-be removed.
-
-If however, this script is invoked as the root user, the script will
-refuse to run until given the name of a test user to create via the "-u"
-option. If the user specified to this option already exists, this script
-will exit with an error. If the user does not already exist, it will be
-created, the script then run *as that user* and assuming successful
-completion of the tests, the test user and their home directory will
-then be deleted.
- 
-EOT
-}
-
-#---------------------------------------------------------------------
-# main
-#---------------------------------------------------------------------
-
-while getopts "hu:" opt
-do
-  case "$opt" in
-    h)
-      usage
-      exit 0
-    ;;
-
-    u)
-      user_to_create="$OPTARG"
-    ;;
-  esac
-done
-
-setup
-tests
-cleanup
-exit 0