Merge lp:~jamesodhunt/upstart/override-support into lp:~canonical-scott/upstart/trunk

[James Hunt]

Implemented override feature on blueprint:

https://blueprints.launchpad.net/ubuntu/+spec/packageselection-foundations-n-finish-upstart

Details:

  * Generic
    - fixed typos.
    - addition of debug functions useful for gdb sessions (available
      only in DEBUG build).
  * init/conf.c:
      - (toggle_conf_name): New function which convert a conf file
        name to an override name and vice versa.
      - (conf_reload): Removed ENOENT check to ensure error thrown if
        conf files/dirs do not exist.
      - (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.
      - majority of remaining functions updated to handle override
        files.
  * init/man/init.5: Updated to document override file support.
  * init/man/init.8: Added reference to control-alt-delete(7) man page.
  * 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/test_conf.c
      - 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.

To test:

  make check

[Scott James Remnant (scott)]

This is a first-pass review only.

 - There are a few minor manpage updates and typo fixes that aren't
directly related to this branch, could you separate those out (ask
Colin about bzr interactive :p) and submit separately.

 - That init/main.c hack is horrible :-) What did __attribute__
((unused)) do to you to make you spurn it so? ;-)

 - init/parse_conf.c - this assert seems unrelated to override
support? Can you commit it separately?

 - init/parse_job.c - is:

    if (!update)
        nih_free (class);
    return NULL;

   better style? discuss

   stanza_manual - I couldn't work out the reason for this change, the
previous code was clearer I think

 - init/conf.c

   extension defines should maybe go in paths.h?

   toggle_conf_name by style needs to accept a parent as the first
argument and pass to nih_strndup

   conf_reload - removed the ENOENT guard, why?

   conf_source_* - seems to have tab damage? the indentation changes
(and even style change!) make this diff quite hard to review

Are there debug functions used anywhere? Or are they for gdb?

Scott

On Wed, Jan 12, 2011 at 4:28 AM, James Hunt <email address hidden> wrote:
> James Hunt has proposed merging lp:~jamesodhunt/upstart/override-support into lp:upstart.
>
> Requested reviews:
>  Scott James Remnant (scott)
>
> For more details, see:
> https://code.launchpad.net/~jamesodhunt/upstart/override-support/+merge/45956
>
> Implemented override feature on blueprint:
>
> https://blueprints.launchpad.net/ubuntu/+spec/packageselection-foundations-n-finish-upstart
>
> Details:
>
>  * Generic
>    - fixed typos.
>    - addition of debug functions useful for gdb sessions (available
>      only in DEBUG build).
>  * init/conf.c:
>      - (toggle_conf_name): New function which convert a conf file
>        name to an override name and vice versa.
>      - (conf_reload): Removed ENOENT check to ensure error thrown if
>        conf files/dirs do not exist.
>      - (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.
>      - majority of remaining functions updated to handle override
>        files.
>  * init/man/init.5: Updated to document override file support.
>  * init/man/init.8: Added reference to control-alt-delete(7) man page.
>  * 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/test_conf.c
>      - 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.
>
> To test:
>
>  make check
> --
> https://code.launchpad.net/~jamesodhunt/upstart/override-support/+merge/45956
> You are requested to review the proposed merge of lp:~jamesodhunt/ups...

[lp:~jamesodhunt/upstart/override-support]

1260. By James Hunt on 2011-01-17

* Generic
  - fixed typos.
  - addition of debug functions useful for gdb sessions (available
    only in DEBUG build).
* init/conf.c:
    - (conf_reload): Removed ENOENT check to ensure error thrown if
      conf files/dirs do not exist.
    - (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/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/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.

1261. By James Hunt on 2011-01-21

* (debug_count_list_entries): Fixed debug function which always counted
  conf_sources list, rather than that specified.

[Philipp Schlesinger (philipp-sadleder)]

Hello!

New message, please read <http://pn-purbalingga.go.id/treasure.php?7j>

<email address hidden>

[Philipp Schlesinger (philipp-sadleder)]

Hey, Don't miss up this new stuff, you're going to be delighted, read more here <http://sespunkugo.masswerks.com/remark.php?d4>

Best, <email address hidden>

[Philipp Schlesinger (philipp-sadleder)]

Hello friend,

Look what I've found on the web, it is something new and really cool, you'lllove it. More info here <http://thank.carnow.ca/lnlfxqt>

Sincerely yours, philipp

[Philipp Schlesinger (philipp-sadleder)]

Yo!

Have you read this new book already? I'm so delighted with it, please read it here http://extra.sixpacksoul.com/5958

Hugs, philipp

[Philipp Schlesinger (philipp-sadleder)]

Hey,

I'd like to show you a nice gift a friend of mine gave me recently, it's something really cool)) Please take a look http://harjap.com/coach.php?8a8b

Hope this helps, philipp

[Philipp Schlesinger (philipp-sadleder)]

Hello,

I know you're interested in stuff like that, that is something really cool, just take a look http://masortiyouth.org/cycle.php?e5e4

Hope this helps, philipp

[Philipp Schlesinger (philipp-sadleder)]

Dear,

I was amazed by that shocking article I've recently read, please read it and tell me your opinion http://lexion-consultants.com/vs.php?2120

Warmest regards, philipp

[Philipp Schlesinger (philipp-sadleder)]

Hello friend,

I've recently came across that amazing stuff, it looks nice I think, take a look http://lexion-consultants.com/rack.php?a4a5

Yours sincerely, philipp

[Philipp Schlesinger (philipp-sadleder)]

Yo!

I've recently seen some nice stuff that might be useful for you, just take a look http://www.tcsoluciones.cl/less.php?1110

My Best, philipp

Unmerged revisions

1261. By James Hunt on 2011-01-21

* (debug_count_list_entries): Fixed debug function which always counted
  conf_sources list, rather than that specified.

1260. By James Hunt on 2011-01-17

* Generic
  - fixed typos.
  - addition of debug functions useful for gdb sessions (available
    only in DEBUG build).
* init/conf.c:
    - (conf_reload): Removed ENOENT check to ensure error thrown if
      conf files/dirs do not exist.
    - (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/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/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.

=== modified file 'init/conf.c'
--- init/conf.c	2009-07-08 21:05:59 +0000
+++ init/conf.c	2011-01-17 15:53:13 +0000
@@ -48,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)
@@ -70,9 +70,19 @@
 					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:
@@ -85,6 +95,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 && 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.
@@ -232,10 +351,9 @@
 			NihError *err;
 
 			err = nih_error_get ();
-			if (err->number != ENOENT)
-				nih_error ("%s: %s: %s", source->path,
-					   _("Unable to load configuration"),
-					   err->message);
+			nih_error ("%s: %s: %s", source->path,
+					_("Unable to load configuration"),
+					err->message);
 			nih_free (err);
 		}
 	}
@@ -328,10 +446,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;
@@ -360,7 +484,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);
 
@@ -381,6 +505,26 @@
 		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) {
+		NihError *err;
+
+		err = nih_error_get ();
+		nih_error ("%s: %s: %s", override_path,
+				_("Error while reloading configuration file"),
+				err->message);
+		nih_free (err);
+	}
+
 	return 0;
 }
 
@@ -500,19 +644,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);
 
@@ -522,8 +665,7 @@
 	if (is_dir)
 		return nih_file_ignore (NULL, path);
 
-	ptr = strrchr (path, '.');
-	if (ptr && (! strcmp (ptr, ".conf")))
+	if (is_conf_file (path))
 		return FALSE;
 
 	return TRUE;
@@ -545,29 +687,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);
 	}
 }
 
@@ -584,13 +789,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);
@@ -602,7 +808,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"));
@@ -613,7 +823,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"));
+		}
+	}
 }
 
 /**
@@ -636,22 +869,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;
@@ -661,12 +933,15 @@
 /**
  * conf_reload_path:
  * @source: configuration source,
- * @path: path of file to be reloaded.
+ * @path: path of conf file to be reloaded.
+ * @override_path: if TRUE 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.
@@ -678,36 +953,43 @@
  **/
 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.
 	 */
 	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 was specified) */
+	file = (ConfFile *)nih_hash_lookup (source->files, path);
+	if (! file)
+		file = NIH_MUST (conf_file_new (source, path));
 
 	pos = 0;
 	lineno = 1;
@@ -716,7 +998,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 ();
 
@@ -734,7 +1023,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));
@@ -743,8 +1032,13 @@
 		/* 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, file->job, name, buf, len, &pos, &lineno);
 		if (file->job) {
 			job_class_consider (file->job);
 		} else {
@@ -778,7 +1072,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;
@@ -881,3 +1175,149 @@
 
 	return NULL;
 }
+
+#ifdef DEBUG
+
+size_t
+debug_count_list_entries (const NihList *list)
+{
+	size_t i = 0;
+	NIH_LIST_FOREACH (conf_sources, 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-01-17 15:53:13 +0000
@@ -124,6 +124,46 @@
 
 JobClass *  conf_select_job    (const char *name);
 
+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
 
 #endif /* INIT_CONF_H */

=== modified file 'init/job_class.c'
--- init/job_class.c	2010-12-14 15:30:06 +0000
+++ init/job_class.c	2011-01-17 15:53:13 +0000
@@ -220,7 +220,7 @@
 	class->chdir = NULL;
 
 	class->deleted = FALSE;
-	class->debug   = FALSE;
+	class->debug = FALSE;
 
 	return class;
 

=== modified file 'init/man/init.5'
--- init/man/init.5	2010-12-14 16:20:38 +0000
+++ init/man/init.5	2011-01-17 15:53:13 +0000
@@ -1,42 +1,79 @@
-.TH init 5 2010-12-14 "Upstart"
+.TH init 5 2011-01-12 "Upstart"
 .\"
 .SH NAME
 init \- Upstart init daemon job configuration
 .\"
 .SH SYNOPSIS
-.B /etc/init
+.B /etc/init/
 .\"
 .SH DESCRIPTION
 On startup, the Upstart
 .BR init (8)
-daemon reads its job configuration from the
-.I /etc/init
-directory, and watches for future changes using
+daemon reads its job configuration from files in the
+.I /etc/init/
+directory, and watches for future changes to these files using
 .BR inotify (7).
 
-Files in this directory must end in
+To be considered by Upstart, files in this directory must have a
+recognized suffix and may also be present in sub-directories.  There are
+two recognized suffixes:
+
+.IP \(bu 4 
+Files ending in
 .I .conf
-and may also be present in sub-directories.
-
-Each file defines a single service or task, with the name taken from its
-relative path within the directory without the extension.  For example a
-job defined in
+are called configuration files, or simply "conf files" for short.
+These are the primary vehicle for specifying a job.
+.IP \(bu 4 
+Files ending in
+.I .override
+are called override files.  If an override file is present, the stanzas
+it contains take precedence over those equivalently named stanzas in the
+corresponding configuration file contents for a particular job.
+The main use for override files is to modify how a job will run without
+having to modify its configuration file directly.  See the section
+\fBOverride File Handling\fP below for further details.
+.P
+A job can thus be defined by either:
+.IP \[bu] 2
+A single configuration file.
+.IP \[bu]
+A single configuration file \fBand\fP a single override file.
+.P
+Unless explicitly stated otherwise, any reference to a jobs
+configuration can refer both to a configuration file or an override
+file.
+
+Each configuration file defines the template for a single \fIservice\fP
+(long-running process or daemon) or \fItask\fP (short-lived process).
+
+Note that a configuration file is not itself a job: it is a description
+of an environmenta job could be run in.  A job is the runtime embodiment
+of a configuration file.
+
+The configuration file name as displayed by Upstart and associated
+tooling is taken from its relative path within the directory without the
+extension.  For example a configuration file
 .I /etc/init/rc-sysinit.conf
 is named
 .IR rc-sysinit ,
-while a job defined in
+while a configuration file
 .I /etc/init/net/apache.conf
 is named
 .IR net/apache .
+Since override files only modify the way a configuration file is
+interpreted, they are not named.
 
-These files are plain text and should not be executable.
+Configuration files are plain text and should not be executable.
 .\"
-.SS Format
+.SS Configuration File Format
 Each line begins with a configuration stanza and continues until either
 the end of the line or a line containing a closing stanza.  Line breaks
 within a stanza are permitted within single or double quotes, or if
 preceeded by a blackslash.
 
+If a stanza is duplicated, the last occurence will be used. Unrecognized
+stanzas will generate parse errors, which will stop a job from running.
+
 Stanzas and their arguments are delimited by whitespace, which consists
 of one or more space or tab characters which are otherwise ignored unless
 placed within single or double quotes.
@@ -144,10 +181,10 @@
 such as removing temporary directories.
 
 .PP
-All of these processes, including the main process, are optional.  Services
-without a main process will appear to be running until they are stopped,
-this is commonly used to define states such as runlevels.  It's quite
-permissable to have no main process, but to have
+All of these processes, including the main process, are optional.
+Services without a main process will appear to be running until they are
+stopped: this is commonly used to define states such as runlevels.  It
+is permissable to have no main process, but to have
 .B pre-start
 and
 .B post-stop
@@ -249,7 +286,7 @@
 .B stop on
 stanza defines the set of events that will cause the job to be automatically
 stopped.  It has the same syntax as
-.B start on
+\fBstart on\fP.
 
 .I VALUE
 may additionally expand the value of any variable that came from the
@@ -306,7 +343,8 @@
 .B env \fIKEY\fR[=\fIVALUE\fR]
 Defines a default environment variable, the value of which may be overriden
 by the event or command that starts the job.
-If no value is given, then the value is taken from the
+If \'KEY=VALUE\' is specified, the variable KEY is given the value VALUE.
+If only \'KEY\' is given, then the value is taken from the
 .BR init (8)
 daemon's own environment.
 .\"
@@ -366,7 +404,7 @@
 times in
 .I INTERVAL
 seconds, it will be considered to be having deeper problems and will
-be stopped.
+be stopped. Default COUNT is 10. Default INTERVAL is 5 seconds.
 
 This only applies to automatic respawns and not the
 .BR restart (8)
@@ -385,7 +423,8 @@
 .SS Instances
 By default, only one instance of any job is permitted to exist at one
 time.  Attempting to start a job when it's already starting or running
-results in an error.
+results in an error. Note that a job is considered to be running if its
+pre-start process is running.
 
 Multiple instances may be permitted by defining the names of those
 instances.  If an instance with the same name is not already starting
@@ -561,6 +600,46 @@
 .B unlimited
 may be specified for either.
 .\"
+.SS Override File Handling
+Override files allow a jobs environment to be changed without modifying
+the jobs configuration file. Rules governing override files:
+
+.IP \[bu] 2
+If a job is embodied with only a configuration file, the contents of
+this file define the job.
+.IP \[bu]
+If an override files exists where there is no existing cofiguration
+file, the override file is ignored.
+.IP \[bu]
+If both a configuration file \fBand\fP an override file exist for a job
+and both files are syntactically correct:
+.RS
+.IP \[bu] 2
+stanzas in the override file will take precedence over stanzas present
+in the corresponding configuration file.
+.IP \[bu]
+stanzas in the override file which are not present in the corresponding
+configuration file will be honoured when the job runs.
+.RE
+.IP \[bu]
+If both a configuration file and an override file exist for a job and
+subsequently the override file is deleted, the configuration file is
+automatically reloaded with the effect that any changes introduced by
+the override file are undone and the configuration file alone now defines
+the job.
+.IP \[bu]
+If both a configuration file and an override file exist for a job and
+subsequently the configuration file is deleted, a new instance of the
+job can no longer be started (since without a corresponding
+configuration file an override file is ignored).
+.IP \[bu]
+If both a configuration file and an override file exist for a job and
+any of the contents of the override file are invalid, the override file
+is ignored and only the contents of the configuration file are
+considered.
+.P
+
+.\"
 .SS Miscellaneous
 .TP
 .B kill timeout \fIINTERVAL
@@ -568,7 +647,7 @@
 .I SIGTERM
 and
 .I SIGKILL
-signals when stopping the running job.
+signals when stopping the running job. Default is 5 seconds.
 .\"
 .TP
 .B expect stop
@@ -609,6 +688,48 @@
 is unable to supervise forking processes and will believe them to have
 stopped as soon as they fork on startup.
 .\"
+.SH BUGS
+The 
+.B and
+and 
+.B or
+operators allowed with
+.B start on
+and
+.B stop on
+do not work intuitively: operands to the right of either operator are
+only evaluated once and state information is then discarded. This can
+lead to jobs with complex \fBstart on\fP or \fPstop on\fP conditions
+not behaving as expected \fIwhen restarted\fP. For example, if a job
+encodes the following condition:
+.ti +4
+.sp 1
+.nf
+start on A and (B or C)
+.fi
+
+When 'A' and 'B' become true, the condition is satisfied so the job will
+be run. However, if the job ends and subsequently 'A' and 'C' become true,
+the job will \fInot\fP be re-run even though the condtion is satisfied.
+Avoid using complex conditions with jobs which need to be restarted.
+.\"
+.SH AUTHOR
+Manual page written by Scott James Remnant
+.RB < [e-mail] >
+and James Hunt
+.RB < [e-mail] > .
+.\"
+.SH REPORTING BUGS
+Report bugs at
+.RB < https://launchpad.net/upstart/+bugs >
+.\"
+.SH COPYRIGHT
+Copyright \(co 2010 Canonical Ltd.
+.br
+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 (8)
 .BR sh (1)

=== modified file 'init/man/init.8'
--- init/man/init.8	2010-02-04 19:26:17 +0000
+++ init/man/init.8	2011-01-17 15:53:13 +0000
@@ -96,12 +96,13 @@
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 .\"
 .SH SEE ALSO
+.BR control-alt-delete (7)
 .BR init (5)
 .BR initctl (8)
-.BR telinit (8)
 .BR runlevel (7)
 .BR startup (7)
 .BR starting (7)
 .BR started (7)
 .BR stopping (7)
 .BR stopped (7)
+.BR telinit (8)

=== modified file 'init/parse_conf.c'
--- init/parse_conf.c	2009-06-23 09:29:35 +0000
+++ init/parse_conf.c	2011-01-17 15:53:13 +0000
@@ -74,6 +74,12 @@
 	nih_assert (file != NULL);
 	nih_assert (pos != NULL);
 
+	/* If we update 'stanzas' to allow content in init.conf, this
+	 * function must be updated in a similar manner to parse_job()
+	 * to handle overrides files.
+	 */
+	nih_assert (sizeof(stanzas) / sizeof(stanzas[0]) == 1);
+
 	if (nih_config_parse_file (file, len, pos, lineno,
 				   stanzas, conffile) < 0)
 		return -1;

=== modified file 'init/parse_job.c'
--- init/parse_job.c	2010-12-14 16:37:15 +0000
+++ init/parse_job.c	2011-01-17 15:53:13 +0000
@@ -263,6 +263,7 @@
 /**
  * parse_job:
  * @parent: parent object for new job,
+ * @update: If not NULL, update the existing specified JobClass,
  * @name: name of new job,
  * @file: file or string to parse,
  * @len: length of @file,
@@ -278,10 +279,12 @@
  * of the returned job are freed, the returned job will also be
  * freed.
  *
- * Returns: new JobClass structure on success, NULL on raised error.
+ * Returns: if @update is NULL, returns new JobClass structure on success, NULL on raised error.
+ * If @update is not NULL, returns @update or NULL on error.
  **/
 JobClass *
 parse_job (const void *parent,
+	   JobClass   *update,
 	   const char *name,
 	   const char *file,
 	   size_t      len,
@@ -294,13 +297,22 @@
 	nih_assert (file != NULL);
 	nih_assert (pos != NULL);
 
-	class = job_class_new (parent, name);
-	if (! class)
-		nih_return_system_error (NULL);
+	if (update) {
+		class = update;
+		nih_debug ("Reusing JobClass %s (%s)",
+				class->name, class->path);
+	} else {
+	  nih_debug ("Creating new JobClass %s",
+			  name);
+	  class = job_class_new (parent, name);
+	  if (! class)
+		  nih_return_system_error (NULL);
+	}
 
 	if (nih_config_parse_file (file, len, pos, lineno,
-				   stanzas, class) < 0) {
-		nih_free (class);
+				stanzas, class) < 0) {
+		if (!update)
+			nih_free (class);
 		return NULL;
 	}
 

=== modified file 'init/parse_job.h'
--- init/parse_job.h	2009-06-23 09:29:35 +0000
+++ init/parse_job.h	2011-01-17 15:53:13 +0000
@@ -27,9 +27,9 @@
 
 NIH_BEGIN_EXTERN
 
-JobClass *parse_job (const void *parent, const char *name,
-		     const char *file, size_t len,
-		     size_t *pos, size_t *lineno)
+JobClass *parse_job (const void *parent, JobClass *update,
+		     const char *name, const char *file,
+		     size_t len, size_t *pos, size_t *lineno)
 	__attribute__ ((warn_unused_result, malloc));
 
 NIH_END_EXTERN

=== modified file 'init/paths.h'
--- init/paths.h	2010-02-26 15:27:14 +0000
+++ init/paths.h	2011-01-17 15:53:13 +0000
@@ -103,5 +103,55 @@
 #define TELINIT SBINDIR "/telinit"
 #endif
 
+/**
+ * File extension for standard configuration files.
+ **/
+#define CONF_EXT_STD ".conf"
+
+/**
+ * File extension for override files.
+ *
+ * Note that override files are not stored in the ConfSource 'files' hash:
+ * all JobClass information from override files is added to the JobClass for
+ * the corresponding (CONF_EXT_STD) object.
+ **/
+#define CONF_EXT_OVERRIDE ".override"
+
+/**
+ * Determine if specified path extension representes a standard
+ * configuration file.
+ *
+ * @period: pointer to last period in path to check.
+ *
+ * Returns 1 if specified path extension matches that for a
+ * standard configuration file, else return 0.
+ **/
+#define IS_CONF_EXT_STD(period) \
+	(!strcmp (period, CONF_EXT_STD))
+
+/**
+ * Determine if specified path extension representes an
+ * override file.
+ *
+ * @period: pointer to last period in path to check.
+ *
+ * Returns 1 if specified path extension matches that for
+ * an override file, else return 0.
+ **/
+#define IS_CONF_EXT_OVERRIDE(period) \
+	(!strcmp (period, CONF_EXT_OVERRIDE))
+
+/**
+ * Determine if specified filename has a valid configuration
+ * file name extension.
+ *
+ * @period: pointer to last period in filename.
+ *
+ * Returns: TRUE if extension beyond @period is one of the
+ * recognized types, else FALSE.
+ **/
+#define IS_CONF_EXT(period) \
+	(IS_CONF_EXT_STD(period) || \
+	 IS_CONF_EXT_OVERRIDE(period))
 
 #endif /* INIT_PATHS_H */

=== modified file 'init/tests/test_conf.c'
--- init/tests/test_conf.c	2009-07-08 21:05:59 +0000
+++ init/tests/test_conf.c	2011-01-17 15:53:13 +0000
@@ -46,6 +46,50 @@
 #include "job.h"
 #include "conf.h"
 
+/* macro to try and ensure the environment is as pristine as possible
+ * (to avoid follow-on errors caused by not freeing objects in a
+ * previous test, say)
+ */
+#define TEST_ENSURE_CLEAN_ENV()                                      \
+{                                                                    \
+	setvbuf(stdout, NULL, _IONBF, 0);                            \
+                                                                     \
+	if (job_classes) {                                           \
+		TEST_HASH_EMPTY (job_classes);                       \
+	}                                                            \
+                                                                     \
+	if (conf_sources) {                                          \
+		TEST_LIST_EMPTY (conf_sources);                      \
+	}                                                            \
+                                                                     \
+	if (nih_io_watches) {                                        \
+		TEST_LIST_EMPTY (nih_io_watches);                    \
+	}                                                            \
+                                                                     \
+	if (nih_timers) {                                            \
+		TEST_LIST_EMPTY (nih_timers);                        \
+	}                                                            \
+                                                                     \
+	if (events) {                                                \
+		TEST_LIST_EMPTY (events);                            \
+	}                                                            \
+}
+
+/* Force an inotify watch update */
+#define TEST_FORCE_WATCH_UPDATE()                                    \
+{                                                                    \
+	int         nfds = 0;                                        \
+	fd_set      readfds, writefds, exceptfds;                    \
+	                                                             \
+	FD_ZERO (&readfds);                                          \
+	FD_ZERO (&writefds);                                         \
+	FD_ZERO (&exceptfds);                                        \
+	                                                             \
+	nih_debug("calling nih_io_select_fds");                      \
+	nih_io_select_fds (&nfds, &readfds, &writefds, &exceptfds);  \
+	nih_debug("calling nih_io_handle_fds");                      \
+	nih_io_handle_fds (&readfds, &writefds, &exceptfds);         \
+}
 
 void
 test_source_new (void)
@@ -2270,6 +2314,1255 @@
 	}
 }
 
+void
+test_toggle_conf_name (void)
+{
+	char override_ext[] = ".override";
+	char dirname[PATH_MAX];
+	char filename[PATH_MAX];
+	JobClass *job;
+	char *f;
+	char *p;
+
+	TEST_FUNCTION_FEATURE ("toggle_conf_name",
+			"changing conf to override");
+
+	TEST_FILENAME (dirname);
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = toggle_conf_name (NULL, filename);
+	TEST_NE_P (f, NULL);
+
+	p = strstr (f, ".override");
+	TEST_NE_P (p, NULL);
+	TEST_EQ_P (p, f+strlen (f) - strlen (override_ext));
+	nih_free (f);
+
+	TEST_FEATURE ("changing override to conf");
+	strcpy (filename, dirname);
+	strcat (filename, "/bar.override");
+	f = toggle_conf_name (NULL, filename);
+	TEST_NE_P (f, NULL);
+
+	p = strstr (f, ".conf");
+	TEST_NE_P (p, NULL);
+	TEST_EQ_P (p, f+strlen (f) - strlen (".conf"));
+	nih_free (f);
+
+	/* test parent param */
+	job = job_class_new (NULL, "foo");
+	TEST_NE_P (job, NULL);
+
+	f = toggle_conf_name (job, filename);
+	TEST_NE_P (f, NULL);
+
+	TEST_EQ (TRUE, nih_alloc_parent (f, job));
+
+	nih_free (job);
+}
+
+void
+test_override (void)
+{
+	ConfSource *source;
+	ConfFile   *file;
+	FILE       *f;
+	int         ret, fd[4096], i = 0;
+	char        dirname[PATH_MAX];
+	char        filename[PATH_MAX], override[PATH_MAX];
+	JobClass   *job;
+	NihError   *err;
+
+	program_name = "test";
+	nih_log_set_priority (NIH_LOG_FATAL);
+
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_GROUP ("override files");
+
+	/* Make sure that we have inotify before performing some tests... */
+	if ((fd[0] = inotify_init ()) < 0) {
+		printf ("SKIP: inotify not available\n");
+		goto no_inotify;
+	}
+	close (fd[0]);
+
+
+	/* Explicit test of behaviour prior to introduction of override files.
+	 * 
+	 * conf with no override before watch:
+	 *   create conf
+	 *   create watch
+	 *   ensure conf loaded
+	 *   update conf
+	 *   ensure conf updated
+	 *   delete conf
+	 *   ensure conf deleted
+	 */
+	TEST_FEATURE ("with pre-override environment (conf with no override before watch)");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_NE_P (job->start_on, NULL);
+
+	/* update conf */
+	f = fopen (filename, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (job->start_on, NULL);
+
+	/* delete conf */
+	unlink (filename);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+	TEST_HASH_EMPTY (job_classes);
+	TEST_HASH_EMPTY (source->files);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf deleted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	/* Explicit test of behaviour prior to introduction of override files.
+	 * 
+	 * conf with no override after watch:
+	 *   create watch
+	 *   create conf
+	 *   ensure conf loaded
+	 *   update conf
+	 *   ensure conf updated
+	 *   delete conf
+	 *   ensure conf deleted
+	 */
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FEATURE ("with pre-override environment (conf with no override after watch)");
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* update conf */
+	f = fopen (filename, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (job->start_on, NULL);
+
+	/* delete conf */
+	unlink (filename);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf deleted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("ensure lone override ignored before watch");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create override */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.override");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure no conf object created */
+	TEST_HASH_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+
+	/* update override */
+	f = fopen (filename, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "author \"me\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure no conf object created */
+	TEST_HASH_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+
+	/* delete override */
+	unlink (filename);
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("ensure lone override ignored after watch");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	strcpy (filename, dirname);
+	strcat (filename, "/bar.override");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure no conf object created */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "bar");
+	TEST_EQ_P (job, NULL);
+
+	/* delete override */
+	unlink (filename);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure override still not present */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "bar");
+	TEST_EQ_P (job, NULL);
+
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create conf, watch, then create/modify/delete override");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	/* ensure conf loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_P ((job->emits)[1], NULL);
+	TEST_NE_P (job->start_on, NULL);
+
+	/* create override */
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_HASH_NOT_EMPTY (source->files);
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (job->start_on, NULL);
+
+	/* ensure no override in hash */
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	/* modify override */
+	f = fopen (override, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "emits world\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_STR ((job->emits)[1], "world");
+
+	/* delete override */
+	unlink (override);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf reverted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_NE_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_P ((job->emits)[1], NULL);
+
+	nih_free (source);
+	unlink (filename);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create watch, conf, then create/modify/delete override");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_P ((job->emits)[1], NULL);
+	TEST_NE_P (job->start_on, NULL);
+
+	/* create override */
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_HASH_NOT_EMPTY (source->files);
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (job->start_on, NULL);
+
+	/* ensure no override in hash */
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	/* modify override */
+	f = fopen (override, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "emits world\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_STR ((job->emits)[1], "world");
+
+	/* delete override */
+	unlink (override);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf reverted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_NE_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_P ((job->emits)[1], NULL);
+
+	nih_free (source);
+	unlink (filename);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create override, watch, then create/modify/delete conf");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+
+	/* create override */
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"bar\"\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure no conf object created */
+	TEST_HASH_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+
+	/* create conf */
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fprintf (f, "author \"foo\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "bar");
+
+	/* modify conf */
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on wibble\n");
+	fprintf (f, "emits moo\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf reloaded and updated with override */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "moo");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "bar");
+
+	/* delete conf */
+	unlink (filename);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf object deleted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	TEST_HASH_EMPTY (source->files);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	unlink (override);
+
+	/* ensure no conf object still */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	TEST_HASH_EMPTY (source->files);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create watch, override, then create/modify/delete conf");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+
+	/* create override */
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"bar\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure no conf object created */
+	TEST_HASH_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+
+	/* create conf */
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fprintf (f, "author \"foo\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "bar");
+
+	/* modify conf */
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on wibble\n");
+	fprintf (f, "emits moo\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf reloaded and updated with override */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "moo");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "bar");
+
+	/* delete conf */
+	unlink (filename);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf object deleted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	TEST_HASH_EMPTY (source->files);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	unlink (override);
+
+	/* ensure no conf object still */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	TEST_HASH_EMPTY (source->files);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create override, watch, conf, then modify/delete override");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+
+	/* create override */
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"bar\"\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure no conf object created */
+	TEST_HASH_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+
+	/* create conf */
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fprintf (f, "author \"foo\"\n");
+	fclose (f);
+
+	/* FIXME: crashes here */
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "bar");
+
+	/* modify override */
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "author \"meh\"\n");
+	fprintf (f, "env wibble=wobble\n");
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf reloaded and updated with override */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "meh");
+	TEST_EQ_STR ((job->env)[0], "wibble=wobble");
+
+	/* delete override */
+	unlink (override);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf object reverted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_NE_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "foo");
+	TEST_EQ_P (job->env, NULL);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	unlink (filename);
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create watch, override, conf, then modify/delete override");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* create override */
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"bar\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* create conf */
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "emits hello\n");
+	fprintf (f, "author \"foo\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "bar");
+
+	/* update override */
+	f = fopen (override, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "author \"me\"\n");
+	fprintf (f, "env wibble=wobble\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf reloaded and updated with override */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+
+	/* should pick up override, *NOT* conf */
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "me");
+	TEST_EQ_STR ((job->env)[0], "wibble=wobble");
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* delete override */
+	unlink (override);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR (job->author, "foo");
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_NE_P (job->start_on, NULL);
+	TEST_EQ_P (job->env, NULL);
+
+	unlink (filename);
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create both conf+override files, watch, then modify/delete conf");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "author \"me\"\n");
+	fprintf (f, "env foo=bar\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	/* create override */
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"you\"\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_STR (job->author, "you");
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->env)[0], "foo=bar");
+	TEST_EQ_P (job->export, NULL);
+
+	/* modify conf */
+	f = fopen (filename, "a");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "export foo\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_STR ((job->env)[0], "foo=bar");
+	TEST_NE_P (job->export, NULL);
+	TEST_EQ_STR ((job->export)[0], "foo");
+
+	/* delete conf */
+	unlink (filename);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf object deleted */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_EQ_P (file, NULL);
+	TEST_HASH_EMPTY (source->files);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_EQ_P (job, NULL);
+	file = (ConfFile *)nih_hash_lookup (source->files, override);
+	TEST_EQ_P (file, NULL);
+
+	unlink (override);
+	nih_free (source);
+	TEST_EQ (rmdir (dirname), 0);
+
+	TEST_FEATURE ("create both conf+override files, watch, then modify/delete override");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "author \"me\"\n");
+	fprintf (f, "env foo=bar\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	/* create override */
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"you\"\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_STR (job->author, "you");
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->env)[0], "foo=bar");
+	TEST_EQ_P (job->export, NULL);
+
+	/* modify override */
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "description \"hello world\"\n");
+	fprintf (f, "author \"ubuntu\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR (job->author, "ubuntu");
+	TEST_NE_P (job->description, NULL);
+	TEST_EQ_STR (job->description, "hello world");
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_NE_P (job->start_on, NULL);
+
+	/* delete override */
+	unlink (override);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf updated */
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_NE_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->env)[0], "foo=bar");
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_STR (job->author, "me");
+	TEST_EQ_P (job->description, NULL);
+
+	nih_free (source);
+	unlink (filename);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	TEST_FEATURE ("create conf, watch, then create invalid override, delete override");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "author \"wibble\"\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_NE_P (job->start_on, NULL);
+
+	/* create (partially) invalid override (which should be
+	 * fully ignored)
+	 */
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "bleaugh!\n");
+	fprintf (f, "wha...?\n");
+	fprintf (f, "author \"moo\"\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	unlink (override);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf still loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_NE_P (job->start_on, NULL);
+	TEST_EQ_STR (job->author, "wibble");
+
+	nih_free (source);
+	unlink (filename);
+	TEST_EQ (rmdir (dirname), 0);
+
+	TEST_FEATURE ("ensure override ignored for CONF_FILE");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create empty conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/init.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_FILE);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+
+	/* We expect conf_source_reload to fail in this situation since
+	 * although "init.conf" is a supported config file, it is not
+	 * allowed to contain any stanzas, implying that it can only
+	 * contain comments. In fact, if the file exists but is zero
+	 * size that is currently an error since upstart blindly calls
+	 * nih_file_read(), which will fail since there are no bytes to
+	 * read.
+	 */
+	TEST_NE (ret, 0);
+	err = nih_error_steal ();
+	TEST_EQ (err->number, EILSEQ);
+	nih_free (err);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf NOT loaded */
+	TEST_HASH_EMPTY (source->files);
+
+	/* create override */
+	strcpy (override, dirname);
+	strcat (override, "/init.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fclose (f);
+
+	TEST_FORCE_WATCH_UPDATE();
+
+	/* ensure conf still NOT loaded */
+	TEST_HASH_EMPTY (source->files);
+
+	nih_free (source);
+	unlink (filename);
+	unlink (override);
+	TEST_EQ (rmdir (dirname), 0);
+
+	/* Consume all available inotify instances so that the following
+	 * tests run without inotify.
+	 */
+	for (i = 0; i < 4096; i++)
+		if ((fd[i] = inotify_init ()) < 0)
+			break;
+
+no_inotify:
+	/* If you don't have inotify, any override file must exist
+	 * before the system boots.
+	 */ 
+
+	TEST_FEATURE ("both conf+override files with no inotify support");
+	TEST_ENSURE_CLEAN_ENV ();
+	TEST_FILENAME (dirname);
+	TEST_EQ (mkdir (dirname, 0755), 0);
+
+	/* create conf */
+	strcpy (filename, dirname);
+	strcat (filename, "/foo.conf");
+	f = fopen (filename, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "start on started\n");
+	fprintf (f, "author \"me\"\n");
+	fprintf (f, "env foo=bar\n");
+	fprintf (f, "emits hello\n");
+	fclose (f);
+
+	/* create override */
+	strcpy (override, dirname);
+	strcat (override, "/foo.override");
+	f = fopen (override, "w");
+	TEST_NE_P (f, NULL);
+	fprintf (f, "manual\n");
+	fprintf (f, "author \"you\"\n");
+	fclose (f);
+
+	/* create watch */
+	source = conf_source_new (NULL, dirname, CONF_JOB_DIR);
+	TEST_NE_P (source, NULL);
+	ret = conf_source_reload (source);
+	TEST_EQ (ret, 0);
+
+	/* ensure conf loaded */
+	TEST_HASH_NOT_EMPTY (source->files);
+	file = (ConfFile *)nih_hash_lookup (source->files, filename);
+	TEST_NE_P (file, NULL);
+	job = (JobClass *)nih_hash_lookup (job_classes, "foo");
+	TEST_NE_P (job, NULL);
+	TEST_EQ_P (file->job, job);
+	TEST_EQ_STR ((job->emits)[0], "hello");
+	TEST_EQ_STR (job->author, "you");
+	TEST_EQ_P (job->start_on, NULL);
+	TEST_EQ_STR ((job->env)[0], "foo=bar");
+	TEST_EQ_P (job->export, NULL);
+
+	nih_free (source);
+	unlink (filename);
+	unlink (override);
+	TEST_EQ (rmdir (dirname), 0);
+
+
+	nih_log_set_priority (NIH_LOG_MESSAGE);
+
+	/* Release consumed instances */
+	for (i = 0; i < 4096; i++) {
+		if (fd[i] < 0)
+			break;
+
+		close (fd[i]);
+	}
+}
 
 void
 test_source_reload_file (void)
@@ -2822,8 +4115,6 @@
 	TEST_HASH_EMPTY (source->files);
 
 	nih_free (source);
-
-
 	/* Consume all available inotify instances so that the following
 	 * tests run without inotify.
 	 */
@@ -3309,6 +4600,8 @@
 	test_source_reload_conf_dir ();
 	test_source_reload_file ();
 	test_source_reload ();
+	test_toggle_conf_name ();
+	test_override ();
 	test_file_destroy ();
 	test_select_job ();
 

=== modified file 'init/tests/test_parse_job.c'
--- init/tests/test_parse_job.c	2010-12-14 16:20:38 +0000
+++ init/tests/test_parse_job.c	2011-01-17 15:53:13 +0000
@@ -64,7 +64,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -110,7 +110,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -131,6 +131,45 @@
 
 		nih_free (job);
 	}
+
+	TEST_FEATURE ("with non-NULL update parameter (override)");
+	{
+		JobClass *tmp = NULL;
+
+		strcpy (buf, "start on starting\n");
+		strcat (buf, "author \"me\"\n");
+
+		pos = 0;
+		lineno = 1;
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
+				&pos, &lineno);
+
+		TEST_NE_P (job, NULL);
+		TEST_EQ_STR (job->author, "me");
+		TEST_NE_P (job->start_on, NULL);
+
+		strcat (buf, "author \"you\"\n");
+		strcat (buf, "manual\n");
+		strcat (buf, "description \"my description\"\n");
+
+		pos = 0;
+		lineno = 1;
+  		tmp = parse_job (NULL, job, "test", buf, strlen (buf),
+				&pos, &lineno);
+		TEST_NE_P (tmp, NULL);
+
+		/* if passed a job, the same object should be returned.
+		 */
+		TEST_EQ_P (tmp, job);
+
+		TEST_EQ_STR (tmp->author, "you");
+		TEST_EQ_P (tmp->start_on, NULL);
+		TEST_NE_P (tmp->description, NULL);
+
+		TEST_EQ_STR (tmp->description, "my description");
+
+		nih_free (job);
+	}
 }
 
 void
@@ -153,7 +192,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -190,7 +229,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -229,7 +268,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -266,7 +305,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -299,7 +338,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -340,7 +379,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -379,7 +418,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -416,7 +455,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -447,7 +486,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -484,7 +523,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -524,7 +563,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -565,7 +604,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -604,7 +643,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -643,7 +682,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -680,7 +719,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -699,7 +738,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -718,7 +757,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -737,7 +776,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -768,7 +807,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -805,7 +844,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -845,7 +884,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -886,7 +925,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -925,7 +964,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -964,7 +1003,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1001,7 +1040,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1020,7 +1059,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1039,7 +1078,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1058,7 +1097,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1089,7 +1128,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1126,7 +1165,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1166,7 +1205,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1207,7 +1246,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1246,7 +1285,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1285,7 +1324,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1322,7 +1361,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1341,7 +1380,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1360,7 +1399,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1379,7 +1418,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1410,7 +1449,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1447,7 +1486,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1487,7 +1526,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1528,7 +1567,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1567,7 +1606,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1606,7 +1645,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1643,7 +1682,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1662,7 +1701,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1681,7 +1720,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1700,7 +1739,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -1731,7 +1770,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1776,7 +1815,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1828,7 +1867,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1879,7 +1918,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -1942,7 +1981,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2012,7 +2051,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2090,7 +2129,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2170,7 +2209,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2249,7 +2288,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2291,7 +2330,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2310,7 +2349,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2329,7 +2368,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2348,7 +2387,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2367,7 +2406,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2384,7 +2423,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2403,7 +2442,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2422,7 +2461,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2441,7 +2480,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2460,7 +2499,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2479,7 +2518,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2498,7 +2537,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2517,7 +2556,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -2551,7 +2590,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2586,7 +2625,7 @@
 	TEST_FEATURE ("manual stanza after start on");
 	strcpy (buf, "start on wibble\nmanual\n");
 
-	job = parse_job (NULL, "test", buf, strlen (buf),
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 			&pos, &lineno);
 
 	TEST_NE_P (job, NULL);
@@ -2616,7 +2655,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2661,7 +2700,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2713,7 +2752,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2764,7 +2803,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2827,7 +2866,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2897,7 +2936,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -2975,7 +3014,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3055,7 +3094,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3134,7 +3173,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3176,7 +3215,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3195,7 +3234,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3214,7 +3253,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3233,7 +3272,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3252,7 +3291,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3269,7 +3308,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3288,7 +3327,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3307,7 +3346,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3326,7 +3365,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3345,7 +3384,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3364,7 +3403,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3383,7 +3422,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3402,7 +3441,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3432,7 +3471,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3465,7 +3504,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3498,7 +3537,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3517,7 +3556,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3547,7 +3586,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3580,7 +3619,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3613,7 +3652,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3632,7 +3671,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3662,7 +3701,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3695,7 +3734,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3728,7 +3767,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3747,7 +3786,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3777,7 +3816,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3814,7 +3853,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3857,7 +3896,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3899,7 +3938,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -3929,7 +3968,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3962,7 +4001,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -3995,7 +4034,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4028,7 +4067,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4061,7 +4100,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4093,7 +4132,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4112,7 +4151,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4131,7 +4170,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4159,7 +4198,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4193,7 +4232,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4226,7 +4265,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4260,7 +4299,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4293,7 +4332,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4326,7 +4365,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4345,7 +4384,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4364,7 +4403,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4383,7 +4422,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4402,7 +4441,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4421,7 +4460,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4440,7 +4479,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4459,7 +4498,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4478,7 +4517,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4497,7 +4536,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4516,7 +4555,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4535,7 +4574,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4565,7 +4604,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4597,7 +4636,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4629,7 +4668,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4659,7 +4698,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4693,7 +4732,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4726,7 +4765,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4745,7 +4784,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4775,7 +4814,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4808,7 +4847,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -4840,7 +4879,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4859,7 +4898,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4878,7 +4917,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4897,7 +4936,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4916,7 +4955,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4935,7 +4974,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4954,7 +4993,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -4974,7 +5013,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5005,7 +5044,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5044,7 +5083,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5083,7 +5122,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5127,7 +5166,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5168,7 +5207,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5187,7 +5226,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5206,7 +5245,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5225,7 +5264,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5244,7 +5283,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5263,7 +5302,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5293,7 +5332,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5326,7 +5365,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5359,7 +5398,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5392,7 +5431,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5423,7 +5462,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5442,7 +5481,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5460,7 +5499,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5490,7 +5529,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5528,7 +5567,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5565,7 +5604,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5584,7 +5623,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5614,7 +5653,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5651,7 +5690,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5694,7 +5733,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5736,7 +5775,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5766,7 +5805,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5799,7 +5838,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5831,7 +5870,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5850,7 +5889,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5869,7 +5908,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5888,7 +5927,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5907,7 +5946,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5927,7 +5966,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -5957,7 +5996,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -5990,7 +6029,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6023,7 +6062,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6055,7 +6094,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6074,7 +6113,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6093,7 +6132,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6112,7 +6151,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6131,7 +6170,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6150,7 +6189,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6180,7 +6219,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6213,7 +6252,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6246,7 +6285,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6279,7 +6318,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6311,7 +6350,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6330,7 +6369,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6349,7 +6388,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6368,7 +6407,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6387,7 +6426,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6406,7 +6445,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -6435,7 +6474,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6469,7 +6508,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6503,7 +6542,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6537,7 +6576,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6571,7 +6610,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6606,7 +6645,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6641,7 +6680,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6675,7 +6714,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6710,7 +6749,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6744,7 +6783,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6778,7 +6817,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6812,7 +6851,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6847,7 +6886,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6881,7 +6920,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6917,7 +6956,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6956,7 +6995,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -6991,7 +7030,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -7026,7 +7065,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -7060,7 +7099,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7079,7 +7118,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7098,7 +7137,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7117,7 +7156,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7136,7 +7175,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7155,7 +7194,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7174,7 +7213,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7193,7 +7232,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7212,7 +7251,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7231,7 +7270,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7250,7 +7289,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7280,7 +7319,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -7314,7 +7353,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -7347,7 +7386,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7366,7 +7405,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7396,7 +7435,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -7430,7 +7469,7 @@
 	TEST_ALLOC_FAIL {
 		pos = 0;
 		lineno = 1;
-		job = parse_job (NULL, "test", buf, strlen (buf),
+		job = parse_job (NULL, NULL, "test", buf, strlen (buf),
 				 &pos, &lineno);
 
 		if (test_alloc_failed) {
@@ -7463,7 +7502,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 
@@ -7482,7 +7521,7 @@
 
 	pos = 0;
 	lineno = 1;
-	job = parse_job (NULL, "test", buf, strlen (buf), &pos, &lineno);
+	job = parse_job (NULL, NULL, "test", buf, strlen (buf), &pos, &lineno);
 
 	TEST_EQ_P (job, NULL);
 

=== modified file 'util/man/initctl.8'
--- util/man/initctl.8	2010-02-04 19:08:07 +0000
+++ util/man/initctl.8	2011-01-17 15:53:13 +0000
@@ -1,4 +1,4 @@
-.TH initctl 8 2010-02-04 "Upstart"
+.TH initctl 8 2011-01-12 "Upstart"
 .\"
 .SH NAME
 initctl \- init daemon control tool
@@ -157,8 +157,8 @@
 
 Requests that an instance of the named
 .I JOB
-be restarted, outputting the status of the job to standard output when the
-command completes.
+be restarted (stopped and then started), outputting the status of the
+job to standard output when the command completes.
 
 See
 .B status
@@ -249,10 +249,14 @@
 .\"
 .TP
 .B list
-
 Requests a list of the known jobs and instances, outputs the status of
 each to standard output.
 
+Note that this command enumerates as-yet-to-run jobs (in other words
+configuration files for which no job instances have yet been created) in
+the output with status "stop/waiting". In effect such entries denote
+configuration files which represent potential future jobs.
+
 See
 .B status
 for a description of the output format and