ChangeLog

2008-06-05  Scott James Remnant  <scott@netsplit.com>

	* init/event.h (event): Add blocking member.
	* init/event.c (event_new): Initialising blocking list.
	* init/tests/test_event.c (test_new): Make sure it's initialised
	to an empty list.

	* init/tests/test_job_process.c (test_handler): Update tests to use
	Blocked.

	* init/event.c (event_pending_handle_jobs): Collect environment
	and events independantly, which means we don't have to worry about
	the list contents or freeing them up in case of error.
	* init/event_operator.c (event_operator_events): Fix parent.
	* init/tests/test_event.c (test_pending_handle_jobs): Update tests.
	* init/init.supp: Update collect suppression.

	* init/event_operator.c (event_operator_collect): Break in two.
	(event_operator_environment): Collect the environment from the event,
	appending the list of event names if necessary.
	(event_operator_events): Block events and pass them to the
	given list.
	* init/event_operator.h: Update prototypes.
	* init/tests/test_event_operator.c (test_operator_collect): Also
	split into two new functions
	(test_operator_environment, test_operator_events): Adjust

	* init/event_operator.c (event_operator_collect): Placed Blocked
	structures in the list, rather than ordinary entries; I strongly
	suspect that while it's nice to iterate the operator tree only once,
	this needs to be three functions really.
	* init/tests/test_event_operator.c (test_operator_collect): Update
	test suite.

	* init/job.h (Job): Make blocking a statically defined list.
	* init/job.c (job_new): Initialise rather than setting to NULL.
	(job_unblock): Assume that blocking members are Blocked structures
	and that the list itself is always iterable.
	* init/tests/test_job.c (test_new): Check the list is empty, rather
	than NULL.
	(test_change_state, test_failed, test_unblock): Change tests cases
	to expect blocking to always be present, and create members as Blocked
	structures.

	* init/blocked.c (blocked_new): Set destructor (forgotten)

	* init/init.supp: Add setenv, which has crept in

	* init/blocked.h: Header containing enum, struct and prototype.
	* init/blocked.c (blocked_new): Function to allocate the structure
	with the right details.
	* init/tests/test_blocked.c (test_new): Tests for the new function.
	* init/Makefile.am (init_SOURCES): Compile using blocked.c and header
	(TESTS): Build blocked test suite
	(test_process_LDADD, test_job_class_LDADD)
	(test_job_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_event_operator_LDADD, test_parse_job_LDADD)
	(test_parse_conf_LDADD, test_conf_LDADD, test_control_LDADD):
	Link blocked.o to most test suites.
	(test_blocked_SOURCES, test_blocked_LDFLAGS, test_blocked_LDADD):
	Details for test suite.

	* init/main.c: Also remove SIGTERM handling, we don't re-exec
	properly and this is a dangerous signal to use anyway.
	(term_handler): Drop function.

	* init/main.c: Remove handling for stop/cont; there's no reason
	a user should be able to pause the event queue.
	(stop_handler): Drop function.
	* init/event.c (event_poll): Remove paused handling.

	* init/control.c: Fix doc string.

	* dbus/com.ubuntu.Upstart.xml (ReloadConfiguration): Add method
	that's effectively the same as the HUP signal.
	* init/control.c (control_reload_configuration): Unsurprisingly,
	the implementation is identical.
	* init/control.h: Add prototype.
	* init/tests/test_control.c (test_reload_configuration): Make sure
	the method works as expected.
	(test_get_job_by_name, test_get_all_jobs): Add missing free calls for
	message in cases of out of memory.

	* dbus/com.ubuntu.Upstart.xml (JobAdded, JobRemoved): Add signals
	for when new jobs are added to the known list and when existing jobs
	are removed, this allows GUIs to always show an up-to-date list.
	* dbus/com.ubuntu.Upstart.Job.xml (InstanceAdded, InstanceRemoved):
	Also add matching signals for when instances are added to the list
	for a job and when they're removed again.
	* init/job_class.c (job_class_register): Emit the JobAdded signal
	for this job when registering if the new signal argument is TRUE;
	pass on the signal argument to job_register()
	(job_class_add): Emit signals when registering jobs with existing
	connections.
	(job_class_unregister): Emit signals when unregistering a job.
	* init/job.c (job_register): Likewise, emit the InstanceAdded signal
	for the job class if the new signal argument is TRUE.
	(job_new): Emit signals when registering instances with existing
	connections.
	(job_change_state): Emit the instance removed signal when destroying
	an inactive instance.
	* init/job_class.h, init/job.h: Add signal argument to prototypes
	* init/control.c (control_register_all): When registering job classes
	on a new connection, do not emit a signal since they will already
	exist at the point when the name appears on the bus or the connection
	is complete.
	* init/tests/test_control.c (test_bus_open): Add comment that we
	are testing for signal non-emission already with the fake server,
	since it was this test that actually made me realise we had to
	not emit them :p
	* init/tests/test_job_class.c (test_register): Test that the signal
	is emitted when signal is TRUE and not emitted when signal is FALSE
	(test_unregister): Test that the JobRemoved signal is emitted
	(test_get_instance_by_name, test_get_all_instances): Free message
	if allocation failed.
	(test_consider, test_reconsider): Test that the JobAdded and
	JobRemoved signals are emitted (or not) when appropriate.
	* init/tests/test_job.c (test_register): Make sure that the
	InstanceAdded signal is emitted when TRUE is passed, and not when
	FALSE is passed.
	(test_new): Make sure the InstanceAdded signal is emitted when the
	job is registered on the bus.
	(test_change_state): Make sure the InstanceRemoved signal is sent
	when deleting an instance.

2008-06-02  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_job.c (test_new, test_register): Also use a private
	dbus server to avoid session bus problems.

	* init/tests/test_job_class.c (test_consider, test_reconsider)
	(test_register, test_unregister): Use a private dbus server instead
	of connecting to the session bus, which might not be there.

	* init/tests/test_control.c (test_disconnected): Simplify using a
	private dbus server rather than faking one.

	* init/tests/test_control.c (test_bus_close): Don't rely on being
	able to connect to the various buses, instead use a special private
	one.

2008-06-01  Scott James Remnant  <scott@netsplit.com>

	* dbus/com.ubuntu.Upstart.Job.xml (GetAllInstances): And also add
	a similar method to return the object path of all instances of a
	particular job.
	* init/job_class.c (job_class_get_all_instances): Implement the
	method, pretty much the same as the other.
	* init/job_class.h: Add prototype.
	* init/control.c: Fix comment.
	* init/tests/test_control.c (test_get_all_jobs): Ensure that the
	individual paths are children of the array.

	* dbus/com.ubuntu.Upstart.xml (GetAllJobs): Add method to return
	the object path of all known jobs.
	* init/control.c (control_get_all_jobs): Implement the method,
	somewhat simple happily.
	* init/control.h: Add prototype for the method.
	* init/tests/test_control.c (test_get_all_jobs): Test that the
	right data is returned.

	* dbus/com.ubuntu.Upstart.xml, dbus/com.ubuntu.Upstart.Job.xml,
	* dbus/com.ubuntu.Upstart.Instance.xml: Add libnih XML NS to the
	files so that we can tag methods as sync or async later.

	* init/control.c (control_get_job_by_name): Remove const from
	return parameter.
	* init/control.h: Update prototype.
	* init/tests/test_control.c (test_get_job_by_name): Remove const
	from path type.

	* init/job_class.c (job_class_get_instance_by_name): Remove wrong
	const from parameter now that we've fixed the bindings generator.
	* init/job_class.h: Update prototype to match.
	* init/tests/test_job_class.c (test_get_instance_by_name): Change
	type of path to match.

	* HACKING (Dependencies): clarify that autoreconf and configure need
	to be run for libnih first.

	* init/Makefile.am (test_process_LDADD, test_job_class_LDADD)
	(test_job_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_event_operator_LDADD, test_parse_job_LDADD)
	(test_parse_conf_LDADD, test_conf_LDADD, test_control_LDADD): Link
	the auto-generated D-Bus code in, otherwise the tests won't be
	complete.

2008-05-24  Scott James Remnant  <scott@netsplit.com>

	* HACKING: Changed branch location again, of both upstart and
	libnih.

2008-05-16  Scott James Remnant  <scott@netsplit.com>

	* init/job_class.c (job_class_consider, job_class_reconsider): Find
	the best class first and compare against the current class before
	acting, this avoids the re-register jump every time a job stops.
	(job_class_select): Rename to job_class_add() since this is takes
	a class and is the direct opposite to job_class_remove().

2008-05-15  Scott James Remnant  <scott@netsplit.com>

	* init/event.c (event_new): We can't rely on the event poll function
	being the last in the main loop, it's often the first, so after
	adding an event to the queue ensure the loop is iterated at least
	once so that the event poll occurs for it.

2008-05-09  Scott James Remnant  <scott@netsplit.com>

	* TODO (Anytime): Update.

	* dbus/com.ubuntu.Upstart.Instance.xml: format to match others

	* dbus/com.ubuntu.Upstart.Job.xml (GetInstanceByName): Add method
	* init/job_class.c (job_class_get_instance_by_name): Implementation.
	* init/job_class.h: Add prototype.
	* init/tests/test_job_class.c (test_get_instance_by_name): Tests
	for new method.

	* init/job_class.h (JobClass): Make instances a hash table.
	* init/job_class.c (job_class_new): Initialise instances as a hash
	table now.
	(job_class_register): Iterate instances as hash table.
	(job_class_remove): Slightly odd construct needed to return FALSE
	if there's anything in the hash table.
	(job_class_unregister): Likewise to assert on no instances.
	* init/tests/test_job_class.c (test_new): Check that instances is
	now a hash table.
	* init/job.h (Job): Make name the first member.
	* init/job.c (job_new): Add to instances as hash table.
	(job_instance): Drop entirely, replaced by a hash lookup.
	* init/tests/test_job.c (test_instance): Drop.
	* init/job_process.c (job_process_find): Iterate instances as a
	hash table.
	* init/event.c (event_pending_handle_jobs)
	(event_finished_handle_jobs): Iterate instances as hash table.
	(event_pending_handle_jobs): Replace job_instance call with an
	ordinary hash lookup.
	* init/tests/test_event.c: Update to use hash table.
	* init/tests/test_conf.c: Update instances stealing for hash table

	* init/job_class.c (job_class_new): initialise instance to the
	empty string.
	* init/tests/test_job_class.c: Update job_new() calls.
	(test_new): Check instance against the empty string.
	* init/job.c (job_new): name may no longer be NULL.
	* init/tests/test_job.c: Update job_new() calls.
	(test_instance): Reset back to "" when done.
	* init/event.c (event_pending_handle_jobs): Always expand the
	name, since the class->instance is always non-NULL.
	* init/tests/test_event.c: Update job_new calls.
	* init/tests/test_conf.c: Update job_new calls.
	* init/tests/test_job_process.c: Update job_new calls.

	* init/job.c (job_new): Singleton jobs have a fixed name of "",
	rather than a NULL name, and a D-Bus name of "_".
	(job_instance): Which rather simplifies this function (in fact,
	it makes this function look like a common one).
	(job_emit_event): Always set INSTANCE variable.
	(job_name): Still distinguish in output, to avoid ugly "()" but
	check character rather than NULL.
	* init/tests/test_job.c (test_new): Check name is set to ""
	and path to ".../_"
	(test_change_state, test_emit_event): Update test cases to assume
	an empty INSTANCE variable
	(test_instance): Update to pass "" instead of NULL.
	* init/job_process.c (job_process_run): Always set UPSTART_INSTANCE
	* init/tests/test_job_process.c (test_run): Always assume an
	UPSTART_INSTANCE variable, it may just be empty.
	* init/tests/test_event.c (test_pending_handle_jobs): Expect
	the name to be set to the empty string.

	* init/Makefile.am (com.ubuntu.Upstart.c com.ubuntu.Upstart.h)
	(com.ubuntu.Upstart.Job.c com.ubuntu.Upstart.Job.h)
	(com.ubuntu.Upstart.Instance.c com.ubuntu.Upstart.Instance.h):
	Drop setting of data-type, turns out it doesn't work anyway.

	* dbus/Upstart.conf: Add configuration file.
	* dbus/Makefile.am (dbussystemdir, dist_dbussystem_DATA): Install
	the configuration file into the right place.

	* dbus/com.ubuntu.Upstart.xml (GetJobByName): Add method
	* init/control.c (control_get_job_by_name): Implementation.
	* init/control.h: Prototype.
	* init/tests/test_control.c (test_get_job_by_name): Test the
	method using a fake message.

2008-05-08  Scott James Remnant  <scott@netsplit.com>

	* dbus/com.ubuntu.Upstart.xml, dbus/com.ubuntu.Upstart.Job.xml,
	* dbus/com.ubuntu.Upstart.Instance.xml: Add DTDs.

	* init/control.c (manager_interfaces): Export the general
	com.ubuntu.Upstart interface
	* init/job_class.c (job_class_interfaces): Export the
	com.ubuntu.Upstart.Job interface
	* init/job.c (job_interfaces): Export the
	com.ubuntu.Upstart.Instance interface

	* init/Makefile.am (BUILT_SOURCES)
	(com.ubuntu.Upstart.c com.ubuntu.Upstart.h)
	(com.ubuntu.Upstart.Job.c com.ubuntu.Upstart.Job.h)
	(com.ubuntu.Upstart.Instance.c com.ubuntu.Upstart.Instance.h):
	Generate C code and header files from the XML files which produce
	object bindings.
	(init_SOURCES): Link the built sources.
	(CLEANFILES): Clean them up afterwards

	* dbus/com.ubuntu.Upstart.xml: Initially empty description for
	manager object interface(s).
	* dbus/com.ubuntu.Upstart.Job.xml: Initially empty description
	for job class object interface(s).
	* dbus/com.ubuntu.Upstart.Instance.xml: Initially empty
	description for job instance object interface(s).
	* dbus/Makefile.am: Distribute the three interface files,
	they're used as sources elsewhere.
	* configure.ac (AC_CONFIG_FILES): Generate dbus/Makefile
	* Makefile.am (SUBDIRS): Descend into the dbus sub-directory.

	* init/job_class.c (job_class_consider, job_class_reconsider):
	Separate out the actual meat of the functions, since it's largely
	duplicated between the two.  This makes the difference between
	the two functions clearer, consider always stages an election
	no matter which is registered, reconsider only stages an election
	if the current class is registered.
	(job_class_select, job_class_remove): Functions containing the
	common code, which now also handle registering and unregistering
	the class with D-Bus.  Here is the right place, not in new, since
	we only export the current best class of a given name.
	(job_class_register, job_class_unregister): Function to register
	a job and its instances, and to unregister a job (we assert that
	there must be no instances for us to do this).
	* init/job_class.h: Add prototypes.
	* init/tests/test_job_class.c (test_consider, test_reconsider):
	Check that D-Bus registration and unregistration happens as
	expected.
	(test_register, test_unregister): test on their own.
	* init/job.c (job_new): Register instances with D-Bus, since
	instances can only ever exist for active classes, all instances
	are always registered on the bus.
	(job_register): Function to register an instance on the bus.
	* init/job.h: Add prototype.
	* init/tests/test_job.c (test_new): Test creating a job with an
	active d-bus connection, which should have it registered.
	(test_register): Test registration on its own.
	* init/control.c (control_register_all): Make this always succeed,
	and register existing jobs on the new connection.
	(control_server_connect, control_bus_open): registration is
	always successful.
	* init/tests/test_control.c (test_server_connect, test_bus_open):
	Test with existing jobs when we get a connection or create the
	bus connection, ensure that the jobs and instances are registered.

	* init/tests/test_job.c (test_change_state): Check for a bug where
	a job with multiple instances will be freed when one instance is
	deleted rather than the last instance.
	* init/job.c (job_change_state): Add debugging messages when we
	destroy a job that's no longer the current one or an instance
	that's no longer active; also ensure that we never destroy a job
	that's the current one.
	* init/event.c (event_pending_handle_jobs): Add a debugging message
	when we create a new instance of a job.
	* init/conf.c (conf_file_destroy): Add a debugging message when
	we destroy a job that's no longer the current one.

2008-05-07  Scott James Remnant  <scott@netsplit.com>

	* init/control.c (control_server_open, control_server_close)
	(control_server_connect): Create and manage a listening d-bus server
	that is used for private direct connections to Upstart for when the
	d-bus daemon is not available.  Each new connection has the same
	objects as the d-bus system bus, they only differ in their method.
	(control_conns, control_init): Cache the open connections, including
	the bus daemon and any private connections; we'll iterate this list
	when sending signals.
	(control_bus_open): Store connection in the list, don't worry about
	setting close-on-exec, we check that by test case and rely on d-bus
	to do it.
	(control_bus_disconnected): Rename to control_disconnected
	(control_disconnected): Work for system bus and private connections,
	remove from the connections list.
	* init/control.h: Add prototypes, remove global definition of bus
	name to just being private again.
	* init/tests/test_control.c (test_server_open, test_server_close)
	(test_server_connect): Test the new functions.
	(test_bus_open): add check for list entry
	(test_bus_disconnected): rename to test_disconnected
	* init/main.c: Open the listening server, warning if we're unable
	to do so (but we won't treat it as a hard error since there's the
	d-bus daemon as the default anyway).
	* init/init.supp: suppress the fact that the control connections
	list stays around.

	* init/job_process.c (job_process_run): Use NIH_ZERO instead of
	NIH_MUST and == 0

2008-05-06  Scott James Remnant  <scott@netsplit.com>

	* init/environ.c (environ_expand_until): Odd gcc optimiser warning,
	it reckons arg_start and end may be used uninitialised, but I don't
	see how they can be.

	* init/main.c (main): Warn if we can't set the root directory.
	* init/job_process.c (job_process_spawn)
	(job_process_error_abort): loop on the return of write()
	* init/tests/test_job_process.c (child, main): assert getcwd() works
	(test_handler): initialise list and entry for gcc's blind spot.
	(test_run): initialise ret for gcc's blind spot
	* init/tests/test_job.c (test_name): jump through hoops for gcc
	(test_change_state): list and entry.
	* init/tests/test_event.c (test_finished_handle_jobs, test_finished)
	(test_pending_handle_jobs, test_poll, test_pending): initialise to
	NULL and buy gcc glasses
	* init/tests/test_event_operator.c (test_operator_collect): another
	NULL to make gcc happy.

2008-05-01  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* init/init.supp: Suppress a few test case artefacts caused by
	valgrind hating reachable memory at exec() time.

	* init/tests/test_job_process.c: Fix a few cases where we were
	still dup'ing the name argument to job_new().
	* init/tests/test_parse_job.c: Include missing signal.h

	* init/event.c (event_pending_handle_jobs)
	(event_finished_handle_jobs): Land the old job event handling
	functions here as static functions, right now they're immense but
	we'll actually move much of the code back out again as we go.
	* init/tests/test_event.c (test_pending_handle_jobs)
	(test_finished_handle_jobs): Also land the test cases in renamed
	and somewhat restructued functions, since we now have to do the
	testing through event_poll().
	(test_poll, test_pending, test_finished): It never hurts to improve
	test cases while you're in there.

2008-04-30  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_change_state): Change calls to job_process_run
	and job_process_kill.
	* init/main.c: Change to job_process_handler

	* init/job_process.c, init/job_process.h: Land the code from job.c
	and defs from job.h that deal specifically with a job's processes,
	rename the functions to job_process_*() in the process.
	* init/tests/test_job_process.c: And land the test cases as well.

	* init/job.c: Strip of everything not related to creation and finding
	of instances and the core state machine; process stuff will move to
	job_process.c and event handling to event.c, class (nee config) stuff
	is already moved to job_class.c
	(job_new): Don't reparent the name, it doesn't help anything, just
	take a copy.
	(job_name, job_failed, job_unblock, job_emit_event): Make extern since
	we need to use these outside or just want to test them.
	* init/job.h: Clean out also.
	* init/tests/test_job.c: Also clean out.
	(test_name, test_failed, test_unblock, test_emit_event): Add test cases
	for newly extern functions.

	* init/main.c: Include events.h to get the ones we need.

	* init/control.c (control_job_config_path, control_job_path)
	(control_path_append): Drop these functions (replaced by the more
	generic nih_dbus_path() function)
	* init/control.h: Make CONTROL_ROOT public, and drop other prototypes.
	* init/tests/test_control.c (test_job_config_path)
	(test_job_path): Drop tests.

2008-04-29  Scott James Remnant  <scott@netsplit.com>

	* init/event.c, init/event.h, init/tests/test_event.c: Strip out the
	event operator code and events list.

	* init/job_class.c, init/job_class.h: We only need the event operator
	code here now.

	* init/events.h, init/event_operator.c, init/event_operator.h,
	init/tests/test_event_operator.c: Separate out the event operator
	code and the list of events into separate source files.
	* init/Makefile.am (init_SOURCES): Build and link event operator code
	and use the lists of events.
	(TESTS): Build and run the event operator test suite.
	(test_event_operator_SOURCES, test_event_operator_LDFLAGS)
	(test_event_operator_LDADD): Details for the event operator test
	suite.
	(test_process_LDADD, test_job_class_LDADD)
	(test_job_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_parse_job_LDADD, test_parse_conf_LDADD, test_conf_LDADD)
	(test_control_LDADD): Link the event operator code.

	* init/job_class.c, init/main.c: Correct includes and some function
	names.

	* init/process.c, init/process.h, init/tests/test_process.c: Land
	original Process code (used by job class and similar).

	* init/process.c, init/process.h, init/tests/test_process.c: Break
	into two pieces, one part becomes job_process which requires both
	job information and process information, the other becomes system
	which requires no job information.
	* init/errors.h: Update error name.
	* init/Makefile.am (init_SOURCES): Build and link job process code
	and header along with system code and header.
	(TESTS): Build and run job process and system test suites.
	(test_job_process_SOURCES, test_job_process_LDFLAGS)
	(test_job_process_LDADD): Details for job process test suite.
	(test_system_SOURCES, test_system_LDFLAGS, test_system_LDADD):
	Details for system test suite.
	(test_process_LDADD, test_job_class_LDADD, test_job_LDADD)
	(test_event_LDADD, test_parse_job_LDADD, test_parse_conf_LDADD)
	(test_conf_LDADD, test_control_LDADD): Link job process and system
	code.

	* init/parse_conf.c: Remove parse_job include.

	* init/init.supp: Update leak check for class init; remove
	valgrind workaround since it's gone away with the change of that
	function.

	* init/conf.h (ConfFile): Change type of job member, but leave name.
	Add prototype for new function.
	* init/conf.c (conf_reload_path): Somewhat simplify the case of
	having parsed a job, we only need to call job_class_consider() now
	to have it dealt with.
	(conf_file_destroy): Likewise after removing the ConfFile from the
	source (so it won't get considered) and marking the job class as
	deleted, we only need to call job_class_reconsider() and check the
	return value to see whether we've been replaced.
	(conf_select_job): In return we provide the function to decide which
	of the available job sources is the best one.
	* init/tests/test_conf.c: Update types in tests.
	(test_select_job): Test the new function.

	* init/parse_job.h: Update to include job_class.h and update prototype
	to return JobClass, we'll keep the name though since we'll never
	parse jobs and otherwise things get annoying.
	* init/parse_job.c: Update to work on job classes.
	* init/tests/test_parse_job.c: Update to match.

	* init/job_class.h (JobClass): Factor out old JobConfig object into
	a new JobClass object with the same properties, but in its own source
	file.
	(ExpectType): Rename old JobExpect to this to match other enums.
	(ConsoleType): Move along with the object that uses it.
	* init/job_class.c (job_class_init, job_class_new)
	(job_class_environment): Bring along methods that only operate on
	a JobClass, cleaning them up in the process.
	(job_class_consider, job_class_reconsider): Replace job_config_replace
	with these two functions that may be used for a new job class and
	when discarding or finishing with an old one respectively.
	* init/tests/test_job_class.c: Tests for the functions.
	* init/Makefile.am (init_SOURCES): Build and link job class source
	and header.
	(TESTS): Build and run job class test suite.
	(test_job_class_SOURCES, test_job_class_LDFLAGS)
	(test_job_class_LDADD): Details for job class test suite.
	(test_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_parse_job_LDADD, test_parse_conf_LDADD, test_conf_LDADD)
	(test_control_LDADD): Link job class code to other tests too.

2008-04-28  Scott James Remnant  <scott@netsplit.com>

	* init/control.c (control_job_config_path, control_job_path): Add
	functions to generate D-Bus object paths for jobs and instances
	(control_path_append): and a static function used by both to append
	escaped path elements.
	* init/control.h: Add prototypes.
	* init/tests/test_control.c (test_job_config_path)
	(test_job_path): Add test cases for the new functions.
	* init/job.h (JobConfig, Job): Add path member to both structures.
	* init/job.c (job_config_new, job_new): Initialise the path members.
	* init/tests/test_job.c (test_config_new, test_new): Make sure
	the path members are initialised to something sensible.
	* init/init.supp: Valgrind whines, I do not know why.

	* init/control.c (control_bus_open): Call out to register objects
	on the new bus connection.
	(control_register_all): Start off by registering the connection
	manager object, no methods/signals for now.
	* init/tests/test_control.c (test_bus_open): Make sure the manager
	object is registered.

2008-04-27  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_control.c (test_bus_open): Correct name of
	error macro.

	* init/job.c (job_emit_event): Make INSTANCE the second variable.
	* init/tests/test_job.c (test_next_state): Update tests.

2008-04-25  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_control.c (test_bus_open): Use D-bus macros for
	error strings instead of naming them by hand.

2008-04-22  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_control.c (test_bus_close): Add another missing
	call to dbus_shutdown.

2008-04-21  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_control.c (test_bus_open): Under valgrind we seem
	to get NoReply instead of Disconnected which is a wee bit odd.
	Add missing call
	(test_bus_disconnected): Add missing call to dbus_shutdown.

2008-04-19  Scott James Remnant  <scott@netsplit.com>

	* init/process.c: Add missing limits.h include

	* init/job.h (JobConfig): Merge instance and instance_name; if
	instance is set, the job is multi-instance with the name derived
	from that; if unset the job is singleton.  We will not support
	unlimited instances.
	* init/job.c (job_config_new): Initialise instance to NULL.
	(job_new): Assert that name is set for instance jobs.
	(job_instance): Alter to only deal with singleton and instance
	jobs, the unlimited instances case is gone.
	(job_handle_event): Use instance instead of instance_name
	* init/tests/test_job.c (test_config_new): Check instance is NULL
	(test_find_by_pid): Adjust the way instance jobs are made, which
	means we have to pass a name to job_config_new now.
	(test_instance): Adjust tests to remove unlmited-instance tests
	and pass name to job_config_new
	(test_change_state, test_run_process): Pass instance name to
	job_new as an allocated argument rather than waiting to set it
	until afterwards.
	(test_handle_event): Set instance instead of instance_name
	* init/parse_job.c (stanza_instance): Make the argument mandatory.
	* init/tests/test_parse_job.c (test_stanza_instance): Remove the
	checks for without argument, and make sure that without argument
	is an error.

	* init/parse_job.c (stanza_oom): Oops, forgot to free never arg.

	* init/job.h (JobConfig): NihList is rather overkill for emits,
	which is static configuration; turn into a NULL-terminated array
	which'll make it easier to turn into a D-Bus property later.
	* init/job.c (job_config_new): Initialise to NULL now.
	* init/tests/test_job.c (test_config_new): Make sure it's NULL.
	* init/parse_job.c (stanza_emits): Store in an array instead.
	* init/tests/test_parse_job.c (test_stanza_emits): Redo tests.

	* init/job.c (job_emit_event): Append exported variables to the
	job event without overwriting the builtins.
	* init/tests/test_job.c (test_change_state): Check that exported
	environment is added to the job events.

	* init/parse_job.c (stanza_export): Parse a new export stanza,
	which takes one or more environment variable names.
	* init/tests/test_parse_job.c (test_stanza_export): Test the new
	stanza.

	* init/job.h (JobConfig): Add new export member.
	* init/job.c (job_config_new): Initialise to NULL.
	* init/tests/test_job.c (test_config_new): Make sure it's NULL.

	* init/environ.c (environ_add, environ_set): Add a replace argument
	which when FALSE does not replace existing entries in the environment
	table.
	* init/environ.h: Adjust prototypes.
	* init/tests/test_environ.c (test_add): Add tests for non-replacement
	mode, including corner cases.
	(test_set): Replace should be TRUE in this test.
	* init/event.c (event_operator_collect): Always replace existing
	environment members.
	* init/job.c (job_config_environment, job_run_process): Always replace
	existing environment members.
	(job_emit_event): Always replace existing environment members, and
	rework this function to get rid of the confusing gotos.

	* init/tests/test_job.c (test_change_state): Add tests to make sure
	we include the INSTANCE variable in the event environment.

2008-04-18  Scott James Remnant  <scott@netsplit.com>

	* init/process.c (process_kill): Make sure we do send the signal to
	the process group; in practice this makes no difference, but it pays
	to be explicit in such things.
	* init/tests/test_process.c (test_kill): Add a test case for when
	the session leader is no more.

	* init/job.h (JobConfig): Another day, another obscure job config
	detail.  This one is for adjusting how likely you are to be killed
	by the OOM Killer.
	* init/job.c (job_config_new): Set to zero by default.
	* init/tests/test_job.c (test_config_new): And make sure it is zero.
	* init/parse_job.c (stanza_oom): And it helps to have a function
	to set that one.
	* init/tests/test_parse_job.c (test_stanza_oom): Test it.
	* init/errors.h: And we need an error if its out of bounds.
	* init/conf.c (conf_reload_path): Which also needs to be caught.
	* init/process.c (process_spawn): Of course, we have to do something
	with the oom adjustment.
	(process_error_read): message for failure error.
	* init/process.h (processErrorType): And need an error if it fails

	* init/main.c: Drop the legacy configuration directory, the format
	of jobs has changed sufficiently to not support it.
	* init/Makefile.am (AM_CPPFLAGS): Remove LEGACY_CONFDIR definition.
	(install-data-local): Don't create it, either.

	* init/enum.c, init/enum.h, init/tests/test_enum.c: Remove these
	source files, a hold-over from when we had them in a separate
	library and passed around the integer values.
	* init/job.c, init/job.h, init/tests/test_job.c: Restore in their
	proper place.
	* init/Makefile.am: Remove enum.* from build instructions.

	* init/main.c: Attempt to connect to the system bus on startup,
	but don't expect it to work.

	* init/control.c (control_bus_open, control_bus_disconnected)
	(control_bus_close): Functions to open a connection to the D-Bus
	system bus, clean up if disconnected or disconnect ourselves
	explicitly.
	* init/control.h: Prototypes.
	* init/tests/test_control.c (test_bus_open)
	(test_bus_disconnected, test_bus_close): Test the functions using
	a fake D-Bus system bus daemon.
	* init/errors.h: Add error for "name taken".
	* init/Makefile.am (init_SOURCES): Build and link control.c and
	control.h
	(TESTS): Build and run control test suite.
	(test_control_SOURCES, test_control_LDFLAGS, test_control_LDADD):
	Details for control test suite.
	(test_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_parse_job_LDADD, test_parse_conf_LDADD, test_conf_LDADD):
	Link control.o

2008-04-16  Scott James Remnant  <scott@netsplit.com>

	* init/job.h (JobConfig): Add leader member.
	* init/job.c (job_config_new): Initialise leader to FALSE.
	* init/tests/test_job.c (test_config_new): Make sure leader is FALSE.
	(test_change_goal, test_change_state, test_run_process)
	(test_kill_process, test_child_handler, test_handle_event)
	(test_handle_event_finished): Jobs have to be leaders now to allow
	waitpid() to work in test cases.
	* init/parse_job.c (stanza_session): Parse "session leader" stanza
	to set to TRUE.
	* init/tests/test_parse_job.c (test_stanza_session): Test new
	stanza parsing.
	(test_stanza_console): Add missing "missing argument" test.
	* init/process.c (process_error_read): Deal with new fork error.
	(process_spawn): If we're not to be a session leader, fork again and
	write the pid back on the open socket.
	* init/process.h (ProcessErrorType): Introduce new fork error.
	* init/tests/test_process.c (test_spawn): Test that we can't start
	a non-session-leader and still have process details.
	(test_spawn, test_kill): Other jobs have to be leaders now to
	allow waitpid() to work.
	* init/tests/test_event.c (test_poll): Jobs have to be leaders now
	to allow waitpid() to work.

2008-04-12  Scott James Remnant  <scott@netsplit.com>

	* configure.ac (NIH_INIT): Require that libnih build D-Bus support,
	failing configure if we can't get it.
	* init/Makefile.am (AM_CFLAGS): Build with D-Bus CFLAGS,
	(init_LDADD, test_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_parse_job_LDADD, test_parse_conf_LDADD, test_conf_LDADD): and
	link with libnih-dbus.la and D-Bus LIBS.
	(init_LDFLAGS): No need for -static now since libnih will only exist
	statically anyway.

	* init/main.c: Use a better name for kbdrequest
	* init/event.h (KBDREQUEST_EVENT): Rename event to keyboard-request

	* init/main.c: Drop the attempt to rescue a crashed system by
	carrying on with no state
	(crash_handler): After the child has core dumped, the parent will
	die and the kernel will panic.  That's the best we can do, I think.

	* init/job.c (job_change_state): Don't generate the stalled event;
	there's nothing useful you can do with it other than start a root
	shell and that's just a security hole waiting to happen.
	(job_new): Don't increment the instances counter.
	* init/job.h: Remove extern for instances counter.
	* init/tests/test_job.c (test_new): Remove the check that the
	instance counter is incremented.
	(test_change_state): Remove the test for the stalled event.
	* init/event.h (STALLED): Remove stalled event definition,
	* TODO: Update.

	* init/job.h (Job): And while we're at it, the instance name is
	guaranteed unique for a given job name, which is also guaranteed
	to be unique - so don't bother with job ids either, since they
	also get reused in bad cases.
	* init/job.c (job_next_id): Drop this function.
	(job_new): Don't assign an id anymore.
	(job_find_by_id): Drop this function.
	(job_run_process): Set UPSTART_INSTANCE to the instance name if set.
	(job_name): Function to create the string used in messages.
	(job_change_goal, job_change_state, job_run_process)
	(job_kill_process, job_kill_timer, job_child_handler)
	(job_process_terminated, job_process_trace_new)
	(job_process_trace_new_child, job_process_trace_signal)
	(job_process_trace_fork, job_process_trace_exec): Use the instance
	name in messages (if set) in place of the job id.
	* init/tests/test_job.c (test_new): Drop checks on the id field.
	(test_find_by_id): Drop test.
	(test_run_process): Check that UPSTART_INSTANCE is set only for
	named job instances, and contains the instance name.
	(test_change_state, test_run_process, test_child_handler): Remove
	id setting and update error message checks.
	* TODO: Update.

	* init/event.h (Event): We don't use the id field for anything;
	and it can't be guaranteed to be unique since it can wrap over
	and get reused.  Drop it.
	* init/event.c (event_next_id): Drop this function.
	(event_new): Don't assign an id anymore.
	(event_find_by_id): Drop this function.
	* init/tests/test_event.c (test_new): Drop checks on the id field
	(test_find_by_id): Drop test.
	(test_poll): Drop id setting which was needless anyway.

2008-04-11  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_job.c (test_child_handler): Add tests to make
	sure that respawn works for both services and tasks; the only
	difference we want for tasks is that zero is a normal exit code.
	* init/job.c (job_process_terminated): Status need not be non-zero
	if the job is not a task.

	Change the default job type from task to service, which will
	finally match people's expectations.

	* init/job.h (JobConfig): Replace service member with task
	* init/job.c (job_config_new): Initialise task to FALSE
	(job_change_state): Unblock if not a task instead of if a service
	* init/tests/test_job.c (test_config_new): Make sure task is FALSE
	(test_change_state): Check service by default, task with flag;
	this also means we expect blockers to be cleared if we end up in
	running for the other checks
	(test_child_handler): Expect blockers to be cleared if we end up
	in running now that service is the default.
	* init/tests/test_event.c (test_poll): Test with a task since
	we want to remain blocked for longer.
	* init/parse_job.c (stanza_respawn): Don't set service to TRUE
	(stanza_service): Rename to stanza_task and set task flag instead
	* init/tests/test_parse_job.c (test_stanza_respawn): Remove checks
	for setting of service flag
	(test_stanza_service): Rename to test_stanza_task and test task

	* init/job.c (job_init): Create hash using nih_hash_string_new()
	* init/conf.c (conf_source_new): Likewise.

2008-03-08  Scott James Remnant  <scott@netsplit.com>

	* HACKING: Terminology changes: Bazaar-NG is now just Bazaar;
	Malone is now just Launchpad's bug tracking system.  Update bugs
	URL to match modern form.

	* init/enum.h (JobWaitType): Rename to JobExpect
	* init/job.h (JobConfig): Rename wait_for to expect
	* init/job.c (job_config_new, job_change_state, job_run_process)
	(job_process_stopped, job_process_trace_new_child): Rename wait_for
	to expect in all occurances.
	* init/tests/test_job.c: Likewise rename all occurances.
	* init/parse_job.c (stanza_wait): Rename to stanza_expect and drop
	the intermediate argument.
	* init/tests/test_parse_job.c (test_stanza_wait): Rename to
	test_stanza_expect and adjust tests to match new syntax.
	* init/tests/test_process.c (test_spawn): Remove set of wait_for.

	* doc/states.dot: Remove the state transition from starting to
	waiting ("emit_stopped" in the graph); we don't have a "respawning
	too fast" exit here anymore, so always go to stopping.
	* doc/states.png: Regenerate.

	* TODO: Document the problems with overflowing ids and instance
	counter before I forget about them.

2008-03-07  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* init/job.h (JobConfig): Add instance_name member.
	(Job): Add name member.
	* init/job.c (job_config_new): Initialise instance name to NULL.
	(job_new): Accept the name as an argument, reparenting and stealing
	(job_handle_event): Expand the instance name and pass to job_new
	(job_instance): Accept a name and look that up in the list of current
	instances returning the instance if found.
	* init/tests/test_job.c: Add extra argument to all job_new calls
	(test_config_new): Make sure instance name is initialised to NULL.
	(test_handle_event): Make sure the job name is set from the instance,
	and make sure an existing instance is reused if we can.
	(test_instance): Make sure that the existing instance is returned.
	* init/parse_job.c (stanza_instance): Check for an optional argument
	and store it in the instance_name member if it exists, otherwise
	free and reset the instance_name member.
	* init/tests/test_parse_job.c (test_stanza_instance): Check the new
	argument is handled properly and stored in the right place.
	* init/tests/test_conf.c (test_source_reload_job_dir)
	(test_file_destroy): Add extra NULL to job_new
	* init/tests/test_event.c (test_poll): Add extra NULL to job_new

	* init/event.c (event_operator_match): Accept an environment array
	and expand the operator value against it before attempting to match.
	(event_operator_handle): Also accept the environment array and pass
	through to calls to event_operator_match().
	* init/event.h: Update prototypes.
	* init/tests/test_event.c (test_operator_match): Add extra NULL
	argument to most tests, and add tests for known and unknown variable
	references.
	(test_operator_handle): Add extra NULL arguments to most tests, and
	add test for passing of environment through.
	(test_operator_reset): Add extra NULL argument to call.
	* init/job.c (job_handle_event): Pass the job environment for the
	stop event handling, but NULL for the start event.
	* init/tests/test_job.c (test_handle_event): Make sure that a stop
	operator is expanded from the job environment before being matched
	against the stop event.

	* init/event.c, init/event.h, init/environ.c: Documentation tweaks.

	* init/job.c (job_change_state): Remove the code to check for runaway
	jobs from here, we'll always let people explicitly start an instance.
	(job_process_terminated): Call job_catch_runaway when actually doing
	the respawn instead.
	* init/tests/test_job.c (test_change_state): Remove "too fast" checks,
	we're going to allow start/stop requests to restart jobs as much as
	they like since this is an external request.
	(test_handle_event, test_handle_event_finished): No need to remove
	a respawn limit with this behaviour.
	(test_child_handler): Instead check that the respawn counter is
	dealt with by the child handler.

	* TODO: Update, I found a bug with the current model.

	* init/tests/test_environ.c (test_expand): Check that a string
	without an expansion still works ok.

2008-03-06  Scott James Remnant  <scott@netsplit.com>

	* init/event.c (event_operator_collect): Just use strcat functions.

2008-03-03  Scott James Remnant  <scott@netsplit.com>

	* init/environ.c (environ_valid): New function to check the validity
	of an environment variable name, should call before accepting any.
	(environ_expand_until): New function to expand variable references
	in a string using an environment table; supports a few common
	shell-like expressions.
	(environ_getn): Change to return the value of the string, not the
	entire environment string.
	* init/environ.h: Add prototypes.
	* init/errors.h: Add errors raised by new functions.
	* init/tests/test_environ.c (test_valid, test_expand): Add test
	cases for the new functions.
	(test_get, test_getn): Change test case to check for the variable
	value instead of returning the whole string.

	* TODO: Add thoughts on blocking commands.

	* TODO: Update.

	* init/event.h (Event): Remove the refs member; we now never hold
	a reference to an event we're blocking since we always copy the
	environment out if we want to keep it.
	(EventOperator): Events are always blocked while we hold them,
	so drop the blocked member.
	(EventProgress): The done state is no longer needed, we can free
	in finished now.
	* init/event.c (event_ref, event_unref): Drop these functions.
	(event_new): Don't ininitialise the refs member since it's gone.
	(event_poll): Remove the done state since it's directly freed
	in event_finished again
	(event_finished): No done state, event is freed before return.
	(event_operator_new): No blocked member.
	(event_operator_copy): Always block the event after copying.
	(event_operator_destroy): Simply unblock.
	(event_operator_handle): Simply block the event on match.
	(event_operator_collect): Always block the copied event
	(event_operator_unblock): This function is no longer required, since
	it has an identical effect to reset.
	(event_operator_reset): Simply unblock the event.
	* init/tests/test_event.c (test_new): Drop the check for refs
	being initialised to zero.
	(test_ref, test_unref, test_operator_collect): Drop test for
	functions that have been dropped in the code.
	(test_operator_new): Drop the check for blocked being initialised
	to FALSE.
	(test_block, test_unblock, test_operator_destroy): Drop any references
	to the refs member.
	(test_operator_destroy): Actually fix the function to test things.
	(test_poll): Drop the check for remaining in the done state.
	(test_operator_new, test_operator_copy): Drop the checks for blocked.
	(test_operator_handle, test_operator_collect, test_opreator_reset):
	Drop references to refs and blocked.
	* init/job.c (job_unblock, job_handle_event): Drop the call to
	event_unref() since the next call was always event_unblock() and
	that's the one that we didn't delete.
	* init/tests/test_job.c (test_change_state, test_child_handler)
	(test_handle_event, test_handle_event_finished): Events don't
	have references anymore, so remove calls to reference, unreference
	and checks for the reference count - it's all done with blocks now.
	(test_new): Remove check that the operator is not blocked for a
	new job since there's no such thing now.
	(test_handle_event): Operators don't have a blocked member anymore,
	if there's an event, it's blocked.

	* init/job.c (job_change_state): Don't reference the event we're
	blocked on, we'll always know when it's finished.
	(job_handle_event_finished): Likewise no reason to unreference it.
	* init/tests/test_job.c (test_change_goal, test_child_handler)
	(test_handle_event, test_change_state)
	(test_handle_event_finished): Remove the expectation that the blocked
	event is referenced by the job.
	* init/tests/test_event.c (test_poll): Don't reference the event,
	since the job would not have.

	* init/job.c (job_emit_event): Use environ_add/set for style
	reasons.

	* init/job.c (job_handle_event): Reset the stop_on operator after
	processing the event, thus the expression needs to be completely
	reevaluated before the job can be stopped again by it.  At last,
	correct behaviour!
	(job_change_state): No reason to reset the stop_on operator when
	starting since it's always reset after evaluating to TRUE now;
	likewise no reason to reset on re-entering running or waiting,
	job_unblock() is sufficient.
	(job_failed): No reason to iterate stop_on to set failed, it's
	empty - job_unblock() does what we want.
	* init/tests/test_job.c (test_handle_event): Check that the operator
	is actually reset and the event not referenced when handling from
	the event.
	(test_change_state, test_child_handler): Don't put anything in stop_on
	and thus don't expect anything to come out of it -- event environment
	is all done in stop_env and blocking done in blocking.

	* init/job.c (job_handle_event): Collect the stop events and store
	them in the blocking list, unblocking any that were there before
	such as the start events.
	(job_change_state): Unblock blocking events when returning to running
	from pre-stop.
	* init/tests/test_job.c (test_handle_event): Make sure the stop
	events are collected and replace any previously blocking events.
	(test_change_state, test_child_handler): Test that stop events in
	the blocking list are kept and unblocked when necessary.

2008-03-02  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_change_state): Shouldn't emit the started event
	on pre-stop cancellation, and shouldn't unblock the job because
	it's a service.

	* init/job.c (job_change_state): Throw away the stop environment
	when starting and returning to running.
	* init/tests/test_job.c (test_change_state): Make sure the stop
	environment is actually thrown away.

	* init/job.c (job_run_process): Append the environment from the
	stop events if given the pre-stop process to run; do this before
	the special events so they can never be overriden.
	* init/tests/test_job.c (test_run_process): Check that the stop event
	environment is included for pre-stop and not for other jobs.

	* init/job.c (job_handle_event): Remove setting of UPSTART_JOB
	and UPSTART_JOB_ID, we set that when we run the process.
	* init/tests/test_job.c (test_handle_event): Don't check for
	UPSTART_JOB and UPSTART_JOB_ID since we no longer copy it in here.

	* init/job.c (job_run_process): Copy the environment to pass it to
	the job, appending the UPSTART_JOB and UPSTART_JOB_ID variables here;
	we never want to be able to match these, etc.
	* init/tests/test_job.c (test_run_process): Add tests to make sure
	that the environment is actually set in the processes we run.

	* init/job.h (Job): Add stop_env member to store environment from
	stop events for the stop script.
	* init/job.c (job_new): Initialise stop_env to NULL.
	(job_handle_event): Copy environment from the stop_on operator into
	the stop_env member.
	* init/tests/test_job.c (test_new): Check that stop_env is NULL.
	(test_handle_event): Add lots of tests to make sure that the
	environment is collected from the events and stored in stop_env
	properly, overwriting what was there already if necessary.

	* init/init.supp (job-run-process-args): Add a suppression for the
	fact that job_run_process will leak its arguments to a new process
	assuming that it will call exec() or exit()

	* init/tests/test_job.c (test_child_handler): Remove bogus free tag
	of the list, which we don't use in this test (valgrind failure)

	* init/job.h (Job): Remove the start_on member.
	* init/job.c (job_new): Don't initialise start_on since it's gone.
	(job_change_state): Drop call to unblock the start_on operator since
	the events are already unblocked by job_unblock.
	(job_failed): Drop setting of start_on events to failed since this
	is already done by job_unblock.  This results in a slight change in
	behaviour, now when a job fails to start - the event or command will
	be immediately unblocked since there's no point waiting until it
	stops again - it was waiting for it to start.
	* init/tests/test_job.c (test_new): Remove start_on checks
	(test_change_state, test_child_handler, test_handle_event): Remove
	all references to start_on, instead relying on the blocking checks
	instead.
	* init/tests/test_event.c (test_poll): Remove solitary reference
	to job's start_on, this wasn't necessary anyway - we proved that it
	was the right event by affecting the job.  Revert previous commit
	that temporarily increased the number of references, they should be
	one again now only the blocking list holds them.

	* init/job.h (job): Add blocking member, a list of events that we're
	blocking from finishing.
	* init/job.c (job_new): Initialise blocking member to NULL.
	(job_handle_event): Collect the list of events from the operator
	and store them in the job's blocking list (unblocking any existing
	first); if the job is already running, unblock unref and discard.
	(job_unblock): New function to deal with unblocking the events we're
	holding onto and resetting the blocking list; this will be extended
	later to also unblock any command.
	(job_change_state): Unblock events in running for services and in
	waiting for everything.
	(job_failed): Unblock events and mark them as failed.
	* init/tests/test_job.c (test_new): Check that it's initialised to NULL
	(test_handle_event): Extend the test cases to check the value of the
	blocking list, and to make sure that the previous blocking list is
	overwritten when necessary.
	(test_change_state, test_child_handler): Extend test cases so that
	wherever we're had a blocked event in start_on, we also have that in
	the blocking list.
	* init/tests/test_event.c (test_poll): Temporarily increase the
	expected number of references/blockers to the event in the poll
	test.

	* init/job.h (Job): Add start_env member, this stores the environment
	to use when starting the event so it doesn't overwrite the current
	environment of a restarting job.
	* init/job.c (job_handle_event): Do the heavy lifting of starting a
	new job instance here; construct the environment from the built-ins
	and configured, append that collected from the start events, locate
	or create a new instance, add the job name and id then copy into
	the new start_env member before starting the job.  At some point
	this will probably all become a function since it'll be similar for
	the control functions.
	(job_change_state): Copy the start_env member into the env member
	when in the starting state; thus the job environment remains the same
	until restarted.
	(job_new): Remove code to initialise the environment, we now do that
	when actually starting the instance.
	* init/tests/test_job.c (test_handle_event): Add test cases for
	starting the job, making sure that the environment is correctly
	copied into the right field and also checking what happens if it's
	already stopping or running.
	(test_change_state): Make sure that start_env is correctly copied
	over into env, overwriting what is there if non-NULL or keeping it
	if NULL.
	(test_new): Remove checks for environment setup, since we don't do
	that anymore here; replace with checking for NULL and restore the
	alloc fail tests.
	* TODO: Update.

	* init/environ.c (environ_add): Allow it to accept NULL length, since
	we can't always keep that around.

	* init/process.c (process_spawn): Accept the environment list as
	a parameter, then finally we can change this function to take a
	JobConfig as the first argument.
	(process_error_read): Remove the associated error handler.
	* init/process.h: Change prototype.
	(ProcessErrorType): Remove error enum for environment.
	* init/tests/test_process.c (test_spawn): Update calls in test to
	just pass in an environment array (direct testing).
	* init/job.c (job_run_process): Pass configuration and environment
	to process_spawn.

	* init/process.c (process_spawn): Take the environment directly out
	the job structure, rather than recreating it.
	(process_environment): Drop function, absorbed elsewhere.
	* init/process.h: Remove prototype.
	* init/tests/test_process.c (test_spawn): Set the job_id variable
	before calling job_new and set config->start_on instead of
	job->start_on so that job_new can pick up both.
	(test_environment): Remove test cases.

	* init/job.h (Job): finally gains env pointer of its own.
	* init/job.c (job_new): Initialise the environment, moving the last
	of the code from process_environment -- this is only temporary
	though in the interests of refactoring, it'll move out of here again
	soon enough.
	* init/tests/test_job.c (test_new): Make sure that the environment is
	set in a manner which tests the overriding of things by other things;
	we have to temporarily comment out the alloc fail stuff though :-(

	* init/event.c (event_operator_collect): Make list the last argument
	for consistency with future functions.
	* init/event.h: Update prototype.
	* init/tests/test_event.c (test_operator_collect): Swap arguments.
	* init/process.c (process_environment): Update.

	* init/job.c (job_config_environment): Function to generate an
	environment table from a JobConfig, code largely moved from process.c
	* init/job.h: Add protoyype.
	(JOB_DEFAULT_ENVIRONMENT): List of environment variables to always
	copy from the environment (moved from process.h)
	* init/tests/test_job.c (test_config_environment): Add test case,
	again largely copied from test_process.c
	* init/process.c (process_environment): Call job_config_environment
	instead of the code moved out.
	* init/process.h (PROCESS_ENVIRONMENT): Move to job.h
	* TODO: Update.

	* TODO: Update.

2008-03-01  Scott James Remnant  <scott@netsplit.com>

	* init/event.c (event_operator_collect): Create a mega-function to
	iterate an EventOperator tree (filtering out those bits that aren't
	TRUE) and collect the events, adding them to a linked list, adding
	their environment to a table and making a string list for another
	environment variable.  Fundamentally this function marshals data
	out of the Event subsystem into the right format for the Job subsystem.
	* init/event.h: Add prototype.
	* init/tests/test_event.c (test_operator_collect): Tests for the
	collector function; some bits may seem similar to test_process.c
	* init/process.c (process_environment): Use event_operator_collect
	to gather the environment, instead of its own code (which pretty
	much got pasted into event_operator_collect anyway).  Force everything
	else to allocate matching the caller.
	* init/tests/test_process.c (test_spawn, test_environment): Had
	forgotten to set the value of the intermediate AND operator to TRUE,
	necessary now.

	* init/process.c (process_environment_add): Move and rename this
	function, since it's not really process associated
	(process_environment): Change to use environ_add or environ_setf
	instead.
	* init/process.h: Remove prototype.
	* init/environ.c (environ_add): New name/location of
	process_environment_add, modified to not take a copy of the string
	(environ_set): Wrapper for the above for common dealing with
	environment we want to set from a format string.
	(environ_get, environ_getn, environ_lookup): Functions to get an
	environment variable entry; largely cripped from event.c but
	bug-fixed at the same time.
	* init/environ.h: Function prototypes.
	* init/event.c (event_operator_match): Change to use environ_lookup
	* init/tests/test_process.c (test_environment_add): Move the tests.
	* init/tests/test_environ.c: Test suite for environment handling
	* init/Makefile.am (init_SOURCES): Build environ.c and environ.h
	(TESTS): Build environment test suite
	(test_environ_SOURCES, test_environ_LDFLAGS, test_environ_LDADD):
	Details for environment test suite
	(test_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_parse_job_LDADD, test_parse_conf_LDADD, test_conf_LDADD):
	Link environ.o to other test suites

	* init/job.c (job_new): Increment the number of instances.
	(job_instance): Simplify the function, it now only returns the
	existing instance or NULL.  This makes it easier to extend when
	we have env-limited instances later on.
	(job_handle_event): If job_instance returns NULL, create
	a new instance with job_new() and always reset the operator afterwards.
	* init/tests/test_job.c (test_new): Check that the instances variable
	is incremented when a new job is created.
	(test_instance): Change to check that it returns NULL when there is
	no active instance, or for multi-instance jobs, instead of creating
	a new one itself.
	(test_config_replace, test_find_by_pid)
	(test_find_by_id, test_change_goal, test_change_state)
	(test_next_state, test_run_process, test_kill_process)
	(test_child_handler, test_handle_event)
	(test_handle_event_finished): Call job_new to create a new instance
	from a config, instead of job_instance.

	* init/tests/test_conf.c (test_source_reload_job_dir)
	(test_file_destroy): Call job_new to create a new instance from a
	config, instead of job_instance.
	* init/tests/test_event.c (test_poll): Call job_new to create a new
	instance from a config, instead of job_instance.
	* init/tests/test_process.c (test_spawn, test_environment): Call
	job_new to create a new instance from a config, instead of job_instance

2008-02-29  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Compare the evaluated $sbindir against the common
	things we put in PATH, if it doesn't match, define EXTRA_PATH to
	contain it.
	* init/paths.h: Append EXTRA_PATH to PATH if defined.

	* init/Makefile.am (AM_CPPFLAGS): Replace TELINIT definition with
	SBINDIR, pointing at the common directory.
	* compat/sysv/Makefile.am (AM_CPPFLAGS): Replace SHUTDOWN definition
	with SBINDIR, pointing at the common directory.
	* init/paths.h (TELINIT): Redefine to be SBINDIR with "/telinit"
	on the end; define SBINDIR if necessary.
	* compat/sysv/reboot.c (SHUTDOWN): Redefine to be SBINDIR with
	"/shutdown" on the end; define SBINDIR if necessary.

2008-02-22  Scott James Remnant  <scott@netsplit.com>

	* init/event.c (event_operator_match): Rewrite to match both
	positionally and by name.
	* init/tests/test_event.c (test_operator_match): Update tests to
	check the new behaviour works.

	* init/parse_job.c (parse_on_operand): Add arguments to env list
	rather than args; sanity check afterwards to ensure that positional
	doesn't follow name-based -- when parsing the job is the right place
	to catch this.
	* init/tests/test_parse_job.c (test_stanza_start)
	(test_stanza_stop): Change args to env when checking operators.
	Check that arguments may be quoted in manners that we expect to be
	sane.  Check that positional arguments cannot follow name-based ones.
	* init/errors.h: Add new error.
	* init/conf.c (conf_reload_path): Treat expected variable as a
	permanent error.

	* init/tests/test_process.c (test_spawn, test_environment): 
	Update event_new() calls to remove extra argument.

	* init/main.c (main, cad_handler, kbd_handler, pwr_handler):
	Update event_new() calls to remove extra argument.

	* init/job.c (job_change_state): Update event_new () call.
	(job_emit_event): Update to put failure information in environment.
	* init/tests/test_job.c (test_new, test_instance)
	(test_child_handler, test_handle_event)
	(test_handle_event_finished): Remove extra argument to event_new,
	rename args to env in operator where necessary.
	(test_change_state): Update to check emitted event by full environment.

	* init/event.h (Event): Remove args member.
	(EventOperator): Rename args member to env.
	Update prototypes to match.
	* init/event.c (event_new): Remove args member.
	(event_finished): Remove copying of args member to failed event.
	(event_operator_new): Rename args member to env.
	(event_operator_copy): Rename args copying to env.
	(event_operator_match): ??
	* init/tests/test_event.c (test_new): Update test to remove args.
	(test_operator_new): Update test to rename args to env.
	(test_operator_copy): Update test to rename args to env.
	(test_operator_match): ???

	* TODO: Update with job atomicity notes.

2008-02-20  Scott James Remnant  <scott@netsplit.com>

	* init/job.c: Switch around job_find_by_pid and job_find_by_id
	* init/job.h: Likewise.

	* init/job.h: Update prototypes to match variable names in the
	code.

2008-02-17  Scott James Remnant  <scott@netsplit.com>

	* init/process.c (process_kill): Change to accept a JobConfig rather
	than a Job, since in theory this should only ever need that in a
	future where we can specify a kill signal (right now it's not used
	for anything!)
	* init/process.h: Update prototype.
	* init/tests/test_process.c (test_kill): Update test cases.
	* init/job.c (job_kill_process, job_kill_timer): Pass in JobConfig
	instead of Job.

	* init/process.c (process_spawn): Accept trace as an argument instead
	of using a random piece of job state to determine whether to trace
	or not.
	* init/process.h: Update prototype.
	* init/tests/test_process.c (test_spawn): Update tests to pass in
	via argument whether to trace the job or not.
	* init/job.c (job_run_process): Pass in the trace variable rather
	than relying on it working it out for itself; this means we don't
	need to set the state until after, therefore don't need to reset it.

	* AUTHORS, logd/jobs.d/logd.in: Update e-mail addresses.

	* README: Update kernel recommendation to 2.6.24, since that's
	the oldest version that the test suite will complete under.

2008-01-17  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* init/job.c (job_run_process): Don't append the list of event
	names, they can be found in $UPSTART_EVENTS now.  This is better
	since it's consistent for exec and script.
	* init/tests/test_job.c (test_run_process): Drop test case.

	* init/process.c (process_environment): Function to build an
	environment table for a job containing built-in variables, those
	from the configuration, events and finally the upstart job ones.
	(process_environment_add): Helper function for the above that
	handles adding a variable to the array; dealing with fetching the
	value from init's environment if necessary.
	(process_setup_environment): This function now gets dropped in
	favour of the new ones.
	(process_spawn): Call the new process_environment() function and set
	the environ variable directly.
	* init/process.h (PROCESS_ENVIRONMENT): Define built-in environment
	variables that are always copied from our own environment.
	Add prototypes.
	* init/tests/test_process.c (test_environment): Check that the
	environment is built correctly and that each bit overrides the
	right other bit.
	(test_environment_add): Check that the array is built correctly.
	(test_spawn): Adjust order and values of expected environment
	to match what's now set.

2008-01-16  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_failed): Separate the logic that marks the job
	and its associated events as failed into its own function, since
	it's a large enough amount of code that we were otherwise duplicating
	everywhere else (and in a few places, failing to mark the events as
	failed as well).
	(job_change_state, job_process_terminated): Call job_failed instead
	of doing it ourselves.
	(job_emit_event): De-nest the logic and fix so that we don't add
	environment to the failed respawn event.
	* init/tests/test_job.c (test_change_state): Add checks on whether
	the event was marked as failed or not.

	* TODO: Update.

	* configure.ac (AC_COPYRIGHT): Update copyright to 2008.

	* TODO: Update.

	* init/tests/test_job.c (test_child_handler): Don't run the signal
	and ptrace tests while in valgrind, sometimes signals (specifically
	SIGCONT after SIGSTOP) don't behave right and we kinda need that
	reliability.

	* init/tests/test_job.c (test_child_handler): After adding extra
	processes, make sure we clean up again so each test is roughly
	independant.  Fix the final test case to not rely on previous
	setup and work on its own.

	* init/tests/test_job.c (test_change_state): Remove useless check
	of job->start_on from a killed/post-stop check (noticed while
	writing the other).

	* init/job.c (job_change_state): Check the return value of
	job_run_process() and if particular processes fail, change the
	goal to stop and push the job into the next state; setting the job
	as failed along the way.
	(job_emit_event): If the exit_status is -1 then it means the job
	failed to spawn, so don't place EXIT_SIGNAL or EXIT_STATUS in the
	event environment.
	* init/tests/test_job.c (test_change_state): Check what happens when
	each process type fails, make sure that the job is stopped for
	pre-start, spawned and post-stop and the failure is ignored for
	post-start and pre-stop.

2008-01-15  Scott James Remnant  <scott@netsplit.com>

	* init/main.c: Selectively compile out certain pieces when make is
	run with CPPFLAGS=-DDEBUG, giving us a build that'll happily run from
	a user terminal.
	* init/event.h: Change the startup event to "debug" when built like
	that, so we don't accidentally do bad things.

	* init/job.c (job_run_process): Catch PROCESS_ERROR and abort the
	attempt to run the process, returning a non-temporary error condition.
	* init/tests/test_job.c (test_run_process): Add test case for
	attempting to spawn a file that doesn't exist.

	* init/process.c (process_error_read): Avoid the word process, since
	it's likely included in the higher error message.

	* init/process.c (process_spawn): Call process_error_abort() on any
	error condition.
	* init/tests/test_process.c (test_spawn): Add a test case for failing
	to spawn a process and receiving ProcessError correctly; fix other
	cases to ensure they return a pid.

	* init/errors.h: Add PROCESS_ERROR to the enum, but not to the string
	list since there's no specific defined string for this one.
	* init/process.h (ProcessError): Structure that builds on NihError
	to add additional information for a process error.
	(ProcessErrorType): enum of different process error types.
	* init/process.c (process_spawn): After forking read the error in
	the parent, returning if we raise one.
	Ensure we close the pipe if the fork fails.
	Re-order so that we set the environment, umask and priority after the
	resource limits (which should apply to them).
	(process_error_abort): New function to immediately abort with an
	error, writing it on the pipe first.
	(process_error_read): Counterpart function to read the error from
	the pipe and raise it, with appropriate error messages.

	* init/process.c (process_spawn): Create a pipe to use for
	communication with the child, ensuring its closed before the parent
	returns and ensuring that the writing end is close-on-exec in the
	child.

	* init/job.c (job_run_process): Change to return a value indicating
	whether there's been a non-temporary error (always returns zero so
	far).
	* init/job.h: Update prototype.
	* init/tests/test_job.c (test_run_process): Check that job_run_process
	always returns zero.

	* init/job.c (job_change_goal): Document in which states this function
	has unexpected side-effects such as freeing the job, since we do
	attempt to call it from within job_change_state().

	* init/process.c (process_setup_limits): Integrate this function back
	into process_spawn() since there's no reason for it to be separate.
	(process_setup_console): Alter this function so it closes the original
	console descriptors, opens the new ones and can reset them to if
	required -- in particular, this no longer takes a Job parameter.
	(process_spawn): Use the new process_setup_console function and
	integrate code from process_setup_limits().
	* init/process.h: Update function prototype.
	* init/main.c (main): Use the new process_setup_console() argument
	form.  Move syslog opening to the end of the function, rather than
	where it is now where it could be at risk of being closed again
	immediately.  Change the root directory in case we're run in some
	weird way.
	(reset_console): Remove function since the code is now in
	process_setup_console()
	* init/enum.h (console_type): Remove CONSOLE_LOGGED and make the
	CONSOLE_NONE constant be zero.
	* init/parse_job.c (stanza_console): Drop parsing of "logged"
	* init/tests/test_parse_job.c (test_stanza_console): Drop testing
	of "logged" parsing.

2008-01-14  Scott James Remnant  <scott@netsplit.com>

	* HACKING: Correct bzr URLs to trunk.

2007-12-15  Scott James Remnant  <scott@netsplit.com>

	* init/process.c (process_spawn): Fix some documentation strings.
	
	* init/process.c (process_kill): Move to beneath the process setup
	functions.
	* init/process.h: Adjust ordering here too.

	* init/process.c (process_spawn): Group console closing and setup
	together, becoming the session and process group leader first.

2007-12-07  Scott James Remnant  <scott@netsplit.com>

	* init/process.c (process_spawn): Drop the debug message since
	it's always repeated by the caller.
	* init/job.c (job_run_process): Drop the word Active which is a
	hold-over from when we had different process states.

	* TODO: Update.

	* init/job.c (job_child_handler): Add code to handle the trapped
	signal and ptrace event cases, distinguishing between a trapped
	signal and process stopped after exec or fork using our trace
	state member.  Call out to other functions to do the work.
	(job_process_trace_new): Called after the first exec to set the
	ptrace options, update the trace state and allow the process to
	continue without delivering the signal.  Also called after the
	fork to do the same.
	(job_process_trace_new_child): Called after a fork for the new child;
	increments the fork counter and if it goes over the number we want,
	detaches from the process and allows it to move to running.  Otherwise
	calls job_process_trace_new() instead.
	(job_process_trace_signal): Called when a signal is trapped, simply
	delivers it to the process unchanged.
	(job_process_trace_fork): Called before a fork for the parent, obtains
	the new child process id from the event, updating the job structure,
	and detaches from the parent which we're no longer interested in.
	(job_process_trace_exec): Called after an exec other than the first,
	assumed to be the end of forking so detaches from the process and
	allows it to move to running.
	* init/tests/test_job.c (test_child_handler): Add test cases for
	the various ptrace states.

	* init/job.c (job_run_process): Set process trace state to new for
	the main job if we need to wait for the daemon or fork; otherwise
	reset the state.
	* init/tests/test_job.c (test_run_process): Add test cases to make
	sure the trace state is set right and picked up by process_spawn.

	* init/process.c (process_spawn): Set a ptrace before execing the
	binary if the trace state is TRACE_NEW, set by the caller.
	* init/tests/test_process.c (test_spawn): Make sure that a job is
	ptraced if set up properly.
	(child): Add a simple case that just exits immediately for testing
	the above.

	* init/job.h (Job): Add new trace_forks member to keep count of how
	many forks we've seen and trace_state member to track whether we've
	just started the trace or just forked.
	* init/enum.h (TraceState): Add enumeration to keep track of ptrace
	state to differentiate between a signal and an event.
	* init/job.c (job_new): Initialise new members.
	* init/tests/test_job.c (test_new): Check new members are initialised

	* init/enum.h (JobWaitType): Add new daemon and fork wait types.
	* init/parse_job.c (stanza_wait): Add parsing for daemon and fork.
	* init/tests/test_parse_job.c (test_stanza_wait): Add tests too.

	* init/job.h (JobConfig): Remove daemon and pid members.
	(Job): Remove pid_timer member.
	(JOB_DEFAULT_PID_TIMEOUT): Remove this constant.
	* init/job.c (job_config_new, job_new): Remove initialisation of
	removed members.
	(job_change_state): Stay in spawned unless we're not waiting for
	anything -- remove the daemon flag.
	* init/tests/test_job.c (test_config_new, test_new): Remove checks
	for initialisation of removed members.
	(test_change_state): Remove daemon flag stays in spawned check since
	the daemon flag has gone.
	* init/parse_job.c (stanza_daemon, stanza_pid): Remove these
	functions since they have no members to set.
	* init/tests/test_parse_job.c (test_stanza_daemon, test_stanza_pid):
	Remove the tests for the now non-existant functions.

	* init/process.c (process_spawn): raise the system error before
	calling another syscall, in case we overwrite errno.

2007-12-06  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_child_handler): Implement a combined child event
	handler to replace the multiple separate ones.  This handler deals
	with adding appropriate messages to the log and decoding any state
	information before calling specific action functions.
	(job_child_reaper): Remove, moving the bulk of the code into new
	(job_process_terminated): function that handles it cleanly.
	(job_child_minder): Remove, moving the bulk of the code into new
	(job_process_stopped): function that's a lot cleaner.
	* init/job.h: Update prototypes.
	* init/tests/test_job.c (test_child_reaper, test_child_minder):
	Combine unit tests from both functions into single new
	(test_child_handler): function.
	* init/main.c (main): Call the combined function on child events
	instead of separate ones.

	* init/job.c (job_child_minder): Add informational message and
	improve style and documentation.

2007-12-02  Scott James Remnant  <scott@netsplit.com>

	* init/enum.h (JobWaitType): Introduce a new enum that specifies
	how to transition the job from spawned to running; either we don't
	wait, or we wait for it to emit the stopped signal.
	* init/job.h (JobConfig): Add the wait_for member.
	Add protoype for job_child_minder.
	* init/job.c (job_config_new): Initialise to JOB_WAIT_NONE.
	(job_child_minder): New function to catch when a process is stopped
	by a signal, and move it to the next state when it does so.
	* init/tests/test_job.c (test_config_new): Check the initialisation
	of wait_for to JOB_WAIT_NONE.
	(test_child_minder): Tests for the new function.
	(test_change_state): Copy the daemon test case to refer to waiter.
	* init/main.c (main): Call job_child_minder whenever the job is
	stopped by a signal
	* init/parse_job.c (stanza_wait): Parse a new "wait" stanza that
	specifies what to wait for before leaving the spawned state.
	* init/tests/test_parse_job.c (test_stanza_wait): Check the new
	stanza.

2007-11-29  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_job.c (test_change_state): Add a few sets to NULL
	so gcc is happy.

2007-11-15  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_child_reaper): Update argument names and types
	to match new NihChildHandler pattern; switch on event instead,
	which can now have three values not two (it always could, this was
	a bug) to output warning and assume that status is always non-zero
	if killed so no need to check that separately.
	* init/job.h: Update prototype.
	* init/tests/test_job.c (test_child_reaper): Update calls to
	job_child_reaper to pass an NihChildEvents member instead of FALSE
	or TRUE for killed.
	* init/main.c: Adjust call to nih_child_add_watch to indicate which
	events we want to pass to the reaper; we don't use NIH_CHILD_ALL
	since we're going to add ptrace stuff to a different function.

2007-11-07  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (main): Tidy up.

2007-11-04  Scott James Remnant  <scott@netsplit.com>

	Complete the simplification of job config; rather than try and
	precompute job replacements, keeping them all in the same hash table
	and chaining them together, we just work it out when it's actually
	necessary based on what's in the conf_sources list.

	* init/job.h (JobConfig): Remove the replacement and replacement_for
	members and put a deleted member in instead.
	* init/job.c (job_config_new): Initialise deleted to FALSE; don't
	replace the job into the hash table, since we only want the current
	one in there now.
	(job_config_find_by_name): Now that there is only ever one job
	config in the hash table, we don't need any special function and
	can just use nih_hash_lookup directly, so drop this function.
	(job_config_should_replace): Rename to job_config_replace
	(job_config_replace): Rework, it now checks to see whether there
	are instances, and if not removes the job from the hash table
	before selecting a new one (which might be the same job).
	* init/tests/test_job.c (test_config_new): Update test to check
	deleted starts off as FALSE and that the job isn't in the hash.
	(test_config_find_by_name): Drop.
	(test_config_should_replace): Rename and rewrite to test replacement
	actually works as we expect.
	(test_change_state): Update tests for entering the waiting mode and
	replacing jobs.
	(test_find_by_pid, test_find_by_id, test_handle_event)
	(test_handle_event_finished): Add jobs to the hash table, otherwise
	we can't find them
	(test_child_reaper): Add job to the hash table, and also create a
	source for it since we end up with it in the waiting state so need
	to be able to keep it.
	* init/Makefile.am (test_process_LDADD, test_job_LDADD)
	(test_event_LDADD): Need the full .o file list now.
	* init/conf.c (conf_file_destroy): Rewrite to mark the job deleted,
	call job_config_replace if it's the current job and free it if
	it isn't the current job either before or after that call.
	(conf_reload_path): Handle job replacement here; look up the
	old job in the hash table, if it exists attempt a replacement
	otherwise add the new job to the hash table.
	* init/tests/test_conf.c (test_source_reload_job_dir)
	(test_source_reload_conf_dir, test_source_reload_file): Update
	tests to check job->deleted and use nih_hash_lookup to see whether
	it's the current job.
	(test_file_destroy): Write tests to check the common cases, we don't
	need to worry about the intermediate now since they can't happen.
	* init/parse_job.c (parse_job): Massively simplify, this only creates
	the config and parses it now.
	* init/tests/test_parse_job.c (test_parse_job): Remove the replacement
	checks.
	* init/tests/test_event.c (test_poll): Add configs to the hash
	table so they can be found.
	* TODO: Update.

2007-11-03  Scott James Remnant  <scott@netsplit.com>

	* init/conf.h (ConfSource): Remove priority, we'll place these
	in a linked list and use that order instead.
	(ConfSourcePriority): Drop accordingly.
	(ConfItem): Drop this structure; permitting jobs and states to be
	defined inside larger conf files made things complicated for no
	benefit; move the item union into
	(ConfFile): here, instead of the items list.
	(ConfItemType): Drop accordingly.
	* init/conf.c (conf_init): Store sources in a linked list, instead
	of a hash table; no idea why it ever was.
	(conf_source_new): Drop priority argument and add to list not hash.
	(conf_file_new): Set data to NULL instead of initialising items,
	set destructor to conf_file_destroy.
	(conf_item_destroy): Rename to conf_file_destroy
	(conf_file_destroy): and adjust to refer to ConfItem instead,
	getting the item type through the source.
	(conf_item_new): Drop.
	(conf_reload): Iterate as linked list not hash table.
	(conf_reload_path): Simplify handling of old files and items a
	little, just look it up and always free if it exists before parsing
	the new file.
	(conf_file_get): No longer any need for this function.
	* init/tests/test_conf.c (test_file_get, test_item_new): Drop
	test functions for those that have been removed.
	(test_item_destroy): Rename to test_file_destroy.
	(test_source_new): Don't pass or check priority, or hash lookup.
	(test_file_new): Check data is set correctly.
	(test_source_reload_job_dir, test_source_reload_conf_dir)
	(test_source_reload_file): Update tests accordingly.
	* init/parse_conf.c (stanza_job): Drop the job stanza, jobs
	may only be defined in dedicated directories.  
	* init/tests/test_parse_conf.c (test_parse_conf): Simply check to only
	make sure the file is parsed.
	(test_stanza_job): Drop function.
	* init/main.c: Update calls to conf_source_new.
	* init/init.supp: Update intermediate function in suppression.

2007-10-26  Scott James Remnant  <scott@netsplit.com>

	* init/process.c (process_spawn): Mask out all signals across the
	fork() rather than just SIGCHLD; reset the signal handlers to default
	before unmasking again.  The original rationale was we needed to
	avoid SIGCHLD occurring before we'd stashed the pid, but that's no
	longer a problem; the new rationale is that we want to avoid the
	signal handlers running in the newly forked child.

2007-10-20  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_init): The job's name is the first item in the
	structure again, so we can use nih_hash_string_key.
	(job_config_name): Drop this function, then.

	* init/conf.h (ConfSourcePriority): Add a priority enum
	(ConfSource): Add priority member.
	* init/conf.c (conf_source_new): Take priority as an argument and
	set it in the structure.
	* init/tests/test_conf.c (test_source_new): Make sure priority
	is set from the argument.
	(test_file_new, test_file_get, test_item_new)
	(test_source_reload_job_dir, test_source_reload_conf_dir)
	(test_source_reload_file, test_source_reload, test_item_destroy):
	Pass in a priority when creating a ConfSource.
	* init/tests/test_parse_conf.c (test_parse_conf): Likewise.
	* init/main.c (main): Set relative priorities for the configuration
	directories.

	* init/conf.h (conf_file, conf_item): Add source and file members
	respectively that point to the parent structure.
	* init/conf.c (conf_file_new, conf_item_new): Set the members.
	* init/tests/test_conf.c (test_file_new, test_file_get)
	(test_item_new): Make sure the new members are set properly.

	* util/Makefile.am (install-data-hook, install-exec-hook): Apply
	transform to source and destination of both manpage and program
	symlinks.
	* compat/sysv/Makefile.am (install-data-hook, install-exec-hook): 
	Likewise for the compatibility symlinks.

	* TODO: Update.

	* init/tests/test_process.c (test_spawn): Make the event a child
	of the operator so it doesn't get freed first.

	* init/job.c (job_instance): Increment an instances counter each
	time we spawn an instance.
	(job_change_state): Decrement the instances counter again.
	(job_detect_stalled): Drop the main loop function, since we perform
	active detection of stall now.
	* init/job.h: Update header.
	* init/tests/test_job.c (test_change_state): Check that we get the
	stalled event for the last instance.
	(test_detect_stalled): Drop the test.
	* init/main.c: Remove job_detect_stalled from the main loop.

	* init/event.c (event_operator_destroy): Destructor for an
	EventOperator that unblocks and unreferences the event first.
	(event_operator_new): Set the operator.
	(event_operator_copy): Remove error handling since it's unnecessary
	with the destructor in place.
	* init/event.h: Add prototype.
	* init/tests/test_event.c (test_operator_destroy): Make sure it
	works properly.
	(test_operator_copy): Don't unblock or unref events before freeing
	them, since that's now taken care of when it's referenced.
	* init/job.c (job_new): Remove unnecessary error handling.
	* init/tests/test_job.c (test_run_process): Reference the event
	when setting it, otherwise we'll assert when we try to free it.
	* TODO: Update.

	* init/job.c (job_new): Drop the parent argument for consistency.
	(job_instance): Update call to job_new.
	* init/job.h: Update prototype.
	* init/tests/test_job.c (test_new): Adjust call, check the parent
	and make sure that start_on and stop_on are copied over properly.
	* TODO: Update.

	* init/conf.c (conf_file_get): Split out the allocation code from here
	(conf_file_new): into this new function.
	* init/conf.h: Add prototype.
	* init/tests/test_conf.c (test_file_new): New tests.
	* TODO: Update.

	* init/job.c (job_change_state): Hardcode the next state when we
	catch a runaway job to be JOB_WAITING.
	(job_next_state): Change next state for JOB_STARTING when goal is
	JOB_STOP to be JOB_STOPPING for consistency with the others; otherwise
	if our goal is stopped during our starting event, we'll never emit
	a stopping event to match it.
	* init/tests/test_job.c (test_next_state): Update test case.
	* doc/states.dot: Adjust the state transitions.
	* doc/states.png: Regenerate.
	* TODO: Update.

2007-10-19  Scott James Remnant  <scott@netsplit.com>

	Dealing with instances has always been tricky since they're copies
	that exist in the hash table; this patch changes that so the job's
	configuration is separated from its state.  The only difference
	between instance and non-instance jobs now is that non-instance
	jobs only ever have one entry in their instances list.

	* init/job.h (Job): Separate out the members that come from the
	configuration into a new JobConfig structure which can be shared
	amongst all of the instances; this means we can drop instance_of.
	(JobConfig): Add instances list.
	(JobProcess): Remove pid member, replaced by pid list in Job.
	Update prototypes of functions to match.
	* init/job.c (job_new): Split off initialisation of configuration
	pieces into new job_config_new function leaving the state here;
	copy the start_on and stop_on members from JobConfig
	(job_copy): Drop this function, we don't need to copy jobs now.
	(job_name): Rename to job_config_name.
	(job_init): Set key function to job_config_name.
	(job_process_new): Drop initialisation of pid.
	(job_process_copy): Drop this function entirely, we don't need it.
	(job_find_by_name): Rename to job_config_find_by_name; massively
	simplify now we won't find instances or deleted jobs in the list.
	(job_should_replace): Rename to job_config_should_replace; simplify
	now that we can do a simple check to see whether a job exists or not
	(job_find_by_pid, job_find_by_id): Loop through the instances after
	looping through the hash table.
	(job_instance): Simplify, now all it needs to do is call job_new()
	if there isn't anything in the instances list, or it's multi-instance.
	(job_change_goal): Document that job should not be used on return.
	No need to check for instance jobs anymore.  Place the job id in
	the output.
	(job_change_state): Document that job should not be used on return.
	Place the job id in the output.  Check for information in the job's
	config.  Merge the waiting and deleted states, so that a job instance
	is automatically deleted when it finishes.
	(job_next_state): Assert that we never call job_next_state when
	in JOB_WAITING since there's no possible next state.  Check config
	for whether a main process exists.
	(job_emit_event): Obtain config-replaced pieces from the job's config
	(job_run_process): Obtain process information from the job's config
	but store the pid in the Job.  Put job id in the output.
	(job_kill_process, job_kill_timer): We don't need to obtain the
	JobProcess just the pid from the job.  Put job id in the output.
	(job_child_reaper): Put job id in the output.  Check job config.
	(job_handle_event): Iterate job instances and process their stop_on
	operators, but process the start_on from the job configs.
	(job_handle_event_finished): Loop through the instances too.
	(job_detect_stalled): Check start_on from the config and just
	check whether there are any instances in the list.
	(job_free_deleted): No deleted state, so drop this function.
	* init/tests/test_job.c (test_new): Split into test_new and
	new test_config_new function.  Create JobConfig object and spawn
	Job instances from that.
	(test_copy): Drop the tests.
	(test_process_new): Drop check of pid.
	(test_process_copy): Drop test.
	(test_find_by_name): Rename to test_config_find_by_name.
	(test_should_replace): Rename to test_config_should_replace.
	(test_instance): Create JobConfig object, and adjust tests to ensure
	that we always get a Job object.
	(test_find_by_pid, test_find_by_id, test_change_goal): Create
	JobConfig object and spawn Job instances from that.
	(test_change_state): Create JobConfig object and spawn Job
	instances from that.  Adjust tests that previously checked for
	JOB_WAITING to check for job being freed.  Drop checks for JOB_DELETED.
	(test_next_state): Create JobConfig object and spawn Job instances
	from that.  Drop JOB_DELETED and JOB_WAITING checks.
	(test_run_process, test_kill_process, test_child_reaper)
	(test_handle_event, test_detect_stalled): Create JobConfig object
	and spawn Job instances from that.
	(test_free_deleted): Drop.
	* init/main.c: Don't add job_free_deleted to the main loop.
	* init/enum.h (JobState): Drop JOB_DELETED.
	* init/enum.c (job_state_name, job_state_from_name): Drop JOB_DELETED.
	* init/tests/test_enum.c (test_state_name, test_state_from_name):
	Drop tests that use the JOB_DELETED value.
	* init/process.c (process_spawn, process_setup_limits)
	(process_setup_environment, process_setup_console): Get details
	from the job config.  Put job id in the output.
	* init/tests/test_process.c (test_spawn, test_kill): Create
	a JobConfig object and make Job instances from that.
	* init/tests/test_event.c (test_poll): Create a JobConfig object
	and make Job instances from that.
	(test_operator_copy): Set pointers to NULL to avoid gcc complaining.
	* init/conf.h (ConfItem): Make the type for a job be JobConfig.
	* init/conf.c (conf_item_destroy): Don't attempt to replace the
	new middle-man target, if it was due to be replaced it would have
	already been.  If we can replace the config, ensure nothing points
	at it and then free it, rather than kicking state.
	* init/tests/test_conf.c (test_source_reload_job_dir)
	(test_source_reload_conf_dir, test_source_reload_file)
	(test_source_reload, test_item_destroy): Call job_config_new to
	create JobConfig objects, track when they are freed rather than
	marked in the deleted state.  Create instances with job_instance,
	and fetch from the instances list.  Expect the job to be freed
	with the item.
	* init/tests/test_parse_conf.c (test_parse_conf)
	(test_stanza_job): Change expected type from Job to JobConfig.
	* init/parse_job.c: Update prototypes of all functions to refer to
	JobConfig instead of Job.
	(parse_job): If the old job already has a replacement, remove the
	replacement from the hash table -- but don't free it because it's
	linked by a ConfItem -- this is temporary.  Likewise for when we
	replace the old job.
	* init/parse_job.h: Update prototype.
	* init/tests/test_parse_job.c: Update all functions to use JobConfig
	instead of Job.
	(test_parse_job): Create an instance.
	* doc/states.dot: Remove the deleted state.
	* doc/states.png: Regenerate.
	* TODO: Update with notes from the conversion.

2007-10-16  Scott James Remnant  <scott@netsplit.com>

	Update to catch up with changes in libnih that make code a little
	bit easier to follow (we hope).

	* init/tests/test_process.c (test_spawn, test_kill): Replace calls
	to nih_list_free() with nih_free()
	* init/event.c (event_poll): Replace nih_list_free with nih_free
	since the former function has gone from libnih.
	(event_new): Adjust setting of the destructor.
	(event_operator_new): Set destructor for the tree node.
	* init/tests/test_event.c (test_new, test_find_by_id, test_ref)
	(test_unref, test_block, test_unblock, test_poll)
	(test_operator_match): Replace nih_list_free with nih_free.
	(test_poll): Use TEST_FREE_TAG and TEST_FREE rather than abusing
	destructors.
	* init/job.c (job_new): Set destructor to nih_list_destroy.
	(job_copy, job_free_deleted): Use nih_free instead of nih_list_free
	* init/tests/test_job.c (test_new, test_copy, test_find_by_name)
	(test_find_by_pid, test_find_by_id, test_instance)
	(test_change_goal, test_change_state, test_next_state)
	(test_should_replace, test_run_process, test_kill_process)
	(test_child_reaper, test_handle_event)
	(test_handle_event_finished, test_detect_stalled)
	(test_free_deleted): Replace all uses of nih_list_free with nih_free
	(test_child_reaper, test_free_deleted): Replace destructor abuse
	with TEST_FREE, etc.
	* init/conf.c (conf_reload_path): Use nih_free instead of nih_list_free
	(conf_source_new, conf_file_get, conf_item_new): Set destructor
	(conf_source_reload, conf_delete_handler): Use nih_free not the
	custom conf_file_free() function.
	(conf_reload_path): Use nih_free not the custom conf_item_free()
	function.
	(conf_delete_handler): Use nih_free not nih_watch_free()
	(conf_source_free, conf_file_free): Drop these functions, since
	all the free chaining happens properly with destructors.
	(conf_item_free): Rename to conf_item_destroy and turn into destructor
	* init/conf.h: Update prototypes.
	* init/tests/test_conf.c (test_source_new, test_file_get)
	(test_item_new, test_source_reload_job_dir)
	(test_source_reload_conf_dir, test_source_reload_file)
	(test_item_free): Replace nih_list_free calls with nih_free
	(test_source_reload_job_dir, test_source_reload_conf_dir)
	(test_source_reload_file, test_source_reload, test_item_free): Replace
	calls to conf_source_free with nih_free
	(test_source_free, test_file_free): Drop functions.
	(test_item_free): Rename to test_item_destroy
	(test_item_new): Assign a job before freeing, otherwise the destroy
	function will foul up as it expects one.
	* init/parse_conf.c (stanza_job): Replace nih_list_free with nih_free
	* init/tests/test_parse_conf.c (test_parse_conf)
	(test_stanza_job): Replace conf_source_free() with nih_free()
	(test_parse_conf, test_stanza_job): Replace conf_item_free()
	with nih_free()
	* init/parse_job.c (parse_job, parse_on_paren, parse_on_collect):
	Replace nih_list_free with nih_free
	(parse_on): always cut out the stack head before returning (it won't
	be empty on error) otherwise we end up with a bunch of list entries
	pointing to it -- and it's way out of scope when we try and free them
	(parse_on_operator, parse_on_operand): Use the job as the context
	not the operator for consistency of freeing.
	* init/tests/test_parse_job.c: Replace all instances of nih_list_free
	with nih_free (too many functions to list).

2007-10-15  Scott James Remnant  <scott@netsplit.com>

	Strip out all of the IPC code, removing it and consigning it to the
	great revision control history in the sky.  We're going to switch
	from home-brew to D-BUS. so all this is somewhat obsolete.  Rather
	than maintain this while we carry on developing, we'll strip it out
	now and put the D-BUS code in ater once the rest of the core changes
	are done (otherwise we'd just be dragging those through maintenance
	too).

	* Makefile.am (SUBDIRS): Remove the upstart sub-directory entirely;
	comment out util, compat/sysv & logd since we'll fix them up later
	* configure.ac (AC_CONFIG_FILES): Remove from here too.
	* upstart/enum.c, upstart/enum.h, upstart/tests/test_enum.c: Move
	these files into the init/ sub-directory; strictly speaking we'll
	probably need to share them again later in some way, but for now
	they can live with the rest of the daemon code.
	* upstart/: Delete.
	* init/Makefile.am (init_SOURCES): Remove control.c, control.h,
	notify.c and notify.h;  add enum.c and enum.h
	(TESTS): Remove test_control and test_notify; add test_enum
	(test_control_SOURCES, test_control_LDFLAGS, test_control_LDADD)
	(test_notify_SOURCES, test_notify_LDADD): Remove.
	(test_enum_SOURCES, test_enum_LDFLAGS, test_enum_LDADD): Add details
	(init_LDADD): Remove libupstart
	(test_process_LDADD, test_job_LDADD, test_event_LDADD)
	(test_parse_job_LDADD, test_parse_conf_LDADD, test_conf_LDADD): Remove
	libupstart, control.o and notify.o; add enum.o
	* init/control.c, init/control.h, init/tests/test_control.c: Delete
	* init/notify.c, init/notify.h, init/tests/test_notify.c: Delete
	* init/enum.c, init/job.c, init/job.h: Update include path for enum.h
	* init/parse_job.c: Remove unnecessary enum.h include
	* init/tests/test_enum.c: Update to reflect where it is.
	* init/main.c (main): Drop control socket opening.
	* init/tests/test_job.c: Remove unnecessary control.h include
	* init/event.c (event_pending, event_finished): Remove calls to
	notify_event and notify_event_finished
	* init/job.c (job_change_goal, job_change_state): Remove calls
	to notify_job.
	* init/tests/test_parse_conf.c: Remove calls to notify_init
	* init/tests/test_parse_job.c: Remove calls to notify_init
	* init/tests/test_event.c (test_poll): Strip out the part of the
	test that checks processes are notified.
	(check_event, check_event_finished): Remove.

	* configure.ac: Bump Autoconf dependency to 2.61 to match libnih
	* HACKING: Bump dependency in docs too.

	* NEWS: Copy in news from 0.3.9; that release doesn't appear in
	this ChangeLog since it was made on a separate branch by backporting
	bug fixes made here.
	* configure.ac: Bump version to 0.5.0, which is where development
	is heading for.

2007-10-12  Scott James Remnant  <scott@netsplit.com>

	* HACKING: Change URL for libnih.

2007-10-08  Scott James Remnant  <scott@netsplit.com>

	* configure.ac (AM_GNU_GETTEXT_VERSION): Bump to 0.16.1 since this
	version of gettext is needed for compatibility with Automake 1.10
	* HACKING: Bump version in the docs too.

	* compat/sysv/Makefile.am: Only create symlinks if COMPAT_SYSV is
	enabled, otherwise we leave dangling ones.

	* Makefile.am (ACLOCAL_AMFLAGS): Specify that aclocal install
	ordinarily system-wide macros into m4 (libtool.m4, specifically).
	This makes it easier for packagers to modify autoconfery since
	aclocal is no longer a destructive event.
	* configure.ac (AM_INIT_AUTOMAKE): Increase Automake requirement to
	1.10 to ensure we have aclocal --instal
	* HACKING: Increase Automake version in the docs.

2007-09-21  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_detect_stalled, job_free_deleted): Call job_init()
	on entry, since we don't have a Job pointer passed to us, we need
	to make sure we don't dereference a potentially NULL list.

2007-06-22  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* init/job.h: Update prototype of job_change_goal.
	(Job): Remove cause member.
	* init/job.c (job_change_goal): Drop additional argument since cause
	is no longer used.
	(job_change_state, job_child_reaper, job_handle_event): Only pass
	two arguments to job_change_goal.
	* init/control.c (control_job_start, control_job_stop): Only pass
	two argumenst to job_change_goal.
	* init/tests/test_job.c (test_change_goal, test_change_state): Only
	pass two arguments to job_change_goal.

	* init/job.c (job_new): Drop setting of cause.
	(job_change_cause): Drop this function entirely.
	(job_change_goal, job_change_state): Drop calls to job_change_cause
	(job_change_state, job_child_reaper): Don't pass job->cause to
	job_change_goal calls.

	* init/tests/test_job.c: Remove all tests that checked the value of
	job->cause, since that variable is going away.
	(test_change_goal): Remove the specific tests that checked whether
	cause was updated or not.

	* init/job.c (job_run_process): Replace the arguments from the event
	with a list of event names.
	* init/tests/test_job.c (test_run_process): Update test case to
	supply arguments from the list of events.

	* init/process.c (process_setup_environment): Drop the UPSTART_EVENT
	environment variable; it doesn't make sense when you can have multiple
	events.
	(process_setup_environment): Put all variables from the job's start
	events into the job's environment; replacing the UPSTART_EVENT variable

	* init/job.c (job_change_cause): Don't notify the job event
	subscribers when changing the cause.
	* init/notify.c (notify_job_finished): Instead notify them when
	the job reaches a rest state.

	* init/notify.c (notify_job): Call notify_job_event regardless,
	since this now looks over the start_on and stop_on fields.
	(notify_job_event): Rewrite to iterate over start_on and stop_on,
	and notifying for each cause event found.
	(notify_job_event_caused): Static function that is the guts of the
	above function.
	* init/tests/test_notify.c (test_job, test_job_event): Modify tests
	to refer exclusively to the start_on/stop_on expressions rather than
	the cause.

	* init/job.c (job_change_cause): Only notify the job event and
	update the cause member, we don't need to ref or block it anymore
	since that's handled by start_on and stop_on.
	* init/tests/test_job.c (test_change_goal): Drop checks on cause
	being referenced and blocked.
	(test_change_state, test_child_reaper, test_handle_event): Update
	test cases to not reference ->cause, and not count any references
	or blockers towards it.
	* init/tests/test_event.c (test_poll): Update expected reference
	and block counts for events handled by jobs.
	
	* init/tests/test_process.c (test_kill): Make sure that all processes
	in the process group are killed, rather than just the lone one.
	* init/process.c (process_kill): Send the signal to all processes
	in the same process group as the pid.
	* init/tests/test_job.c (test_change_state, test_kill_process):
	After spawning a child, call setpgid() to put it in its own process
	group otherwise we could end up TERMing ourselves.

	* init/tests/test_job.c (test_child_reaper): Update test cases to
	include checking of the start_on and stop_on expression trees.
	* init/job.c (job_child_reaper): Mark all blocked events in the
	start_on and stop_on trees as failed; since these are copies of
	the cause event, we can drop that setting already.

	* TODO: Update again, still thinking about the atomicity of event
	expressions.

2007-06-21  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_job.c (test_change_state): Include tests on a job's
	start_on and stop_on event expression trees, and make sure that events
	are unblocked and unreferenced at the appropriate moments.
	* init/job.c (job_change_state): Unblock the events that started the
	job in running (if a service), and reset when we reach waiting (leave
	referenced otherwise so the environment is always present).
	Unblock and unreference the events that stopped the job in
	starting (for restarting), running (if coming from pre-stop) and
	waiting.
	
	* init/tests/test_job.c (test_handle_event): Rewrite tests using
	event expressions, and make sure events are referenced and blocked
	correctly matching how jobs are affected.  Include tests for correct
	instance behaviour.
	(test_instance): Make sure that instances copy across the expression
	state, and reset the parent.
	* init/job.c (job_instance): After spawning a new instance, reset
	the start_on expression of the master job.

	* init/event.c (event_operator_copy): Change to making the parent
	of copies nodes be the actual tree parent, rather than the top
	parent; otherwise you can't free an entire tree in one go.
	* init/tests/test_event.c (test_operator_copy): Check parents of
	copied nodes.
	* init/tests/test_job.c (test_copy): Update parent checks here too.

	* init/tests/test_job.c (test_copy): Make sure that the job copy
	references and blocks the event; and in the event of failure, doesn't
	* init/job.c (job_copy): Reset the start_on and stop_on expressions
	in the event of failure.

2007-06-20  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* init/parse_job.c (parse_on): New generic parsing function to deal
	with event expressions, including operators, parentheses, etc.
	(parse_on_operator): Function called by parse_on() to deal with an
	operator or operand.
	(parse_on_paren): Function called by parse_on() to deal with a
	parenthesis.
	(parse_on_operand): Function called by parse_on_operator() to deal
	with a non-operator token.
	(parse_on_collect): Function called by all of the above to collect
	the operators on the stack and deposit them into the output box,
	either for collection by a later operator or for returning from
	parse_on().
	(stanza_start, stanza_stop): Call the new parse_on() function to
	deal with "start on" and "stop on", storing it in the appropriate
	part of the job.
	* init/tests/test_parse_job.c (test_parse_job): Replace list empty
	checks for start_events/stop_events with NULL checks on the new
	start_on/stop_on members.
	(test_stanza_start, test_stanza_stop): Test new stanza code.

	* init/errors.h (PARSE_EXPECTED_EVENT, PARSE_EXPECTED_OPERATOR)
	(PARSE_MISMATCHED_PARENS): Add numerics and strings for the errors
	that can be generated by parsing an event expression.
	* init/conf.c (conf_reload_path): Handle the new errors properly,
	including the line number where they occurred.
	* logd/jobs.d/logd.in: Update "stop on" to work with the new parser.

	* init/parse_job.c (stanza_emits): Each entry in the emits list
	is now an NihListEntry with the event name as the string data
	pointer, rather than an EventInfo structure (since that structure
	is gone).
	* init/tests/test_parse_job.c (test_stanza_emits): Update test
	case to check for NihListEntry structures.

	* init/parse_job.c: Where the stanza function parses an argument and
	can possibly reject it, save the position and line number and do not
	return that unless we're happy with the argument.  This ensures errors
	are raised pointing *at* the argument, rather than past it.
	* init/tests/test_parse_job.c: Fix several test case errors where
	the buffer was built incorrectly.  Pedantically check pos and lineno
	after successful parsing, and after errors, to make sure they are
	where they should be.

2007-06-18  Scott James Remnant  <scott@netsplit.com>

	* init/job.h (Job): Replace the start_events and stop_events NihLists
	with start_on and stop_on EventOperators.
	* init/job.c (job_new): Drop list initialising, and instead just set
	the new start_on/stop_on members to NULL.
	(job_copy): Copy the entire event operator tree to the new job,
	including references and blockers.  emits has changed to a list of
	NihListEntry with embedded strings, so copy them that way.
	(job_run_process): Drop "->info."
	(job_handle_event): Instead of iterating the events lists, call
	event_operator_handle and check the return value and top node value.
	(job_detect_stalled): Modify to iterate the start_on tree.
	* init/tests/test_job.c (test_change_state, test_detect_stalled): 
	Drop references to "->info." since we can get the variables directly.
	(test_new): Check that start_on and stop_on are NULL.
	(test_copy): Adjust tests of copying start_on and stop_on trees as
	well as the emits list.
	(test_handle_event, test_handle_event_finished) 
	(test_detect_stalled): Change references from start_events to start_on,
	stop_events to stop_on and construct using EventOperators instead.
	(test_handle_event): Update number of blockers now that the event
	expressions themselves will block the event.
	* init/tests/test_event.c (test_poll): Update number of blockers since
	both the events and cause will block it for now; also change
	start_events and stop_events to start_on and stop_on respectively.

	* init/event.c (event_operator_copy): Copy the children nodes as well.
	* init/tests/test_event.c (test_operator_copy): Test copying
	with children nodes.

	* init/tests/test_control.c (test_event_emit): Drop "->info."

	* init/notify.c (notify_event, notify_event_finished): Drop
	"->info." from event references.

	* init/process.c (process_setup_environment): Drop "->info." from
	cause references
	* init/tests/test_process.c (test_spawn): Likewise.

	* init/event.h (Event): Directly include the name, args and env
	fields rather than using an interim structure; this makes more sense
	since we use them differently than a match does.
	(EventOperatorType, EventOperator): New structure to build event
	expression trees that combine a match with "or" and "and" boolean
	operators; solve some problems by holding the reference and blocker
	on the matched event inside this structure directly and provide
	methods to unblock and reset them.
	(EventInfo): Drop this structure completely now that it is unused.
	* init/event.c (event_info_new): Rename this structure to
	event_operator_new() and initialise the new fields properly.
	(event_info_copy): Likewise rename to event_operator_copy and deal
	with copying event references and blockers over to the new structure,
	since the state is useful to copy.
	(event_match): Rename to event_operator_match and switch the arguments
	around since it makes slightly more sense that way.
	(event_operator_update): Function to update the value of an EVENT_OR
	or EVENT_AND operator based on the value of the two children.
	(event_operator_handle): Function to iterate an entire expression
	tree looking for a given event, and update the values of other
	operators if matched.
	(event_operator_unblock): Function to iterate an expression tree
	and release any events we're blocking.
	(event_operator_reset): Function to iterate an expression tree,
	unreferencing any events and resetting all values back to FALSE.
	(event_new, event_pending, event_finished): Update references to
	the Event structure to discard the intermediate "->info."
	* init/tests/test_event.c (test_info_new): Rename to
	test_operator_new() and test various features of the function added
	in the converstion.
	(test_info_copy): Likewise rename to test_operator_copy() and add a
	few more tests, especially that blockers and references are copied.
	(test_match): Rename to test_operator_match() and adjust argument
	order to match the change.
	(test_new) Call event_init() to avoid a valgrind error and update
	references to drop "->info."
	(test_poll): Use EventOperators in the job to test event polling,
	rather than the old structures.
	(test_operator_update, test_operator_handle, test_operator_unblock)
	(test_operator_reset): Test behaviour of the new functions.

2007-06-13  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update utmp/wtmp thoughts.

2007-06-12  Scott James Remnant  <scott@netsplit.com>

	* init/paths.h: Remove extra /, oops.
	* init/Makefile.am (install-data-local): Make destination
	configuration directories as part of "make install".
	(AM_CPPFLAGS): Define LEGACY_CONFDIR to be $(sysconfdir)/event.d
	* logd/Makefile.am (jobs.d/logd): Replace mkdir_p with MKDIR_P
	* init/main.c: Use macro to pick up /etc/event.d so it can be moved
	by configure

	* TODO: Update.

	* init/Makefile.am (AM_CPPFLAGS): Define CONFDIR to be
	$(sysconfdir)/init, replacing the old CFG_DIR definition.
	* init/paths.h (CFG_DIR): Replace with CONFDIR definition,
	and set the default to /etc/init
	* init/main.c: Load configuration from /etc/init/init.conf,
	/etc/init/conf.d and /etc/init/jobs.d; retain loading from /etc/event.d
	for the time being.
	* init/man/init.8: Change reference to directory.
	* logd/Makefile.am: Replace references of eventdir with jobsdir,
	and event.d with jobs.d
	* logd/event.d: Rename to logd/jobs.d

	* init/conf.c (conf_reload): Ignore ENOENT, it's not interesting
	in the general case.

	* init/tests/test_conf.c (test_source_reload): Test the general
	reload function.

	* init/tests/test_conf.c (test_source_free): s/unlink/rmdir/
	(test_source_reload_file): Test that configuration files work, and
	are parsed with anything alongside ignored automatically.
	* init/conf.c (conf_file_filter): As well as not filtering out the
	source path itself, we also need to not filter out the path we're
	watching which is different in the case of files; we need to know
	about it because we handle its removal.
	(conf_delete_handler): Compare the path deleted against the path
	we're watching, rather than the source path, since this means the
	watch needs to be freed.

	* compat/sysv/shutdown.c: Use nih pidfile functions since they're
	more reliable than doing it ourselves.

2007-06-11  Scott James Remnant  <scott@netsplit.com>

	* init/conf.c (conf_reload_path): Call parse_conf for mixed files
	and directories.  Make a correction to the old_items code, was
	passing the wrong arguments to nih_list_add; the effect we wanted
	was that we add the old items head into the list, and remove the
	existing head (what we did was add the first item to the old_items
	list and then cut the rest out).
	* init/tests/test_conf.c (test_source_reload_dir): Rename to
	test_source_reload_job_dir, since that's what this does.
	(test_source_reload_conf_dir): Add another function that tests
	directories of mixed configuration.

	* init/parse_conf.c (parse_conf): Parse a configuration file that
	defines jobs by name.
	(stanza_job): Job stanza, slightly trickier than it would appear to
	need to be, to parse the block in-place and keep pos/lineno
	consistent.
	* init/parse_conf.h: Prototype for external function.
	* init/tests/test_parse_conf.c: Test suite for mixed configuration
	parsing.
	* init/Makefile.am (init_SOURCES): Build and link parse_conf.c and
	parse_conf.h
	(TESTS): Build and run parse_conf tests
	(test_parse_conf_SOURCES, test_parse_conf_LDFLAGS) 
	(test_parse_conf_LDADD): Details for parse_conf test suite.
	(test_conf_LDADD): Add parse_conf.o and conf.o since this calls
	them now.

	* init/conf.c (conf_source_reload, conf_source_reload) 
	(conf_reload_path): Add some debugging messages.

	* init/conf.c (conf_source_new): Add missing call to conf_init()

	* init/conf.c (conf_item_new): Drop source parameter, since it's
	unused in the function and makes it harder to call this when we
	only have one data pointer.
	(conf_reload_path): Drop source from conf_item_new() call.
	* init/conf.h: Update prototype.
	* init/tests/test_conf.c (test_item_new, test_item_free) 
	(test_file_free): Drop source parameter from calls.

2007-06-10  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (main): Add a handler for the SIGHUP signal
	(hup_handler): Handler for SIGHUP, just calls conf_reload().

	* init/main.c (main): Read the configuration again.

	* TODO: Update.

	* init/tests/test_conf.c (test_source_reload_dir): Reset the priority
	and clean up consumed inotify instances.
	(test_source_free, test_file_free, test_item_free): Test the free
	functions on their own, paying special attention to conf_item_free()
	even though this really duplicates other tests.

	* init/conf.c (conf_reload_path): In the case where we fail to map
	the file into memory, we still need to purge all the items that
	previously existed.
	* init/tests/test_conf.c (test_source_reload): Rename to
	test_source_reload_dir, so that we can keep this and the file
	tests separate to make it easier to deal with.
	(test_source_reload_dir): Add tests for physical and parse errors
	when re-loading jobs with and without inotify, and for inotify-based
	modification handling of jobs.

	* init/tests/test_conf.c (test_source_reload): Add test for walk
	of non-existant directory with and without inotify; also test for
	what happens when the top-level directory is deleted, again with
	and without inotify.
	* init/conf.c (conf_delete_handler): Handle the case of the top-level
	directory being deleted by freeing the watch (so next time we asked
	to reload, we can restore it).

	* init/tests/test_conf.c (test_source_reload): Add a test for
	deletion of a running job.

	* init/conf.c (conf_item_free): Fix this up; when deleting an item
	from a source, we first mark it for deletion unless it's already
	marked for replacement.  Then if it's the replacement for something
	else, we mark that to be replaced by whatever we're being replaced
	by (so there are no references to us) and change that state if
	necessary.  Finally we replace our own item and free the record
	before returning.
	* init/tests/test_conf.c (test_source_reload): Check that we handle
	the cases of modiciation of a running job, modification of a
	replacement of a running job and deletion of a replacement for a
	running job.

	* init/parse_job.c (parse_job): Instead of freeing the previous
	replacement, which could leave invalid references to it, mark it
	for deletion and change the state.
	* init/tests/test_parse_job.c (test_parse_job): Adjust the test so
	that we hold a reference to the replacement job and make sure that
	the state is changed to deleted, rather than checking for a destructor
	being called on it.

	* init/init.supp (conf-init): Add valgrind suppression for the
	configuration sources hash table.

	* init/conf.c (conf_item_free): Don't overwrite any previous
	replacement, only mark us for deletion if we wouldn't otherwise
	be replaced.  Add some commented possible code for testing.
	* init/tests/test_conf.c (test_source_reload): Test replacement of
	jobs works properly; test modification with direct write and with
	atomic rename replace; test deletion.

	* init/conf.c (conf_reload_path): It turns out that the flag trick
	doesn't work for items since we often reparse them within the same
	file tag (it works with files because they're atomic and reparsed).
	Store the old items in a different list instead.
	(conf_source_free): We need to be careful about freeing sources,
	so have a function to do it properly.
	(conf_item_new): Since the flag member isn't useful, don't bother
	setting it.
	* init/conf.h: Add conf_source_free prototype.
	(ConfFile): Remove flag member.
	* init/tests/test_conf.c (test_source_reload): Add test for inotify
	create detection.

	* init/conf.c (conf_file_delete): Rename to conf_file_free and match
	the pattern of those kinds of functions.
	(conf_item_delete): Likewise rename to conf_item_free and match the
	pattern of these kinds of functions.
	* init/conf.h: Add prototypes.

	* init/conf.c (conf_reload_path): Fix bug with job name generation.
	Allow non-parsing errors to be returned from the function.
	(conf_item_delete): Drop all replacement management code, we'll put
	this back through testing.
	* init/tests/test_conf.c (test_source_reload): Test reloading adds
	the right inotify watch and parses the files, also check that loading
	without inotify and mandatory reloading work.

	* init/conf.c (conf_source_reload): Move the item deletion detection
	code from this function, where it would only happen on a mandatory
	reload
	(conf_reload_path): to this function, where it will happen every time
	the file is parsed; which is actually what we want.

2007-06-08  Scott James Remnant  <scott@netsplit.com>

	* init/conf.h (ConfItem): Drop the name and replace it with a type.
	(ConfItemType): Enum for different types of configuration items
	(ConfFile): Change items from a hash table to a list.
	* init/conf.c (conf_file_get): Initialise the items member as a list.
	(conf_item_set): Rename to conf_item_new again.
	(conf_item_new): Allocates a new ConfItem and adds it to the file's
	list, we won't reuse items anymore since it doesn't really make sense.
	(conf_source_reload): Adjust clean-up code now that items is a list.
	(conf_reload_path): Work out the name of jobs found by filename,
	allocate a new item for them and parse the job into it.  Perform
	handling of errors by outputting a warning.
	(conf_item_delete): Takes both source and file so we can make
	intelligent decisions.
	(conf_file_delete): Takes a source and passes it to conf_item_delete
	(conf_delete_handler): Pass both source and file to conf_file_delet
	* init/tests/test_conf.c (test_file_get): Check that the items
	list is empty; rather than the hash being unallocated.
	(test_item_set): Rename back to test_item_new and only allocate a
	single item which should get added to the list.

2007-06-06  Scott James Remnant  <scott@netsplit.com>

	* init/parse_job.c (stanza_respawn): Permit the word "unlimited",
	raise a specific error for illegal limit and illegal interval.
	(stanza_pid, stanza_kill, stanza_normal, stanza_umask) 
	(stanza_nice, stanza_limit): Raise specific errors rather than
	a generic "illegal value" error.
	* init/tests/test_parse_job.c (test_stanza_respawn): Check that
	we can use "unlimited", also check for new error return.
	(test_stanza_pid, test_stanza_kill, test_stanza_normal) 
	(test_stanza_umask, test_stanza_nice, test_stanza_limit): Check
	for new specific errors.
	* init/errors.h: Replace CFG_ILLEGAL_VALUE with a series of parse
	errors.

	* init/conf.c: Comments.

	* init/conf.c (conf_item_set): Call out to conf_item_delete() to
	handle unsetting of an item's data.
	(conf_source_reload): Add code to deal with mandatory reloading,
	calls conf_file_delete() and/or conf_item_delete() as appropriate.
	(conf_delete_handler): Call conf_file_delete() on the ConfFile that
	we find.
	(conf_file_delete): Function to delete all items in a file.
	(conf_item_delete): Placeholder function to delete an item.

	* init/conf.c (conf_file_new): Rename to conf_file_get; in practice
	we never just want to allocate one of these, we always want to
	return the existing entry if it exists.
	(conf_item_new): Rename to conf_item_set; again in practice we always
	want to update an existing item.  This function will grow the "deal
	with replacement" stuff.
	(conf_reload): Start putting in place the code that will allow
	mandatory reloads, as well as initial setup.  This function iterates
	over the sources and deals with errors.
	(conf_source_reload): Function to reload an individual source, calls
	out to one of the following two functions and will eventually perform
	the deleted items scan.
	(conf_source_reload_file): Set up a watch on a file, and reload it.
	(conf_source_reload_dir): Set up a watch on a directory and reload it.
	(conf_file_filter): Filter for watching parent directory of files.
	(conf_create_modify_handler): File creation and modification handler.
	(conf_delete_handler): File deletion handler.
	(conf_file_visitor): Tree walk handler.
	(conf_reload_path): Function that deals with files themselves,
	currently just sorts out the ConfFile structure and maps the file
	into memory.
	* init/conf.h: Add new prototypes, update existing ones.
	* init/tests/test_conf.c (test_file_new): Rename to test_file_get,
	also test repeated calls when already in the table.
	(test_item_new): Rename to test_item_set, also test repeated calls
	when already in the table.
	(test_source_reload): Start of test for reloading sources.

2007-06-05  Scott James Remnant  <scott@netsplit.com>

	* init/conf.c: Make a start on the new configuration management
	routines, which will allow finer-grained tracking of configuration
	and support mandatory reloading.
	(conf_source_new, conf_file_new, conf_item_new): Start off with the
	functions to allocate the tracking structures we need to use.
	* init/conf.h: Structures and prototypes
	* init/tests/test_conf.c: Test suite for allocation functions.
	* init/Makefile.am (init_SOURCES): Build and link conf.c and conf.h
	(TESTS): Run the conf test suite.
	(test_conf_SOURCES, test_conf_LDFLAGS, test_conf_LDADD): Details for
	the conf test suite.

2007-06-04  Scott James Remnant  <scott@netsplit.com>

	* init/parse_job.c (stanza_description, stanza_author, stanza_version)
	(stanza_chroot, stanza_chdir, stanza_pid): Instead of erroring when
	the string has already been allocated, free it and replace it with the
	new one. Attempting to forbid duplicates is just too inconsistent,
	especially for the integer ones which we compare against the default;
	using the last one allows us to be entirely consistent.
	(stanza_daemon, stanza_respawn, stanza_service, stanza_instance):
	Don't error if the flag is already set, just ignore it.
	(stanza_respawn, stanza_pid, stanza_kill, stanza_console) 
	(stanza_umask, stanza_nice): Don't compare the current value against
	the default, just overwrite it!
	(parse_exec, parse_script): Free existing process command string
	before setting a new one over the top.
	(parse_process, stanza_exec, stanza_script, stanza_limit): Instead of
	erroring if the structure is already set and allocated, just don't
	allocate a new one and allow its members to be overwritten.
	* init/tests/test_parse_job.c (test_stanza_exec) 
	(test_stanza_script, test_stanza_pre_start) 
	(test_stanza_post_start, test_stanza_pre_stop) 
	(test_stanza_post_stop, test_stanza_description) 
	(test_stanza_author, test_stanza_version, test_stanza_daemon) 
	(test_stanza_respawn, test_stanza_service, test_stanza_instance) 
	(test_stanza_pid, test_stanza_kill, test_stanza_console) 
	(test_stanza_umask, test_stanza_nice, test_stanza_limit) 
	(test_stanza_chroot, test_stanza_chdir): Replace tests that check
	for an error in the case of duplicate stanzas with tests that make
	sure the last of the duplicates is used.
	* init/errors.h (CFG_DUPLICATE_VALUE, CFG_DUPLICATE_VALUE_STR): Drop
	this error, since we don't consider this a problem anymore.

	* upstart/Makefile.am (libupstart_la_LIBADD): Add $(LTLIBINTL)
	* init/Makefile.am (init_LDADD): Reorder and add $(LTLIBINTL)
	* util/Makefile.am (initctl_LDADD): Reorder and add $(LTLIBINTL)
	* compat/sysv/Makefile.am (reboot_LDADD): Reorder and add $(LTLIBINTL)
	(runlevel_LDADD): add $(LTLIBINTL)
	(shutdown_LDADD): Reorder and add $(LTLIBINTL)
	(telinit_LDADD): Reorder and add $(LTLIBINTL)
	* logd/Makefile.am (logd_LDADD): Add $(LTLIBINTL)

2007-06-03  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_job.c (test_run_process): Add a test case for a
	crasher when the event has no arguments.
	* init/job.c (job_run_process): Fix the bug, we need to check the
	arguments before trying to append them.

	* init/cfgfile.c, init/cfgfile.h, init/tests/test_cfgfile.c: Rename
	to parse_job and strip out all functions except the parsing and stanza
	ones.
	* init/Makefile.am (init_SOURCES): Build and link parse_job.c and h
	(TESTS): Run the parse job test suite
	(test_cfgfile_SOURCES, test_cfgfile_LDFLAGS, test_cfgfile_LDADD):
	Rename and update.
	* init/parse_job.c: Rename all cfg_stanza_*() functions to just
	stanza_*(), rename all cfg_parse_*() functions to just parse_*().
	(parse_job, parse_process, stanza_exec, stanza_script, stanza_start)
	(stanza_stop, stanza_emits, stanza_normal, stanza_env, stanza_limit):
	Don't use NIH_MUST, it's fine to be out of memory and we should fail
	in that case with a useful error.  The user can always reload the
	config file.
	(cfg_read_job, cfg_watch_dir, cfg_job_name, cfg_create_modify_handler)
	(cfg_delete_handler, cfg_visitor): Drop these functions for now.
	* init/parse_job.h: Update so it just contains the one prototype.
	* init/tests/test_parse_job.c: Update all tests to pass a string
	to parse_job(), and check errors raised; rather than mucking around
	with file descriptors all of the time.  Spend the effort while we're
	in here to run TEST_ALLOC_FAIL where we can.
	* init/main.c: Drop config file loading for now since it's missing.

2007-05-27  Scott James Remnant  <scott@netsplit.com>

	* init/cfgfile.h (CFG_DIR): Drop this define, since it's in paths.h
	(CfgDirectory): 

	* init/cfgfile.c (cfg_read_job): Separate out the job-handling code
	into a new function that we could call from a stanza if we want
	later; this one now just maps the file into memory and deals with
	exceptions from the parsing.
	(cfg_parse_job): Function containing the seperated out code; parses
	a new job, marking it as a replacement for any existing job with the
	same name.  Drop the warnings for using pid options without a daemon,
	since these are actually useful for other things later.
	* init/tests/test_cfgfile.c (test_read_job): Drop the check on
	unexpected daemon options, since we don't issue these warnings
	anymore.

2007-05-20  Scott James Remnant  <scott@netsplit.com>

	* init/event.c (event_match): Change to accept Event as the first
	argument and EventInfo as the second, making it obvious that this
	matches a received Event against known EventInfo rather than just
	comparing two info structs (since the order matters).
	* init/event.h: Update prototype.
	* init/tests/test_event.c (test_match): Update test accordingly.
	(test_poll): Fix typo.
	* init/job.c (job_handle_event): Pass in the event as the first
	argument to event_match, rather than its info.
	* TODO: Update.

	* init/job.c (job_emit_event): Return the event that we emit; don't
	bother tracking block status or setting blocked, leave that to the
	state loop so things are more obvious.
	(job_change_state): Set the blocked flag here for starting and stopping
	to the return value of job_emit_event().

	* init/event.c (event_ref, event_unref): Reference counting of events
	so we don't free those we still need.
	(event_block, event_unblock): Blocker counting that replaces the
	previous jobs member.
	(event_new): Initialise refs and blockers fields.
	(event_emit_finished): Remove this function.
	(event_poll): Handle the new done state, and deal with the blockers
	and references counts; turns out that we can fall all the way through
	this switch if these are zero without needing to check again.
	(event_pending): Remove call to event_emit_finished, the event_poll()
	loop handles this case now.
	(event_finished): Set progress to done on the way out.
	* init/event.h (EventProgress): Add new done state
	(Event): Add refs and blockers members, replacing jobs
	* init/tests/test_event.c (test_new): Check refs and blockers are
	initialised to zero.
	(test_ref, test_unref, test_block, test_unblock): Check the ref
	counting function behaviours.
	(test_emit_finished): Drop this function since it's not used
	* init/job.c (job_change_cause): Reference and block the event,
	and unblock and unreference before changing.
	(job_emit_event): Reference the event that blocks the job from
	continuing.
	(job_handle_event_finished): Unreference the blocking event again.
	(job_change_state): Make sure that blocked has been cleared before
	allowing a state change.
	* init/tests/test_job.c: Change tests to use refs/blockers on the
	cause event when counting, and also to follow the status of blocked
	since that is now ref-counted as well.

2007-05-18  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (main, cad_handler, kbd_handler, pwr_handler): Use
	event_new rather than event_emit.
	* init/job.h (Job): Change type of cause and blocked to Event
	* init/job.c (job_change_goal, job_change_cause, job_emit_event) 
	(job_handle_event, job_handle_event_finished): Update all references
	to EventEmission to use Event instead.
	(job_detect_stalled): Call event_new instead of event_emit
	(job_run_process): Use the info member of cause, not event member
	* init/tests/test_job.c (test_change_goal, test_change_state) 
	(test_run_process, test_child_reaper, test_handle_event) 
	(test_handle_event_finished): Update all references to EventEmission
	to use Event instead.
	(test_detect_stalled): Correct to use right structure types.
	* init/process.c (process_setup_environment): Use cause's info member,
	rather than event member.
	* init/tests/test_process.c (test_spawn): Update to use Event.
	* init/notify.h (NotifySubscription): Change member to event
	* init/notify.c (notify_subscribe_event) 
	(notify_subscription_find, notify_job_event, notify_event) 
	(notify_event_finished): Update functions to use event member and
	Event structures.
	* init/tests/test_notify.c (test_subscribe_event) 
	(test_subscription_find, test_job, test_job_event, test_event) 
	(test_event_finished): Update to use Event instead of EventEmission
	* init/control.c (control_event_emit): Update to use event_new.
	* init/tests/test_control.c (test_event_emit) 
	(test_subscribe_events, test_unsubscribe_events): Update to use
	Event rather than EventEmission.

	* init/event.h: Fix up a few references.
	* init/tests/test_event.c (test_new): Remove reference to emission.

	* init/event.h (EventEmission): Rename to Event, and rename event
	member to info.
	* init/event.c (event_emit_next_id): Rename to event_next_id
	(event_emit): Rename to event_new, and add standard parent argument.
	(event_emit_find_by_id): Rename to event_find_by_id
	(event_poll): Iterate over Events in the list
	(event_pending, event_finished): Operate on Event
	* init/tests/test_event.c (test_emit): Rename to test_new and
	adjust for names and arguments.
	(test_emit_find_by_id): Rename to test_find_by_id and adjust for
	names.
	(test_emit_finished, test_poll): Adjust names.

	* init/cfgfile.c (cfg_stanza_start, cfg_stanza_stop) 
	(cfg_stanza_emits): Convert to use EventInfo and event_info_*.
	* init/job.c (job_copy): Use EventInfo and event_info_copy.
	(job_handle_event, job_detect_stalled): Iterate EventInfo structures
	* init/tests/test_cfgfile.c (test_stanza_start, test_stanza_stop) 
	(test_stanza_emits): Update to use EventInfo
	* init/tests/test_job.c (test_copy, test_handle_event) 
	(test_handle_event_finished, test_detect_stalled): Update to use
	EventInfo and event_info_new
	* init/event.c (event_copy): Use nih_str_array_copy here, to make the
	code somewhat simpler.
	(event_finished): Copy the arguments and environment from the old
	event, rather than stealing and reparenting.
	* init/job.c (job_copy): Use nih_str_array_copy here too.
	(job_run_process): Use nih_str_array_append to add the arguments from
	the emission onto the command run.

	* init/event.h (Event): Rename to EventInfo, since this structure
	representations information about an event, rather than an actual
	event in progress.
	* init/event.c (event_new): Rename to event_info_new, also now can
	take arguments and environment like event_emit() can.
	(event_copy): Rename to event_info_copy.
	* init/tests/test_event.c (test_new): Rename to test_info_new,
	update names in test and test being given args or env.
	(test_copy): Rename to test_info_copy and update names in test.
	(test_match, test_poll): Use EventInfo.

	* TODO: Update.

2007-04-24  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Add AM_PROG_CC_C_O since we use per-target flags
	for one of the test cases.

2007-03-16  Scott James Remnant  <scott@netsplit.com>

	* upstart/message.c (upstart_message_newv): Add va_end to match
	va_copy because the standard says so.
	* upstart/wire.c (upstart_push_packv, upstart_pop_packv): Add
	va_end here as well.

2007-03-13  Scott James Remnant  <scott@netsplit.com>

	* init/main.c: Wait until we've closed inherited standard file
	descriptors and opened the console instead before trying to open the
	control socket; otherwise we end up closing it by accident if we
	weren't opened with sufficient descriptors in the first place.
	Also wait until we've set up the logger before trying to parse the
	configuration.  In fact both of these things need to be pretty low
	down the main() function.

	* init/tests/test_job.c (test_run_process): Skip /dev/fd test cases
	if that's not available.

	* init/tests/test_control.c (test_log_priority): Make sure we know
	that the message has been sent before calling the watcher.

	* init/cfgfile.c (cfg_watch_dir): We get ENOSYS for missing inotify
	support, not EOPNOTSUPP.
	* init/tests/test_cfgfile.c (test_watch_dir): Actually make the
	directory tree before testing for inotify, since we use the same
	tree there too.

	* util/initctl.c (job_info_output): Restructure so gcc doesn't think
	name can be used uninitialised.
	* init/tests/test_cfgfile.c (test_watch_dir): Correct an error where
	i wouldn't be initialised if we skipped the inotify tests.

	* util/initctl.c (job_info_output): Restructure so gcc doesn't think
	* init/process.c (process_setup_environment): job id fits inside
	a %u now

	* upstart/message.h: Style; always refer to "unsigned int" as
	"unsigned int", and never "unsigned.
	* upstart/tests/test_message.c (my_handler): Catch a stray couple
	of "unsigned"s

	* init/control.c (control_job_query, control_job_start) 
	(control_job_stop): Change type of id argument to unsigned int,
	and call printf with %u to output it.
	* init/tests/test_control.c (check_job, check_job_instance) 
	(check_job_instance_end, check_job_status__waiting) 
	(check_job_status_end__waiting, check_job_status__starting) 
	(check_job_status_end__starting, check_job_status__running) 
	(check_job_status_end__running, check_job_status__pre_stop) 
	(check_job_status_end__pre_stop, check_job_status__stopping) 
	(check_job_status_end__stopping, check_job_status__deleted) 
	(check_job_status_end__deleted, check_job_unknown) 
	(check_job_invalid, check_job_unchanged, check_event): Change
	type of id arguments to unsigned int.
	(check_list): Change type of id to unsigned int.
	* init/tests/test_notify.c (check_job_status) 
	(check_job_status_end, check_job_finished, check_event) 
	(check_event_caused, check_event_finished): Change type of id
	arguments to unsigned int.

	* init/job.h (Job): Change the type of the id to unsigned int.
	* init/job.c (job_next_id): Change ids to be unsigned ints, and now
	we can just use %u in the nih_error call.
	(job_find_by_id): Change argument to be unsigned int
	* init/tests/test_job.c (test_find_by_id): Change id type to unsigned
	int.
	* init/event.h (Event): Change the type of the id to unsigned int.
	* init/event.c (event_emit_next_id): Change ids to be unsigned ints,
	and now we can just use %u in the nih_error call.
	(event_emit_find_by_id): Change argument to be unsigned int
	* init/tests/test_event.c (test_emit, test_emit_find_by_id) 
	(check_event, check_event_finished): Change id type to unsigned int.

	* util/initctl.c (output_name): Use an unsigned int for the job id,
	which means we can use ordinary %u for the printf argument.
	(handle_job, handle_job_finished, handle_job_instance) 
	(handle_job_instance_end, handle_job_status) 
	(handle_job_status_end, handle_job_unknown, handle_job_invalid) 
	(handle_job_unchanged, handle_event, handle_event_caused) 
	(handle_event_finished): Change argument type of id from uint32_t
	to unsigned int.
	(job_info_output): Change output type of id from %zu to %u

	* upstart/message.c (upstart_message_handle): Use unsigned int for
	ids, rather than a fixed-width type.
	* upstart/tests/test_message.c (my_handler): Use unsigned int for
	the ids, and give "unsigned int" instead of "unsigned" to va_arg as
	a matter of style.

	* upstart/wire.c (upstart_push_int, upstart_pop_int): Send over the
	wire using a plain old integer type, instead of a fixed width type;
	there's no advantage to using the fixed-width type and we could hurt
	ourselves if we tried running on ILP64.
	(upstart_push_unsigned, upstart_pop_unsigned): Likewise use a plain
	unsigned int over the wire.
	(upstart_push_string, upstart_pop_string): Use an unsigned int for
	the length of the string, technically this means that we silently
	truncate any string that's greater than 4GB on 64-bit platforms;
	it's either that or make the test cases harder (we did this before
	anyway).
	(upstart_push_header, upstart_pop_header): Type is always an unsigned
	int (best conversion from an enum)

2007-03-11  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.3.9

	* NEWS: Update.

	* util/man/initctl.8: Document the new commands.

	* TODO: Update.

	* init/job.c (job_handle_event): Correct the function so we don't
	try and stop the master of an instance, and cause an assertion error.

	* util/initctl.c: Oops, correct function pointers in command table

	* util/tests/test_initctl.c (test_version_action): 

	* util/initctl.c (handle_version): Handle receipt of the version
	reply.
	(version_action): Send the version-query message to the server and
	expect one response.
	(log_priority_action): Parse the single argument into an NihLogLevel
	and send it to the server.

	* init/control.c (control_version_query, control_log_priority):
	Functions to handle the new messages from the server pov
	* init/tests/test_control.c (test_version_query) 
	(test_log_priority): Test the new messages are handled properly.
	(check_version): Check the version string matches.
	* upstart/message.h: Add messages for querying the version of the
	init daemon and changing the log priority.
	* upstart/message.c (upstart_message_newv)
	(upstart_message_handle): Marshal the new messages.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Test the marshalling of the new messages,

	* upstart/libupstart.ver: Add enum functions to the global list.

	* util/initctl.c (start_action, stop_action): Imply --no-wait if
	we take the job id or name from an environment variable, since we'd
	end up waiting for ourselves otherwise
	* util/tests/test_initctl.c (test_start_action, test_stop_action):
	Update test cases to make sure no-wait is implied.

2007-03-09  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.3.8

	* NEWS: Updated.
	* configure.ac: Increase version to 0.3.7

	* init/tests/test_job.c (test_change_state): Add a test case for
	deleting the last instance of a replaced job.
	* init/job.c (job_change_state): When moving a instance of a job into
	the deleted state, check whether we should replace the job it's an
	instance of, and if so, change that job's state too.
	* TODO: Update.

	* util/initctl.c (handle_job_list): Always allocate current_list,
	since we need it to be the parent of pointers we attach to it.
	(handle_job_list_end): Always free the current list, only suppress
	output if there aren't any entries in it.
	(initctl_recv): Check the current_list pointer, no need for in_list
	(handle_job_instance, handle_job_instance_end, handle_job_status):
	Check current_list not in_list.
	* util/tests/test_initctl.c: Correct some memory leaks.

	* init/process.c (process_setup_environment): Set the UPSTART_JOB_ID
	environment variable to the job's unique id.
	* init/tests/test_process.c (test_spawn): Make sure it's set.

	* util/man/initctl.8: Update the initctl manpage.
	* compat/sysv/man/reboot.8: Correct a minor grammar error.
	* compat/sysv/man/shutdown.8: Fix reference from runlevel to telinit.

	* README: Add a README that copies the text from the web page and
	adds some notes about recommended operating system versions.

	* util/initctl.c: Completely rewrite initctl, top to bottom; handling
	of the new messages is done natively, meaning that the commands just
	vary the requests send and number of responses expected.
	* util/tests/test_initctl.c: Test all of the new code.

	* init/main.c: Improve restarting and rescuing a little; store the
	program path in a static variable so we can always access it, and
	use the exported loglevel to pass the same to the new process.
	* TODO: Update.

	* compat/sysv/shutdown.c: More error/fatal adjustments.
	* compat/sysv/telinit.c: More error/fatal adjustments.

2007-03-08  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (main, crash_handler): Promote deadly errors to nih_fatal
	* logd/main.c (main): Promote deadly errors to nih_fatal
	* compat/sysv/reboot.c (main): Promote deadly errors to nih_fatal
	* compat/sysv/shutdown.c (main, shutdown_now): Promote deadly errors
	to nih_fatal
	* compat/sysv/telinit.c (main): Promote deadly errors to nih_fatal

	* init/event.c (event_pending): The message that we're handling an
	event should be logged with --verbose.

	* init/cfgfile.c (cfg_parse_script): Remove the unnecessary check for
	a token inside a script block.

	* TODO: Update.

	* init/control.c (control_watch_jobs): Rename to control_subscribe_jobs
	and update to handle new event name.
	(control_unwatch_jobs): Rename to control_unsubscribe_jobs and update
	to handle the new event name.
	(control_watch_events): Rename to control_subscribe_events and update
	to handle the new event name.
	(control_unwatch_events): Rename to control_unsubscribe_events and
	update to handle the new event name.
	* init/tests/test_control.c (test_watch_jobs): Rename to
	test_subscribe_jobs and update to new event name.
	(test_unwatch_jobs): Rename to test_unsubscribe_jobs and update to 
	new event name.
	(test_watch_events): Rename to test_subscribe_events and update to
	new event name.
	(test_unwatch_events): Rename to test_unsubscribe events and update
	to new event name.

	* upstart/message.h: Rename the watch commands to subscribe/unsubscribe
	and regroup with new message numbers.
	* upstart/message.c (upstart_message_newv) 
	(upstart_message_handle): Marshal the updated subscription messages.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Update tests to new names and numbers.
	* TODO: Update.

	* upstart/message.c (upstart_message_handle): Raise a the unknown
	message error if the type is unknown, rather than the invalid message
	error.
	* upstart/tests/test_message.c (test_handle): Correct test case.

	* init/job.c (job_change_state): Correct a problem here too, when
	moving from pre-stop to running, we don't want to emit a started event
	since we never emitted a stopping event and never killed the process
	anyway.  We do need to notify the job as finished, since the process
	that tried to stop it will need to be told not to wait any longer.
	* init/tests/test_job.c (test_change_state): Add a test for pre-stop
	back to running.

	* doc/states.dot: Fix an error in the state diagram; when moving from
	starting back to waiting, due to a failed respawn, we need to emit
	the stopped event otherwise it will never happen.
	* doc/states.png: Update.

2007-03-05  Scott James Remnant  <scott@netsplit.com>

	* upstart/message.c (upstart_message_new): Make this a wrapper around
	(upstart_message_newv): which has all the old code, but accepts a
	va_list instead of making its own.
	* upstart/message.h: Add prototype.

	* init/main.c (crash_handler): Simply trying to leave a SEGV handler
	doesn't work so well, we end up repeating the problem instruction.
	We really can't resume from this point, and can't even jump elsewhere
	since our state is probably buggered up.  Only thing for it is to
	re-exec ourselves with a clean state.

	* init/cfgfile.c (cfg_read_job, cfg_delete_handler): Don't try and
	free the magic (void *)-1 replacement (delete).

	* util/events.c, util/events.c, util/jobs.c, util/jobs.h: With the
	new message responses, that intermix event and job information freely,
	it no longer makes sense to distinguish between them.  So fold these
	files back into the main initctl.c
	* util/initctl.h: Drop unused header.
	* util/Makefile.am (initctl_SOURCES): Update sources list.
	(TESTS): Change which tests we build
	(test_initctl_SOURCES, test_initctl_CFLAGS, test_initctl_LDFLAGS) 
	(test_initctl_LDADD): Build the new combined test case binary, use
	an automake feature to rebuild initctl.c with -DTEST and a different
	.o file, and thus be able to define out main()

	* util/tests/test_events.c, util/tests/test_jobs.c: Collapse the two
	test case files into one single
	* util/tests/test_initctl.c

	* init/control.c (control_job_find): And implement the find function
	that returns a list of jobs matching an optional pattern.
	* init/tests/test_control.c: Make sure we do send all messages.
	(check_list): Complex function to check the responses to a job list
	(test_job_find): Test a couple of job lists.
	* init/tests/test_notify.c: Make sure we do send all messages.

	* init/control.c (control_job_query): Implement the query message,
	this just needs to return the status or instance set.
	* init/tests/test_control.c (test_job_query): Test the query command.
	(check_job_status__deleted, check_job_status_end__deleted): Pair of
	functions to check we can query deleted jobs directly.

	* init/control.c (control_send_instance): Function to send an instance
	job, collating all of its instances together.
	* init/control.h: Update.
	* init/tests/test_control.c (test_send_instance): Check we receive
	the right messages.
	(check_job_instance, check_job_instance_end): Pair of functions to
	check the instance messages.

	* upstart/message.h: Add new UPSTART_JOB_INSTANCE and
	UPSTART_JOB_INSTANCE_END messages which we'll use to communicate that
	a job is an instance, and group the instances of it together.
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Marshal the new instance messages.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Test the new message types.

	* upstart/message.h: Restore arguments to JOB_LIST, but rename to
	pattern since that's what it is.
	* upstart/message.c (upstart_message_handle): Restore arguments
	with updated name.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Restore tests for arguments, rename and make sure we
	include a wildcard.

2007-03-04  Scott James Remnant  <scott@netsplit.com>

	* upstart/message.h: Drop arguments to JOB_LIST.
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Drop arguments to JOB_LIST.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Drop the arguments from the test.

	* init/control.c (control_job_start): Update to return INVALID for
	instances and replacements; add the forgotten UPSTART_JOB message.
	(control_job_stop): Update to return INVALID for replacements; add
	the forgotten UPSTART_JOB message.  Deal with instance masters
	magically by iterating all instances and stopping those instead.
	* init/tests/test_control.c (check_job_deleted): Rename to 
	check_job_invalid and check that message.
	(check_job): Function to check the job we've acted upon.
	(test_job_start): Check that we get the UPSTART_JOB message first,
	restore the check on deleted jobs causing an error and add checks
	that instance and replacement jobs also cause an error.
	(test_job_stop): Check that we get the UPSTART_JOB message first,
	restore the check on deleted jobs causing an error.  Make sure
	instances are handled.

	* upstart/message.h: More message changes; add a JOB_FIND message
	and replace UPSTART_JOB_DELETED with UPSTART_JOB_INVALID since there's
	a few more problem conditions.
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Marshal the new message and update names.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Update tests to check the new message and update the
	values and names of the existing ones.

	* init/job.h (Job): Remove the delete flag, add replacement and
	replacement_for pointers instead.
	* init/job.c (job_new): Initialise replacement and replacement_for
	pointers to NULL.
	(job_find_by_name): Update to return what job the one we found is
	a replacement for, and to skip DELETED jobs.
	(job_instance): Make it simply illegal to call this for deleted jobs,
	instances or replacements.
	(job_change_goal): Make it illegal to change the goal of a replacement
	job.
	(job_free_deleted): Remove the previous code to handle deleted instance
	masters, because it's now bogus.
	(job_should_replace): New function to determine whether a job is
	replaceable.
	* init/tests/test_job.c (test_new): Check pointers are set.
	(test_copy): Check that replacement and replacement_for are not
	copied, since their state of an individual job.
	(test_find_by_name): Update tests to make sure we ignore deleted jobs,
	instances and replacements.
	(test_instance): Remove test that will now cause an assertion,
	and no longer check delete is set.
	(test_change_goal): Remove test that will now cause an assertion.
	(test_free_deleted): Remove test cases for deleted masters.
	(test_should_replace): Test the new check function.
	(test_change_state): Make sure that we end up in deleted for instances
	and replaced jobs, and that replacements become the real job.
	* init/cfgfile.c (cfg_read_job): Update to handle replacement jobs;
	the old job's previous replacement is discarded, and set to the
	current job; and then if the job should be replaced, it's moved
	to deleted (which should promote the new job).
	(cfg_delete_handler): Handle deletion of a job in a similar manner,
	except we sent the replacement pointer to the special -1 value since
	we have no actual replacement.
	* init/tests/test_cfgfile.c (test_watch_dir): Update tests to make
	sure that deletion and modification are handled wrt replacement.
	(test_read_job): Make sure that reparsing an existing file is handled.
	* init/tests/test_control.c (test_job_start): Remove checks that
	delete gets set to true for instances.
	(test_job_stop, test_job_start): Temporarily comment out deleted
	job behaviour, since that's been somewhat changed.

	* upstart/message.h: We're not going to return JOB_LIST for JOB_STOP
	since that's just awkward for the client; just act on the master,
	and return JOB_UNCHANGED.

	* init/notify.c (notify_job_status): Move this function to
	* init/control.c (control_send_job_status): here, since we need it for
	the new control responses.
	(control_job_query): New single function to list all jobs or a
	particular job.
	* init/control.h: Add prototype.
	* init/tests/test_control.c (test_error_handler): Simplify this a
	little to just sending a NO_OP message, since we can send an entire
	stream of messages and leave them in the queue.
	(check_job_status__stopping, check_job_process) 
	(check_job_status_end__stopping): Trio of check functions for a job
	status that's stopping, with an active main process.
	(test_send_job_status): Test the now global status function.
	(check_job_status__starting, check_job_status_end__starting): Pair
	of check functions for a starting job with no process yet.
	(test_watch_jobs, test_unwatch_jobs): Update to expect the full new
	job status messages, with an optional process part as well.
	(check_event): Function to check an event.
	(test_watch_events): Minor update to use above function.
	(check_job_status__waiting, check_job_status_end__waiting): Pair of
	check functions for the first step in starting a job (goal change only)
	(check_job_unknown, check_job_deleted, check_job_unchanged): Trio
	of functions to check common error responses.
	(test_job_start): Update tests to newer behaviour.
	(check_job_status__running, check_job_status_end__running) 
	(check_job_status__pre_stop, check_job_status_end__pre_stop): Checks
	for the states we go through when stopping a job.
	(test_job_stop): Update tests to newer behaviour.
	* init/notify.c (notify_job, notify_job_event, notify_job_finished):
	Update to call the newly exported function.
	* init/job.c: Make job_id and job_id_wrapped externally available.
	* init/job.h: Update.
	* init/event.c: Make emission_id and emission_id_wrapped externally
	available.
	* init/event.h: Update.

	* upstart/message.h: Rename UPSTART_JOB_INVALID to
	UPSTART_JOB_UNCHANGED, as it's not really invalid just a no-op
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Update the constant, fields are unchanged,
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Rename constants/messages.

	* upstart/message.h: Turns out we need extra errors to indicate that
	the job was deleted or already at that goal, otherwise the client
	would sit there waiting for the finished event.	
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Marshal the new error messages.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Test the handling of the new messages.

	* init/tests/test_job.c (test_free_deleted): Found a bug; because
	master instances never change state, they never end up in the deleted
	state so are never reaped.  Add some test cases for cleaning them up,
	but not while they have remaining instances.
	* init/job.c (job_free_deleted): Implement the bug fix.

	* init/job.c (job_instance): Split out the instance spawning code
	into its own function, as we'll frequently need a pointer to the
	instance before we try and change the goal.
	(job_change_goal): Clean this function back up again, it no longer
	needs to return values and can assert that it's never called for
	deleted jobs or instance mastersr.
	(job_handle_event): Spawn an instance when we get a start event.
	* init/job.h: Update.
	* init/tests/test_job.c (test_instance): Check instance creation.
	(test_change_goal): Update tests now that it doesn't return a value
	again, and doesn't spawn instances itself.
	(test_handle_event): Make sure instances are spawned.

	* init/tests/test_event.c (test_poll): Needs a slight fix now that
	we generate more events than we check, and that subscriptions go
	away automatically.

	* init/notify.c (notify_job_status): Static function to handle
	sending the more complicated job status message series 
	(notify_job): Call notify_job_status() to send the new-style message
	(notify_job_event): Send the new UPSTART_EVENT_CAUSED message with
	the emission id, then call notify_job_status() to send the new-style
	common status message.
	(notify_job_finished): New function to be called when we reach the
	job rest state, notifies and unsubscribes directly subscribed
	processes, and includes failed information.
	(notify_event_finished): Unsubscribe processes after sending the
	finished event, since the event has gone away.  Also don't send
	this to processes subscribed to all events, since it's not useful
	for them.
	* init/notify.h: Add prototype.
	* init/tests/test_notify.c: Update all test cases and helper
	functions to the new message types.
	(test_job_finished): Check the new finished message is sent with
	a status message preceeding it.
	* init/job.c (job_change_state, job_change_state): Notify subscribed
	processes with notify_job_finished() when in the running (for service)
	or waiting states, just before we drop the cause.

	* upstart/message.h: Add failed, failed_process and exit_status
	arguments to UPSTART_JOB_FINISHED.
	* upstart/message.c (upstart_message_new, upstart_message_handle): 
	Marshal the new arguments.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Test the new arguments.

	* upstart/message.h: Update the message types, introducing a more
	structured job message set and replacing the UPSTART_EVENT_JOB_STATUS
	message with UPSTART_EVENT_CAUSED which will be immediately followed
	by an ordinary UPSTART_JOB_STATUS message.
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Marshal the new messages.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Test the new message types.
	* TODO: Update.

2007-03-03  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* init/cfgfile.c (cfg_parse_exec, cfg_parse_script): Separate out
	the parsing of an exec or script stanza into separate functions,
	seeing as this is quite a common operation.  This also means we
	just need to change them in one place now.
	(cfg_parse_process): Function to call either of the above depending
	on the next argument.
	(cfg_stanza_exec): Call cfg_parse_exec instead.
	(cfg_stanza_script): Call cfg_parse_script instead.
	(cfg_stanza_pre_start, cfg_stanza_post_start) 
	(cfg_stanza_pre_stop, cfg_stanza_post_stop): Call cfg_parse_process
	with the right arguments instead of doing by hand in each function.

	* init/event.c (event_emit_next_id): Split the id assigning code into
	a static inline function for easier modification.
	* init/job.c (job_next_id): Use the same style function here too.

2007-03-02  Scott James Remnant  <scott@netsplit.com>

	* init/event.c (event_emit): Port the slightly more efficient in the
	early case code from job_new.

	* init/job.h (Job): Add a unique id to the job structure.
	* init/job.c (job_new): Assign an incrementing id to each new job
	allocated.
	(job_find_by_id): Locate a job by its unique id, sadly not very
	efficient in a hash table ;-)
	(job_name): New hash key function since name isn't the first entry
	anymore.
	(job_init): Change hash key function.
	* init/tests/test_job.c (test_find_by_id): Make sure we can find a
	job by its id.

	* init/job.c (job_change_goal): Return the new instance in that
	circumstance, and clean up a little bit.
	* init/job.h: Update prototype.
	* init/tests/test_job.c (test_change_goal): Update tests.

	* init/job.c (job_find_by_name): Skip jobs marked for deletion too.
	* init/tests/test_job.c (test_find_by_name): Update test case.

	* init/event.h, init/notify.h, upstart/message.h: Provide C-level names
	for enums, this makes the compiler generate things that gdb can get.

	* init/job.c (job_run_process, job_kill_process, job_kill_timer):
	Change process argument to be a plain ProcessType, this means we
	know exactly which process we're trying to run or kill.
	(job_change_state): Update calls to job_run_process
	and job_kill_process
	* init/tests/test_job.c (test_run_process, test_kill_process): Update
	function calls to just pass a ProcessType in.

	* upstart/enum.h: Rename JobAction to ProcessType.
	* upstart/enum.c (job_action_name): Rename to process_name.
	(job_action_from_name): Rename to process_from_name.
	* upstart/tests/test_enum.c (test_action_name, test_action_from_name):
	Rename and update to match.
	* init/job.c (job_new, job_copy, job_change_state) 
	(job_next_state): Change JOB_*_ACTION constants to PROCESS_*.
	(job_find_by_pid): Change JobAction argument to ProcessType.
	(job_emit_event): Call process_name on the failed process.
	(job_child_reaper): Update to use ProcessType instead of JobAction.
	* init/job.h (Job): Change type of failed_process to ProcessType.
	* init/tests/test_job.c (test_find_by_pid): Update to use ProcessType
	instead of JobAction in tests.
	(test_new, test_copy, test_change_goal, test_change_state) 
	(test_next_state, test_run_process, test_kill_process) 
	(test_child_reaper, test_handle_event_finished): Change JOB_*_ACTION
	constants to PROCESS_*
	* init/cfgfile.c (cfg_stanza_exec, cfg_stanza_script) 
	(cfg_stanza_pre_start, cfg_stanza_post_start) 
	(cfg_stanza_pre_stop, cfg_stanza_post_stop): Change JOB_*_ACTION
	constants to PROCESS_*
	* init/tests/test_cfgfile.c (test_stanza_exec) 
	(test_stanza_script, test_stanza_pre_start) 
	(test_stanza_post_start, test_stanza_pre_stop) 
	(test_stanza_post_stop, test_read_job, test_watch_dir): Change
	JOB_*_ACTION constants to PROCESS_*
	* init/tests/test_event.c (test_poll): Change JOB_*_ACTION constants
	to PROCESS_*
	* init/tests/test_control.c (test_job_start, test_job_stop): Change
	JOB_*_ACTION constants to PROCESS_*

	* init/cfgfile.c (cfg_watch_dir): Restore the prefix argument; pass
	as the data pointer to the inotify callbacks and visitor function.
	Change the return value to be the watch structure.
	(cfg_job_name): Add prefix argument and prepend to relative path.
	(cfg_create_modify_handler, cfg_delete_handler, cfg_visitor): Get
	the prefix for the job names from the data pointer and pass to
	cfg_job_name().
	* init/cfgfile.h: Update prototypes.
	* init/tests/test_cfgfile.c (test_watch_dir): Actually test the
	watch functions.
	* init/main.c (main): Pass NULL for the prefix for the global job
	directory, compare the return value against (void *)-1.
	* TODO: Update.

	* init/cfgfile.c (cfg_stanza_on): Drop the simple on stanza.
	* init/tests/test_cfgfile.c (test_stanza_on): Remove test case.

	* TODO: Update.

2007-03-01  Scott James Remnant  <scott@netsplit.com>

	* util/jobs.c (handle_job_status): Drop the process field from the
	output for now.
	* util/events.c (handle_event_job_status): Likewise
	* util/tests/test_jobs.c (test_start_action, test_list_action) 
	(test_jobs_action): Drop pid from messages we simulate.
	* util/tests/test_events.c (test_emit_action): Likewise.

	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Remove the pid field from the job status and event job status
	messages.
	* upstart/message.h: Update description of job status and event
	job status message to remove the pid field.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Remove checks using the pid field.

	* init/control.c (control_job_start, control_job_stop) 
	(control_job_query, control_job_list): Remove the pid field from
	the messages, it'll come back later when we get better message
	formats.
	* init/tests/test_control.c (check_job_status, check_job_waiting) 
	(check_job_started, check_job_stopped): Remove checks on the process
	id, since that field is gone from the message.
	(test_job_stop): Use the pid field of the main process.
	(test_job_start): Initialise the main action process.

	* init/notify.c (notify_job, notify_job_event): Remove the pid field
	from the message, it'll come back later when we get better message
	formats.
	* init/tests/test_notify.c (check_job_status) 
	(check_event_job_status): Remove checks on the pid, since that field
	is no longer present.

	* init/job.c (job_process_copy): Use job_process_new here, oops.

	* init/cfgfile.c (cfg_stanza_exec, cfg_stanza_script) 
	(cfg_stanza_pre_start, cfg_stanza_post_start) 
	(cfg_stanza_pre_stop, cfg_stanza_post_stop): Use job_process_new
	to allocate process structures and store in the process array.
	* init/tests/test_cfgfile.c (test_read_job, test_stanza_exec) 
	(test_stanza_script, test_stanza_pre_start) 
	(test_stanza_post_start, test_stanza_pre_stop) 
	(test_stanza_post_stop): Update test cases to use process array
	member information.

	* init/tests/test_event.c (test_poll): Update to use newer job process
	array and find the pid under there.

	* init/job.h (Job): Remove the pid and aux_pid fields; replace the
	individual JobProcess pointers with an array of them of a fixed
	minimum size; replace failed_state with failed_process.
	(JobProcess): add a pid field here, so now we can obtain the pid on
	an individual process/action basis rather than global.
	* init/job.c (job_process_new): Function to create a JobProcess
	structure, setting the initial values to FALSE/NULL/0.
	(job_process_copy): Function to copy a JobProcess.
	(job_new): Don't initialise the pid or aux_pid members, initialise
	the process array to a fixed initial size and set the members to NULL,
	initialise the failed_process member to -1.
	(job_copy): Update to use job_process_copy and copy the process array.
	(job_find_by_pid): Look through the process structures in the job's
	process array to find the pid, and optionally return which action it
	was.
	(job_change_state): Call job_kill_process in the JOB_KILLED state if
	we have a main process and that has a pid, pass in the main process.
	(job_next_state): Check the process id of the main process when
	deciding what the next state is for running.
	(job_run_process): Store the process id in the process structure
	(job_kill_process): Accept a process structure and use that to obtain
	the process id we need to send TERM too.  Remove the code that forced
	a state change if kill() failed, since we will get a child signal
	anyway and should do it there.
	(job_kill_timer): Likewise, accept a process structure and don't
	forcibly change the state anymore.
	(job_child_reaper): Rewrite to switch based on the action that died,
	rather than the state we were in; assert that the state is what we
	expected.
	(job_emit_event): The argument to the failed event is now the action
	name, rather than the state name; an action of -1 indicates that
	respawn failed.
	* init/tests/test_job.c (test_process_new, test_process_copy): Make
	sure the structure is created and copied properly.
	(test_new, test_copy): Drop checks on the pid and aux_pid members,
	add checks for the process array and pid members of processes.
	(test_find_by_pid): Update test case to make sure we can find the pid
	of any process, returning the action index rather than the process
	pointer.
	(test_run_process, test_kill_process, test_change_goal)
	(test_change_state, test_next_state, test_child_reaper): Update test
	cases to use pid fields inside process structures rather than the
	pid or aux_pid members.
	(test_handle_event, test_handle_event_finished) 
	(test_free_deleted): Update to avoid pid field checks.

	* upstart/enum.h (JobAction): Enumeration of different actions.
	* upstart/enum.c (job_action_name, job_action_from_name): Enumeration
	to string conversion functions.
	* upstart/tests/test_enum.c (test_action_name) 
	(test_action_from_name): Tests for the new functions.

	* init/cfgfile.c (cfg_read_job): Instead of trying to copy over an
	old job's state and instances into the new one, mark the old job
	as deleted.  This ensures we never end up applying a new post-stop
	script to a job started with an old pre-start script, etc.  It also
	makes life so much simpler.
	* init/tests/test_cfgfile.c (test_read_job): Update tests to make
	sure the old job is marked for deletion, instead of freed.
	* TODO: Update.

	* init/notify.c (notify_job): Split out notification to processes
	subscribed to the cause event into a new function
	(notify_job_event): We can call this when we change cause.
	* init/job.c (job_change_state): Notify anyone subscribed to the
	job after we've changed the state, rather than before, otherwise
	we won't know the new pids or anything.
	(job_change_cause): Call notify_job_event before changing the cause
	so that subscribers get a final status update.
	* init/tests/test_notify.c (test_job_event): Check the new function.
	* TODO: Update.

	* init/cfgfile.c (cfg_stanza_respawn): Remove the shortcut that
	lets you specify "respawn COMMAND".  It was confusing as it hid
	the common "[when] exec"/"[when] script" syntax, made it non-obvious
	that "exec" and "respawn" were the same flag, etc.
	* init/tests/test_cfgfile.c (test_stanza_respawn): Update tests.
	(test_stanza_service): Fix test case to not use shortcut.
	* logd/event.d/logd.in: Update to not use respawn shortcut.

2007-02-25  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_child_reaper): Shift the signal value into the
	higher byte to make it easier to detect, and not stamp over exit
	statuses between 128 and 255.
	(job_emit_event): Detect the signal stored in the new way.
	* init/cfgfile.c (cfg_stanza_normal): Store signal in the higher bytes.
	* init/tests/test_job.c (test_copy, test_change_state) 
	(test_child_reaper): Update test cases.
	* init/tests/test_cfgfile.c (test_stanza_normal): Update test.

	* TODO: Update.

	* init/event.h (PWRSTATUS_EVENT): Add new power-status-changed event.
	* init/main.c (pwd_handler): Handle the SIGPWR signal by generating
	the new event, leave it up to a job to parse the file and do
	whatever it likes.

	* TODO: Update.

2007-02-13  Scott James Remnant  <scott@netsplit.com>

	* upstart/tests/test_message.c (test_reader, test_handle_using)
	(test_handle); Usual fix for gcc optimiser thinking that fixed
	for loops might not be.
	* init/tests/test_job.c (test_run_process, test_kill_process):
	Likewise.
	* init/tests/test_notify.c (test_subscription_find): I still don't
	know what a type-punned pointer is, nor why dereferencing such a
	thing would break strict-aliasing rules.
	* init/tests/test_cfgfile.c (test_read_job): More type-punning.
	* util/tests/test_jobs.c (test_start_action): More for-loop action.
	* util/tests/test_events.c (test_emit_action): And again.

2007-02-11  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_change_goal): We need to be able to stop a running
	job without a process, because that's what a job-as-state is!  The
	check was added because job_child_reaper calls job_change_goal and
	then job_change_state immediately after, we should fix that instead.
	(job_child_reaper): If we call job_change_goal while in the running
	state, it will call job_change_state for us; so check for that first
	and don't change the state!
	* init/tests/test_job.c (test_change_goal): Update the test to ensure
	that we can stop a job with no running process.

	* init/cfgfile.c (cfg_stanza_normalexit): normalexit is inconsistent,
	change to "normal exit"
	* init/tests/test_cfgfile.c (test_stanza_normalexit): Update.

	* init/cfgfile.c (cfg_stanza_start, cfg_stanza_stop) 
	(cfg_stanza_pre_start, cfg_stanza_post_start) 
	(cfg_stanza_pre_stop, cfg_stanza_post_stop, cfg_stanza_respawn):
	We're not going to allow stanza keywords to be quoted, since this
	gives us an easy way to allow users to make something explicitly
	not a keyword.

2007-02-10  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.3.6

	* configure.ac: Increase version to 0.3.5
	* NEWS: Update.
	* TODO: Update.

	* TODO: More notes.

	* TODO: Note an issue with using JobProcess->pid

	* init/cfgfile.c (cfg_stanza_pre_start, cfg_stanza_post_start) 
	(cfg_stanza_pre_stop, cfg_stanza_post_stop): Add a needed check
	for a token when parsing "exec".  Correct line number we expect
	to see the duplicated value on.  Correct expected error for missing
	argument from "Unexpected token" to "Expected token".

	* init/tests/test_cfgfile.c (main): Actually invoke the tests for
	the scripts.

	* init/cfgfile.c (cfg_read_job): Correct type of lineno in error.

	* TOOD: Minor notify bug

	* TODO: Big update.

	* init/tests/test_job.c (test_child_reaper): Make sure that we can
	reap post-start and pre-stop processes, and have only the aux_pid
	changed.  Also make sure that if the running process dies while
	in these states, with or without an aux process, that we don't
	transition badly.

	* init/job.c (job_find_by_pid): Check aux_pid as well.
	* init/tests/test_job.c (test_find_by_pid): Make sure we can find it.

	* init/job.h (Job): Add an auxiliary pid member.
	* init/job.c (job_new): Initialise the aux_pid member.
	(job_change_state): Run the post-start and pre-stop scripts when we
	enter the state with the same name (assuming they exist).
	(job_run_process): Store the pid in aux_pid when starting the
	post-start or pre-stop processes.
	* init/tests/test_job.c (test_change_state): Add tests for running
	the new post-start and pre-stop scripts; which get their process ids
	stored in aux_pid instead of pid.
	(test_new): Make sure the aux_pid member is initialised properly.
	(test_copy): Make sure the aux_pid member is not copied.

	* TODO: Update.

	* init/tests/test_job.c (test_change_state): Add a check for the
	daemon stanza holding the job in spawned; we snuck this in a while
	back and never tested it (there's no support to get it out of
	spawned yet).

	* init/job.h (Job): Add new post_start and pre_stop scripts.
	* init/job.c (job_new): Initialise new scripts to NULL.
	(job_copy): Copy the information from the new scripts over as well.
	* init/tests/test_job.c (test_new): Check they're initialised.
	(test_copy): Check that the information is copied properly.
	* init/cfgfile.c (cfg_stanza_post_start, cfg_stanza_pre_stop): Add
	new script stanza functions for the additional two scripts that
	we want.
	* init/tests/test_cfgfile.c (test_stanza_post_start) 
	(test_stanza_pre_stop): Add tests for the new stanzas.

	* init/cfgfile.c (cfg_stanza_exec, cfg_stanza_script): Rewrite to
	allocate a JobProcess and parse the command or script into it.
	(cfg_read_job): Fix the long broken assumption that pid_file and
	pid_binary are required for respawn, when they're actually required
	for daemon.
	(cfg_stanza_start, cfg_stanza_stop): Remove script second-level.
	(cfg_stanza_respawn): Parse into the job's process.
	(cfg_stanza_pre_start, cfg_stanza_post_stop): New stanzas for the
	processes alone.
	* init/tests/test_cfgfile.c (test_read_job): Update a few test
	cases to match reality.
	(test_stanza_start, test_stanza_stop): Remove script-related checks.

2007-02-09  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_job.c (test_kill_process): Poll the event queue
	after each test to get rid of the allocated events and make valgrind
	happy.
	* init/tests/test_control.c (test_job_start, test_job_stop)
	(test_event_emit): Poll the event queue after each test to get rid
	of the allocated events, as they make valgrind complain.
	(test_event_emit): Free args and env when done.

	* init/job.h (JobName): Drop obsolete structure
	(JobProcess): Add a new structure to represent a single process
	within the job, instead of using two variables to pick either the
	script or command.
	(Job): Change command and script to a single JobProcess called process;
	change start_script and stop_script to a JobProcess called pre_start
	and post_stop respectively.
	* init/job.c (job_new): Initialise new members to NULL.
	(job_copy): Copy the process structures across, including contents.
	(job_change_state): Call job_run_process passing in the structure;
	rather than fiddling with if statements.
	(job_run_script, job_run_command, job_run_process): Combine all of
	these three functions into a single new job_run_process function.
	* init/tests/test_job.c (test_new, test_copy, test_change_goal) 
	(test_change_state, test_child_reaper) 
	(test_handle_event_finished): Change to using JobProcess for when
	we need to construct a command.
	(test_run_script, test_run_command): Merge into single new
	(test_run_process) function.
	* init/tests/test_event.c (test_poll): Replace command with process.
	* init/tests/test_control.c (test_job_start): Change to using
	JobProcess to specify the command.

	* init/main.c (main): Run job_free_deleted each time through the
	main loop.

	* init/job.c (job_change_goal): Minor tweak to the logic; we may
	have just made the job an instance, that should still let us stop
	the one underneath.

	* TODO: Update.

	* util/jobs.c (do_job): Always expect a list of replies.

	* init/control.c (control_job_status, control_job_stop)
	(control_job_query): Reply with information about all instances of
	the job.
	* init/tests/test_control.c (test_job_status, test_job_stop)
	(test_job_query): Make sure we get the list end even for a single job;
	and make sure we get details of all instances attached to the job.

	* init/tests/test_job.c (test_change_goal): Check that starting
	an instance job actually starts a new instance of it.

	* init/cfgfile.c (cfg_stanza_limit): Support the word "unlimited" in
	limit arguments for both the soft and hard values.
	* init/tests/test_cfgfile.c (test_stanza_limit): Make sure that we
	can make limits be unlimited.

	* init/event.c (event_copy): Function to copy an event structure.
	* init/event.h: Add prototype.
	* init/tests/test_event.c (test_copy): Make sure we copy the event
	correctly, with or without arguments and/or environment.
	* init/job.c (job_copy): Function to copy a job structure, leaving
	the state as it is.
	* init/job.h: Add prototype.
	* init/tests/test_job.c (test_copy): Make sure that we copy the
	job details whether they are NULL or non-NULL, but don't copy the
	state.
	* init/init.supp: Update supression.
	* init/job.c (job_find_by_name): If we get a job that's an instance,
	return what it's an instance of.
	* init/tests/test_job.c (test_find_by_name): Restore accidentally
	deleted test function; test that we get the real job, not an instance.

	* init/job.c (job_new): instance_of is initialised to NULL.
	* init/job.h: Add a new instance_of pointer, pointing to the parent
	that we're an instance of.
	* init/tests/test_job.c (test_new): Check that.
	* init/tests/test_cfgfile.c (test_read_job): Make sure instance_of
	pointers are updated.

	* init/job.c (jobs): Store jobs in a hash table.
	(job_new): Add to hash table, not to a list.
	(job_handle_event, job_handle_event_finished, job_detect_stalled) 
	(job_free_deleted): Iterate across the hash table, rather than list.
	(job_find_by_name): Use nih_hash_lookup, we keep this function because
	we'll add "is instance or not" smarts soon!
	(job_find_by_pid): Iterate across the entire hash table.
	* init/tests/test_job.c (test_find_by_name): Drop test since this
	function is now gone.
	(test_free_deleted): Can't assume things are in a line now.
	* init/control.c (control_job_list): Iterate the hash table.

	* init/event.c: Don't hide the events list anymore
	* init/event.h: Publish it and the init function.
	* init/job.c: Don't hide the jobs list anymore.
	(job_list): Since we don't hide it, we can drop this.
	* init/job.h: Publish it and the init function.
	* init/notify.c: Don't hide the subscriptions list anymore.
	* init/notify.h: Publish it and the init function.
	* init/control.c (control_job_list): Iterate the job list directly
	* init/tests/test_control.c (test_event_emit): Use the events list
	available to us.
	* init/tests/test_event.c (test_poll): Call job_init directly and
	just use the events list available to us.
	* init/tests/test_job.c (test_new): Call job_init directly.
	(test_change_state): Use the events list available to us.
	* init/tests/test_notify.c (test_unsubscribe): Use the subscriptions
	list available to us.

	* doc/states.dot: Add updated state graph.
	* doc/Makefile.am (EXTRA_DIST): Ship the states diagram.
	(states.png): Include rules to build the png, we'll put it in bzr
	anyway, but this is useful.

	* init/cfgfile.c (cfg_delete_handler): Handle deleted jobs; mark
	the job as deleted, and if it's dormant, invoke a state change.

	* upstart/enum.h: Add a new JOB_DELETED state.
	* upstart/enum.c (job_state_name, job_state_from_name): Add the new
	state to the string functions.
	* upstart/tests/test_enum.c (test_state_name) 
	(test_state_from_name): Check the enum works.
	* init/job.c (job_change_goal): New decision; we can start a waiting
	job if it's marked delete (it might be a new instance) -- we'll use
	the new deleted state to decide that we shouldn't.
	(job_change_state): Once we reach waiting, if the job is to be deleted,
	move to the next state.
	(job_next_state): The next state for a waiting job if the goal is stop
	is deleted.  We should never call job_next_state () for a deleted job.
	(job_free_deleted): Very simple function, just detects
	deleted jobs and frees them.
	* init/job.h: Add prototype for new function.
	* init/tests/test_job.c (test_change_goal): Update test to use new
	deleted state; and don't even change the goal.
	(test_change_state): Add a check to make sure we end up in deleted.
	(test_next_state): Make sure waiting goes to deleted.
	(test_free_deleted): Check the function.

	* init/job.c (job_change_goal): Don't try and start a job if it's
	marked to be deleted and is just waiting for cleanup.
	* init/tests/test_job.c (test_change_state): Make sure that the cause
	is released when we reach waiting.

	* init/tests/test_cfgfile.c (test_read_job): Make sure that a deleted
	job gets resurrected.

	* init/cfgfile.c (cfg_visitor): Correct number of arguments and call
	to cfg_job_name.

	* TODO: Update.

	* init/cfgfile.c (cfg_stanza_daemon): Don't allow arguments anymore.
	* init/tests/test_cfgfile.c (test_stanza_daemon): Update tests.

	* init/job.c (job_handle_event_finished): Function to unblock all
	jobs blocked on a given event emission.
	(job_new, job_emit_event): Rename blocker to blocked; it's useful for
	testing for truth.
	* init/job.h: Add prototype, rename member.
	* init/tests/test_job.c (test_handle_event_finished): Test it.
	(test_new, test_change_state): Update name here too.
	* init/event.c (event_finished): Call job_handle_event_finished
	function to unblock jobs.
	* init/tests/test_event.c (test_poll): Make sure the job gets
	unblocked; a few other tests have to change since running event_poll
	always unblocks the job if nothing listens to it.

	* init/job.c (job_child_reaper): Set failed back to FALSE if
	we're respawning, since we don't want to be failing.
	* init/tests/test_job.c (test_child_reaper): cause will be NULL.
	also free and poll events when done.
	(test_handle_event): pid can never be -1
	(test_change_state): poll events when done

	* init/tests/test_job.c (test_child_reaper): Process will always
	be zero on return from reaper.

	* init/tests/test_job.c (test_child_reaper): Killed doesn't go past
	stopping; it goes to waiting, which will clear the cause.

	* init/tests/test_job.c (test_child_reaper): Fill in values before
	we test against them.

	* init/tests/test_job.c (test_kill_process): Fix violated assertion

	* init/tests/test_job.c (test_change_state): This should be failed
	because nothing cleared it.

	* init/tests/test_job.c (test_change_state): Fix a couple of array
	index problems.

	* init/tests/test_job.c (test_change_state): Why set that which
	does not change?

	* init/tests/test_job.c (test_change_state): Add newline to test.

	* init/job.c (job_emit_event): Add the job name as an argument;
	oops.

	* init/tests/test_control.c (test_job_stop): Need to kill the process
	ourselves, as we're blocked on an event.
	(test_job_query): Fix wrong value in test.
	(check_job_stopped, test_job_stop, test_unwatch_jobs): Change job
	name to match the test.

	* init/job.c (job_change_state): Must only not enter some states
	with no process now; others like killed actually usually want one!

	* init/tests/test_cfgfile.c (test_read_job): Fix test case.

	* init/tests/test_job.c (test_handle_event): Clean up tests.
	(test_detect_stalled): Clean up.

	* init/job.c (job_child_reaper): Update the reaping of the child
	processes; there's a much larger state range for the main process
	now, so that needs to be taken into account.
	* init/tests/test_job.c (test_child_reaper): New test cases.

	* init/job.c (job_next_state): Encapsulate the slightly odd three
	exit states of running in this function, otherwise we'll end up
	special-casing it in places I'd rather not think about.
	(job_change_goal): Only change the state of a running job if it
	has a process.
	* init/tests/test_job.c (test_next_state): Add a test case for the
	dead running job
	(test_change_goal): Add test case for the dead running job

	* init/tests/test_job.c (test_change_state): Add test cases for
	the forgotten stopping to killed transition.

	* init/job.c (job_kill_process, job_kill_timer): Just check the pid
	and state, and no longer any need to notify jobs since we're just
	called from one state amongst many.
	(job_change_state): Skip over the killed state if there's no process.
	* init/tests/test_job.c (test_kill_process): Update test cases.

	* init/job.c (job_run_process): Simplify a little bit, no need to
	do the state assertions here, just make sure there's no already
	a process running.
	* init/tests/test_job.c (test_run_command, test_run_script): Run
	tests in the spawned state, since that's where we run the primary
	command or script.  Drop check for process state since that's no
	longer set.

	* init/job.c (job_change_state, job_next_state): Ok, here's the big
	one ... rewrite this to use the new state transitions.  This has
	suddenly got a lot simpler and easier to read, this was definitely a
	good idea.
	(job_emit_event): Function to make emission of events easier.
	(job_failed_event): replaces this one which wasn't so easy.
	* init/tests/test_job.c (test_change_state): I can't say how much I
	wasn't looking forwards to rewriting these test cases; anyway, it's
	done now and I hope they're all right;
	(test_next_state): Make sure the state transitions are correct too.

	* init/job.h: Rename is_instance to delete and spawns_instance to
	just instance.
	* init/job.c (job_new): Update.
	* init/tests/test_job.c (test_new): Update.
	* init/cfgfile.c (cfg_stanza_instance): Update.
	* init/tests/test_cfgfile.c (test_stanza_instance): Update.

	* init/event.h: Correct the event names.

	* init/job.h: Add blocker event member.
	* init/job.c (job_new): Initialise it to NULL.
	* init/tests/test_job.c (test_new): Check it.

	* init/job.c (job_change_goal): Have a stab at this function with the
	new state machine; it gets somewhat simpler (until we introduce the
	second scripts), now we just induce things by a state change.
	* init/tests/test_job.c (test_change_goal): Made easier (for now)
	because we don't need to deal with processes and can just wait to
	be blocked on an event.

2007-02-08  Scott James Remnant  <scott@netsplit.com>

	* init/cfgfile.c (cfg_read_job): Drop check for useless respawn script
	(cfg_stanza_respawn): Drop handling of "respawn script"
	* init/tests/test_cfgfile.c (test_stanza_respawn): Drop the checks
	for "respawn script"

	* init/job.h: Move things about a bit more; remove respawn_script
	since that state is going away.
	* init/job.c (job_new): Drop initialisation of process_state.
	* init/tests/test_job.c (test_new): Improve the tests.

	* init/main.c (STATE_FD): Remove this define, not used anymore.

	* init/tests/test_event.c (test_poll): Update the event checking
	to match what's likely to happen.

	* init/event.h: Remove commented out bit.

	* init/tests/test_notify.c (check_job_status, test_job): Correct
	state usage to match a possible state.

	* init/control.c (control_job_start, control_job_stop) 
	(control_job_query, control_job_list): Drop process state and
	description from the job status messages we send back.
	* init/tests/test_control.c (test_error_handler) 
	(check_job_started, test_job_start, check_job_stopped) 
	(check_job_stopping, test_job_query, check_job_starting) 
	(test_job_list, test_watch_jobs, test_unwatch_jobs): Remove
	process_state and description, and update usage of job states.

	* init/notify.c (notify_job): Don't include process state or
	description in the job status message anymore.
	* init/tests/test_notify.c (check_job_status, test_job): Update tests

	* init/cfgfile.c (cfg_read_job): Drop the copying of the process_state
	member, since it doesn't exist anymore.
	* init/tests/test_cfgfile.c (test_read_job): Drop the check too.

	* init/job.h (Job): Drop the process_state member.

	* util/jobs.c (handle_job_status): Drop the process_state and
	description arguments; output a process id only if it's greater
	than zero.
	* util/tests/test_jobs.c (test_start_action, test_list_action) 
	(test_jobs_action): Update tests to use newer states and arguments.
	* util/events.c (handle_event_job_status): Simplify in the same way

	* upstart/message.h: Remove process_state and description from the
	job status event (we already had the foresight to not put them in
	the event job status event).
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Update handling of the messages to reduce the arguments.
	* upstart/tests/test_message.c (test_new, my_handler) 
	(test_handle): Update the tests for the new job status message.

	* upstart/enum.h (JobState): Change the job states to the new set
	of states that we've planned.
	(ProcessState): Drop process state entirely; this information is now
	contained in the single JobState field.
	* upstart/enum.c (job_state_name, job_state_from_name): Update
	strings to match the new state names.
	(process_state_name, process_state_from_name): Drop these functions.
	* upstart/tests/test_enum.c (test_state_name) 
	(test_state_from_name): Update test cases to match new names.
	(test_process_state_name, test_process_state_from_name): Drop.

	* init/main.c (main): Remove the logd hack for now.
	* init/job.c (job_new): Change the default console to none for now.
	* init/tests/test_job.c (test_new): Update test.
	* init/cfgfile.c (cfg_stanza_console): Can't guard against duplicates
	for a while.
	* init/tests/test_cfgfile.c (test_stanza_console): Comment out dup test

	* init/cfgfile.c (cfg_read_job): Remove the restriction that there
	must be either an 'exec' or 'script' for a job; jobs without either
	define states others can use.
	* init/tests/test_cfgfile.c (test_read_job): Convert the test to
	a "must work".
	* init/job.c (job_change_state): Remove restriction that we must
	have either a script or a command; having neither should just wedge
	the job at the running rest state.  Note that there's no way to get
	it out yet, because we don't force that particular state change.
	* init/tests/test_job.c (test_change_state): Make sure that works.

	* init/job.c (job_change_cause): Put the knowledge about how to
	change the cause into a separate function, since it's slightly
	tricky.
	(job_change_goal, job_change_state): Set the cause using the above
	function.

	* init/job.h (Job): Rename goal_event to cause, also shuffle things
	around so that the state is mostly together.
	* init/job.c, init/process.c, init/notify.c, init/cfgfile.c: Update
	references (and comments) to match the new name.
	* init/tests/test_job.c, init/tests/test_event.c,
	init/tests/test_process.c, init/tests/test_cfgfile.c,
	init/tests/test_notify.c: Likewise.

	* init/job.c (job_child_reaper): Don't change the goal event; the
	state changes will handle this.
	(job_change_goal): Only dereference/reference the goal event if we're
	actually changing it.
	* init/tests/test_job.c (test_change_state, test_child_reaper):
	Update tests to not assume that the goal event gets changed.
	(test_kill_process): Eliminate race condition.

	* init/job.c (job_child_reaper): Correct some problems with job and
	event failure; we now don't overwrite an existing failure record,
	and don't record failure if the main process failed and the goal was
	stop; since we likely caused it.
	* init/tests/test_job.c (test_child_reaper): More test cases.

	* logd/event.d/logd.in: Stop on the new runlevel events, not the
	shutdown event.

	* compat/sysv/shutdown.c (shutdown_now): Emit an ordinary runlevel
	change event now; including the INIT_HALT environment variable
	* compat/sysv/man/shutdown.8: Update the manual

	* compat/sysv/telinit.c: Now just sends out a runlevel event with
	an argument giving the new runlevel.
	* compat/sysv/man/telinit.8: Update description of the command.

	* upstart/message.h: Remove the UPSTART_SHUTDOWN message.
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Remove handling for the shutdown message.
	* upstart/tests/test_message.c (test_new, test_handle): Remove
	tests against the shutdown message.
	* init/control.c (control_shutdown): Remove the shutdown command
	from the server.
	* init/tests/test_control.c (test_shutdown): Remove tests for it.
	* init/event.h: Remove the shutdown event.
	* util/initctl.c: Remove the shutdown command reference.
	* util/events.c (shutdown_action): Remove the command.
	* util/events.h: Update.
	* util/tests/test_events.c (test_shutdown_action): Remove tests.

	* init/job.c (job_detect_idle): Rename to job_detect_stalled
	(job_detect_stalled): Remove the idle state detection
	(job_set_idle_event): Idle event has been removed.
	* init/job.h: Update.
	* init/tests/test_job.c (test_detect_idle): Rename to
	(test_detect_stalled): and remove idle detection tests.
	* init/main.c (main): Replace job_detect_idle with job_detect_stalled
	* init/control.c (control_shutdown): Don't set the idle event.
	* init/tests/test_control.c (test_shutdown): Don't detect the idle
	event (and thus the second event)

	* init/cfgfile.c (cfg_stanza_service): Parser for service stanza.
	* init/tests/test_cfgfile.c (test_stanza_service): Test the service
	stanza.
	(test_stanza_respawn): Check that respawn implies service.
	* TODO: Update.

	* init/job.h (Job): Add a new service member.
	* init/job.c (job_new): Service starts off as false.
	(job_change_state): Check service instead of respawn.
	* init/tests/test_job.c (test_change_state): Check with service
	instead of respawn, since that's what we really mean.

	* init/cfgfile.c (cfg_read_job): Copy a whole bunch more state
	into the newly parsed job.
	* init/job.c (job_run_process): Only output the first error.
	* init/tests/test_cfgfile.c (test_read_job): Make sure important
	things are copied.
	* TODO: Update.

	* init/main.c: Restore a much simplified version of the term
	handler that doesn't try and copy across any state.

	* compat/sysv/telinit.c: Update call to event_emit; we'll revisit
	this shortly when we get rid of the shutdown event.

	* util/events.c (handle_event): Add new id field (but ignore it)
	Functio
	(handle_event_job_status): New function to handle the new event.
	(handle_event_finished): Function to handle the end of the event.
	(emit_action): Send the newer event, and loop over replies until
	we get a finished one.
	* util/tests/test_events.c (test_emit_action): Update tests cases.

	* init/control.c (control_event_emit): New function to handle the
	new-style emit message.
	* init/tests/test_control.c (test_event_emit): Make sure the new
	message function behaves.

	* init/event.c, init/job.c, init/main.c, init/tests/test_event.c,
	init/tests/test_job.c: Completely drop the serialisation code, it's
	getting out of date and in the way.

	* init/event.h: Remove compatibility macros.
	(EventEmission): Drop the callback function; it was too error prone
	to try and do it this way, and we only ever wanted to release a job
	anyway as control requests are better handled through the notify
	interface.
	(EventEmissionCb): Drop unused typedef.
	* init/event.c (event_emit): Drop callback argument.
	(event_finished): Don't call the callback
	* init/tests/test_event.c: Update to avoid callbacks.
	* init/job.c (job_change_state): Convert to using event_emit and
	EventEmission.
	(job_detect_idle): Drop extra arguments to event_emit.
	* init/main.c (main, cad_handler, kbd_handler): Drop extra arguments
	to event_emit.
	* init/control.c (control_shutdown): Use event_emit instead of
	event_queue.
	* init/tests/test_control.c (test_shutdown): Convert to using
	EventEmission.
	(test_watch_events, test_unwatch_events): Drop extra arguments to
	event_emit.
	* init/tests/test_notify.c (test_subscribe_event, test_job) 
	(test_event, test_event_finished): Drop extra arguments to event_emit
	* init/tests/test_job.c (test_change_goal, test_change_state) 
	(test_run_script, test_child_reaper, test_detect_idle): Drop
	extra arguments to event_emit.
	* init/tests/test_process.c (test_spawn): Drop extra arguments to
	event_emit.

	* TODO: Update.

	Rewrite the notification subsystem quite significantly; now we
	have individual functions to subscribe to different types of
	notification, and can even subscribe to individual jobs or events.

	* init/notify.c (notify_subscribe_job, notify_subscribe_event) 
	(notify_unsubscribe): New subscription and unsubscription functions
	that assume one record per subscription, not process.
	(notify_subscription_find): Function to find a subscription.
	(notify_job): Send a message to anything subscribed to the goal event
	as well.
	(notify_event): Use EventEmission and include the id in the event.
	(notify_event_finished): New function, sends a finished message and
	includes both the id and whether the event failed.
	* init/notify.h (NotifySubscribe): New notify structure that is
	once per subscription, rather than per-process; and allows
	subscription to individual jobs or events.
	* init/tests/test_notify.c (test_subscribe_job) 
	(test_subscribe_event, test_unsubscribe): Test the new subscription
	functions, replacing the old
	(test_subscribe): tests.
	(test_subscription_find): Check finding works
	(check_event, test_event): Update to use emissions, and check that the
	id is correct.
	(test_event_finished): Check this one works too
	(check_event_job_status, test_job): Make sure processes subscribed
	via the goal event are notified too.
	* init/event.c (event_pending): Pass the emission directly.
	(event_finished): Notify subscribers that the event has finished.
	* init/control.c (control_error_handler): Call notify_unsubscribe
	(control_watch_jobs, control_unwatch_jobs, control_watch_events) 
	(control_unwatch_events): Update to the new subscription API.
	* init/tests/test_control.c (test_error_handler): Use new API
	(test_watch_jobs, test_unwatch_jobs, test_watch_events)
	(test_unwatch_events): Also update these to the new API; use a
	destructor to make sure the subscription is freed.

	* init/tests/test_process.c: Don't use printf, use TEST_FUNCTION

2007-02-07  Scott James Remnant  <scott@netsplit.com>

	* upstart/message.h: Allocate new grouped event messages.
	* upstart/message.c (upstart_message_new, upstart_message_handle):
	Add support for the new grouped event messages.
	* upstart/tests/test_message.c (test_new, test_handle) 
	(my_handler): Make sure the new messages are passed correctly.

	* init/job.c (job_change_state): Clear the goal event whenever we
	reach the final rest state of a job (waiting for all jobs, running
	for services).
	* init/tests/test_job.c (test_change_state): Check that the goal
	event goes away at the right times.
	* TODO: Update.

	* init/tests/test_job.c (test_child_reaper): Make sure that the
	event is marked failed properly

	* init/job.c (job_start_event, job_stop_event): There's no reason
	for these to exist as seperate functions anymore, especially since
	we want to eventually have some kind of match table.
	(job_handle_event): Perform the iterations and match calls here
	instead, since we just call job_change_goal now.
	* init/job.h: Remove prototypes.
	* init/tests/test_job.c (test_start_event, test_stop_event): Fold into
	(test_handle_event): which now handles all the cases.

	* init/job.c (job_detect_idle): Call event_emit
	* init/main.c (main, cad_handler, kbd_handler): Call event_emit
	instead of event_queue.
	* init/tests/test_event.c (test_new): Call event_poll
	* init/tests/test_job.c (test_change_state, test_child_reaper) 
	(test_detect_idle, test_change_state): Update to use newer event API.
	* TODO: Update.

	* init/job.c (job_start, job_stop): Drop these functions; call
	job_change_goal instead (which is now public).
	(job_change_state, job_child_reaper): Call job_change_goal instead.
	* init/job.h: Update.
	* init/tests/test_job.c (test_start, test_stop): Merge into new
	(test_change_goal): function.
	* init/main.c (main): Call job_change_goal instead of job_start.
	* init/control.c (control_job_start, control_job_stop): Call
	job_change_goal instead.

	* init/tests/test_job.c (test_new, test_change_state) 
	(test_run_script, test_start, test_stop, test_start_event): 

	* init/job.h (Job): goal_event is now an EventEmission, and is
	a direct pointer to the one in the events queue, rather than a copy.
	* init/process.c (process_setup_environment): Reference the event
	name and environment through the goal event, not directly.
	* init/job.c (job_run_script): Reference the event name and
	environment through the goal event, not directly.
	(job_change_state, job_child_reaper): Replace direct setting of the
	job goal with a call to job_stop; the process state is always
	PROCESS_NONE in all three cases, so this is completely safe.
	(_job_start, _job_stop): Merge these two functions together into
	(job_change_goal): which behaves a lot more like job_change_state,
	except that it doesn't loop.  This handles the changing of the
	emission.
	(job_start, job_start_event, job_stop, job_stop_event): Simplify
	these functions, now they just call job_change_goal passing in
	the emission pointer (or NULL).

	* init/main.c, init/job.c, init/job.h, init/event.c, init/event.h,
	init/tests/test_job.c, init/tests/test_event.c: Remove state
	serialisation code for the time being; maintaining it is getting
	increasingly harder, and it introduces some major bugs.  It will
	get rewritten shortly.

	* init/event.c (event_pending): Pass the emission directly to
	job_handle_event now.
	* init/job.c (job_handle_event, job_start_event, job_stop_event):
	Deal with event emissions rather than just plain events, the change
	so far doesn't do anything else other than take the structure change.
	* init/job.h: Change prototypes.
	* init/tests/test_job.c (test_start_event, test_stop_event)
	(test_handle_event): Update tests to use emissions.

	* init/tests/test_event.c (test_read_state, test_write_state): Check
	the passing of the progress information.
	* init/event.c (event_read_state, event_write_state): Add progress
	field to the serialisation (oops).

	* init/event.h: Add missing attribute for event_read_state.
	* init/cfgfile.h: Add missing attributes.
	* init/main.c (read_state): Don't discard return value.
	* TODO: Update.

	* init/main.c (read_state): Handle the Emission keyword; also handle
	Event really being an EventEmission.
	* init/event.c (event_emit): Make the next emission id a static global
	(event_read_state, event_write_state): Serialise event emission
	structures, not plain events; also send over the last id we used so
	it appears seamless.  This doesn't yet handle the callback/data bit
	of the serialisation, which turns out to be a little tricky ... oops
	* init/event.h: Update.
	* init/tests/test_event.c (test_read_state, test_write_state): Check
	that serialisation is done with EventEmissions instead, and all the
	fields are passed (except callback and data which are ... tricky).

	* init/main.c (main): Call event_poll instead of event_queue_run.

	* init/event.c (event_poll): Add the new function that replaces
	event_queue_run(); handles the new-style event emission structures
	in the list and only returns when there are no non-handling events.
	(event_pending, event_finished): Handling of particular event states
	during poll; split out for readability.
	(event_queue, event_queue_run): Drop these obsolete functions.
	(event_read_state): Force type from event_queue.
	* init/event.h: Add event_poll prototype; remove prototypes of old
	functions, replacing with #defines for now so things still compile.
	* init/tests/test_event.c (test_queue): Drop tests.
	(test_read_state, test_write_state): Force type from event_queue
	Change type we check size of.
	(test_poll): Pretty thoroughly test the new poll function.
	* init/job.c (job_change_state): Force type from event_queue
	* init/control.c (control_event_queue): Force type from event queue
	* init/tests/test_job.c (test_detect_idle): Force type from event_queue
	* init/tests/test_control.c (test_event_queue, test_shutdown):
	Force type from event_queue

	* init/event.c: Revert to a single list of events with an enum
	(event_emit): Set the progress to pending initially.
	(event_emit_find_by_id): Simplify now it just checks one list
	(event_emit_finished): Function for jobs to call once they've done
	with an event; just sets the progress to finished for the event
	queue to pick up.
	* init/tests/test_event.c (test_emit_finished): Check it.

	* init/event.h: Add prototype.
	(EventProgress): Add new enum	
	(EventEmission): And add progress member to this structure
	* init/tests/test_event.c (test_emit): Make sure the event is pending

	* init/event.c (event_emit_find_by_id): Locate an event emission
	by its id in either the pending or handling queue.
	* init/event.h: Add prototype
	* init/tests/test_event.c (test_emit): Make sure that the emission
	id is unique each time.
	(test_emit_find_by_id): Test the function.

	* init/event.c (event_emit): New function to replace event_queue();
	returns an EventEmission structure with the details filled in as
	given.
	* init/event.h: Add prototype.

	* init/event.c (event_init): Rename the single events queue to
	pending and add a new handling list.

	* init/event.h (EventEmission, EventEmissionCb): Add a new emission
	structure that wraps an event, for use in the queue.

	* util/tests/test_events.c (test_events_action): Update test now
	that nih_message is more sensible.
	* util/tests/test_jobs.c (test_start_action, test_list_action) 
	(test_jobs_action): Update test

	* util/events.c (emit_action): Actually pass the emit_env array
	* util/tests/test_events.c (test_emit_action): Make sure it does.

	* util/initctl.c (main): Catch nih_command_parser() returning a
	negative value to indicate an internal error, and always exit 1.

	* util/events.c (handle_event): Build up multiple lines to describe
	the event, including its arguments and environment.
	* util/tests/test_events.c (test_events_action): Check the new output
	format is right.

	* init/main.c (main): Take out inadvertantly leaked debugging code;
	sorry about that.

	* init/job.c (job_child_reaper): Rewrite this to make the logic a
	little easier to follow, and support signals in normalexit.  This
	also now applies to deciding whether the job failed, if it did, we
	store that information in the job so the stop and stopped events
	can get it.
	* init/tests/test_job.c (test_child_reaper): Add new test cases for
	the setting of the failed flags.

	* init/cfgfile.c (cfg_stanza_normalexit): Allow signal names in the
	arguments, which are added to the normalexit array or'd with 0x80
	* init/tests/test_cfgfile.c (test_stanza_normalexit): Check that we
	can now parse signal names correctly.

	* init/job.c (job_failed_event): Change add to addp to fix leak.

	* init/job.c (job_failed_event): Function to turn an event into one
	that includes all the necessary arguments and environment.
	(job_change_state): Call job_failed_event for the stop and stopped
	events (bit hacky at the moment, will improve later).
	* init/tests/test_job.c (test_change_state): Check that the failed
	events are generated properly.

2007-02-06  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_change_state): Reset the failed member when
	we enter the starting state.
	* init/tests/test_job.c (test_change_state): Make sure that the
	failed member is reset when we enter the starting state.

	* init/job.h (Job): Add failed, failed_state and exit_status members.
	* init/job.c (job_new): Initialise new members.

	* init/job.c (job_child_reaper): Convert signals to names when
	outputting status messages.
	* init/tests/test_job.c (test_child_reaper): Check that the signal
	name gets converted over.

	* init/event.h (CTRLALTDEL_EVENT): Now we've broken the shared
	namespace of events and jobs, rename the control-alt-delete event
	back to control-alt-delete.

	* init/job.c (job_change_state): Replace the events generated as
	part of the job state, named for the job and state, with new state
	events that have the job name as an argument.
	* init/event.h: Define new job event names.
	* init/tests/test_job.c (test_change_state): Make sure the new
	events are correct, with the job name as an argument.

	* init/job.c (job_change_state): Remove the job event; this has
	been repeatedly proved to be confusing.
	* init/tests/test_job.c (test_change_state): Remove checks for the
	job event.

	* util/events.c (emit_action): Pass in extra arguments.
	(env_option): Function to parse an option given an environment
	variable.
	* util/events.h: Add prototype.
	* util/tests/test_events.c (test_emit_action): Make sure that the
	emit action works with no arguments and with arguments.
	(test_events_action): Send back events with the right number of args.
	(test_env_option): Check the env option parser works.
	* util/initctl.c: Give shutdown its own command and options, give
	emit a new -e option.

	* util/events.c (shutdown_action): Split out from emit, seeing as
	these are going to be different from now on.
	* util/events.h: Add prototype.
	* util/tests/test_events.c (test_shutdown_action): Copy test cases.

	* init/control.c (control_event_queue): Take the arguments and
	environment from the event queue request; and reparent into the
	event.
	* init/tests/test_control.c (test_event_queue): Check that arguments
	and environment are copied across properly.

	* init/notify.c (notify_event): Pass in the arguments and environment
	for the event.
	* init/tests/test_notify.c (check_event): Check for event arguments
	and environment from the notify process.
	(test_event): Add arguments and environment to the event we test with

	* upstart/tests/test_message.c (test_new, test_handle): Send
	arguments and environment with the UPSTART_EVENT_QUEUE and
	UPSTART_EVENT messages.
	* upstart/wire.c (upstart_pop_int, upstart_pop_unsigned): Shrink
	only once.
	(upstart_pop_string): Check the length is at least one first, as
	we may just have an 'S'.

	* upstart/message.c (upstart_message_new, upstart_message_handle):
	The UPSTART_EVENT and UPSTART_EVENT_QUEUE messages gain new array
	arguments containing the arguments and environment for the event.
	* upstart/message.h: Document the new arguments.

	* util/tests/test_events.c, util/tests/test_jobs.c: Update the
	message format checks here too.

	* upstart/tests/test_wire.c (test_pop_pack): Free the array.

	* upstart/tests/test_message.c (test_new, test_handle)
	(test_handle_using, test_reader): Update tests to include and
	expect new type markers between each field.

	* upstart/wire.c (upstart_push_int, upstart_push_unsigned):
	Take out silly asserts; it must have room!

	* upstart/wire.c (upstart_push_string, upstart_pop_string): Rewrite
	to use a type like the rest of the functions; this removes the strange
	length restriction and allows us to make the pop function
	non-destructive.
	* upstart/tests/test_wire.c (test_push_string): Update.
	(test_pop_string): Update, adding in non-destructive, wrong type
	and insufficient space for type test cases.
	(test_push_array, test_pop_array): These needed updated too,
	changing the string format changed the array format.
	(test_push_pack, test_pop_pack): And obviously the pack format changed.

	* upstart/wire.c (upstart_pop_header): Make the function
	non-destructive in the face of errors.
	* upstart/tests/test_wire.c (test_pop_header): Make sure that
	invalid headers are non-destructive on error.

	* upstart/tests/test_wire.c (test_pop_int, test_pop_unsigned):
	Make sure that insufficient space is non-destructive.

	* upstart/wire.c (upstart_push_int, upstart_pop_int) 
	(upstart_push_unsigned, upstart_pop_unsigned): Convert to array-style
	type first format.
	(upstart_push_string, upstart_push_header): Write the length and
	type fields out by hand so they don't get an 'i' prefix.
	(upstart_pop_string, upstart_pop_header): Read the length and type
	fields by hand so they don't get an 'i' prefix.
	* upstart/tests/test_wire.c (test_push_int, test_pop_int) 
	(test_push_unsigned, test_pop_unsigned): Update test cases to match.
	(test_push_pack, test_pop_pack): Pack format was changed too.

	* upstart/wire.c (upstart_push_packv, upstart_pop_packv): Add calls
	to push and pop array.
	* upstart/tests/test_wire.c (test_push_pack, test_pop_pack): Test
	support for arrays.

	* upstart/wire.c (upstart_push_array, upstart_pop_array): Implement
	new array functions; note that these use a newer format that allows
	us to transmit NULL without needing to limit the size of the array.
	* upstart/wire.h: Add prototypes.
	* upstart/tests/test_wire.c (test_push_array, test_pop_array):
	Test the new array functions.

	* init/job.c (job_run_script): Build up the argument list, appending
	those from the goal event if one is set.
	(job_run_command): Use nih_str_array_add to build up the arguments,
	but don't append those from the goal event (use script).
	* init/tests/test_job.c (test_run_script): Make sure the arguments get
	passed to the running shell scripts.

	* init/job.c (job_run_script): Only use the /dev/fd trick if we can
	actually stat /dev/fd; also don't hardcode that path ...
	* init/paths.h (DEV_FD): Add here.

	* init/process.c (process_setup_environment): Copy environment
	variables from the goal event into the job's process.
	* init/tests/test_process.c (test_spawn): Make sure the environment
	reaches the job, but doesn't override that in the job already.

	* init/tests/test_job.c (test_start_event): 

	* init/job.c (job_start_event, job_stop_event): Copy the arguments
	and environment from the event into the goal event.

	* init/job.c (job_read_state, job_write_state): Read and write
	arguments and environment for goal event.
	* init/tests/test_job.c (test_read_state, test_write_state): Test
	with arguments and environment to the goal event.

	* init/event.c (event_read_state, event_write_state): Read and write
	the arguments and environment of the event.
	* init/tests/test_event.c (test_read_state, test_write_state): Make
	sure arguments and environment are correctly serialised.

	* init/cfgfile.c (cfg_stanza_console): Fix a leak of the console
	argument in the case of duplicated options.
	(cfg_stanza_env): Drop the counting now nih_str_array_addp does it;
	and be sure to use that function.
	(cfg_stanza_umask): Fix leak of umask argument
	(cfg_stanza_nice): Fix leak of nice argument
	* init/tests/test_event.c (test_new): Call event_queue_run so init
	is called outside of a TEST_ALLOC_FAIL block.

	* init/event.c (event_new): Start off with NULL args and env, to
	match job (saves a few bytes).
	(event_match): Watch for NULL arguments!
	* init/tests/test_event.c (test_new): Check for NULL not alloc'd

	* init/cfgfile.c (cfg_stanza_on, cfg_stanza_start) 
	(cfg_stanza_stop): Parse arguments to the on stanza and store them
	directly in the event.
	* init/tests/test_cfgfile.c (test_stanza_on, test_stanza_start) 
	(test_stanza_stop): Make sure arguments are parsed into the event.

	* init/event.c (event_new): Use nih_str_array_new.
	* init/cfgfile.c (cfg_stanza_env): Rewrite to use nih_str_array.

	* init/job.c (job_run_script): Check the error returned from
	nih_io_reopen; don't just loop.  We only ever expect ENOMEM (the
	other error, EBADF, is impossible).

	* init/job.c (job_change_state): Reset the goal_event to NULL when
	we catch a run-away job (as it's not stopping for the same event
	it started with).
	(job_child_reaper): Reset the goal_event to NULL after setting the
	goal to STOP.
	* init/tests/test_job.c (test_change_state, test_child_reaper):
	Check that the goal event gets reset whenever the goal gets changed.

	* init/tests/test_event.c: Use TEST_ALLOC_FAIL

	* init/event.c (event_match): Match arguments using fnmatch() and
	allow more arguments in event1 than event2 (but not the other way
	around).
	* init/tests/test_event.c (test_match): Check the new permitted
	combinations.

	* init/event.h (Event): Add args and env members to Event.
	* init/event.c (event_new): Initialise args and env members to
	zero-length arrays.
	* init/tests/test_event.c (test_new): Use TEST_ALLOC_FAIL and
	make sure args and env are both initialised to a list containing
	just NULL.

	* util/jobs.c (start_action): Get the UPSTART_JOB environment variable
	and use that if we don't have any arguments passed to us.
	(do_job): Code split from the above function that handles a named job
	* util/tests/test_jobs.c (test_start_action): Make sure UPSTART_JOB
	is picked up.

	* init/process.h: Add necessary attributes.

	* init/process.c (process_setup_environment): Set the UPSTART_JOB
	environment variable from the job, and the UPSTART_EVENT environment
	variable from the job's goal_event member (if set).
	* init/tests/test_process.c (test_spawn): Make sure we get the
	environment in the job.

	* init/job.h: Add attributes to job_new and job_read_state.
	* init/tests/test_job.c: Use CHECK_ALLOC_FAIL on the functions we
	didn't get around to touching while we were in here.

	* init/job.c (job_start_event, job_stop_event): Set the goal_event
	member to a copy of the event we found.
	(job_read_state): Use event_new instead of trying to do it by hand.
	* init/tests/test_job.c (test_start_event, test_stop_event): Use 
	CHECK_ALLOC_FAIL; and make sure the goal_event is set properly.
	(test_start, test_stop, test_write_new): Use event_new here too

	* init/job.c (job_write_state): Output a goal_event field containing
	the event name or nothing for NULL.
	(job_read_state): Parse the goal_event field
	* init/tests/test_job.c (test_write_state): Make sure the state is
	written out properly.
	(test_read_state): Make sure that the state is parsed correctly too.

	* init/job.c (job_start, job_stop): Split all of the code except
	the goal_event setting into two new static functions that this calls
	(_job_start, _job_stop): New static functions
	(job_start_event, job_stop_event): Call _job_start and _job_stop
	instead of job_start and job_stop

	* init/job.c (job_catch_runaway): Move this function up a bit.

	* init/job.c (job_start, job_stop): Clear the goal_event member,
	these functions are called for a manual start.
	* init/tests/test_job.c (test_start, test_stop): Make sure the
	goal_event member is freed and set to NULL.

	* init/job.h (Job): Add a new goal_event member
	* init/job.c (job_new): Initialise the goal_event member to NULL.
	* init/tests/test_job.c (test_new): Check with TEST_ALLOC_FAIL;
	also make sure goal_event is initialised to NULL.

2007-02-05  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.3.3

	* NEWS: Update.

	* init/process.c (process_spawn): Exit with 255 so we don't clash
	with anything that uses 1 as a normal exit code.  Note why we only
	close 0..2 (everything else is FD_CLOEXEC).
	* init/cfgfile.c (cfg_watch_dir): Mark the inotify watch descriptor
	as FD_CLOEXEC.
	* init/control.c (control_open): nih_io_set_cloexec can only ever
	return EINVAL, so no point checking it.

2007-02-04  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_control.c: Remove strange old code.

2007-02-03  Scott James Remnant  <scott@netsplit.com>

	* init/control.c (control_open_sock, control_reopen)
	(control_close_handler): Drop these functions; unconnected datagram
	sockets don't close -- so why try dealing with it?
	(control_error_handler): Don't reopen the socket on error, just log
	it -- the socket should be fine, there's no remote end to be lost,
	after all.
	* init/tests/test_control.c (test_close_handler): Drop.
	(test_error_handler): Drop the reopen tests.

	* init/tests/test_job.c (test_run_script): Control socket doesn't
	get unexpectedly opened anymore; so no need to close it.

	* init/control.c (control_open): Remove the strange behaviour that
	this can be called to get the socket.  Instead make control_io
	global; we're all adults after all.
	* init/tests/test_control.c (test_open): Remove the test for the
	silly behaviour.
	* init/notify.c (notify_job, notify_event): Use the control_io
	pointer directly, and just do nothing if we lost it somehow.

	* init/main.c (main): Being unable tp open the control socket, or
	parse the configuration, should be a fatal error; stop being so
	damned liberal! <g>   Don't reset the signal state if we're
	being restarted, as this loses any pending signals -- be happy
	that our parent left them in a good state.  Set SIGCHLD to the
	standard handler, otherwise we might lose this before we start
	the main loop (which does the same anyway).
	(term_handler): Rework so we don't need to close and open the
	control socket; instead we just close it in the child that's
	going to send the state, and notify the parent that it's safe to
	exec (which will cause it to be closed so the new init can open it).

	* init/tests/test_control.c (test_open): Fix valgrind error
	* init/tests/test_notify.c (test_subscribe): Fix valgrind error

	* init/notify.c (notify_subscribe): Make safe against ENOMEM.
	* init/tests/test_notify.c (test_subscribe): Use TEST_ALLOC_FAIL

	* init/control.c: Add needed attributes; tidy up formatting.
	(control_open): Don't let ENOMEM fail opening the control socket.
	* init/control.h: Add needed attributes.
	* init/tests/test_control.c (test_open): Test for failed allocation.
	* init/main.c (term_handler): Make sure we catch failure to open
	the control socket again.

	* TODO: Update

	* init/cfgfile.c (cfg_watch_dir): Clean this up a bit; now we only
	output a warning if inotify failed for any reason other than not
	being supported AND walking worked.

	* init/cfgfile.c (cfg_watch_dir): Update to even newer watch API;
	our create_handler is now always called if inotify is successful,
	so we just need to fall back to walking the directory when it
	isn't -- if inotify isn't supported, don't even bother complaining.
	(cfg_create_modify_handler): Check the stat of the file visited to
	make sure it's a regular file.
	(cfg_visitor): Check the stat of the file visited to make sure it's
	a regular file.

	* init/cfgfile.c: Update include to upstart/enum.h
	* init/job.c: Update include to upstart/enum.h
	* init/job.h: Update include to upstart/enum.h

	* logd/main.c: Add attribute to open_logging

	* util/initctl.c: Split out the command functions into new files;
	* util/jobs.c: This gets the job-related commands
	* util/events.h: This gets the event-related commands
	* util/initctl.h, util/jobs.h, util/events.h: Headers
	* util/tests/test_jobs.c: Test suite for job-related commands.
	* util/tests/test_events.c: Test suite for event-related commands.
	* util/Makefile.am (initctl_SOURCES): Add new files.
	(TESTS): Build new test suites.
	(test_jobs_SOURCES, test_jobs_LDFLAGS, test_jobs_LDADD):
	Details for job-related commands test suite binary.
	(test_events_SOURCES, test_events_LDFLAGS, test_events_LDADD):
	Details for event-related commands test suite binary.
	* TODO: Remove item about splitting initctl now we've done it.

	* TODO: Big update; strip anything we have a spec for.

	* upstart/message.c (upstart_message_handle): Make sure that if we
	fail to parse a message, we don't leave strings around in memory.
	* upstart/tests/test_message.c (test_open): Check that we get a
	raised EADDRINUSE if we try an open a socket twice.
	(test_handle): Add lots of checks for things like NULL names and
	incomplete messages; as well as the obvious unknown message.
	(test_reader): Make sure that errors while handling messages are
	dealt with by logging it.

	* upstart/job.c, upstart/job.h, upstart/tests/test_job.c: Rename to
	enum.c, enum.h and tests/test_enum.c; since this just includes enums
	and convert functions really.
	* upstart/Makefile.am: Update.
	* upstart/libupstart.h: Update include.
	* upstart/tests/test_message.c: Update include.

2007-02-01  Scott James Remnant  <scott@netsplit.com>

	* logd/main.c (main): Ensure we error if daemonise fails.

	* compat/sysv/shutdown.c (main): Ensure that signals and timers
	are added, even if we run out of memory.

	* upstart/tests/test_message.c: Change from assert to assert0 
	* upstart/tests/test_wire.c: Change from assert to assert0
	* init/tests/test_notify.c: Change from assert to assert0
	* init/tests/test_control.c: nih_io_message_send should always return
	a value greater than zero.

	* upstart/tests/test_wire.c: Change to use assert instead of NIH_ZERO;
	the rationale here is that in test cases we just want to fail, not
	try again repeatedly.
	* upstart/tests/test_message.c: Likewise.

	* init/tests/test_control.c: Use assert to ensure we get the expected
	return values of functions that raise errors.
	* init/tests/test_notify.c: Use assert to ensure we get the expected
	return values of functions that raise errors.

	* init/cfgfile.c (cfg_watch_dir): Port to the new NihWatch API and
	use nih_dir_walk().  This also fixes the long-standing bug where we
	wouldn't watch the configuration directory if inotify was disabled.
	Drop both the parent and prefix members for now, until we clean this
	up later.
	(cfg_create_modify_handler): Wrap cfg_read_job after figuring out
	the job name.
	(cfg_job_name): Function to figure out the job name from a path.
	(cfg_visitor): Visitor function to handle initial parsing, figuring
	out the job name; otherwise identical to the standard handler.
	* init/cfgfile.h: Update prototype for cfg_watch_dir.
	* init/main.c (main): Update call to cfg_watch_dir.

2007-01-31  Scott James Remnant  <scott@netsplit.com>

	* upstart/tests/test_message.c: Use TEST_ALLOC_FAIL to make sure
	allocations are handled properly.

2007-01-30  Scott James Remnant  <scott@netsplit.com>

	* upstart/wire.c: Note that if any of the push functions fail, the
	entire buffer should be discarded.
	* upstart/tests/test_wire.c (test_push_int, test_push_unsigned) 
	(test_push_string, test_push_header, test_push_pack): Us
	TEST_ALLOC_FAIL to ensure that failing to allocate memory is caught.

	* upstart/tests/test_message.c (my_handler): Free the name and
	description after checking; they aren't otherwise.

	* upstart/wire.c (upstart_push_packv, upstart_pop_packv): Consume
	a copy of the va_list, so these can be called multiple times on the
	same list without ill effect.

	* upstart/message.h: Add warn_unused_result attributes to
	upstart_message_handle and upstart_message_handle_using as they raise
	errors.

	* upstart/wire.c: push functions return negative values to indicate
	insufficient memory.
	* upstart/wire.h: Add warn_unused_result attributes to push functions

	* upstart/tests/test_message.c: Guard calls to nih_io_buffer_push and
	nih_io_message_add_control with NIH_ZERO to ensure they succeed.
	* upstart/tests/test_wire.c: Guard calls to nih_io_buffer_push

	* HACKING: Update from libnih with new Documentation,
	Function Attributes and Test Cases sections.

2007-01-10  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (crash_handler): s/SEGV/SIGSEGV/

	* init/main.c (main): Rename variable

	* TODO: Update.

	* init/main.c (main): Change the way we clear the arguments; by
	deleting just the final NULL terminator, we fool the kernel into
	only returning one argument in cmdline.

	* init/main.c (segv_handler): Rename to crash_handler and handle
	SIGABRT as well, so we can catch assertion errors.  Of course, in
	theory, with our high test converage this should never happen in
	practice <chortle>

2007-01-09  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (main): Clear arguments so that upstart only ever
	appears as /sbin/init in ps, top, etc.

	* TODO: Update.

	* util/initctl.c: Add data pointer to functions and handle calls.

	* init/control.c: Add data pointer to all functions.
	* init/tests/test_control.c: Pass data pointer to
	upstart_message_handle_using()
	* init/tests/test_notify.c: Pass data pointer to
	upstart_message_handle_using()

	* upstart/message.c (upstart_message_handle) 
	(upstart_message_handle_using): Add a data pointer argument to these
	functions and pass it to the handler.
	(upstart_message_reader): Pass the io structure's data pointer.
	* upstart/message.h (UpstartMessageHandler): Add a data pointer to
	the message handler.
	* upstart/tests/test_message.c (test_handle, test_handle_using):
	Pass a data pointer to the function call and check it's passed
	to the handler correctly.
	(test_reader): Check that the io data pointer gets passed.

	* init/tests/test_cfgfile.c (test_stanza_console, test_stanza_env) 
	(test_stanza_umask, test_stanza_nice, test_stanza_limit): Finish off
	the newer style test cases.

	* init/cfgfile.c (cfg_stanza_console, cfg_stanza_umask)
	(cfg_stanza_nice, cfg_stanza_limit, cfg_stanza_chroot)
	(cfg_stanza_chdir): Guard against duplicate uses of the stanzas.
	* init/tests/test_cfgfile.c (test_stanza_daemon) 
	(test_stanza_respawn): Check that neither daemon or respawn override
	exec if they have no arguments.
	(test_stanza_script): Add missing function
	(test_stanza_chroot, test_stanza_chdir): Add tests for these simple
	stanzas.

	* init/cfgfile.c: Change remaining uses of nih_error_raise and
	return to just nih_return_error.

	* init/cfgfile.c (cfg_stanza_exec, cfg_stanza_daemon)
	(cfg_stanza_respawn, cfg_stanza_script): Disallow duplicates,
	both of command strings, scripts, limits and of just the flags.
	* init/tests/test_cfgfile.c (test_stanza_exec) 
	(test_stanza_daemon, test_stanza_respawn, test_stanza_instance):
	Check the behaviour of these stanzas.
	
	* init/cfgfile.c (cfg_stanza_start, cfg_stanza_stop): Disallow
	duplicate values for the script.
	* init/tests/test_cfgfile.c (test_stanza_start, test_stanza_stop):
	Test cases for those two functions.

	* init/cfgfile.c (cfg_stanza_description, cfg_stanza_author) 
	(cfg_stanza_version): Don't allow stanza to be duplicated anymore.
	* init/tests/test_cfgfile.c (test_stanza_description) 
	(test_stanza_author, test_stanza_version): Test cases for these
	simple stanza; making sure duplication is not permitted.
	(test_stanza_on): Add a test case for this stanza too.

	* init/cfgfile.c (cfg_stanza_kill): Guard against duplicate uses
	of the kill timeout stanza.
	* init/tests/test_cfgfile.c (test_stanza_kill): Test the complex
	kill stanza.
	(test_stanza_pid): Check duplicate usage results in an error.

	* init/job.h (Job): Rename pidfile to pid_file and binary to pid_binary
	* init/job.c (job_new): Update names here too.
	* init/errors.h: Add a new "duplicate value" error.
	* init/cfgfile.c (cfg_read_job): Change name of variables, and catch
	the duplicate value error to add the line number.
	(cfg_stanza_pid): Change variable names, and clean this function up
	a little.  Make it an error to use a stanza more than once.
	* init/tests/test_cfgfile.c (test_stanza_pid): Write a newer test
	case function for the pid stanza.

	* init/cfgfile.c (cfg_stanza_normalexit): Use do/while instead of
	while, that we don't have to test has_token first as next_arg does
	that for us.

	* init/cfgfile.c (cfg_stanza_normalexit): Change to peek at the next
	token to see whether it's missing or not, and then just fetch each
	next argument at a time.  This is more efficient than parsing them
	all in one go, and also means we can report the error in the right
	place!
	* init/tests/test_cfgfile.c (test_stanza_normalexit): Since we've
	changed the function that parses the stanza, add a proper test case
	function for it, covering all the behaviours.

	* init/job.c (job_new): Initialise the emits member to an empty list.
	* init/job.h (Job): Add the emits member as a list.
	* init/tests/test_job.c (test_new): Check the emits list starts off
	empty.
	* init/tests/test_cfgfile.c (test_stanza_emits): Test the new emits
	stanza; this function will also serve as a prototype for cleaning up
	the config tests.

	* init/cfgfile.c (cfg_stanza_emits): Add function to parse the new
	emits stanza.

	* init/cfgfile.c (cfg_stanza_depends): Remove the depends stanza
	from the configuration file.  Dependency support has never been used,
	and is to be replaced by a more flexible event/state configuration
	and blocking on the starting/stopping events.
	* init/tests/test_cfgfile.c: Remove references and tests for the
	depends stanza.
	* init/job.h: Remove the depends list from the job structure.
	* init/job.c (job_new): No depends list to initialise.
	(job_change_state): No dependencies to release
	(job_start): No dependencies to iterate; this removes a particularly
	hairy and complex interaction between state changes.  Remove the
	dependency event.
	(job_release_depends): Drop this function.
	* init/tests/test_job.c (test_start, test_stop): Massively simplify
	these tests cases now we don't have dependencies to worry about.
	(test_release_depends): Drop tests

2007-01-08  Scott James Remnant  <scott@netsplit.com>

	* init/cfgfile.c: Rewrite using the nih_config API, rather than one
	huge function we now just have seperate handler functions for each
	stanza.  We can also use more fine-grained parsing than slurping
	all args in and counting them.
	(cfg_read_job): Catch exceptions from the configuration parser and
	add the line number where the problem occurred to an output message.
	Parser errors are now fatal, and not ignored.
	* init/errors.h: Add a file containing errors raised within the init
	daemon codebase.
	* init/Makefile.am (init_SOURCES): Build with errors.h
	* init/tests/test_cfgfile.c: Update test cases now we don't expect
	a job to be returned if there's a parser error.

	* TODO: Update

2007-01-06  Scott James Remnant  <scott@netsplit.com>

	* logd/main.c (logging_reader): Fix inadvertent shadowing of the
	len parameter.

	* compat/sysv/telinit.c: Oops, nearly forgot to port this to send
	the messages in the new way.
	* compat/sysv/shutdown.c (shutdown_now): Likewise, port this too.

	* TODO: Update.

	* util/initctl.c (handle_job_status): Output the process argument,
	not the pid argument which contains the origin of the message.

	* upstart/message.c (upstart_message_handle): Raise a new unknown
	message error if we don't have a handler  and a new illegal message
	error if the source is illegal.
	* upstart/tests/test_message.c (test_handle): Adjust tests to check
	for the new errors that we raise.
	* upstart/errors.h: Define strings for new errors.

	* util/initctl.c: Yet another makeover for this little program,
	port it to the new message/control framework using handler functions
	and NihIoMessage.  This starts to make each action function look
	very similar, so there's method to this madness.

2007-01-05  Scott James Remnant  <scott@netsplit.com>

	* logd/main.c (main): Make sure that we add the SIGTERM handler.

	* init/tests/test_job.c (test_run_script): This test case relies
	on there only being one file descriptor watch, which won't be true
	if the control socket has been opened because there's a message to
	go out.  Make sure it's closed first.

	* init/init.supp: Update supressions file now that control_init
	has been renamed to notify_init

	* init/Makefile.am: Include notify.o from all tests.
	* init/job.c (job_change_state, job_kill_process, job_start) 
	(job_stop): Use the new notify_job function name.
	* init/event.c (event_queue_run): Use the new notify_event function
	name.

	* init/control.c (control_error_handler): Handle ECONNREFUSED now
	that the process id is available to us.
	* init/tests/test_control.c (test_error_handler): Make sure children
	going away is handled properly.

	* upstart/message.c (upstart_message_new): Store the process id in
	the int_data message field.
	* upstart/tests/test_message.c (test_new): Check the int_data field
	is filled in.

	* init/main.c (main): Guard against various things returning an error
	that we weren't catching.

	* init/tests/test_notify.c: Whitespace fix.

	* init/control.c (control_watch_jobs, control_unwatch_jobs) 
	(control_watch_events, control_unwatch_events): Restore functionality
	to subscribe and unsubscribe from job and event notifications.	
	* init/tests/test_control.c (test_watch_jobs, test_unwatch_jobs) 
	(test_watch_events, test_unwatch_events): Check that the subscription
	and unsubscription messages work.
	* init/Makefile.am (test_control_LDADD): Link to notify.o

	* init/control.c: Drop unused include of upstart/errors.h

	* init/notify.c: Move functions that handle subscription and
	notification from control.c.  Other than changing the names, we're
	keeping the API the same for now; expect it to change later when we
	add the ability to subscribe to individual jobs or events.
	(notify_init): initialise the subscriptions list; we don't have a
	separate send queue now that the control I/O is always asynchronous.
	* init/notify.h: Moved notification enum, structure and prototypes
	from control.h, changing the names so they match notify_* in the
	process.
	* init/Makefile.am (init_SOURCES): Build and link notify.c using
	notify.h
	(TESTS): Build the notify test suite binary.
	(test_notify_SOURCES, test_notify_LDFLAGS, test_notify_LDADD): Details
	for notify test suite binary.
	* init/tests/test_notify.c: Rewrite test cases in the manner of
	test_control.c so that we have one function for notify_job and
	one for notify_event, each of which contains the child process that
	receives the notification,

	* init/control.c (control_open): Allow this to be called to obtain
	the control socket, which means we can make it static.
	* init/tests/test_control.c (test_open): Check that it works.

	* init/control.c, init/control.h, init/tests/test_control.c: Move
	functions that handle subscription and notification to new notify.c
	(control_init): Drop completely, no need to maintain a send queue now
	(control_open): Change to return an NihIo that uses the default
	control watcher, and our error handler.  Split socket opening into
	(control_open_sock): which can be called from other functions.
	(control_close): Use nih_io_close() to close the socket and free the
	structure in one go.
	(control_reopen): Close the open control socket and open it again
	without destroying the NihIo structure, its queues or state.
	(control_close_handler): Handle the control socket going away
	(control_error_handler): Handle errors on the control socket,
	including the connection refused error that indicates a client went
	away.
	(control_handle): Split this into a miriad of small functions with
	a table to link them to the message type; this will make expanding
	each message handler much easier in future.
	* init/control.h: Update.
	* init/tests/test_control.c: Rewrite test cases to check the new
	handler functions; as a side-effect, this gets rid of the evil giant
	child/parent functions in favour of one test function per handler
	function.

	* upstart/message.c (upstart_message_handle_using): Wrapper function
	around upstart_message_handle that ensures all messages as passed to
	a single function.
	* upstart/message.h: Update.
	* upstart/tests/test_message.c (test_handle_using): Make sure it
	calls the single function.

2007-01-04  Scott James Remnant  <scott@netsplit.com>

	* upstart/message.c (upstart_message_reader): Handle any errors
	that occurred while handling the message.

2007-01-02  Scott James Remnant  <scott@netsplit.com>

	* upstart/message.c (upstart_message_handle): Check that the name
	argument is never NULL.
	(upstart_message_reader): Simple message reader function that can
	be associated with an I/O watch and handles each message received.
	* upstart/message.h: Add prototype.
	* upstart/tests/test_message.c (test_reader): Test the reader function.

	* upstart/control.c: Rename to upstart/message.c
	* upstart/control.h: Rename to upstart/message.h
	* upstart/tests/test_control.c: Rename to upstart/tests/test_message.c
	* upstart/libupstart.h: Update includes.
	* upstart/wire.c: Include message.h
	* upstart/wire.h: Update includes.
	* upstart/tests/test_wire.c: Update includes.
	* upstart/errors.h: Rename UPSTART_INVALID_MESSAGE to
	UPSTART_MESSAGE_INVALID so that it's prefixed.
	* upstart/Makefile.am (libupstart_la_SOURCES) 
	(upstartinclude_HEADERS, TESTS): Update filenames.

	* upstart/control.c (upstart_message_new): New function that
	creates an NihIoMessage directly from its arguments, which are a type
	followed by a variable number of args depending on that type.
	(upstart_message_handler): Function to find a handler function for
	a particular message type and origin process.
	(upstart_message_handle): New function that takes an NihIoMessage
	and invokes a handler function with a variable number of args
	depending on the message type.
	(upstart_send_msg, upstart_send_msg_to, upstart_recv_msg): Drop these
	functions, leave it up to the caller to decide whether to send and
	receive the messages synchronously or asynchronously; now that the
	capability is in nih_io_*.
	* upstart/control.h (UpstartMsgType): Rename to UpstartMessageType.
	(UpstartMessageHandler): Function with variable number of arguments
	that handles a message received.
	(UpstartMsg): Drop this structure entirely, we'll encode or decode
	the wire format directly from or into a function call, rather than
	use an intermediate structure to marshal it.
	(UpstartMessage): New structure to make a table that can be passed
	to upstart_message_handle to determine which handler should be called.
	* upstart/tests/test_control.c: Test new behaviour.
	* upstart/wire.c (upstart_push_header, upstart_pop_header): Change
	structure name for type parameter.
	* upstart/wire.h: Update.
	* upstart/tests/test_wire.c: Update.

	* configure.ac (AC_COPYRIGHT): Update copyright to 2007.

2006-12-29  Scott James Remnant  <scott@netsplit.com>

	* upstart/wire.c (upstart_write_int, upstart_write_unsigned) 
	(upstart_write_string, upstart_write_header, upstart_write_packv) 
	(upstart_write_pack): Rename to *_push_*
	(upstart_read_int, upstart_read_unsigned, upstart_read_string) 
	(upstart_read_header, upstart_read_packv, upstart_read_pack): Rename
	to *_pop_*.
	All of the above modified to modify an NihIoMessage structure,
	instead of trying to carry around buffers ourself.
	* upstart/wire.h: Update to match above.
	* upstart/tests/test_wire.c: Update all tests to match the above
	changes.

2006-12-21  Scott James Remnant  <scott@netsplit.com>

	* upstart/wire.c (upstart_read_packv, upstart_write_packv): Change
	nih_assert_notreached to nih_assert_not_reached.

	* init/job.c (job_run_script): Open the NihIo structure in stream mode.
	* logd/main.c (logging_watcher): Open the NihIo structure in
	stream mode.
	(logging_reader): Need to pass the length of the size_t as a pointer
	so that it can be modified if less is read.

2006-12-17  Scott James Remnant  <scott@netsplit.com>

	* upstart/wire.c (upstart_write_packv, upstart_write_pack) 
	(upstart_read_packv, upstart_read_pack): Functions to write a pack
	of different variables to the stream, or read them from it
	* upstart/wire.h: Add prototypes.
	* upstart/tests/test_wire.c (test_write_pack, test_read_pack):
	Check we can read and write a pack of variables at once.

	* upstart/wire.c (upstart_write_header, upstart_read_header): Drop
	the version from the header, we'll just keep the protocol always
	backwards compatible.
	* upstart/wire.h: Update.
	* upstart/tests/test_wire.c (test_write_header, test_read_header):
	Check that everything works.

	* upstart/wire.c (upstart_write_string, upstart_read_string):
	Transmit the length as an unsigned, and use 0xffffffff to mean NULL
	instead of zero so we can still transmit the empty string.
	* upstart/wire.h: Update.
	* upstart/tests/test_wire.c (test_write_string, test_read_string):
	Tests for the functions to make sure the wire is at it should be.

	* upstart/wire.c (upstart_read_str, upstart_write_str): Rename to
	upstart_read_string and upstart_write_string.
	* upstart/wire.h: Update.
	
	* upstart/wire.c (upstart_write_unsigned, upstart_read_unsigned):
	Functions to send unsigned values over the wire, which we'll use
	to get a bit extra for the string lengths.
	* upstart/wire.h: Update.
	* upstart/tests/test_wire.c (test_write_unsigned) 
	(test_read_unsigned): Test the new functions.

	* upstart/wire.c (upstart_write_ints, upstart_read_ints): Drop
	these functions, we'll go with something far more generic and
	useful.
	* upstart/wire.h: Remove prototypes.

	* upstart/wire.c (upstart_write_int, upstart_read_int): Transmit
	integers as signed 32-bit values in network byte order.
	* upstart/tests/test_wire.c (test_write_int, test_read_int): Test
	the functions to make sure the wire is at it should be,

	* upstart/control.c (upstart_read_int, upstart_write_int) 
	(upstart_read_ints, upstart_write_ints, upstart_read_str) 
	(upstart_write_str, upstart_read_header, upstart_write_header): Move
	functions to new wire.c file.
	* upstart/wire.c: Source file to hold wire protocol functions.
	* upstart/wire.h: Prototypes.
	* upstart/tests/test_wire.c: (empty) test suite.
	* upstart/libupstart.h: Include wire.h
	* upstart/Makefile.am (libupstart_la_SOURCES): Build and link wire.c
	(upstartinclude_HEADERS): Install wire.h
	(TESTS): Build and run wire test suite.
	(test_wire_SOURCES, test_wire_LDFLAGS, test_wire_LDADD): Details for
	wire test suite binary.

	* upstart/control.c (MAGIC): Change to "upstart\n", the final
	character was originally \0 and then was a " " for the 0.2 series.
	* upstart/tests/test_control.c (test_recv_msg): Change to match.

2006-12-15  Scott James Remnant  <scott@netsplit.com>

	* util/initctl.c, compat/sysv/telinit.c, compat/sysv/shutdown.c:
	Update all uses of the UpstartMsg structure to avoid the
	intermediate union that no longer exists.	

	* init/control.c, init/tests/test_control.c: Update all uses of
	the UpstartMsg structure to avoid the intermediate union that no
	longer exists.	

	* upstart/control.h: Combine all the previous message structures
	into just one that has all of the fields anyway.
	* upstart/control.c, upstart/tests/test_control.c: Update all uses of
	the UpstartMsg structure to avoid the intermediate union that no
	longer exists.

	* upstart/control.h (UPSTART_API_VERSION): Define API version macro
	to be public.
	* upstart/control.c (MSG_VERSION, upstart_send_msg_to): Replacing the
	previous MSG_VERSION macro here.

	* upstart/control.c (upstart_read_int, upstart_write_int) 
	(upstart_read_ints, upstart_write_ints, upstart_read_str) 
	(upstart_write_str, upstart_read_header, upstart_write_header):
	New functions to replace the old "write a struct" protocol with
	something a little more regimented and supportable.
	(IOVEC_ADD, IOVEC_READ, WireHdr, WireJobPayload, WireJobStatusPayload)
	(WireEventPayload): Remove these structures, use the functions
	instead.
	(upstart_send_msg_to): Call write functions intead of using macros,
	this makes the code somewhat neater.
	(upstart_recv_msg): Call read functions instead of using macros,
	again making the code somewhat neater.
	* upstart/tests/test_control.c (test_recv_msg): Change wire
	tests to match new protocol, and thus actually work properly,
	previously these were endian sensitive.

2006-12-14  Scott James Remnant  <scott@netsplit.com>

	* compat/sysv/shutdown.c (wall): Construct the wall message so that
	we don't put \r into a po file; for some reason, gettext hates that
	and bitches about it.  Someone's confusing internationalisation with
	operating system portability, I expect.

	* util/man/initctl.8: Drop reference to start(8), as that's just
	a symlink to initctl now.

	* init/man/init.8: Link to initctl.

	* compat/sysv/reboot.c (main): Clear up help text a little.

	* HACKING: Correct some typos.

	* configure.ac (AC_INIT): Correct bug reporting address.

2006-12-13  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.3.2

	* NEWS: Update.

	* util/initctl.c (print_job_status): Drop the newline from the
	output.

2006-12-13  Alex Smith  <alex@alex-smith.me.uk>

	* util/initctl.c (print_job_status): Clean up initctl job status
	output, which was badly converted from printf to nih_message.

2006-12-13  Scott James Remnant  <scott@netsplit.com>

	* compat/sysv/man/shutdown.8: Add missing documentation on the
	format of TIME by copying it from --help output.

2006-12-13  Alex Smith  <alex@alex-smith.me.uk>

	* init/process.c (process_setup_console): Actually send output to
	/dev/null instead of /dev/console, when CONSOLE_NONE.

2006-12-13  Scott James Remnant  <scott@netsplit.com>

	* Makefile.am (EXTRA_DIST): Distribute the nih ChangeLog as well.

	* init/tests/test_job.c: Port to the new test framework.
	* init/job.c (job_set_idle_event): Fix a slight memory leak,
	repeated setting of the idle event never freed the previous one set.

2006-12-12  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_cfgfile.c: Port to the new test framework.

	* init/tests/test_control.c: Port to the new test framework.
	* init/init.supp: Suppress the list head allocated within control_init.

	* init/control.c (control_watcher): Need to save the pid when we
	get ECONNREFUSED, otherwise we lose it when we free the message.

	* init/tests/test_process.c: Port to the new test framework.
	* init/init.supp: Suppress the list head allocated within job_init.

	* init/init.supp: Include a valgrind suppressions file.
	* init/Makefile.am (EXTRA_DIST): Distribute the suppressions file.

	* init/tests/test_event.c: Port to the new test framework.

	* logd/Makefile.am, util/Makefile.am, compat/sys/Makefile.am
	(AM_CPPFLAGS): Add -I$(srcdir), necessary for testing "programs"
	that don't have usual library path semantics.

	* upstart/tests/test_control.c: Port to the new test framework.
	* upstart/control.c (upstart_free): Drop this function, while not
	exposing libnih is a valiant effort, it already slips out because
	of the error handling.

	* upstart/tests/test_job.c: Add missing include.

	* upstart/tests/test_job.c: Port to the new test framework.
	(test_process_state_name): Check that this returns NULL.

	* HACKING: Update location of download directory.  Document
	requirement that all code have test cases.

	* logd/main.c (open_logging): Likewise.

	* init/control.c (control_open): No need to set ENOMEM, errno is
	always set anyway.

	* configure.ac (AM_INIT_AUTOMAKE): Include nostdinc so we don't get
	Automake's broken default includes.
	* upstart/Makefile.am (DEFAULT_INCLUDES): Drop override now that
	we don't need it.
	(DEFS, INCLUDES): Replace these variables with the combined
	(AM_CPPFLAGS): variable that declares everything.
	* init/Makefile.am (DEFAULT_INCLUDES): Drop override now that
	we don't need it.
	(DEFS, INCLUDES): Replace these variables with the combined
	(AM_CPPFLAGS): variable that declares everything.
	* util/Makefile.am (DEFAULT_INCLUDES): Drop override now that
	we don't need it.
	(DEFS, INCLUDES): Replace these variables with the combined
	(AM_CPPFLAGS): variable that declares everything.
	* compat/sysv/Makefile.am (DEFAULT_INCLUDES): Drop override now that
	we don't need it.
	(DEFS, INCLUDES): Replace these variables with the combined
	(AM_CPPFLAGS): variable that declares everything.
	* logd/Makefile.am (DEFAULT_INCLUDES): Drop override now that
	we don't need it.
	(DEFS, INCLUDES): Replace these variables with the combined
	(AM_CPPFLAGS): variable that declares everything.

2006-11-02  Scott James Remnant  <scott@netsplit.com>

	* util/initctl.c (start_action): Remove break calls which shouldn't
	be there.

2006-10-18  Sean E. Russell  <ser@ser1.net>

	* init/main.c: Include sys/time.h
	* init/cfgfile.c: Include sys/time.h and sys/resource.h
	* init/job.c: Include sys/time.h and sys/resource.h

2006-10-17  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.3.1

	* NEWS: Update.
	* TODO: Update.

	* configure.ac (AM_GNU_GETTEXT_VERSION): Quote version number.

	* logd/Makefile.am (event.d/logd): Make the event.d sub-directory
	in case we're building outside of the source tree.

	* compat/sysv/runlevel.c (store): Don't break strict-aliasing rules
	by avoiding dereferencing type-punned pointer.  Answers on a
	postcard, please.

2006-10-13  Scott James Remnant  <scott@netsplit.com>

	* util/initctl.c (start_action, emit_action): Add missing \n

	* util/initctl.c: Rewrite using nih_command_parser.
	* util/man/initctl.8: Improve.

	* util/start.c: Remove, replaced by initctl.
	* util/man/start.8: Remove, replaced by initctl.
	* util/Makefile.am (sbin_PROGRAMS): Drop start, now just a symlink
	to initctl.
	(dist_man_MANS): Drop start.8, now a symlink to initctl.8
	(install-exec-hook): Make symlinks to initctl, add start
	(install-data-hook): Make symlinks to initctl.8, add start.8

	* initctl: Rename to util again, I don't want a separate directory
	for every single little tool; and we'll be shipping more than just
	initctl (e.g. a non-compat reboot).
	* configure.ac (AC_CONFIG_FILES): Make util/Makefile instead of
	initctl/Makefile.
	* Makefile.am (SUBDIRS): Descend into util, not initctl.

	* compat/sysv/reboot.c: Remove long options where they didn't exist
	before.  Write help text.
	* compat/sysv/man/reboot.8: Update.

	* init/main.c (main): Formatting.
	* logd/main.c (main): Formatting.
	* logd/man/logd.8: Formatting.
	* compat/sysv/runlevel.c (main): Formatting.
	* compat/sysv/telinit.c (main): Formatting.
	* compat/sysv/man/shutdown.8: Remove long options.

	* compat/sysv/shutdown.c: Remove -e/--event, it has no place in a
	compatibility tool.  Get rid of long options that never existed
	before.  Specify help text to describe the options.
	* compat/sysv/man/shutdown.8: Spruce up a bit.

	* compat/sysv/telinit.c (main): Set help text to list the valid
	runlevels.
	* compat/sysv/man/telinit.8: Refine the notes to mention runlevel(8).

	* compat/sysv/runlevel.c (main): Make the help text describe the
	options, rather than the behaviour.
	* compat/sysv/man/runlevel.8: Flesh out a little more.

	* configure.ac (AC_INIT): Change bug reporting address to the
	mailing list, since Launchpad doesn't accept random bugs without
	accounts and complicated control messages.
	* init/main.c, logd/main.c: Add a period to the synopsis.

	* init/main.c (main): Set the synopsis, and direct people to look
	at telinit in the --help output.
	* init/man/init.8: Flesh this out a little more, still a lot of
	explaining to do about jobs and events, but we'll wait until we've
	changed that code before documentating the behaviour.

	* logd/main.c (main): Correct help text to describe the options,
	rather than what the program does.  As per standard style.
	Don't become a daemon until the logging socket is open, and make
	that exclusive with waiting for SIGCONT.
	* logd/man/logd.8: Write some more extensive documentation,
	including describing the startup interlock and the socket protocol.
	* TODO: Plan to get rid of the signal interlock from  logd.

2006-10-12  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Expand AC_GNU_SOURCE so we get _GNU_SOURCE and so
	that gettext doesn't complain.
	(AM_GNU_GETTEXT_VERSION): Increase to 0.15
	(AC_PREREQ): Increase to 2.60
	* HACKING: Update autoconf and gettext requirements.

2006-10-11  Scott James Remnant  <scott@netsplit.com>

	* init/control.c (control_init): Pass NULL to nih_list_new.
	Clarify list item types.
	* init/event.c (event_init): Pass NULL to nih_list_new.
	* init/job.c (job_init): Pass NULL to nih_list_new.

	* init/main.c: Change nih_signal_add_callback to nih_signal_add_handler
	and NihSignalCb to NihSignalHandler.

	* init/cfgfile.c, init/cfgfile.h, init/control.c, init/control.h,
	init/event.c, init/event.h, init/job.c, init/job.h, init/main.c,
	init/process.c: Clean up documentation strings and parent pointer
	types.

	* compat/sysv/shutdown.c: Change nih_signal_add_callback to
	nih_signal_add_handler.

	* compat/sysv/reboot.c: Set synopsis text depending on command
	used (probably should use nih_command_parser?)
	* compat/sysv/runlevel.c: Set synopsis and help text, and correct
	usage.
	* compat/sysv/shutdown.c: Set synopsis text.
	* compat/sysv/telinit.c: Set synopsis text.

	* compat/sysv/runlevel.c, compat/sysv/shutdown.c: Clean up
	documentation strings.

	* logd/main.c: Set synopsis and help text.

	* logd/main.c: Clean up documentation strings.
	Change nih_signal_add_callback to nih_signal_add_handler.

	* upstart/control.c, upstart/control.h, upstart/job.c: Clean up
	documentation strings and correct parent pointer type.

	* HACKING: Detail function documentation requirement and format.

2006-10-10  Scott James Remnant  <scott@netsplit.com>

	* event.d/logd.in: Move to logd/event.d
	* event.d/Makefile.am: Remove
	* logd/Makefile.am: Create the logd job definition and install
	* Makefile.am (SUBDIRS): event.d directory has been removed.
	* configure.ac (AC_CONFIG_FILES): No longer make event.d/Makefile

	* configure.ac: Check for --enable-compat, default to sysv if given
	or no compat if not given.
	* compat/sysv/Makefile.am: Don't build binaries or install manpages
	unless COMPAT_SYSV is defined.

2006-10-06  Scott James Remnant  <scott@netsplit.com>

	* doc/upstart-logo.svg: Include the logo Alexandre designed.
	* doc/Makefile.am (EXTRA_DIST): Ship the logo in the tarball.
	* Makefile.am (SUBDIRS): Install under doc
	* configure.ac: Generate doc/Makefile
	* AUTHORS: Ensure he's credited fully.

2006-09-27  Scott James Remnant  <scott@netsplit.com>

	* event.d/Makefile.am (do_subst): Eliminate duplicate /s

	* man/init.8: Move to init/man
	* init/Makefile.am: Update to install man page.
	* man/logd.8: Move to logd/man
	* logd/Makefile.am: Update to install man page.
	* man/initctl.8, man/start.8: Move to initctl/man
	* initctl/Makefile.am: Update to install man pages.
	* man/reboot.8, man/runlevel.8, man/shutdown.8, man/telinit.8:
	Move to compat/sysv/man
	* compat/sysv/Makefile.am: Update to install man pages.
	* man/Makefile.am: Remove
	* configure.ac (AC_CONFIG_FILES): Remove man/Makefile
	* Makefile.am (SUBDIRS): Don't build in man

	* util: Rename to initctl
	* configure.ac (AC_CONFIG_FILES): Update.
	* Makefile.am (SUBDIRS): Update.

	* util/reboot.c: Move to compat/sysv
	* util/shutdown.c: Move to compat/sysv
	* util/Makefile.am: Update.
	* compat/sysv/Makefile.am: Update.

	* configure.ac: Replace macros with single call to NIH_INIT.
	Bump version to 0.3.0 to begin new development cycle.

2006-09-21  Scott James Remnant  <scott@netsplit.com>

	* logd/main.c: Revert the change that logged to the console, in
	practice this doesn't work so well.  I want to get rid of logd
	in the long term, or at least just have it as a simple logging
	proxy, so giving it features seems wrong.

2006-09-20  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.2.8
	* NEWS: Updated.

	* logd/main.c (main): Check the kernel command-line for "quiet"
	(line_reader): Write to console unless silent or a daemon

	* man/Makefile.am (dist_man_MANS): Drop sulogin.8
	* man/sulogin.8: Drop, we don't include an sulogin

2006-09-19  Michael Biebl  <mbiebl@gmail.com>

	* event.d/Makefile.am (logd): Drop $(srcdir)
	* init/Makefile.am (init_SOURCES): Distribute paths.h

2006-09-18  Michael Biebl  <mbiebl@gmail.com>

	* configure.ac: Check for sys/inotify.h

2006-09-18  Scott James Remnant  <scott@netsplit.com>

	* util/shutdown.c (warning_message): Adjust method of constructing
	the message to not confuse poor translators who think \r and \n are
	the same thing!

2006-09-14  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_change_state): Catch runaway respawns when we
	enter the running state, so we catch stop/start loops too.
	* init/tests/test_job.c (test_change_state): Update test.

	* event.d/logd: Rename to logd.in
	* event.d/logd.in: Replace /sbin with @sbindir@ so we can transform
	* event.d/Makefile.am: Generate logd from logd.in

	* util/reboot.c: Don't hardcode the location of /sbin/shutdown
	* util/Makefile.am (DEFS): Use autoconf to seed it
	* util/shutdown.c (sysvinit_shutdown): Don't hardcode the location
	of /dev/initctl

	* init/paths.h: Create a new configuration file that can contain
	all of the path definitions, and in particular, allow them to be
	overidden elsewhere.
	* init/Makefile.am (DEFS): Override definitions of CFG_DIR and
	TELINIT using autoconf
	* init/main.c: Include paths.h.  Don't hardcode location of telinit
	* init/job.c: Include paths.h
	* init/process.c: Include paths.h
	* init/process.h: Remove definitions from here.

	* configure.ac: Bump version to 0.2.7

2006-09-13  Scott James Remnant  <scott@netsplit.com>

	* NEWS: Updated.

	* TODO: More TODO.

2006-09-10  Scott James Remnant  <scott@netsplit.com>

	* util/reboot.c (main): Don't give -H with "halt".

2006-09-09  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.2.6

	* NEWS: Update.
	* TODO: Update.

	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Change
	the magic to be the package string.
	* upstart/tests/test_control.c (test_recv_msg): Update tests.

	* util/initctl.c (main): Set the usage string.
	* util/shutdown.c (main): Set the usage string.
	* util/start.c (main): Set the usage string.
	* compat/sysv/runlevel.c (main): Set the usage string.
	* compat/sysv/telinit.c (main): Set the usage string.

	* man/Makefile.am: Use install-data-hook and $(man8dir)
	* util/Makefile.am: Also use install-exec-hook

	* Makefile.am (SUBDIRS): Install contents of the man directory
	* configure.ac (AC_CONFIG_FILES): Generate man/Makefile
	* man/Makefile.am: Install manpages in the appropriate places.
	* man/init.8, man/logd.8, man/initctl.8, man/reboot.8,
	* man/shutdown.8, man/start.8, man/sulogin.8, man/runlevel.8,
	* man/telinit.8: Include some basic manpages so we at least have
	some level of documentation.

	* init/job.c (job_child_reaper): Don't check the exit status of
	a respawning job if the goal is to stop it.

	* compat/sysv/telinit.c (main): Generate events rather than
	starting and stopping jobs directly, the events are named
	"runlevel-X".  0, 1, 6 and s/S are shutdown events.

	* logd/main.c (main): Raise SIGSTOP before entering the main loop.
	* init/main.c (main): Interlock with logd.

	* event.d/logd: Should not be a console owner, but should stop
	on shutdown.

	* init/process.c (process_setup_console): Revert part of the previous
	change, should just output to /dev/null if we don't have logd.

	* configure.ac: Bump version to 0.2.5

	* init/main.c (main): Start the logd job if it exists.

	* init/process.c (process_setup_console): Ignore ECONNREFUSED as
	that just means that logd isn't around, handle errors by falling
	back to opening the console.

	* init/process.c (process_setup_console): Implement handling for
	CONSOLE_LOGGED and generally clean up the other handling.
	* init/process.h: Update.
	* init/main.c (main): Pass NULL for the job to setup console.
	* TODO: Update.

	* logd/main.c: Implement the logging daemon, it accepts connections
	on a unix stream socket with the abstract name
	"/com/ubuntu/upstart/logd", expects the length of the name and the
	name to follow; then sequences of lines which are logged to
	/var/log/boot, or memory until that file can be opened.

2006-09-08  Scott James Remnant  <scott@netsplit.com>

	* util/shutdown.c (event_setter): Change the event names to
	distinguish between "shutdown -h" and "shutdown -h -H".

	* init/job.c (job_handle_event): Allow jobs to react to their own
	events, this is how we'll do respawn eventually.
	* init/tests/test_job.c (test_handle_event): Remove test.

	* init/main.c (cad_handler, kbd_handler): Generate the new event
	names.
	* init/event.h (CTRLALTDEL_EVENT, KBDREQUEST_EVENT): Add definitions
	of these event names, change the ctrlaltdel event to just that.

	* logd/main.c (main): Add the code to daemonise, etc.

2006-09-07  Scott James Remnant  <scott@netsplit.com>

	* TODO: Long discussion today on #upstart, many improvements to the
	job and event model that make it more elegant.
	* AUTHORS: Include a list of thanks.

	* util/shutdown.c (shutdown_now): If we get ECONNREFUSED when we
	try and send the shutdown event to init, it probably means we're
	still in sysvinit.  So try that instead.
	(sysvinit_shutdown): Function to send a hand-crafted runlevel
	change message across /dev/initctl.

	* util/initctl.c (main): Add a shutdown command that takes an
	arbitrary event name to be issued after "shutdown".  You'll
	nearly always want the /sbin/shutdown tool instead.

	* init/job.c (job_detect_idle): Only generate the stalled event
	if at least one job handles it in its start_events list.
	* init/tests/test_job.c (test_detect_idle): Make sure that works.

	* init/event.h (STARTUP_EVENT, SHUTDOWN_EVENT, STALLED_EVENT):
	Macros to define the standard event names.
	* init/main.c (main): Use STARTUP_EVENT macro instead of "startup"
	* init/control.c (control_handle): Use SHUTDOWN_EVENT macro
	instead of "shutdown".
	* init/job.c (job_detect_idle): Use STALLED_EVENT macro instead
	of "stalled".

	* init/job.c (job_detect_idle): Add some log messages for when we
	detect the idle or stalled states.
	(job_kill_process, job_kill_timer): Increase log verbosity.
	* init/event.c (event_queue_run): Log which events we're handling
	if --debug is given.

	* compat/sysv/telinit.c (main): Send a shutdown command when
	requesting to enter runlevel 0 or runlevel 6, likewise for
	runlevel 1, s or S which all run "rc1" not "rcS".
	* init/main.c (main): When called directory (pid != 1) try and
	run telinit before complaining that we're not init.  Make sure
	errors aren't lost.

2006-09-04  Johan Kiviniemi  <johan@kiviniemi.name>

	* upstart/control.c (upstart_addr): Replace use of __builtin_offsetof
	with offsetof.
	* upstart/tests/test_control.c (test_recv_msg): Likewise.

2006-09-04  Scott James Remnant  <scott@netsplit.com>
	
	* util/shutdown.c (main): Exit normally after sending the warning
	message if -k is given.

2006-09-01  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.2.2

	* NEWS: Update.
	* configure.ac: Bump version to 0.2.1

	* init/process.c (process_setup_console): Ensure that the console
	is always initialised to at least /dev/null
	* init/job.c (job_change_state): Initialise event to NULL.
	* init/event.c (event_read_state): Don't mask initialisation of
	other variable.
	* init/cfgfile.c (cfg_job_stanza, cfg_parse_script, cfg_next_token): 
	Print lineno using %zi not %d
	* compat/sysv/runlevel.c (store): Cast pointer type of timeval.

	* init/main.c: Move the kernel headers include beneath the C
	library ones, so that compilation doesn't fail on !i386.
	* util/reboot.c: Likewise.

	* init/main.c (term_handler): Close the control connection if we
	re-exec init, otherwise it won't be able to bind.  Drop debugging.

	* init/main.c (term_handler): It always helps if we dup2 the
	right file descriptor.

	* init/main.c: Use the TERM signal instead of USR1, as old init
	used that for something else.  Also rather than passing across
	file descriptor numbers, use a fixed descriptor and just pass
	"--restart".  When we get that option we need to unmask signals
	otherwise we sit there looking like a lemon.

	* init/job.c (job_change_state): Don't free the event unless we
	generate one.

	* NEWS: Update.

	* init/cfgfile.c (cfg_watcher): Ignore any file with '.' or '~'

	* TODO: Update.

	* init/main.c (main): Parse command-line arguments, specifically
	look for --state-fd which we'll use for reexec.  Don't do a couple
	of things if we're passed this.
	(read_state): Parse the line-buffered state.
	* init/job.c (job_read_state, job_write_state): Job state
	serialisation so that we can re-exec ourselves.
	* init/job.h: Update.
	* init/tests/test_job.c: Test the serialisation.
	* init/event.c (event_read_state, event_write_state): And similar
	functions for serialising the event queue.
	* init/event.h: Update.
	* init/tests/test_event.c: Test the serialisation.
	* init/cfgfile.c (cfg_read_job): Fix a bug, need to subtract current
	time to get due time.

	* upstart/job.c (job_goal_from_name, job_state_from_name) 
	(process_state_from_name): Add opposite numbers that convert a
	string back into an enumeration.
	* upstart/job.h: Update.
	* upstart/tests/test_job.c: Test the new functions.

2006-08-31  Scott James Remnant  <scott@netsplit.com>

	* init/job.h (Job): Add respawn_limit, respawn_interval,
	respawn_count and respawn_time members so that we can keep track of
	runaway processes.
	* init/job.c (job_catch_runaway): Increment the respawn_count
	within respawn_interval, or reset it if we go over.
	(job_new): Initialise respawn_limit and respawn_interval to sensible
	defaults.
	* init/tests/test_job.c (test_new): Check the defaults are set.
	(test_change_state): Check the respawning code works.
	* init/cfgfile.c (cfg_job_stanza): Parse the "respawn limit" stanza.
	* init/tests/test_cfgfile.c (test_read_job): Test the new stanza.

	* init/process.c (process_setup_console): Remove the console reset
	code, it tends to just crash X and seems to do nothing interesting.
	* init/main.c (reset_console): Instead put it here and just do it
	on startup.

	* configure.ac: Bump version to 0.2.0

	* util/Makefile.am (install-exec-local): Create symbolic links,
	not hard links.

	* init/main.c: Can't catch STOP.

	* util/reboot.c: Pause init while shutting down or rebooting.

	* init/main.c (stop_handler): Catch STOP/TSTP and CONT.
	* init/event.c (event_queue_run): Don't run the event queue while
	paused.
	* init/job.c (job_detect_idle): Don't detect idle jobs while paused.

	* util/reboot.c: if we get the -w argument ("only write to wtmp")
	we need to exit, and not behave as halt normally would.

	* compat/sysv/runlevel.c (main): Add missing newline.
	* compat/sysv/telinit.c (main): And here too.

	* init/main.c (main): Check for idle after the startup event queue
	has been run, otherwise we may just sit there.

	* compat/sysv/Makefile.am (sbin_PROGRAMS): Build and install telinit
	(telinit_SOURCES, telinit_LDFLAGS, telinit_LDADD): Details for
	telinit binary.
	* compat/sysv/telinit.c: Trivial telinit program that just runs
	the appropriate rcX job.
	* compat/sysv/runlevel.c (main): Suggest help on illegal runlevel.

	* util/Makefile.am: Tidy up.

	* configure.ac (AC_CONFIG_FILES): Create compat/sysv/Makefile
	* Makefile.am (SUBDIRS): Build things found in compat/sysv
	* compat/sysv/Makefile.am (sbin_PROGRAMS): Build and install runlevel
	(runlevel_SOURCES, runlevel_LDFLAGS, runlevel_LDADD): Details for
	runlevel binary.
	* compat/sysv/runlevel.c: Helper to store and retrieve the current
	"runlevel" from utmp/wtmp; as well as the reboot time.

	* init/main.c (main): Drop debugging set.

	* init/job.c (job_change_state): As well as the job/state events,
	send the job event when a service is running or a task is stopping.
	* init/tests/test_job.c (test_change_state): Check the events get
	sent properly.

	* util/start.c: Write a simple utility to start, stop, or query
	the status of the named jobs.
	* util/Makefile.am (sbin_PROGRAMS): Build and install start
	(start_SOURCES, start_LDFLAGS, start_LDADD): Details for start
	(install-exec-local): Also install as stop and status.
	* util/reboot.c (main): Drop the debugging set.

	* init/cfgfile.c (cfg_job_stanza): Correct nih_alloc error.

	* init/process.c (process_setup_environment): Guard memory alloc.
	* init/job.c (job_set_idle_event): Likewise.
	(job_change_state): And here too.
	(job_run_command): Likewise.
	* init/control.c (control_send): Likewise.
	* init/cfgfile.c: And throughout this file.
	* upstart/control.c (upstart_recv_msg): And once here too.

	* upstart/control.h: Abolish the separate halt, reboot and poweroff
	messages and replace with a single shutdown message that takes
	an event name (for the idle event issued afterwards).
	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Handle
	the new shutdown event type by just treating it as an event.
	* upstart/tests/test_control.c (test_messages): Update tests.
	* init/job.c (job_set_idle_event): Store a copy of the idle event
	name.
	* init/control.c (control_send): Copy the shutdown event name.
	(control_handle): Replace individual handling with the new
	single event.
	* init/tests/test_control.c (test_watcher): Update.
	* util/initctl.c: Drop handling for things that shutdown does now.
	* util/shutdown.c: Send the UPSTART_SHUTDOWN event and let the user
	specify anything they want, just give defaults.

	This is quite a big change and abolishes level events entirely,
	along with the event history.  We now just treat events as a
	transient queue of strings that go past, may cause things to change,
	but are otherwise forgotten.  This turns out to be much easier to
	understand and has no real loss of power.

	* init/event.c: Vastly simplify; gone are the separate notions of
	edge and level events, instead we just treat them as one-shot
	things that go past and are forgotten about.
	* init/event.h (Event): Remove value member.
	Update prototypes.
	* init/tests/test_event.c: Update.
	* init/job.c (job_change_state): Change the event pattern to be
	one that includes the job name and a description of the transition
	instead of the new state.
	(job_detect_idle): Call event_queue rather than event_queue_edge.
	* init/tests/test_job.c: Update.
	* init/cfgfile.c (cfg_job_stanza): Drop "when" and "while".
	* init/tests/test_cfgfile.c (test_read_job): Drop mentions of
	"when" and "while".
	* init/control.c (control_send, control_handle): Drop cases for
	level events.
	(control_handle_event): Don't include a level in the event.
	* init/tests/test_control.c: Update
	* init/main.c: Call event_queue rather than event_queue_edge.
	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Change
	event handling so that only a name is read.
	* upstart/control.h: Remove value/level event structures.
	* upstart/tests/test_control.c (test_messages): Update.
	* upstart/job.c (process_state_name): Not used for events, adjust
	documentation so it doesn't lie.
	* util/initctl.c (main): Drop the set function, simplify trigger.
	* util/shutdown.c (shutdown_now): Call UPSTART_EVENT_QUEUE for
	shutdown into maintenance mode.

	* init/control.c (control_handle): Place a message in the syslog
	before halting, powering off or rebooting.

	* util/shutdown.c: Adjust so that the warning message is sent out
	if shutdown is immediate, and when it actually happens.  Include
	the hostname as wall does.

2006-08-30  Scott James Remnant  <scott@netsplit.com>

	* TODO: Update.

	* util/shutdown.c: Implement shutdown utility along the same lines
	as the sysvinit one, but with rather different code.

	* util/initctl.c (main): Call setuid on the effective user id so
	that we can be made setuid root and executable by a special group.
	* util/reboot.c (main): Likewise.

	* util/initctl.c (main): Check the effective rather than the real
	user id, if we're effectively root, that's good enough.

	* util/reboot.c: Implement reboot/halt/poweroff utility.
	* util/Makefile.am (sbin_PROGRAMS): Build and install reboot
	(reboot_SOURCES, reboot_LDFLAGS, reboot_LDADD): Details for reboot
	(install-exec-local): Create hardlinks to reboot for halt and poweroff.

2006-08-29  Scott James Remnant  <scott@netsplit.com>

	* init/main.c (main): Actually run the idle-detect function.
	* init/job.c (job_detect_idle): Interrupt the main loop, otherwise
	we may end up waiting for a signal before we process the event
	we just issued.

2006-08-27  Scott James Remnant  <scott@netsplit.com>

	* util/shutdown.c: Template main function.
	* util/Makefile.am (sbin_PROGRAMS): Build and install the
	shutdown binary.
	(shutdown_SOURCES, shutdown_LDFLAGS, shutdown_LDADD): Details for
	the shutdown binary

	* util/initctl.c (main): Add commands for halt, poweroff and reboot.

	* init/event.c (event_queue_run): Remove the parameters.
	* init/event.h: Update.
	* init/main.c (main): Update.
	* init/tests/test_control.c (test_watcher): Update.
	* init/tests/test_job.c (test_detect_idle): Update.

	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Deal
	with halting, rebooting and powering off; or at least the appropriate
	messages.
	* upstart/control.h: Add control message structures for halting,
	powering off and rebooting the machine.
	* upstart/tests/test_control.c (test_messages): Run the tests.
	* init/control.c (control_handle): Add handling for halt, power off
	and reboot that issue the shutdown event and arrange for the halt,
	poweroff or reboot to be issued the next time the system is idle.
	* init/tests/test_control.c (test_watcher): Test the events.

	* TODO: Update.

	* init/job.c (job_detect_idle): Function to detect when the system is
	stalled or idle.
	* init/job.h: Update
	* init/tests/test_job.c (test_detect_idle): Test the new function.

	* util/initctl.c (main): Handle the list command.

	* TODO: Update.

	* upstart/control.c (WireJobStatusPayload): add description to the
	job status payload.
	(upstart_send_msg_to, upstart_recv_msg): Send and receieve the
	description over the wire.
	* upstart/control.h (UpstartJobStatusMsg): add a description field
	* upstart/tests/test_control.c: Update test cases.
	* init/control.c (control_handle): Include the job description in
	the message.
	(control_send): Copy the description when we put the message on
	the queue.
	(control_handle_job): Copy the description here too
	* init/tests/test_control.c: Update test cases.

	* init/job.c (job_list): Add a function to return the job list.
	* init/job.h: Update.
	* init/control.c (control_handle): Handle the JOB_LIST message
	by sending back a list of job status messages followed by the
	JOB_LIST_END message.
	* init/tests/test_control.c (test_watcher_child): Check the
	JOB_LIST message works properly.

	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Handle
	the JOB_LIST and JOB_LIST_END messages which have no payload.
	* upstart/control.h: Add enums and structures for job list messages.
	* upstart/tests/test_control.c (test_messages): Update tests.

	* init/main.c (main): Check that we're both uid and process #1

	* init/main.c (main): Stop handling SIGTERM, we never want people
	to kill init.  Handle SIGINT and SIGWINCH through the ordinary
	handler and SIGSEGV through a direct handler.
	(segv_handler): Write a sensible core dump handler, we use a child
	to dump core while we carry on in the parent hopefully stepping over
	the bad instruction.
	(cad_handler): Generate the control-alt-delete event.
	(kbd_handler): Generate the kbdrequest event.

2006-08-25  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Bump version to 0.1.2
	* NEWS: Update.

	* TODO: Update.

	* init/process.c (process_setup_environment): Inherit the PATH
	and TERM environment variables from the init process, so the
	console works properly.
	* init/process.h (PATH): Declare a default value for this variable
	* init/main.c (main): Set the value of PATH to the default.
	* init/tests/test_process.c (child): Update test case.

	* NEWS: Update.
	* configure.ac: Bump version to 0.1.1

2006-08-24  Scott James Remnant  <scott@netsplit.com>

	* init/cfgfile.h (CFG_DIR): Change configuration directory to
	/etc/event.d -- it's not been used by anyone, but is similar to
	other directories that have which is a good precedent.
	* event.d/Makefile.am (eventdir, dist_event_DATA): Install files
	into the new directory name.
	* Makefile.am (SUBDIRS): Rename sub directory
	* configure.ac (AC_CONFIG_FILES): Rename generated Makefile

	* init/Makefile.am (DEFAULT_INCLUDES): Set to include the right
	directories so out of tree builds work.
	* logd/Makefile.am (DEFAULT_INCLUDES): Set to include the right
	directories so out of tree builds work.
	* upstart/Makefile.am (DEFAULT_INCLUDES): Set to include the right
	directories so out of tree builds work.
	(upstartinclude_HEADERS): Install errors.h
	* util/Makefile.am (DEFAULT_INCLUDES): Set to include the right
	directories so out of tree builds work.

	* Makefile.am (SUBDIRS): Add m4 to the list
	* configure.ac (AC_CONFIG_FILES): Generate m4/Makefile
	* upstart/Makefile.am (upstartinclude_HEADERS): Add errors.h

	* upstart/control.c (upstart_open): 

	* init/control.c (control_open): Raise the error before
	performing other actions so errno is not lost.

	* TODO: Update.o
	* init/cfgfile.c (cfg_next_token): Don't count quote characters
	unless we're actually planning to dequote the file, otherwise we
	end up allocating short.

	* init/control.c (control_close): Free the io_watch using list_free
	in case a destructor has been set.
	* init/tests/test_control.c: Initialise the type of the message, and
	free job correctly.

	* upstart/tests/test_control.c: Fix overwrite of buffer.
	* init/tests/test_job.c: Clean up not-freed job.

2006-08-23  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_event.c: free the entry allocated and initialise
	the return values.

	* init/cfgfile.c (cfg_skip_token): Drop this function; we'll
	make sure *pos is pointing at the start of the thing we want
	to parse, not the first token.  Update the other functions
	accordingly.
	(cfg_read_job): Implement function to look over a job file and
	parse all of the stanzas that are found.  Also sanity checks the
	job afterwards and deals with reloading existing jobs.
	(cfg_job_stanza): Function that parses an individual stanza,
	calling out to the other parse functions; this is the main config
	file parser!
	(cfg_parse_args, cfg_parse_command): Drop requirement that filename
	and lineno be passed, so we can be called to reparse arguments after
	we've already done so.
	(cfg_parse_script): Remove requirement that it be called at the
	start of the entire stanza, and instead at the start of the script.
	When hitting EOF, return the script so far, not NULL.
	(cfg_parse_args): Correct bug where we didn't check sufficient
	characters while skipping whitespace.
	(cfg_next_token): Correct bug where we didn't copy the character
	after a slash into the text, instead of just not copying the slash.
	Adjust line numbers to match the fact that it's zero based now.
	* init/cfgfile.h: Define prototype.
	* init/tests/test_cfgfile.c (test_read_job): Pretty thoroughly
	test the config file parser code.

2006-08-22  Scott James Remnant  <scott@netsplit.com>

	* init/cfgfile.c (cfg_tokenise): Rename to cfg_next_token.
	(cfg_skip_token): Code to skip whitespace, token and whitespace.
	(cfg_parse_args): Function to parse an argument list.
	(cfg_next_token): Extend to support the removal of quotes and
	slashes from the token.

	* init/cfgfile.c (cfg_parse_script): Pass filename and lineno and
	increment the latter as we go.
	(cfg_script_end): Pass and increment lineno.

	* init/cfgfile.c: Correct a missing semi-colon in prototypes.
	(cfg_parse_command): Function to parse any stanza that requires
	a command and arguments list, e.g. exec/respawn/daemon.  We don't
	want to require that the list be quoted, etc. and do want to allow
	it to be folded over lines.
	(cfg_tokenise): Function used by the above to tokenise the file,
	handling things like \, quoted strings and newlines, etc.  Can be
	used both to determine the length of the token and to copy it.

	* init/cfgfile.c (cfg_read_script): Rename to cfg_parse_script.

	* init/cfgfile.c (cfg_read_script): Function to parse a script
	fragment ("foo script\n....end script\n") from the job file, which
	is the most complex form we can find.  Write it assuming the file is
	in a character array which may not be NULL terminated (ie. a mmap'd
	file).
	(cfg_script_end): Used by the above to detect the end of the
	fragment.
	* init/cfgfile.h: Empty header file.
	* init/Makefile.am (init_SOURCES): Build and link cfgfile.c
	using the cfgfile.h header
	(TESTS): Build and run the config file test cases.
	(test_cfgfile_SOURCES, test_cfgfile_LDFLAGS, test_cfgfile_LDADD):
	Details for config file test case binary.

	* init/main.c (main): Remove the calls to the unfinished config
	file code.

2006-08-21  Scott James Remnant  <scott@netsplit.com>

	* init/main.c: Add missing include for unistd.h
	* init/process.c (process_setup_console): Drop use of job.
	* util/initctl.c (main): Check that we're run as root.

	* init/main.c (main): Write the main function

	* init/event.c (event_queue_cb): Rename to event_queue_run.
	* init/event.h: Update.

	* init/process.c (process_setup_console): Become an exported
	function that includes the code to reset a console.

2006-08-19  Scott James Remnant  <scott@netsplit.com>

	* logd/main.c (main): Write the basic main function.

	* util/initctl.c (main): Fill in the details to give us a basic
	test client.

	* TODO: Update.

	* util/initctl.c (main): Provide the most basic main function.
	* util/Makefile.am (sbin_PROGRAMS): Build the initctl binary
	* Makefile.am (SUBDIRS): Build the utilities.
	* configure.ac (AC_CONFIG_FILES): Generate the util Makefile.

2006-08-18  Scott James Remnant  <scott@netsplit.com>

	* init/Makefile.am (test_job_LDADD): Remove the duplicate link.

	* TODO: Update.

	* init/job.c (job_handle_child): Rename to job_child_reaper.
	* init/job.h: Update.
	* init/tests/test_job.c: Update function names.

	* init/control.c (control_cb): Rename to control_watcher
	* init/tests/test_control.c: Update function names.

	* TODO: Update.

	* Makefile.am (SUBDIRS): Install the rc.d files.
	* configure.ac (AC_CONFIG_FILES): Generate the rc.d Makefile.
	* rc.d/Makefile.am (rcdir): Define rcdir to be /etc/rc.d
	(dist_rc_DATA): Install the logd file into that directory.
	* rc.d/logd: Write a simple service definition for the log daemon,
	this saves us hardcoding any information about it into init; it'll
	just need to know the name.

	* Makefile.am (SUBDIRS): Build the logd daemon
	* configure.ac (AC_CONFIG_FILES): Generate the logd Makefile.
	* logd/Makefile.am (sbin_PROGRAMS): Install the logd binary into
	the sbin directory by default.
	(logd_SOURCES): Build and link main.c
	* logd/main.c (main): Add basic main function for testing purposes.

2006-08-16  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_start): Ignore self-dependencies; over-document
	why the dependency event prodding has a surprise in its tail.
	(job_change_state): Move the job_release_depends call to here.

	* init/event.c (event_queue_cb): Add event consumer/dispatcher.
	* init/event.h: Update.

	* init/control.c (control_send): Make the event code clearer.
	(control_handle): Handle the changed event semantics.
	(control_handle_event): Issue the new event type.
	* init/tests/test_control.c: Update tests.

	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Adjust
	marshal code to match.
	* upstart/control.h: Update all structures appropriately to the
	previous changes.
	* upstart/tests/test_control.c: Update.

	* init/job.c (job_change_state): Change call to event_trigger_level
	to event_queue_level.

	* init/event.c (event_trigger_edge, event_trigger_level): Place
	the event on the event_queue rather than directly triggering it.
	Rename to event_queue_edge and event_queue_level respectively.
	* init/event.h: Update.
	* init/tests/test_event.c: Update test cases.

	* init/job.c (job_handle_event): Add another sanity check, jobs
	should not be able to react to their own events; that's just silly.
	* init/tests/test_job.c (test_handle_event): Check that the new
	condition does the right thing.
	
	* init/job.c (job_change_state): Make it illegal for a job to exist
	without either a command or script or both.  This is for sanity
	reasons, allowing no primary process makes no sense and can lead
	to event loops if someone is feeling nefarious.
	* init/tests/test_job.c (test_change_state): Drop test on behaviour
	we've just outlawed.

	* init/job.c (job_start): Only announce the change if we're still
	in the waiting state, we could have moved on to running already.

	* init/job.c (job_start): If holding the job, at least announce
	the goal change to subscribed clients.

	* TODO: Update.

	* init/job.c (job_start): Check for dependencies before starting
	the process, if we have any that aren't running we stay in waiting
	until they are.  Any that aren't even starting get poked with a
	dependency event to see whether that wakes them up.
	* init/tests/test_job.c (test_start): Test paths through new
	dependency code.

	* init/job.c (job_run_process): Once we've got an active process
	in the running state, release our dependencies.

	* init/job.c (job_release_depends): Function to release any waiting
	dependencies on the given job.
	* init/job.h: Update.
	* init/tests/test_job.c (test_release_depends): Test the behaviour
	of the function on its own.

	* init/job.h (Job): Add depends list field
	(JobName): New structure to hold the name of a job.
	* init/job.c (job_new): Initialise the depends list.
	* init/tests/test_job.c (test_new): Make sure the depends list is
	initialised properly.

	* init/job.c (job_next_state): Return JOB_STARTING if we're in
	JOB_WAITING and the goal is JOB_START.  This is only called when
	there's some change, and I don't want to hard-code the goal there.
	(job_start): Don't hardcode JOB_STARTING, instead just use the next
	state.
	* init/tests/test_job.c (test_next_state): Adjust test case.

	* init/control.c (control_subscribe): Allow the current
	subscription to be found by passing NOTIFY_NONE.
	(control_handle): Don't remove an existing subscription to jobs,
	a GUI will probably want a permanent one to keep the status up to
	date.

	* init/job.c (job_kill_process, job_kill_timer): Don't hardcode
	JOB_STOPPING here, instead move to the next logical state. 
	(job_kill_process): Notify subscribed processes that we killed
	the job.
	(job_start, job_stop): Notify subscribed processes of a change of
	goal that doesn't result in an immediate state change.

	* init/event.c (event_trigger_edge, event_trigger_level): Swap
	order so that events are announced before processed.

	* init/control.c (control_handle): Handle requests to watch and
	unwatch jobs and events.
	* init/tests/test_control.c (test_cb_child, test_cb): Check that
	subscriptions work.

	* init/tests/test_control.c (test_cb_child): Add a sleep to avoid
	a race that upsets gdb, have tried this with a STOP/CONT interlock
	but can't seem to find where the child should reach first.

	* init/job.c (job_change_state): Notify the control handler.
	* init/event.c (event_trigger_edge, event_trigger_level): Pass
	event to the control handler.
	* init/tests/test_control.c (test_cb_child): Expect to receive
	job status events as well.
	* init/Makefile.am (test_event_LDADD, test_process_LDADD) 
	(test_job_LDADD): Add control.o to the linkage.

	* init/control.c (control_cb): Don't display an error for
	ECONNREFUSED, just remove any subscriptions.
	* init/tests/test_control.c (test_handle_job, test_handle_error):
	Clean up our subscriptions properly.

	* init/control.c (control_handle_job): Function to send out an
	UPSTART_JOB_STATUS message to subscribed processes whenever a
	job state changes.
	(control_handle_event): Function to send out an
	UPSTART_EVENT_TRIGGERED message to subscribed processes whenever
	an event is triggered.
	* init/control.h: Update.
	* init/tests/test_control.c (test_handle_job, test_handle_event):
	Check that the functions work properly.

	* init/control.c (control_handle): Handle messages that trigger
	edge and level events; subscribe the process to receive notification
	of job changes during the event.
	* init/tests/test_control.c (test_cb_child): Check that the messages
	are handled properly (without subscription check).

	* init/control.c (control_cb): Unsubscribe a process if it stops
	listening.

	* init/control.c (control_send): Copy the pointers in the new
	event messages.
	* init/tests/test_control.c (test_send): Check the pointers are
	copied across correctly.

	* init/control.c (control_subscribe): Add function to handle
	processes that want to subscribe to changes.
	(control_init): Initialise the subscriptions list.
	* init/control.h: Add structures and prototypes.
	* init/tests/test_control.c (test_subscribe): Test the function.

	* upstart/control.h (UpstartMsgType): add messages for triggering
	edge and level events, receiving the trigger for an event and for
	watching jobs and events.
	(UpstartEventTriggerEdgeMsg, UpstartEventTriggerLevelMsg)
	(UpstartEventTriggeredMsg, UpstartWatchJobsMsg)
	(UpstartUnwatchJobsMsg, UpstartWatchEventsMsg):
	(UpstartUnwatchEventsMsg): Add structures for the new messages.
	(UpstartMsg): And add them to the union.
	* upstart/control.c (WireEventPayload): The event messages can all
	share a wire payload type; the watch messages don't need any special
	payload.
	(upstart_send_msg_to): Add the payloads onto the wire.
	(upstart_recv_msg): And take the payloads back off the wire.
	* upstart/tests/test_control.c (test_messages): Test the new
	message types.

	* upstart/control.h (UpstartJobStatusMsg): add a process id.
	* upstart/control.c (WireJobStatusPayload): and here too.
	(upstart_send_msg_to): copy the process id onto the wire.
	(upstart_recv_msg): copy the process id from the wire.
	* init/control.c (control_handle): Fill in the pid from the job.
	* upstart/tests/test_control.c (test_messages): Check the pid gets
	passed across the wire properly.

	* init/control.c (control_cb): Disable the poll for write once the
	send queue becomes empty.

	* upstart/Makefile.am (libupstart_la_SOURCES): Correct ordering.

	* init/control.c (control_handle): Add missing break.

	* upstart/job.c (job_goal_name, process_state_name): For completeness
	add these two functions as well.
	* upstart/job.h: Update.
	* upstart/tests/test_job.c (test_goal_name) 
	(test_process_state_name): Test the new functions.

	* init/job.c (job_state_name): Move this utility function from here
	* upstart/job.c (job_state_name): to here so all clients can use
	it.
	* init/job.h: Update.
	* upstart/job.h: Update.
	* init/tests/test_job.c (test_state_name): Move the test case from here
	* upstart/tests/test_job.c: to here as well.
	* upstart/Makefile.am (libupstart_la_SOURCES): Build and link job.c
	(TESTS): Run the job test cases
	(test_job_SOURCES, test_job_LDFLAGS, test_job_LDADD): Details for
	job test case binary.
	* init/Makefile.am (test_job_LDADD, test_process_LDADD) 
	(test_event_LDADD): Link to libupstart.la

	* init/control.c: Code to handle the server end of the control
	socket, a bit more complex than a client as we want to avoid
	blocking on malcious clients.
	* init/control.h: Prototypes.
	* init/tests/test_control.c: Test the control code.
	* init/Makefile.am (init_SOURCES): Build and link control.c
	using the control.h header
	(init_LDADD): Link to libupstart as well
	(TESTS): Build and run the control test suite.
	(test_control_SOURCES, test_control_LDFLAGS, test_control_LDADD):
	Details for control test suite binary.

	* upstart/control.c: Add a way to disable the safety checks.
	* upstart/tests/test_control.c (test_free): Fix bad test case.

	* upstart/control.c (upstart_recv_msg): fixed bogus return type
	for recvmsg from size_t to ssize_t so we don't infiniloop on error.

	* upstart/control.c (upstart_send_msg_to, upstart_recv_msg): Avoid
	job_start as the short-cut for assigning name, as that might become
	a more complex message eventually.  Use job_query instead.

	* upstart/control.c (upstart_free): Add wrapper function around
	nih_free so we're a proper library and don't expose libnih too much
	(upstart_recv_msg): Stash the sender pid in an argument.
	* upstart/control.h: Update.
	* upstart/tests/test_control.c (test_recv_msg): Test pid is
	returned properly.
	(test_free): Test the nih_free wrapper.

	* init/job.c (job_run_script): Document future FIXME.

	* init/exent.h, init/job.h, init/process.h: Fix up headers.

	* upstart/control.c, upstart/control.h, upstart/errors.h,
	upstart/job.h, upstart/libupstart.h: Fix up headers.

	* upstart/control.c: Write the code to handle the control socket
	and communication over it; turns out this was possible to write so
	that both ends are handled in the same code.
	* upstart/control.h: Structures and prototypes.
	* upstart/tests/test_control.c: Test the new code.

	* upstart/Makefile.am (libupstart_la_LIBADD): Link to libnih

	* upstart/errors.h: Header file containing errors raised by
	libupstart.
	* upstart/libupstart.h: Include errors.h

2006-08-15  Scott James Remnant  <scott@netsplit.com>

	* init/event.h: Add missing attribute for event_new()

	* init/job.h (JobGoal, JobState, ProcessState, ConsoleType): Move
	the enums from here
	* upstart/job.h: into here so that we can use them across the
	control socket.

	* Makefile.am (SUBDIRS): Build the libupstart library
	* configure.ac (AC_CONFIG_FILES): Generate upstart/Makefile
	* upstart/Makefile.am: Makefile for sub-directory
	* upstart/libupstart.ver: Linker version script.
	* upstart/libupstart.h: "Include everything" header file.

	* TODO: Update.

	* init/job.c (job_handle_child): Warn when processes are killed
	or exit with an abnormal status.  Warn when respawning.

	* init/job.c (job_handle_child): Respawn processes that were not
	supposed to have died.
	* init/tests/test_job.c (test_handle_child): Test the respawn code.

	* TODO: Update.

	* init/event.c (event_trigger_edge, event_trigger_level): Call
	job_handle_event so that we actually do something useful.
	* init/Makefile.am (test_event_LDADD): Link to process.o and job.o
	now that event.c calls code from job.

	* init/job.c (job_start_event): Function to start a job if an event
	matches.
	(job_stop_event): Function to stop a job if an event matches.
	(job_handle_event): Iterate the job list and dispatch the given event,
	causing jobs to be stopped or started using the above two functions.
	* init/job.h: Update.
	* init/tests/test_job.c: Test the new functions.

	* init/job.c (job_new): Initialise start_events and stop_events to
	an empty list.
	* init/job.h (Job): Add start_events and stop_events list heads.
	* init/tests/test_job.c (test_new): Check the lists are initialised
	correctly to the empty list.

	* init/event.c (event_match): Function to check events for equality.
	* init/event.h: Update.
	* init/tests/test_event.c (test_match): Test function.

	* init/job.c (job_change_state): Trigger the level event with the
	same name as the job, with the value taken from the state.
	* init/tests/test_job.c (test_change_state): Check the event
	gets set to the right values as we go.
	* init/Makefile.am (test_job_LDADD, test_process_LDADD): Link to
	event.o now that job.c uses code from there.

	* init/event.c (event_change_value): Rename event_set_value to this
	as we intended in the first place; makes it more consistent with job.
	Always change the value.
	(event_trigger_edge): Add a high-level function to trigger an edge
	event.
	(event_trigger_level): And another to trigger a level event with
	a given value, this inherits the "don't change it" functionality
	that was in event_set_value.
	* init/event.h: Update.
	* init/tests/test_event.c: Test new behaviours and functions.

	* init/event.c: Add simple code to keep track of events, whether
	they have been recorded or not and their current value if any.
	* init/event.h: Structures and prototypes.
	* init/tests/test_event.c: Test cases for event code.
	* init/Makefile.am (init_SOURCES): Build and link event.c using event.h
	(TESTS): Run the event test suite.
	(test_event_SOURCES, test_event_LDFLAGS, test_event_LDADD): Details
	for event test suite binary.

	* init/job.c (job_run_process, job_kill_process, job_kill_timer):
	Downgrade error messages to warning as they're not fatal.
	(job_change_state): Change info message to be more regular.

	* init/job.c (job_start): A very simple, but very necessary, function.
	Set the goal of the given job to JOB_START and kick it off.
	(job_stop): And its companion, cause a running job to be stopped.
	* init/job.h: Update.
	* init/tests/test_job.c: Test the functions.

	* init/job.c (job_handle_child): Child handler to kick jobs into
	the next state when their process dies.
	* init/job.h: Update.
	* init/tests/test_job.c (test_handle_child): Test the handler
	directly by just invoking it with various job states.

2006-08-14  Scott James Remnant  <scott@netsplit.com>

	* init/tests/test_process.c (test_kill): Use select rather than
	poll for consistency with other test cases.

	* init/job.c (job_kill_process): Add function to send the active
	process of a job the TERM signal, and then set a timer to follow
	up with the KILL signal if the job doesn't get cleaned up in time.
	(job_kill_timer): Timer callback to send the KILL signal; this
	does the same job as the child handler and puts the job into the
	next state as there's no point waiting around now.
	* init/job.h: Update.
	* init/tests/test_job.c (test_kill_process): Test both functions
	in one test case (as one is just the bottom half of the other).

	* init/tests/test_process.c (test_spawn): Use the right thing in
	the test case filename and unlink it to make sure.

	* init/job.c (job_change_state): Write the principal state gate
	function, called once a state has been left to enter the given new
	state (which one should determine with job_next_state).  Spawns
	the necessary processes or moves to the next appropriate state.
	* init/job.h: Update.
	* init/tests/test_job.c: Test the state changes.

	* init/job.c (job_run_process): Internal function to call
	process_spawn and update the job structure.
	(job_run_command): Simple(ish) wrapper for the above to split
	a command by whitespace, or use a shell if it needs more complex
	argument processing.
	(job_run_script): More complex wrapper that uses a shell to execute
	verbatim script, either using -c or a /dev/fd/NN and feeding the
	shell down a pipe to it.
	* init/job.h: Update.
	* init/tests/test_job.c: Test the new functions.

	* init/Makefile.am (init_SOURCES, TESTS): Reorder so that process.c,
	which is arguably lower level, comes first.
	(test_job_LDADD): Link the process code.
	(test_process_LDADD): Swap the order.

	* TODO: Update.

	* init/process.c (process_spawn): Correct typo (progress -> process),
	thanks Johan.

2006-08-12  Scott James Remnant  <scott@netsplit.com>

	* init/process.c (process_spawn): Correct formatting of function.
	* init/process.h (SHELL): Define the location of the shell, all in
	the spirit of not hard-coding stuff like this.

	* init/job.c (job_new): Initialise all structure members to zero
	as this doesn't happen automatically.

2006-08-10  Scott James Remnant  <scott@netsplit.com>

	* init/job.h (job_state_name): Declare as a const function.

2006-08-09  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_next_state): State transition logic; this uses
	our departure from the specification (the goal) so that the state
	can always be currently accurate rather than suggestive.
	(job_state_name): Cute function to convert enum into a name.
	* init/job.h: Update.
	* init/tests/test_job.c (test_next_state): Test the transitions.
	(test_state_name): And the return values.

	* TODO: Add file to keep track of things.

	* init/job.c: Include nih/macros.h and nih/list.h
	* init/process.c: Include order fixing, include nih/macros.h
	* init/tests/test_job.c: Include nih/macros.h and nih/list.h
	* init/tests/test_process.c: Include nih/list.h

	* init/job.c: Include order fixing.
	(job_find_by_name): Function to find a job by its (unique) name.
	(job_find_by_pid): Function to find a job by the pid of its process.
	* init/job.h: Update.
	* init/tests/test_job.c (test_find_by_name, test_find_by_pid): Test
	new functions.

	* init/process.c (process_spawn): Spawn a process using the job
	details to set up the environment, etc.
	(process_setup_console): Set up the console according to the job.
	(process_setup_limits): Set up the limits according to the job.
	(process_setup_environment): Set up the environment according to
	the job.
	(process_kill): Simple function to send a kill signal or raise an
	error; mostly just a wrapper without any particular logic.
	* init/process.h: Prototypes and macros.
	* init/tests/test_process.c: Test cases.
	* init/Makefile.am (init_SOURCES): Build and link process.c and
	its header file.
	(TESTS): Run the process test suite.
	(test_process_SOURCES, test_process_LDFLAGS, test_process_LDADD):
	Details for process test sutie binary.

2006-08-08  Scott James Remnant  <scott@netsplit.com>

	* init/job.c (job_new): nih_list_free is necessary.
	* init/tests/test_job.c (test_new): Free job when done.

	* init/job.h: Header file to contain the definition of the Job
	structure and associated typedefs, etc.
	(JobGoal): In a divergence from the specification, we introduced a
	"goal" for a job which tells us which way round the state machine
	we're going (towards start, or towards stop).
	(JobState): Which means this always holds the current state, even
	if we're trying to get out of this state (ie. if we've sent the TERM
	signal to the running process, we're still in the running state until
	it's actually been reaped).
	(ProcessState): And in another divergence, we keep the state of the
	process so we know whether we need to force a state transition or
	can just expect one because something transient is happening.
	* init/job.c (job_new): Function to allocate a Job structure, set
	the pointers to NULL and other important members to sensible
	defaults.
	(job_init): Initialise the list of jobs.
	* init/tests/test_job.c: Test suite.
	* init/Makefile.am (init_SOURCES): Compile and link job.c using
	its header file.
	(TESTS): Run the job test suite.
	(test_job_SOURCES, test_job_LDFLAGS, test_job_LDADD): Details for the
	job test suite binary.

2006-08-02  Scott James Remnant  <scott@netsplit.com>

	* configure.ac: Check for C99

	* HACKING: Document dependency on libnih.

2006-07-27  Scott James Remnant  <scott@netsplit.com>

	* init/Makefile.am (DEFS): Append to the default DEFS list, rather
	than overriding, otherwise we lose HAVE_CONFIG_H

2006-07-13  Scott James Remnant  <scott@netsplit.com>

	* HACKING: Correct incorrect Bazaar URL.

	* AUTHORS: Change e-mail address to ubuntu.com.
	* HACKING: Update Bazaar and Release URLS.
	* configure.ac (AC_COPYRIGHT): Change copyright to Canonical Ltd.
	(AC_INIT): Change bug submission address to Launchpad.
	* init/main.c: Update header to use Canonical copyright and
	credit me as author.

2006-05-16  Scott James Remnant  <scott@netsplit.com>

	* init/main.c: Add the simplest template main.c
	* init/Makefile.am: Add template Makefile.am that builds init from
	main.c and links to libnih statically
	* configure.ac (AC_CONFIG_FILES): Configure nih and init subdirs.
	* Makefile.am (SUBDIRS): Recurse into nih and init subdirs.

2006-05-14  Scott James Remnant  <scott@netsplit.com>

	* ChangeLog: Initial project infrastructure created.