Remove std::move(...) so that copy ellision can occur.

Add support for unpin command in dinitctl (includes corresponding
control protocol changes)

Add support for pinning services to dinitctl

Make "pinStart" and "start", and "pinStop" and "stop", separate
operations.

"pinStart" and "pinStop" set the pin for the started and stopped
states respectively, but do not attempt to move the service into
the chosen state.

Update README with info on service hierarchy and service states
(especially active vs inactive)

Mark service active if it is started while not active.
(It will mark itself inactive when it stops).

During shutdown, let process attrition occur naturally, instead of forcing
the services down early.

Also, don't restart a service which has desired_state = STARTED if auto-restart
is disabled.

Various changes to match changes to command protocol.

Refactor/fix control commands, add a few start/stop alternatives

Fix stop(). Give it a boolean argument for 2 modes of operation:
One, release the service if it was explicitly started (which will
 bring it down only if it is no longer needed by any active service)
Two, release the service and bring it down (which will also bring
 down any dependent services).

Make sure to initialise all members of ControlConn

Restore "restart" flag functionality. Services no longer auto-restart
just because they are active (required) - they now only do so if
the auto-restart flag has been set for the service.

Cleanups and refactoring.

Largish re-work of how dependencies are handled. The "start" and
"dependentStopped" methods were overloaded in unsound ways.

Add require() and release() methods to make an explicit requirement
on a dependency. A require() is added when the service is explictly
started, or when it is a dependency of such a service (directly),
or when it is a dependency of a service which has been required.

Fix "skip to reply packet" method.

It was possible to skip over an information packet but not read any
further reply, so the packet type test (rbuffer[0] == ...) would not
work correctly.

Refactoring, and one fix: stopping an already-stopped service can be
used to remove its explicitly-started state, and in that case needs
to notify dependencies of complete shutdown.

Introduce "explicitly started" state flag for services, and automatically
stop services which were not explicitly started when they have no
dependents running.

This means that if you start a service, and then stop that service, the
system should return to its original state with no additional services
running.

Fix protocol errors in dinitctl

Add license (Apache license version 2.0).

Update gitignore

Make sure to not write a partial command packet.

dinitctl: recognize and report FAILEDSTART events.

Refactoring: remove unneeded method

Make "dinitctl start" start a service and "dinitctl stop" stop a
service, rather than the other way around...

Change command line and implement stopping of services in dinitctl.

"dinitctl start <servicename>" and "dinit stop <servicename>" now function
as you'd expect.

Rename dinit-start to dinitctl, as I think one command for service
management is probably the best route to take.

Move source files int src directory

Add socket-uid and socket-gid service settings for controlling
activation socket ownership.

Update TODO list

Implement socket activation (single, unix-family socket only)

Add some info about Nosh, another init/service system I just found out about.

Make sure to initialise all state bits

A forced stop at the point of reaching STARTED state should not
actually change the desired state: call start() after stop() if
the desired state is not STOPPED.

Re-read PID file after recovering a BGPROCESS service.

Update TODO (log messages to console should be buffered when a service
is holding the console)

Minor re-organisation and logging improvements

Add support for "bgprocess" services - daemons which fork and put
themselves in the background (but which ideally write their PID
into a file that can be read by Dinit).

If a "scripted" service has no stop command, allow it to stop immediately.

This allows no stop command to be specified if none is needed. (This probably
already worked, but only because Dinit would try to exec "" (the empty string)
when the service stopped, which would fail, and the service would get marked
as stopped anyway).

When performing shutdown, un-pin services after issuing stop.

Fix: scripted service might not have its start/stop registered
if the script finishes too quickly.

Add "smooth-recovery" option for process services.

A process service with smooth-recovery set will restart its
process (if it dies unexpectedly) without bring the service
itself down. I.e the service remains in STARTED state, and
any dependents do not have to be brought down.

Move to asynchronous handling of child exec status.

This gives ever-so-slightly better parallelism, and staves off
potential future priority inversion problems.

Remove the "release_console" on-start flag. It is now redundant.

Various improvements to state transitions.

Introduce a new variable to track if a service is waiting for its
dependencies (starting) or dependents (stopping). In these cases
it is possible to transition directly from STARTING to STOPPED or
from STOPPING to STARTED. This also removes the need for special
handling of "internal" services (which will never transition from
STARTING to STARTED or STOPPING to STOPPED excet via transitions
of their dependencies/dependents).

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