Run "run-on-console" services as a new process group/session so
that ^C can be used to interrupt it.

(Probably will make this optional, later).

Don't reque for console immediately if we acquire it when dependencies
haven't started.

The theory was that we could append to the end of the queue. In practice,
though, we might be the only service in the queue, in which case
we'll immediately acquire the console if we queue for it and so go
into infinite recursion.

I could swear I fixed this not too long ago...

Fix another hanging state: "internal" services can be stopped
while they are starting and immediately transition from
STARTING to STOPPED. If this is not allowed, they hang in
STARTING state.

(Other service types eventually start due to an external event,
and can then stop).

Add "run-on-console" service option, to specify that a service
runs on the console.

Only one service can be running on the console at a time, so
there is a queue to obtain the console.

Not 100% complete yet. Part of the functionality seems to have
crept in with previous commit though? git gremlins...

Fix a problem that left services incorrectly marked as active.

For scripted services, accept both a "command" and "stop-command" setting.
Do not automatically add "start" or "stop" to the command.

Fix: when a dependency failed, the dependent process was not marked
as inactive.

Merge "shutdown" and "dinit-reboot" functionality into the "shutdown"
executable.

dinit-reboot function (of actually unmounting file systems and performing
shutdown) is accessed using --system argument, which is not expected to
be used by users.

Implement a shutdown commoand which issues a shutdown via Dinit's
control protocol. Includes 'halt' and 'reboot' alias scripts.

Implement a dinit-reboot helper program to be called by the main
Dinit process to actually perform shutdown.

Control protocol: Remove 'ROLLBACK' command, add a 'SHUTDOWN'
command to replace it. Remove the rollback handler interface
from ServiceSet.

Record shutdown type (halt, poweroff, reboot) in the service set.

Documentation updates.

Overhaul of dinit-start utility.

It isn't yet complete, but is functional.

Include desired state of service in SERVICERECORD packets.

Fix bug in ServiceSet::loadService (only worked properly for already-loaded
services) and add an accessor method for desired_state.

Fix include style for service-constants.h include

Move service event types into service-constants.h

Control stream: Use a circular receive buffer

Overhaul of the control protocol.

Numeric service handles can be allocated for a service (via FINDSERVICE/LOADSERVICE
requests), and commands are issued against a service handle. Notification of events
is performed using information packets which include the relevant service handle.

Remove obselete TODO comment.

Split service constants (state/event enumerations) into a separate
include file.

Prevent force_stop state being set in a service that has already
stopped.

Add a publicly-accessible method to load a service (and return
a pointer to its service record).

Fix bind of control socket, and unlink control socket path on exit

Add an event listener interface to services.

Minor re-arrangement of fields and code documentation improvements.

Cleanup error handling / logging

Add possibility to pin services started or stopped. This prevents
them from automatically stopping or starting as part of a dependency
chain.

Improve error message logged when failing to load a service (give
reason for failure).

(Also correct some comments explaining util-linux-ng shutdown/init
behavior).

Add "nosigterm" service setting to inhibit sending SIGTERM to service
process. (Unless an aleternative signal is specified using 'termsignal',
no termination signal will be sent).

Add a "query version" command to the control protocol.

Add possibility to retrieve textual description of errors from service
load exceptions.

Control protocol cleanups.

Comment update.

Fix remaining case of ControlConn being used after being deleted.

In processPacket() always check the response of queuePacket(), to
avoid writing to instance variables after the ControlConn instance
has been deleted.

Also make some functions private.

Various control protocol improvements, still needs significant work.

Introduce queuePacket() variant which takes a `const char *` buffer
rather than a pre-made vector. Use it where appropriate to send ACK
responses.

Add function to queue outgoing packet to a control connection.

Move compiler flags out of the Makefile and into mconfig

Various exception handling fixes and 'noexcept' declarations

Remove incorrect comment

Remove functional TODO comments.

Add a control command to initiate service rollback (and receive
notification when rollback is complete).

Fix some logging, and add a variable to track how many control connections
are open. Don't terminate while there are still control connections.

Commit .gitignore

Add the "termsignal" setting to process services. This allows an
additional signal (alongside SIGTERM) to be sent to the process to
terminate it.

Catch allocation exception when receiving a control socket connection

Documentation updates

Improve the state model.

A service now transitions into the STARTING state from the STOPPED state
as soon as start() is called, rather than after all dependencies have
started. Similarly a service enteres the STOPPING state (from STARTED)
immediately when stop() is called.

Forced re-starts should now work properly in all cases.

Add 'dependencyStarted' method instead of directly overloading 'start'

Add sample config for OpenBSD build

Rename 'reboot' variable to 'do_reboot' to avoid conflict with OpenBSD
'reboot' function.

Remove unintentionally committed debug statements

Logging and comment fixes

Add dinit-log.h as a dependency for objects

Improve logging facilities.

Allow variadic 'log' calls, and automatically convert std::string
and int arguments to char * in an exception-free manner.

Fix bug: "internal" services never properly registered that they had
stopped.

Update README

Update TODO list

Several changes, centered around improving logging and handling
read-only initial filesystem.

* introduce basic logging functions
* allow "onstart" commands to specify if console output should
  stop and/or if control socket should be opened after a service
  starts
* fix a bug in load_service / service constructor interaction,
  caused services with arguments to fail

Use C++11 typesafe enums for service type (ServiceType) and state
(ServiceState).

Make start_ps_process more C++ish and prevent it throwing exceptions

The function already has a status result so it doesn't make much
sense to allow exceptions to propogate out of it.

Allow for quoted program arguments (and executable).

In loadServiceRecord(), the 'command' setting was parsed and unquoted
resulting in a single string. Now, the beginning and end of each part
(i.e. the executable and each argument) are recorded so they can be
stored as part of the service record, and nul terminators are stored
behind each part.

Fix comment in relation to vfork (we are using fork instead now)

Minor cleanup: use C++-style cast and add some comments

Back out incorrect comment introduced earlier.

Improve comments - remove no longer relevant comment, add some new comments.

Add parameter documentation for read_setting_value

Augment read_setting_value so that it can return the position (start and end)
of each part of the setting value.

Change parameter type of read_setting_{name,value} from string_iterator pointer to string_iterator reference.

Improve comment.

Add support for "internal" services (which don't actually run any
external process) and enhance config file parsing a little.

Re-vamp the "build system".

Move compiler options etc into make variables in the "mconfig" file.
The main makefile includes the mconfig file, so it shouldn't generally
be necessary to edit the makefile itself. Includes sample config for
GCC and LLVM+libc+++.

Simple cleanups.

Finish soft dependency support.

If a soft dependency fails to start, it no longer cancels its
dependent's start.

Set dependents desired state to STOPPED immediately
when stop of dependency requested.

Previously, if the state was STARTING when the stop
was issued, dependencies were not stopped.

Implement "soft" dependencies. These are created by using
"depends-soft=" in the service file in place of "depends-on=".
If a service stops or dies, it will not cause dependents with
only a soft dependency to stop. This can be used to control
startup order without creating a real dependency.

Note: if a soft dependency fails to start, it still causes the
dependent to also fail to start.

Just adding some comments.

Filter "auto" from the command line. LILO adds it automatically for
non-interactive boots; we can just ignore it.

forceStop() needs to issue stop().

Both were issued when a process died unexpectedly, but in case of
a dependent, forceStop() would be issued without stop() meaning that
the dependent would not actually stop.

Properly intiiatiise force_stop

Clean up exception throwing/handling during service loading, and fix
dependency cycle detection.

Initial commit.