Command to exit with state code.

Use "nssm statuscode <servicename>" to set the exit code to the value of
dwCurrentState, eg 4 for running.  An exit code of 0 implies an error.

Thanks Meang Akira Tanaka.

Alow prefixing log output with a timestamp.

When AppTimestampLog is set to 1 all output to stdout and stderr will be
prefixed with a millisecond-precision ISO8601 timestamp.

Timestamp prefixing implies online rotation mode.  It should be
considered experimental as it requires splitting input lines by LF with
no way of knowing for certain that the input stream actually is
line-based.

Thanks Nicolas Ducrocq.

Ensure logging threads exit.

We need to close all handles to ensure that all logging threads are
joined.

Care must be taken to close the writing end of the logging pipe first so
that the logging thread can issue a final ReadFile() call.  Before the
thread exits it should close the reading end, however as a safety
measure we WaitForSingleObject() then close the reading end from the
main rotation thread.

Use close_handle().

Call new close_handle() function when tidying up trying to set up I/O.

Added close_handle().

New function to close then zero a handle.

If we pass a second handle pointer, it will be set to the value of the
handle that was closed, or INVALID_HANDLE_VALUE.  We can inspect the
remembered handle to see if we need to wait, eg for a thread.

Initialise hook command widget correctly.

We weren't explicitly zeroing the GUI widget for entering the hook command.

Seek to end of large files correctly.

The documentation for SetFilePointer() is potentially confusing.  When the
third argument is NULL, the second argument is treated as a 32-bit
offset to move the pointer.  When the third argument is not NULL, it is
a pointer to an unsigned integer representing the high order part of a
64-bit signed offset, and the second argument is treated as the
corresponding (signed) low order part.

The documentation states that "if you do not need the high order
32-bits" the third argument must be NULL, and indeed we were setting it
to NULL on the basis that we were moving 0 bytes from FILE_END and 0 can
most definitely be represented in 32-bits.

However in practice when seeking to the end of a file whose size cannot
be represented in 32-bits we actually need to use a 64-bit offset, even
though the 64-bit integer we use is 0.  So we must pass a pointer to a
zeroed high part.

Note that when SetFilePointer() succeeds the return value is the low
order part of the actual offset and the high order value is filled with
the high order offset, which has two important implications.  Firstly we
cannot simply declare our zero variable statically but must pass a new
value each time.  Secondly it is insufficient to check that the function
returned something other than INVALID_SET_FILE_POINTER, as we were
doing; instead we must treat that return value as success if and only
iff GetLastError() returns NO_ERROR.

Marcin Lewandowski noticed that large files were not always appended
correctly.  Because we were passing NULL as the third argument to
SetFilePointer() it returned INVALID_SET_FILE_POINTER and we didn't call
SetEndOfFile().

SetFilePointerEx() is supported on all versions of Windows we target,
and has a much simpler definition than SetFilePointer().  We now use
that instead.

Use WideCharToMultiByte() correctly.

Ensure we call free_imports() when exiting.

CRLF for utf8.* files.

Respect throttle time when trying to start a service.

If we manage the service, retrieve the AppThrottle milliseconds value
and return if the start control doesn't return in that time.

This prevents hanging waiting for a service which fails to start.

Handle virtual accounts when dumping service config.

If we are copying the service we need to build the virtual service
account name for the new service.

Support virtual service accounts.

Specify the account name as "NT Service\<servicename>" or use the
virtual account radio button in the GUI to run the service as a virtual
service account.

Thanks Christian Long.

Use UTF-8 functions when working with explicit encodings.

LSA functions explicitly operate on UTF-16 strings.
GetProcAddress() explicitly operates on multibyte strings.

Added UTF-8 functions.

We want to use UTF-8 everywhere.  To that end we use new functions that
will convert strings between UTF-8 and UTF-16.

Before doing anything at all we set the console, if we have one, to
codepage UTF-8.  Before exiting we restore the console codepage to
whatever it was before.

NTSTATUS returns STATUS_SUCCESS on success.

Technically it isn't correct to check for failure with if (status).

Allow listing all services.

To list all services, not just those managed by NSSM, use:

    nssm list all

Allow waiting for debugger.

If the service is started with the single argument "debug" eg by setting
the Start parameters of the service in services.msc, we delayed startup
in service_main() until the await_debugger variable is set to false.

Attach to nssm.exe with your debugger of choice, set a breakpoint within
that function and poke the variable when ready.

Beware that the behaviour of the service manager when service_main
doesn't complete operation promptly is undefined.

Use QueryFullProcessImageName() if available.

A 32-bit process running on 64-bit Windows can't read the image name of
a 64-bit process, so printing the process tree will fail.  However, on
Windows Vista or later we have QueryFullProcessImageName() which is able
to retrieve the path.

Be quieter loading imports.

There's no need to log an event if we couldn't load a missing DLL.

There's no need to go to the trouble of converting to a wide buffer if
we aren't then going to log an event.

Command to show processes started by the service.

Print process tree with PID and module path.

Thanks Bader Aldurai.

Added get_debug_token().

New function to obtain SeDebugPrivilege privilege.

Abstract kill_process_tree().

The function is now walk_process_tree() and instead of killing a process
it invokes the supplied callback function.  When killing a process we
pass a pointer to kill_process().

This will allow performing operations things other than killing
processes on the tree.

Let the dump command copy a service.

If an optional second argument is given to dump, the name of the service
in the output will be set to the argument's value.  In any case, an
"install" line will be written, replacing the Application dump line.

Thus a service can be copied by running:

    nssm dump <servicename> <newservicename> | %COMSPEC% /k

Command to dump service configuration.

Output commands which can be used to recreate the service configuration
with:

    nssm dump <servicename>

Commands are quoted and escaped as best we can manage.

Don't mangle the input to split_hook_name().

Define for default parameter string.

Export hook strings.

Allow adding or removing individual dependencies.

Specifying a DependOnService or DependOnGroup argument as +<dependency>
will add the dependency to the list.  Specifying it as -<dependency>
will remove it from the list.  The dependency may also be given as
:<dependency> to make scripting more legible.

Groups should technically be prefixed with a + symbol.  NSSM will follow
the rules above even when the + prefix is used.

Added append_to/remove_from_dependencies().

Allow adding or removing individual environment variables.

Specifying an environment string as +KEY=VALUE will append KEY=VALUE to
the existing block, or create a new one if none was previously
configured.  If KEY is already present, +KEY=VALUE will override it in
place.

Specifying -KEY=VALUE will remove KEY=VALUE from the existing block.

Specifying -KEY will remove KEY regardless of its value.

Removing the last key will delete the whole block.

Specifying :KEY=VALUE is equivalent to KEY=VALUE, ie it creates a new
block with only KEY=VALUE present.  Its main purpose is to make scripts
easier to read.

    nssm set <servicename> AppEnvironment :FIRST=one
    nssm set <servicename> AppEnvironment +SECOND=two
    nssm set <servicename> AppEnvironment +THIRD=two

Don't leak memory in get_service_dependencies().

Ensure we free qsc when there are no dependencies.
Ensure we free qsc when we couldn't allocate a buffer.
Free the buffer and zero its pointer's size when there are no
dependencies.

Some notes on the environment and registry.

Documentation is good!

Added append_to/remove_from_environment_block().

New functions to add an environment variable to an existing environment
block or to remove a variable (specified by KEY=VALUE or just KEY) from
a block.

A new block is always returned.  It will have length 2 (NULL NULL) if
the requested action was a no-op.

Functions to work with null delimited lists.

copy_double_null() duplicates a null delimited list.

append_to_double_null() adds an entry to a list, or replaces an entry
which matches a given substring of the new value.

remove_from_double_null() removes an entry from a list, possibly only if
it matches a given substring.

Handle second parameter of unformat_double_null().

The length of the formatted buffer is supposed to be a count of
characters NOT including the trailing NULL.

Added enumerate_registry_values().

New function to retrieve values under a key.

Correct return code from setting_get_priority().

The function was returning 1 when filling the destination buffer with
the default value.  It should return 0 when the value is default and 1
when it has been set by the administrator.

Open registry with read/write when setting parameters.

We may need to query existing settings so we need KEY_READ as well as
KEY_WRITE access.

Ensure we have the right key for querying Environment.

The Environment value is under the service key not our subkey.
If we're querying it we should expect that the service definition exists
in the registry.

RegQueryValueEx() returns error code directly.

Formatting an error message should use the return value not
GetLastError().

Added quote().

New function to quote strings for passing to the command prompt.
Protect metacharacters with ^ when quoting.  Always quote when
metacharacters are present even if we wouldn't otherwise.

Added nssm_exe().

New function to retrieve argv[0].

Redirect hooks' output.

If AppRedirectHook is 1 and stdout and/or stderr are being redirected,
also redirect the output of hooks.

Doing so requires using a logging thread and so implies online rotation
if log rotation is used.

Thanks Nabil Redmann.

Added dup_handle().

New wrapper around DuplicateHandle().

David Bremner committed some fixes.

CreateFile returns INVALID_HANDLE_VALUE on failure https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx

CreateToolhelp32Snapshot returns INVALID_HANDLE_VALUE on failure https://msdn.microsoft.com/en-us/library/windows/desktop/ms682489(v=vs.85).aspx

service->passwordlen is a count of TCHARs, fix SecureZeroMemory for UNICODE

move misplaced return

remove dead breaks and returns

Try to create messages at install time.

If the service was never run under a privileged account we might not
have been able to set the message source in the registry.

Set the message source when installing the service, as we are guaranteed
to have the necessary rights.

Compiler food.

SetConsoleCtrlHandler() returns BOOL which is not bool.

Added list command to enumerate NSSM services.

Use "nssm list" to print all services which are managed by NSSM.

Technically we should stop ignoring Control-C.

Before signalling our application we implement a null Control-C handler
so we don't get killed ourselves when signalling the process group.  We
should probably restore the default behaviour after signalling.

Don't ignore must_exist in open_registry().

A typo meant that we were passing true to the overloaded open_registry()
which also takes an HKEY as a parameter.

As a result we would end up spamming ERROR_FILE_NOT_FOUND when updating
a service via the GUI if there were no hooks to update, ironically in a
section of code whose purpose was to check that it didn't need to do or
report anything.

Thanks Igor Zenkov and James Gleason.

Not an error if no hook found in the registry.

Hooks are optional so we shouldn't log an error if one wasn't found.

Thanks Mathias Breiner.

Alternative open_registry_key() signature.

Allow passing a pointer to an HKEY and having the function return the
result of RegCreateKeyEx()/RegOpenKeyEx().  Existing functions wrap the
new invocation so no code changes are needed.

The new function can be used to handle ERROR_FILE_NOT_FOUND as success
when must_exist is false.

Help git figure out how to diff .mc and .rc files.

Visual Studio wants .mc and .rc files to be UTF-16LE, which git thinks
are binary.  Use .gitattributes to force treating them as text only when
diffing, explicitly not handling them as text when submitting as they
must retain their encoding to keep Visual Studio happy.

Thanks to Mathias Breiner for proposing the use of .gitattributes in the
repo.  I had the rules in .git/info/exclude in my working copy for a
long time and forgot about the issue!

Use CRLF consistently.

The mismatch of line endings has long been an annoyance.

Thanks Mathias Breiner for advocating finally doing something about it.

Use service_registry_path() in create_exit_action().

As a result of registry function refactoring we were constructing the
default path to AppExit incorrectly.  Using the function created for the
purpose works correctly, unsurprisingly.

Thanks Igor Zenkov.

Workaround for Resource Compiler warnings/errors under VS2010.

VS2010 RC.exe yielded lots of warnings and some errors when including some (unnecessary) platform header files via nssm.h. So now including only what is really required.
This includes a workaround for error RC2247 found here: http://stackoverflow.com/a/18317658

Fix compilation on VS2015.

Paul Baxter and Mathias Breiner independently reported fixes to get the
project to compile on Visual Studio 2015.

EventMessageFile should be unquoted.

We were writing a quoted message source path to the registry.
Stefan and Michael Scherer point out that it should be unquoted.

Compiler food.

Fix crash on Windows XP.

The pointer returned by GetEnvironmentStrings() on Unicode versions of
Windows XP was to the raw environment block, not a copy as described in
the documentation.  Retrieving it into service->initial_env and keeping
it around for the lifetime of the service could cause a crash.  Instead
we now copy the memory and immediately call FreeEnvironmentStrings().

Thanks Scott Ware.

Clean up Parameters properly.

If create_parameters() failed to write Application, AppParameters or
AppDirectory it would try to clean up by deleting the Parameters key.
The method used to do so was flawed.  It would attempt to delete the key
defined by the NSSM_REGISTRY macro but that macro contains a printf
control string and is not suitable for standalone use.

Incorrect capitalisation of AppStderrCopyAndTruncate.

Describe startup environment in the README.

Abstracted open_registry().

Added service_registry_path() to construct a registry path for a service
which may contain the Parameters subkey and optional sub-subkey.  If no
Parameters subkey is needed the constructed path references the native
service parameters.

The open_registry() function is now a wrapper around the new
open_registry_key() function which opens an arbitrary key.

The new open_service_resgistry() function also wraps open_registry_key()
to access native parameters.

Use nssm_imagepath().

We were calling GetModuleFileName() in a number of places.  Use
nssm_imagepath() instead.

Ensure that a quoted path is used for the service image path when
creating the service, thus avoiding a theoretical security vulnerability
whereby the service manager could be tricked into launching the wrong
program.

When setting the path to NSSM in the environment for event hooks we
still use the unquoted path, as environment variables are typically
unquoted.

Thanks Gerald Haider.

Added nssm_imagepath() and nssm_unquoted_imagepath().

Functions to retrieve the path to nssm.exe both with and without path
quoting.

Save the environment.

Before the previous two commits we used to read the environment from the
registry and set it using an optimisation which modified the retrieved
block in-place.

Now we need to set the environment twice after querying the registry -
once in get_parameters() and once just before CreateProcess(), which
means we can't use the in-place optimisation and must copy the block
before operating on it.

Additionally, nssm_hook() cleans the environment so we have to reinstate
it immediately prior to launching the application.

Compiler food.

Missing header from previous commit.

Set the environment before querying the registry.

Handle AppEnvironment and AppEnvironmentExtra before querying registry
parameters.  Doing so allows paths and arguments passed to the service
to reference such environment variables.

Thanks Yuriy Lesiuk.

Formatting.

Start service in a new thread so we don't block stop controls.

Run hooks in response to certain events.

User-configurable hooks will be run before and/or after certain events,
eg after the application starts successfully.

Hooks will run with the environment of the application, with additional
environment variables providing information about the service status and
the hook which has been called.

Don't create registry keys needlessly.

Don't log an error when trying to access a registry key which doesn't
exist when it's expected that it might not be present.

Don't open a key with RegCreateKeyEx() when we are potentially going to
delete a value.  Instead try RegOpenKeyEx() and return success if it
already isn't present.

Fixed permissions check in open_registry().

We were checking for the presence of KEY_WRITE in the SAM to decide
whether to call RegCreateKeyEx() or RegOpenKeyEx().  KEY_WRITE is an
alias for STANDARD_RIGHTS_WRITE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY so
the function was incorrectly calling RegCreateKeyEx() even when
RegOpenKeyEx() would be more appropriate.

Don't time out waiting for service status change.

Wait for service to start (or fail to start) or stop instead of timing
out after five seconds.

An NSSM service which doesn't start properly and temporarily enters
paused state may end up reporting running state in response to a stop
control.  Therefore we now consider SERVICE_RUNNING to be a valid
response to SERVICE_CONTROL_STOP.

RegisterPowerSettingNotification is unnecessary.

We were importing RegisterPowerSettingNotification but not actually
calling it.  This didn't matter because including
SERVICE_ACCEPT_POWEREVENT in the accepted controls list is sufficient to
receive power notifications.

Restrict acceptance of service controls.

Don't accept a pause/continue control unless the service is marked as
paused.
Don't accept any control until startup is pending.
Don't accept any control after processing a stop control.

More StringFileInfo parameters.

The CompanyName and OriginalFileName parameters are mandatory according
to the spec, so we now provide them.

Refactor kill functions to be independent of services.

Removed most explicit references to service data in kill functions so
they can be used to kill arbitrary process trees.

The function to wait for service status change has been renamed
await_single_handle() to reflect that it can wait for any single object
not just a service's process handle.

Single waiting function.

Use a single function to wait for service status to change, regardless
of if we are waiting for the service to run for a minimum period of time
to be unthrottled or for it to shut down..

Allow slow service startup again.

Previously we enforced a maximum delay in reporting to the service
manager that the service was started, and waited for the application to
become unthrottled in the background.

Users may prefer that the service not report a started state until the
application is unthrottled.  Therefore we now loop and increment the
status checkpoint and wait hint to satisfy the service manager that we
aren't hung.

Thanks Tom Saul.

Typo millisencondes.

Don't try to operate on freed data structure.

We were calling HeapFree() on the logger structure then trying to
call CloseHandle() on one of its elements.

Copy/truncate file rotation.

Some processes, notably Logstash, open files for reading without setting
the FILE_SHARE_READ share mode.  If NSSM is using such a file for I/O
redirection and it tries to rotate the file, its MoveFile() call will
fail.

If the new (REG_DWORD) value(s) AppStdoutCopyAndTruncate and/or
AppStderrCopyAndTruncate are non-zero, NSSM will instead try to rotate
the file(s) by calling CopyFile() to create a copy of the file then
calling SetEndOfFile() to truncate the original file to zero size.
Doing so allows the rotation to succeed at the cost of time and disk
space to create a full copy of the file.

If the new (REG_DWORD) value AppRotateDelay is non-zero, NSSM will sleep
for the given number of milliseconds after rotation, regardless of the
rotation method used.  Testing with Logstash specifically has shown that
introducing a delay of 1000ms may be sufficient to avoid an issue
whereby the reading application loses the final line of input from the
old file due to not noticing that it has been truncated.

Thanks Miguel Angel Terrón.

Allow skipping kill_process_tree().

Don't try to kill the application's process tree - just the application
itself - if the REG_DWORD value AppKillProcessTree is 0.

Thanks Barrett Lewis.

Import RegisterPowerSettingNotification().

Restart in response to PBT_APMRESUMEAUTOMATIC event.

NSSM 2.24.

Terminate the correct process.

We were calling TerminateProcess() on the service process handle in
instead of the handle passed to kill_process().

Thanks Sam Townsend.

NSSM 2.23.

Use CloseServiceHandle() on service handles.

We were incorrectly calling CloseHandle() to close service handles.
CloseServiceHandle() is not only for service manager handles and should
be used on service handles as well.

Fixed some typos and whitespace errors.

Fixed running service under local username.

Trying to set a local account to run the service would fail with
LsaLookupNames() complaining that the name could not be looked up.

Thanks Allen Vailliencourt.

Suppress ERROR_PROC_NOT_FOUND events.

Don't log "The specified procedure could not be found" if
GetProcAddress() fails.  ERROR_PROC_NOT_FOUND is expected when running a
version of Windows which doesn't support the desired. function

Thanks Alain Douangpraseuth.